Source code upload
[framework/connectivity/dnsmasq.git] / src / forward.c
1 /* dnsmasq is Copyright (c) 2000-2011 Simon Kelley
2
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.
7  
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.
12      
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/>.
15 */
16
17 #include "dnsmasq.h"
18
19 static struct frec *lookup_frec(unsigned short id, unsigned int crc);
20 static struct frec *lookup_frec_by_sender(unsigned short id,
21                                           union mysockaddr *addr,
22                                           unsigned int crc);
23 static unsigned short get_id(unsigned int crc);
24 static void free_frec(struct frec *f);
25 static struct randfd *allocate_rfd(int family);
26
27 /* Send a UDP packet with its source address set as "source" 
28    unless nowild is true, when we just send it with the kernel default */
29 static void send_from(int fd, int nowild, char *packet, size_t len, 
30                       union mysockaddr *to, struct all_addr *source,
31                       unsigned int iface)
32 {
33   struct msghdr msg;
34   struct iovec iov[1]; 
35   union {
36     struct cmsghdr align; /* this ensures alignment */
37 #if defined(HAVE_LINUX_NETWORK)
38     char control[CMSG_SPACE(sizeof(struct in_pktinfo))];
39 #elif defined(IP_SENDSRCADDR)
40     char control[CMSG_SPACE(sizeof(struct in_addr))];
41 #endif
42 #ifdef HAVE_IPV6
43     char control6[CMSG_SPACE(sizeof(struct in6_pktinfo))];
44 #endif
45   } control_u;
46   
47   iov[0].iov_base = packet;
48   iov[0].iov_len = len;
49
50   msg.msg_control = NULL;
51   msg.msg_controllen = 0;
52   msg.msg_flags = 0;
53   msg.msg_name = to;
54   msg.msg_namelen = sa_len(to);
55   msg.msg_iov = iov;
56   msg.msg_iovlen = 1;
57   
58   if (!nowild)
59     {
60       struct cmsghdr *cmptr;
61       msg.msg_control = &control_u;
62       msg.msg_controllen = sizeof(control_u);
63       cmptr = CMSG_FIRSTHDR(&msg);
64
65       if (to->sa.sa_family == AF_INET)
66         {
67 #if defined(HAVE_LINUX_NETWORK)
68           struct in_pktinfo p;
69           p.ipi_ifindex = 0;
70           p.ipi_spec_dst = source->addr.addr4;
71           memcpy(CMSG_DATA(cmptr), &p, sizeof(p));
72           msg.msg_controllen = cmptr->cmsg_len = CMSG_LEN(sizeof(struct in_pktinfo));
73           cmptr->cmsg_level = SOL_IP;
74           cmptr->cmsg_type = IP_PKTINFO;
75 #elif defined(IP_SENDSRCADDR)
76           memcpy(CMSG_DATA(cmptr), &(source->addr.addr4), sizeof(source->addr.addr4));
77           msg.msg_controllen = cmptr->cmsg_len = CMSG_LEN(sizeof(struct in_addr));
78           cmptr->cmsg_level = IPPROTO_IP;
79           cmptr->cmsg_type = IP_SENDSRCADDR;
80 #endif
81         }
82       else
83 #ifdef HAVE_IPV6
84         {
85           struct in6_pktinfo p;
86           p.ipi6_ifindex = iface; /* Need iface for IPv6 to handle link-local addrs */
87           p.ipi6_addr = source->addr.addr6;
88           memcpy(CMSG_DATA(cmptr), &p, sizeof(p));
89           msg.msg_controllen = cmptr->cmsg_len = CMSG_LEN(sizeof(struct in6_pktinfo));
90           cmptr->cmsg_type = daemon->v6pktinfo;
91           cmptr->cmsg_level = IPV6_LEVEL;
92         }
93 #else
94       iface = 0; /* eliminate warning */
95 #endif
96     }
97   
98  retry:
99   if (sendmsg(fd, &msg, 0) == -1)
100     {
101       /* certain Linux kernels seem to object to setting the source address in the IPv6 stack
102          by returning EINVAL from sendmsg. In that case, try again without setting the
103          source address, since it will nearly alway be correct anyway.  IPv6 stinks. */
104       if (errno == EINVAL && msg.msg_controllen)
105         {
106           msg.msg_controllen = 0;
107           goto retry;
108         }
109       if (retry_send())
110         goto retry;
111     }
112 }
113           
114 static unsigned int search_servers(time_t now, struct all_addr **addrpp, 
115                                      unsigned int qtype, char *qdomain, int *type, char **domain, int *norebind)
116                               
117 {
118   /* If the query ends in the domain in one of our servers, set
119      domain to point to that name. We find the largest match to allow both
120      domain.org and sub.domain.org to exist. */
121   
122   unsigned int namelen = strlen(qdomain);
123   unsigned int matchlen = 0;
124   struct server *serv;
125   unsigned int flags = 0;
126   
127   for (serv = daemon->servers; serv; serv=serv->next)
128     /* domain matches take priority over NODOTS matches */
129     if ((serv->flags & SERV_FOR_NODOTS) && *type != SERV_HAS_DOMAIN && !strchr(qdomain, '.') && namelen != 0)
130       {
131         unsigned int sflag = serv->addr.sa.sa_family == AF_INET ? F_IPV4 : F_IPV6; 
132         *type = SERV_FOR_NODOTS;
133         if (serv->flags & SERV_NO_ADDR)
134           flags = F_NXDOMAIN;
135         else if (serv->flags & SERV_LITERAL_ADDRESS) 
136           { 
137             if (sflag & qtype)
138               {
139                 flags = sflag;
140                 if (serv->addr.sa.sa_family == AF_INET) 
141                   *addrpp = (struct all_addr *)&serv->addr.in.sin_addr;
142 #ifdef HAVE_IPV6
143                 else
144                   *addrpp = (struct all_addr *)&serv->addr.in6.sin6_addr;
145 #endif 
146               }
147             else if (!flags || (flags & F_NXDOMAIN))
148               flags = F_NOERR;
149           } 
150       }
151     else if (serv->flags & SERV_HAS_DOMAIN)
152       {
153         unsigned int domainlen = strlen(serv->domain);
154         char *matchstart = qdomain + namelen - domainlen;
155         if (namelen >= domainlen &&
156             hostname_isequal(matchstart, serv->domain) &&
157             (domainlen == 0 || namelen == domainlen || *(matchstart-1) == '.' ))
158           {
159             if (serv->flags & SERV_NO_REBIND)   
160               *norebind = 1;
161             else
162               {
163                 unsigned int sflag = serv->addr.sa.sa_family == AF_INET ? F_IPV4 : F_IPV6;
164                 /* implement priority rules for --address and --server for same domain.
165                    --address wins if the address is for the correct AF
166                    --server wins otherwise. */
167                 if (domainlen != 0 && domainlen == matchlen)
168                   {
169                     if ((serv->flags & SERV_LITERAL_ADDRESS))
170                       {
171                         if (!(sflag & qtype) && flags == 0)
172                           continue;
173                       }
174                     else
175                       {
176                         if (flags & (F_IPV4 | F_IPV6))
177                           continue;
178                       }
179                   }
180                 
181                 if (domainlen >= matchlen)
182                   {
183                     *type = serv->flags & (SERV_HAS_DOMAIN | SERV_USE_RESOLV | SERV_NO_REBIND);
184                     *domain = serv->domain;
185                     matchlen = domainlen;
186                     if (serv->flags & SERV_NO_ADDR)
187                       flags = F_NXDOMAIN;
188                     else if (serv->flags & SERV_LITERAL_ADDRESS)
189                       {
190                         if (sflag & qtype)
191                           {
192                             flags = sflag;
193                             if (serv->addr.sa.sa_family == AF_INET) 
194                               *addrpp = (struct all_addr *)&serv->addr.in.sin_addr;
195 #ifdef HAVE_IPV6
196                             else
197                               *addrpp = (struct all_addr *)&serv->addr.in6.sin6_addr;
198 #endif
199                           }
200                         else if (!flags || (flags & F_NXDOMAIN))
201                           flags = F_NOERR;
202                       }
203                     else
204                       flags = 0;
205                   } 
206               }
207           }
208       }
209   
210   if (flags == 0 && !(qtype & F_NSRR) && 
211       option_bool(OPT_NODOTS_LOCAL) && !strchr(qdomain, '.') && namelen != 0)
212     /* don't forward simple names, make exception for NS queries and empty name. */
213     flags = F_NXDOMAIN;
214   
215   if (flags == F_NXDOMAIN && check_for_local_domain(qdomain, now))
216     flags = F_NOERR;
217
218   if (flags)
219     {
220       int logflags = 0;
221       
222       if (flags == F_NXDOMAIN || flags == F_NOERR)
223         logflags = F_NEG | qtype;
224   
225       log_query(logflags | flags | F_CONFIG | F_FORWARD, qdomain, *addrpp, NULL);
226     }
227   else if ((*type) & SERV_USE_RESOLV)
228     {
229       *type = 0; /* use normal servers for this domain */
230       *domain = NULL;
231     }
232   return  flags;
233 }
234
235 static int forward_query(int udpfd, union mysockaddr *udpaddr,
236                          struct all_addr *dst_addr, unsigned int dst_iface,
237                          struct dns_header *header, size_t plen, time_t now, struct frec *forward)
238 {
239   char *domain = NULL;
240   int type = 0, norebind = 0;
241   struct all_addr *addrp = NULL;
242   unsigned int crc = questions_crc(header, plen, daemon->namebuff);
243   unsigned int flags = 0;
244   unsigned int gotname = extract_request(header, plen, daemon->namebuff, NULL);
245   struct server *start = NULL;
246     
247   /* RFC 4035: sect 4.6 para 2 */
248   header->hb4 &= ~HB4_AD;
249   
250   /* may be no servers available. */
251   if (!daemon->servers)
252     forward = NULL;
253   else if (forward || (forward = lookup_frec_by_sender(ntohs(header->id), udpaddr, crc)))
254     {
255       /* retry on existing query, send to all available servers  */
256       domain = forward->sentto->domain;
257       forward->sentto->failed_queries++;
258       if (!option_bool(OPT_ORDER))
259         {
260           forward->forwardall = 1;
261           daemon->last_server = NULL;
262         }
263       type = forward->sentto->flags & SERV_TYPE;
264       if (!(start = forward->sentto->next))
265         start = daemon->servers; /* at end of list, recycle */
266       header->id = htons(forward->new_id);
267     }
268   else 
269     {
270       if (gotname)
271         flags = search_servers(now, &addrp, gotname, daemon->namebuff, &type, &domain, &norebind);
272       
273       if (!flags && !(forward = get_new_frec(now, NULL)))
274         /* table full - server failure. */
275         flags = F_NEG;
276       
277       if (forward)
278         {
279           forward->source = *udpaddr;
280           forward->dest = *dst_addr;
281           forward->iface = dst_iface;
282           forward->orig_id = ntohs(header->id);
283           forward->new_id = get_id(crc);
284           forward->fd = udpfd;
285           forward->crc = crc;
286           forward->forwardall = 0;
287           if (norebind)
288             forward->flags |= FREC_NOREBIND;
289           if (header->hb4 & HB4_CD)
290             forward->flags |= FREC_CHECKING_DISABLED;
291
292           header->id = htons(forward->new_id);
293           
294           /* In strict_order mode, always try servers in the order 
295              specified in resolv.conf, if a domain is given 
296              always try all the available servers,
297              otherwise, use the one last known to work. */
298           
299           if (type == 0)
300             {
301               if (option_bool(OPT_ORDER))
302                 start = daemon->servers;
303               else if (!(start = daemon->last_server) ||
304                        daemon->forwardcount++ > FORWARD_TEST ||
305                        difftime(now, daemon->forwardtime) > FORWARD_TIME)
306                 {
307                   start = daemon->servers;
308                   forward->forwardall = 1;
309                   daemon->forwardcount = 0;
310                   daemon->forwardtime = now;
311                 }
312             }
313           else
314             {
315               start = daemon->servers;
316               if (!option_bool(OPT_ORDER))
317                 forward->forwardall = 1;
318             }
319         }
320     }
321
322   /* check for send errors here (no route to host) 
323      if we fail to send to all nameservers, send back an error
324      packet straight away (helps modem users when offline)  */
325   
326   if (!flags && forward)
327     {
328       struct server *firstsentto = start;
329       int forwarded = 0;
330       
331       if (udpaddr && option_bool(OPT_ADD_MAC))
332         plen = add_mac(header, plen, ((char *) header) + PACKETSZ, udpaddr);
333       
334       while (1)
335         { 
336           /* only send to servers dealing with our domain.
337              domain may be NULL, in which case server->domain 
338              must be NULL also. */
339           
340           if (type == (start->flags & SERV_TYPE) &&
341               (type != SERV_HAS_DOMAIN || hostname_isequal(domain, start->domain)) &&
342               !(start->flags & SERV_LITERAL_ADDRESS))
343             {
344               int fd;
345
346               /* find server socket to use, may need to get random one. */
347               if (start->sfd)
348                 fd = start->sfd->fd;
349               else 
350                 {
351 #ifdef HAVE_IPV6
352                   if (start->addr.sa.sa_family == AF_INET6)
353                     {
354                       if (!forward->rfd6 &&
355                           !(forward->rfd6 = allocate_rfd(AF_INET6)))
356                         break;
357                       daemon->rfd_save = forward->rfd6;
358                       fd = forward->rfd6->fd;
359                     }
360                   else
361 #endif
362                     {
363                       if (!forward->rfd4 &&
364                           !(forward->rfd4 = allocate_rfd(AF_INET)))
365                         break;
366                       daemon->rfd_save = forward->rfd4;
367                       fd = forward->rfd4->fd;
368                     }
369                 }
370               
371               if (sendto(fd, (char *)header, plen, 0,
372                          &start->addr.sa,
373                          sa_len(&start->addr)) == -1)
374                 {
375                   if (retry_send())
376                     continue;
377                 }
378               else
379                 {
380                   /* Keep info in case we want to re-send this packet */
381                   daemon->srv_save = start;
382                   daemon->packet_len = plen;
383                   
384                   if (!gotname)
385                     strcpy(daemon->namebuff, "query");
386                   if (start->addr.sa.sa_family == AF_INET)
387                     log_query(F_SERVER | F_IPV4 | F_FORWARD, daemon->namebuff, 
388                               (struct all_addr *)&start->addr.in.sin_addr, NULL); 
389 #ifdef HAVE_IPV6
390                   else
391                     log_query(F_SERVER | F_IPV6 | F_FORWARD, daemon->namebuff, 
392                               (struct all_addr *)&start->addr.in6.sin6_addr, NULL);
393 #endif 
394                   start->queries++;
395                   forwarded = 1;
396                   forward->sentto = start;
397                   if (!forward->forwardall) 
398                     break;
399                   forward->forwardall++;
400                 }
401             } 
402           
403           if (!(start = start->next))
404             start = daemon->servers;
405           
406           if (start == firstsentto)
407             break;
408         }
409       
410       if (forwarded)
411         return 1;
412       
413       /* could not send on, prepare to return */ 
414       header->id = htons(forward->orig_id);
415       free_frec(forward); /* cancel */
416     }     
417   
418   /* could not send on, return empty answer or address if known for whole domain */
419   if (udpfd != -1)
420     {
421       plen = setup_reply(header, plen, addrp, flags, daemon->local_ttl);
422       send_from(udpfd, option_bool(OPT_NOWILD), (char *)header, plen, udpaddr, dst_addr, dst_iface);
423     }
424
425   return 0;
426 }
427
428 static size_t process_reply(struct dns_header *header, time_t now, 
429                             struct server *server, size_t n, int check_rebind, int checking_disabled)
430 {
431   unsigned char *pheader, *sizep;
432   int munged = 0, is_sign;
433   size_t plen; 
434
435   /* If upstream is advertising a larger UDP packet size
436      than we allow, trim it so that we don't get overlarge
437      requests for the client. We can't do this for signed packets. */
438
439   if ((pheader = find_pseudoheader(header, n, &plen, &sizep, &is_sign)) && !is_sign)
440     {
441       unsigned short udpsz;
442       unsigned char *psave = sizep;
443       
444       GETSHORT(udpsz, sizep);
445       if (udpsz > daemon->edns_pktsz)
446         PUTSHORT(daemon->edns_pktsz, psave);
447     }
448
449   /* RFC 4035 sect 4.6 para 3 */
450   if (!is_sign && !option_bool(OPT_DNSSEC))
451      header->hb4 &= ~HB4_AD;
452
453   if (OPCODE(header) != QUERY || (RCODE(header) != NOERROR && RCODE(header) != NXDOMAIN))
454     return n;
455   
456   /* Complain loudly if the upstream server is non-recursive. */
457   if (!(header->hb4 & HB4_RA) && RCODE(header) == NOERROR && ntohs(header->ancount) == 0 &&
458       server && !(server->flags & SERV_WARNED_RECURSIVE))
459     {
460       prettyprint_addr(&server->addr, daemon->namebuff);
461       my_syslog(LOG_WARNING, _("nameserver %s refused to do a recursive query"), daemon->namebuff);
462       if (!option_bool(OPT_LOG))
463         server->flags |= SERV_WARNED_RECURSIVE;
464     }  
465     
466   if (daemon->bogus_addr && RCODE(header) != NXDOMAIN &&
467       check_for_bogus_wildcard(header, n, daemon->namebuff, daemon->bogus_addr, now))
468     {
469       munged = 1;
470       SET_RCODE(header, NXDOMAIN);
471       header->hb3 &= ~HB3_AA;
472     }
473   else 
474     {
475       if (RCODE(header) == NXDOMAIN && 
476           extract_request(header, n, daemon->namebuff, NULL) &&
477           check_for_local_domain(daemon->namebuff, now))
478         {
479           /* if we forwarded a query for a locally known name (because it was for 
480              an unknown type) and the answer is NXDOMAIN, convert that to NODATA,
481              since we know that the domain exists, even if upstream doesn't */
482           munged = 1;
483           header->hb3 |= HB3_AA;
484           SET_RCODE(header, NOERROR);
485         }
486       
487       if (extract_addresses(header, n, daemon->namebuff, now, is_sign, check_rebind, checking_disabled))
488         {
489           my_syslog(LOG_WARNING, _("possible DNS-rebind attack detected: %s"), daemon->namebuff);
490           munged = 1;
491         }
492     }
493   
494   /* do this after extract_addresses. Ensure NODATA reply and remove
495      nameserver info. */
496   
497   if (munged)
498     {
499       header->ancount = htons(0);
500       header->nscount = htons(0);
501       header->arcount = htons(0);
502     }
503   
504   /* the bogus-nxdomain stuff, doctor and NXDOMAIN->NODATA munging can all elide
505      sections of the packet. Find the new length here and put back pseudoheader
506      if it was removed. */
507   return resize_packet(header, n, pheader, plen);
508 }
509
510 /* sets new last_server */
511 void reply_query(int fd, int family, time_t now)
512 {
513   /* packet from peer server, extract data for cache, and send to
514      original requester */
515   struct dns_header *header;
516   union mysockaddr serveraddr;
517   struct frec *forward;
518   socklen_t addrlen = sizeof(serveraddr);
519   ssize_t n = recvfrom(fd, daemon->packet, daemon->edns_pktsz, 0, &serveraddr.sa, &addrlen);
520   size_t nn;
521   struct server *server;
522   
523   /* packet buffer overwritten */
524   daemon->srv_save = NULL;
525   
526   /* Determine the address of the server replying  so that we can mark that as good */
527   serveraddr.sa.sa_family = family;
528 #ifdef HAVE_IPV6
529   if (serveraddr.sa.sa_family == AF_INET6)
530     serveraddr.in6.sin6_flowinfo = 0;
531 #endif
532   
533   /* spoof check: answer must come from known server, */
534   for (server = daemon->servers; server; server = server->next)
535     if (!(server->flags & (SERV_LITERAL_ADDRESS | SERV_NO_ADDR)) &&
536         sockaddr_isequal(&server->addr, &serveraddr))
537       break;
538    
539   header = (struct dns_header *)daemon->packet;
540   
541   if (!server ||
542       n < (int)sizeof(struct dns_header) || !(header->hb3 & HB3_QR) ||
543       !(forward = lookup_frec(ntohs(header->id), questions_crc(header, n, daemon->namebuff))))
544     return;
545    
546   server = forward->sentto;
547   
548   if ((RCODE(header) == SERVFAIL || RCODE(header) == REFUSED) &&
549       !option_bool(OPT_ORDER) &&
550       forward->forwardall == 0)
551     /* for broken servers, attempt to send to another one. */
552     {
553       unsigned char *pheader;
554       size_t plen;
555       int is_sign;
556       
557       /* recreate query from reply */
558       pheader = find_pseudoheader(header, (size_t)n, &plen, NULL, &is_sign);
559       if (!is_sign)
560         {
561           header->ancount = htons(0);
562           header->nscount = htons(0);
563           header->arcount = htons(0);
564           if ((nn = resize_packet(header, (size_t)n, pheader, plen)))
565             {
566               header->hb3 &= ~(HB3_QR | HB3_TC);
567               forward_query(-1, NULL, NULL, 0, header, nn, now, forward);
568               return;
569             }
570         }
571     }   
572   
573   if ((forward->sentto->flags & SERV_TYPE) == 0)
574     {
575       if (RCODE(header) == SERVFAIL || RCODE(header) == REFUSED)
576         server = NULL;
577       else
578         {
579           struct server *last_server;
580           
581           /* find good server by address if possible, otherwise assume the last one we sent to */ 
582           for (last_server = daemon->servers; last_server; last_server = last_server->next)
583             if (!(last_server->flags & (SERV_LITERAL_ADDRESS | SERV_HAS_DOMAIN | SERV_FOR_NODOTS | SERV_NO_ADDR)) &&
584                 sockaddr_isequal(&last_server->addr, &serveraddr))
585               {
586                 server = last_server;
587                 break;
588               }
589         } 
590       if (!option_bool(OPT_ALL_SERVERS))
591         daemon->last_server = server;
592     }
593   
594   /* If the answer is an error, keep the forward record in place in case
595      we get a good reply from another server. Kill it when we've
596      had replies from all to avoid filling the forwarding table when
597      everything is broken */
598   if (forward->forwardall == 0 || --forward->forwardall == 1 || 
599       (RCODE(header) != REFUSED && RCODE(header) != SERVFAIL))
600     {
601       int check_rebind = !(forward->flags & FREC_NOREBIND);
602
603       if (!option_bool(OPT_NO_REBIND))
604         check_rebind = 0;
605       
606       if ((nn = process_reply(header, now, server, (size_t)n, check_rebind, forward->flags & FREC_CHECKING_DISABLED)))
607         {
608           header->id = htons(forward->orig_id);
609           header->hb4 |= HB4_RA; /* recursion if available */
610           send_from(forward->fd, option_bool(OPT_NOWILD), daemon->packet, nn, 
611                     &forward->source, &forward->dest, forward->iface);
612         }
613       free_frec(forward); /* cancel */
614     }
615 }
616
617
618 void receive_query(struct listener *listen, time_t now)
619 {
620   struct dns_header *header = (struct dns_header *)daemon->packet;
621   union mysockaddr source_addr;
622   unsigned short type;
623   struct all_addr dst_addr;
624   struct in_addr netmask, dst_addr_4;
625   size_t m;
626   ssize_t n;
627   int if_index = 0;
628   struct iovec iov[1];
629   struct msghdr msg;
630   struct cmsghdr *cmptr;
631   union {
632     struct cmsghdr align; /* this ensures alignment */
633 #ifdef HAVE_IPV6
634     char control6[CMSG_SPACE(sizeof(struct in6_pktinfo))];
635 #endif
636 #if defined(HAVE_LINUX_NETWORK)
637     char control[CMSG_SPACE(sizeof(struct in_pktinfo))];
638 #elif defined(IP_RECVDSTADDR) && defined(HAVE_SOLARIS_NETWORK)
639     char control[CMSG_SPACE(sizeof(struct in_addr)) +
640                  CMSG_SPACE(sizeof(unsigned int))];
641 #elif defined(IP_RECVDSTADDR)
642     char control[CMSG_SPACE(sizeof(struct in_addr)) +
643                  CMSG_SPACE(sizeof(struct sockaddr_dl))];
644 #endif
645   } control_u;
646   
647   /* packet buffer overwritten */
648   daemon->srv_save = NULL;
649   
650   if (listen->family == AF_INET && option_bool(OPT_NOWILD))
651     {
652       dst_addr_4 = listen->iface->addr.in.sin_addr;
653       netmask = listen->iface->netmask;
654     }
655   else
656     {
657       dst_addr_4.s_addr = 0;
658       netmask.s_addr = 0;
659     }
660
661   iov[0].iov_base = daemon->packet;
662   iov[0].iov_len = daemon->edns_pktsz;
663     
664   msg.msg_control = control_u.control;
665   msg.msg_controllen = sizeof(control_u);
666   msg.msg_flags = 0;
667   msg.msg_name = &source_addr;
668   msg.msg_namelen = sizeof(source_addr);
669   msg.msg_iov = iov;
670   msg.msg_iovlen = 1;
671   
672   if ((n = recvmsg(listen->fd, &msg, 0)) == -1)
673     return;
674   
675   if (n < (int)sizeof(struct dns_header) || 
676       (msg.msg_flags & MSG_TRUNC) ||
677       (header->hb3 & HB3_QR))
678     return;
679   
680   source_addr.sa.sa_family = listen->family;
681 #ifdef HAVE_IPV6
682   if (listen->family == AF_INET6)
683     source_addr.in6.sin6_flowinfo = 0;
684 #endif
685
686   if (!option_bool(OPT_NOWILD))
687     {
688       struct ifreq ifr;
689
690       if (msg.msg_controllen < sizeof(struct cmsghdr))
691         return;
692
693 #if defined(HAVE_LINUX_NETWORK)
694       if (listen->family == AF_INET)
695         for (cmptr = CMSG_FIRSTHDR(&msg); cmptr; cmptr = CMSG_NXTHDR(&msg, cmptr))
696           if (cmptr->cmsg_level == SOL_IP && cmptr->cmsg_type == IP_PKTINFO)
697             {
698               union {
699                 unsigned char *c;
700                 struct in_pktinfo *p;
701               } p;
702               p.c = CMSG_DATA(cmptr);
703               dst_addr_4 = dst_addr.addr.addr4 = p.p->ipi_spec_dst;
704               if_index = p.p->ipi_ifindex;
705             }
706 #elif defined(IP_RECVDSTADDR) && defined(IP_RECVIF)
707       if (listen->family == AF_INET)
708         {
709           for (cmptr = CMSG_FIRSTHDR(&msg); cmptr; cmptr = CMSG_NXTHDR(&msg, cmptr))
710             {
711               union {
712                 unsigned char *c;
713                 unsigned int *i;
714                 struct in_addr *a;
715 #ifndef HAVE_SOLARIS_NETWORK
716                 struct sockaddr_dl *s;
717 #endif
718               } p;
719                p.c = CMSG_DATA(cmptr);
720                if (cmptr->cmsg_level == IPPROTO_IP && cmptr->cmsg_type == IP_RECVDSTADDR)
721                  dst_addr_4 = dst_addr.addr.addr4 = *(p.a);
722                else if (cmptr->cmsg_level == IPPROTO_IP && cmptr->cmsg_type == IP_RECVIF)
723 #ifdef HAVE_SOLARIS_NETWORK
724                  if_index = *(p.i);
725 #else
726                  if_index = p.s->sdl_index;
727 #endif
728             }
729         }
730 #endif
731       
732 #ifdef HAVE_IPV6
733       if (listen->family == AF_INET6)
734         {
735           for (cmptr = CMSG_FIRSTHDR(&msg); cmptr; cmptr = CMSG_NXTHDR(&msg, cmptr))
736             if (cmptr->cmsg_level == IPV6_LEVEL && cmptr->cmsg_type == daemon->v6pktinfo)
737               {
738                 union {
739                   unsigned char *c;
740                   struct in6_pktinfo *p;
741                 } p;
742                 p.c = CMSG_DATA(cmptr);
743                   
744                 dst_addr.addr.addr6 = p.p->ipi6_addr;
745                 if_index = p.p->ipi6_ifindex;
746               }
747         }
748 #endif
749       
750       /* enforce available interface configuration */
751       
752       if (!indextoname(listen->fd, if_index, ifr.ifr_name) ||
753           !iface_check(listen->family, &dst_addr, ifr.ifr_name, &if_index))
754         return;
755       
756       if (listen->family == AF_INET &&
757           option_bool(OPT_LOCALISE) &&
758           ioctl(listen->fd, SIOCGIFNETMASK, &ifr) == -1)
759         return;
760       
761       netmask = ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr;
762     }
763   
764   if (extract_request(header, (size_t)n, daemon->namebuff, &type))
765     {
766       char types[20];
767
768       querystr(types, type);
769
770       if (listen->family == AF_INET) 
771         log_query(F_QUERY | F_IPV4 | F_FORWARD, daemon->namebuff, 
772                   (struct all_addr *)&source_addr.in.sin_addr, types);
773 #ifdef HAVE_IPV6
774       else
775         log_query(F_QUERY | F_IPV6 | F_FORWARD, daemon->namebuff, 
776                   (struct all_addr *)&source_addr.in6.sin6_addr, types);
777 #endif
778     }
779
780   m = answer_request (header, ((char *) header) + PACKETSZ, (size_t)n, 
781                       dst_addr_4, netmask, now);
782   if (m >= 1)
783     {
784       send_from(listen->fd, option_bool(OPT_NOWILD), (char *)header, 
785                 m, &source_addr, &dst_addr, if_index);
786       daemon->local_answer++;
787     }
788   else if (forward_query(listen->fd, &source_addr, &dst_addr, if_index,
789                          header, (size_t)n, now, NULL))
790     daemon->queries_forwarded++;
791   else
792     daemon->local_answer++;
793 }
794
795 /* The daemon forks before calling this: it should deal with one connection,
796    blocking as neccessary, and then return. Note, need to be a bit careful
797    about resources for debug mode, when the fork is suppressed: that's
798    done by the caller. */
799 unsigned char *tcp_request(int confd, time_t now,
800                            struct in_addr local_addr, struct in_addr netmask)
801 {
802   size_t size = 0;
803   int norebind = 0;
804   int checking_disabled;
805   size_t m;
806   unsigned short qtype, gotname;
807   unsigned char c1, c2;
808   /* Max TCP packet + slop */
809   unsigned char *packet = whine_malloc(65536 + MAXDNAME + RRFIXEDSZ);
810   struct dns_header *header;
811   struct server *last_server;
812   
813   while (1)
814     {
815       if (!packet ||
816           !read_write(confd, &c1, 1, 1) || !read_write(confd, &c2, 1, 1) ||
817           !(size = c1 << 8 | c2) ||
818           !read_write(confd, packet, size, 1))
819         return packet; 
820   
821       if (size < (int)sizeof(struct dns_header))
822         continue;
823       
824       header = (struct dns_header *)packet;
825
826       /* save state of "cd" flag in query */
827       checking_disabled = header->hb4 & HB4_CD;
828        
829       /* RFC 4035: sect 4.6 para 2 */
830       header->hb4 &= ~HB4_AD;
831       
832       if ((gotname = extract_request(header, (unsigned int)size, daemon->namebuff, &qtype)))
833         {
834           union mysockaddr peer_addr;
835           socklen_t peer_len = sizeof(union mysockaddr);
836           
837           if (getpeername(confd, (struct sockaddr *)&peer_addr, &peer_len) != -1)
838             {
839               char types[20];
840
841               querystr(types, qtype);
842
843               if (peer_addr.sa.sa_family == AF_INET) 
844                 log_query(F_QUERY | F_IPV4 | F_FORWARD, daemon->namebuff, 
845                           (struct all_addr *)&peer_addr.in.sin_addr, types);
846 #ifdef HAVE_IPV6
847               else
848                 log_query(F_QUERY | F_IPV6 | F_FORWARD, daemon->namebuff, 
849                           (struct all_addr *)&peer_addr.in6.sin6_addr, types);
850 #endif
851             }
852         }
853       
854       /* m > 0 if answered from cache */
855       m = answer_request(header, ((char *) header) + 65536, (unsigned int)size, 
856                          local_addr, netmask, now);
857
858       /* Do this by steam now we're not in the select() loop */
859       check_log_writer(NULL); 
860       
861       if (m == 0)
862         {
863           unsigned int flags = 0;
864           struct all_addr *addrp = NULL;
865           int type = 0;
866           char *domain = NULL;
867            
868           if (option_bool(OPT_ADD_MAC))
869             {
870               union mysockaddr peer_addr;
871               socklen_t peer_len = sizeof(union mysockaddr);
872               
873               if (getpeername(confd, (struct sockaddr *)&peer_addr, &peer_len) != -1)
874                 size = add_mac(header, size, ((char *) header) + 65536, &peer_addr);
875             }
876       
877           if (gotname)
878             flags = search_servers(now, &addrp, gotname, daemon->namebuff, &type, &domain, &norebind);
879           
880           if (type != 0  || option_bool(OPT_ORDER) || !daemon->last_server)
881             last_server = daemon->servers;
882           else
883             last_server = daemon->last_server;
884       
885           if (!flags && last_server)
886             {
887               struct server *firstsendto = NULL;
888               unsigned int crc = questions_crc(header, (unsigned int)size, daemon->namebuff);
889
890               /* Loop round available servers until we succeed in connecting to one.
891                  Note that this code subtley ensures that consecutive queries on this connection
892                  which can go to the same server, do so. */
893               while (1) 
894                 {
895                   if (!firstsendto)
896                     firstsendto = last_server;
897                   else
898                     {
899                       if (!(last_server = last_server->next))
900                         last_server = daemon->servers;
901                       
902                       if (last_server == firstsendto)
903                         break;
904                     }
905               
906                   /* server for wrong domain */
907                   if (type != (last_server->flags & SERV_TYPE) ||
908                       (type == SERV_HAS_DOMAIN && !hostname_isequal(domain, last_server->domain)))
909                     continue;
910                   
911                   if ((last_server->tcpfd == -1) &&
912                       (last_server->tcpfd = socket(last_server->addr.sa.sa_family, SOCK_STREAM, 0)) != -1 &&
913                       (!local_bind(last_server->tcpfd,  &last_server->source_addr, last_server->interface, 1) ||
914                        connect(last_server->tcpfd, &last_server->addr.sa, sa_len(&last_server->addr)) == -1))
915                     {
916                       close(last_server->tcpfd);
917                       last_server->tcpfd = -1;
918                     }
919                   
920                   if (last_server->tcpfd == -1) 
921                     continue;
922
923                   c1 = size >> 8;
924                   c2 = size;
925                   
926                   if (!read_write(last_server->tcpfd, &c1, 1, 0) ||
927                       !read_write(last_server->tcpfd, &c2, 1, 0) ||
928                       !read_write(last_server->tcpfd, packet, size, 0) ||
929                       !read_write(last_server->tcpfd, &c1, 1, 1) ||
930                       !read_write(last_server->tcpfd, &c2, 1, 1))
931                     {
932                       close(last_server->tcpfd);
933                       last_server->tcpfd = -1;
934                       continue;
935                     } 
936                   
937                   m = (c1 << 8) | c2;
938                   if (!read_write(last_server->tcpfd, packet, m, 1))
939                     return packet;
940                   
941                   if (!gotname)
942                     strcpy(daemon->namebuff, "query");
943                   if (last_server->addr.sa.sa_family == AF_INET)
944                     log_query(F_SERVER | F_IPV4 | F_FORWARD, daemon->namebuff, 
945                               (struct all_addr *)&last_server->addr.in.sin_addr, NULL); 
946 #ifdef HAVE_IPV6
947                   else
948                     log_query(F_SERVER | F_IPV6 | F_FORWARD, daemon->namebuff, 
949                               (struct all_addr *)&last_server->addr.in6.sin6_addr, NULL);
950 #endif 
951                   
952                   /* There's no point in updating the cache, since this process will exit and
953                      lose the information after a few queries. We make this call for the alias and 
954                      bogus-nxdomain side-effects. */
955                   /* If the crc of the question section doesn't match the crc we sent, then
956                      someone might be attempting to insert bogus values into the cache by 
957                      sending replies containing questions and bogus answers. */
958                   if (crc == questions_crc(header, (unsigned int)m, daemon->namebuff))
959                     m = process_reply(header, now, last_server, (unsigned int)m, 
960                                       option_bool(OPT_NO_REBIND) && !norebind, checking_disabled);
961                   
962                   break;
963                 }
964             }
965           
966           /* In case of local answer or no connections made. */
967           if (m == 0)
968             m = setup_reply(header, (unsigned int)size, addrp, flags, daemon->local_ttl);
969         }
970
971       check_log_writer(NULL);
972       
973       c1 = m>>8;
974       c2 = m;
975       if (!read_write(confd, &c1, 1, 0) ||
976           !read_write(confd, &c2, 1, 0) || 
977           !read_write(confd, packet, m, 0))
978         return packet;
979     }
980 }
981
982 static struct frec *allocate_frec(time_t now)
983 {
984   struct frec *f;
985   
986   if ((f = (struct frec *)whine_malloc(sizeof(struct frec))))
987     {
988       f->next = daemon->frec_list;
989       f->time = now;
990       f->sentto = NULL;
991       f->rfd4 = NULL;
992       f->flags = 0;
993 #ifdef HAVE_IPV6
994       f->rfd6 = NULL;
995 #endif
996       daemon->frec_list = f;
997     }
998
999   return f;
1000 }
1001
1002 static struct randfd *allocate_rfd(int family)
1003 {
1004   static int finger = 0;
1005   int i;
1006
1007   /* limit the number of sockets we have open to avoid starvation of 
1008      (eg) TFTP. Once we have a reasonable number, randomness should be OK */
1009
1010   for (i = 0; i < RANDOM_SOCKS; i++)
1011     if (daemon->randomsocks[i].refcount == 0)
1012       {
1013         if ((daemon->randomsocks[i].fd = random_sock(family)) == -1)
1014           break;
1015       
1016         daemon->randomsocks[i].refcount = 1;
1017         daemon->randomsocks[i].family = family;
1018         return &daemon->randomsocks[i];
1019       }
1020
1021   /* No free ones or cannot get new socket, grab an existing one */
1022   for (i = 0; i < RANDOM_SOCKS; i++)
1023     {
1024       int j = (i+finger) % RANDOM_SOCKS;
1025       if (daemon->randomsocks[j].refcount != 0 &&
1026           daemon->randomsocks[j].family == family && 
1027           daemon->randomsocks[j].refcount != 0xffff)
1028         {
1029           finger = j;
1030           daemon->randomsocks[j].refcount++;
1031           return &daemon->randomsocks[j];
1032         }
1033     }
1034
1035   return NULL; /* doom */
1036 }
1037
1038 static void free_frec(struct frec *f)
1039 {
1040   if (f->rfd4 && --(f->rfd4->refcount) == 0)
1041     close(f->rfd4->fd);
1042     
1043   f->rfd4 = NULL;
1044   f->sentto = NULL;
1045   f->flags = 0;
1046   
1047 #ifdef HAVE_IPV6
1048   if (f->rfd6 && --(f->rfd6->refcount) == 0)
1049     close(f->rfd6->fd);
1050     
1051   f->rfd6 = NULL;
1052 #endif
1053 }
1054
1055 /* if wait==NULL return a free or older than TIMEOUT record.
1056    else return *wait zero if one available, or *wait is delay to
1057    when the oldest in-use record will expire. Impose an absolute
1058    limit of 4*TIMEOUT before we wipe things (for random sockets) */
1059 struct frec *get_new_frec(time_t now, int *wait)
1060 {
1061   struct frec *f, *oldest, *target;
1062   int count;
1063   
1064   if (wait)
1065     *wait = 0;
1066
1067   for (f = daemon->frec_list, oldest = NULL, target =  NULL, count = 0; f; f = f->next, count++)
1068     if (!f->sentto)
1069       target = f;
1070     else 
1071       {
1072         if (difftime(now, f->time) >= 4*TIMEOUT)
1073           {
1074             free_frec(f);
1075             target = f;
1076           }
1077         
1078         if (!oldest || difftime(f->time, oldest->time) <= 0)
1079           oldest = f;
1080       }
1081
1082   if (target)
1083     {
1084       target->time = now;
1085       return target;
1086     }
1087   
1088   /* can't find empty one, use oldest if there is one
1089      and it's older than timeout */
1090   if (oldest && ((int)difftime(now, oldest->time)) >= TIMEOUT)
1091     { 
1092       /* keep stuff for twice timeout if we can by allocating a new
1093          record instead */
1094       if (difftime(now, oldest->time) < 2*TIMEOUT && 
1095           count <= daemon->ftabsize &&
1096           (f = allocate_frec(now)))
1097         return f;
1098
1099       if (!wait)
1100         {
1101           free_frec(oldest);
1102           oldest->time = now;
1103         }
1104       return oldest;
1105     }
1106   
1107   /* none available, calculate time 'till oldest record expires */
1108   if (count > daemon->ftabsize)
1109     {
1110       if (oldest && wait)
1111         *wait = oldest->time + (time_t)TIMEOUT - now;
1112       return NULL;
1113     }
1114   
1115   if (!(f = allocate_frec(now)) && wait)
1116     /* wait one second on malloc failure */
1117     *wait = 1;
1118
1119   return f; /* OK if malloc fails and this is NULL */
1120 }
1121  
1122 /* crc is all-ones if not known. */
1123 static struct frec *lookup_frec(unsigned short id, unsigned int crc)
1124 {
1125   struct frec *f;
1126
1127   for(f = daemon->frec_list; f; f = f->next)
1128     if (f->sentto && f->new_id == id && 
1129         (f->crc == crc || crc == 0xffffffff))
1130       return f;
1131       
1132   return NULL;
1133 }
1134
1135 static struct frec *lookup_frec_by_sender(unsigned short id,
1136                                           union mysockaddr *addr,
1137                                           unsigned int crc)
1138 {
1139   struct frec *f;
1140   
1141   for(f = daemon->frec_list; f; f = f->next)
1142     if (f->sentto &&
1143         f->orig_id == id && 
1144         f->crc == crc &&
1145         sockaddr_isequal(&f->source, addr))
1146       return f;
1147    
1148   return NULL;
1149 }
1150
1151 /* A server record is going away, remove references to it */
1152 void server_gone(struct server *server)
1153 {
1154   struct frec *f;
1155   
1156   for (f = daemon->frec_list; f; f = f->next)
1157     if (f->sentto && f->sentto == server)
1158       free_frec(f);
1159   
1160   if (daemon->last_server == server)
1161     daemon->last_server = NULL;
1162
1163   if (daemon->srv_save == server)
1164     daemon->srv_save = NULL;
1165 }
1166
1167 /* return unique random ids. */
1168 static unsigned short get_id(unsigned int crc)
1169 {
1170   unsigned short ret = 0;
1171   
1172   do 
1173     ret = rand16();
1174   while (lookup_frec(ret, crc));
1175   
1176   return ret;
1177 }
1178
1179
1180
1181
1182