Return to loop.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / dnsmasq / src

Annotation of embedaddon/dnsmasq/src/loop.c, revision 1.1.1.1

1.1       misho       1: /* dnsmasq is Copyright (c) 2000-2016 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: #ifdef HAVE_LOOP
                     20: static ssize_t loop_make_probe(u32 uid);
                     21: 
                     22: void loop_send_probes()
                     23: {
                     24:    struct server *serv;
                     25:    
                     26:    if (!option_bool(OPT_LOOP_DETECT))
                     27:      return;
                     28: 
                     29:    /* Loop through all upstream servers not for particular domains, and send a query to that server which is
                     30:       identifiable, via the uid. If we see that query back again, then the server is looping, and we should not use it. */
                     31:    for (serv = daemon->servers; serv; serv = serv->next)
                     32:      if (!(serv->flags & 
                     33:           (SERV_LITERAL_ADDRESS | SERV_NO_ADDR | SERV_USE_RESOLV | SERV_NO_REBIND | SERV_HAS_DOMAIN | SERV_FOR_NODOTS | SERV_LOOP)))
                     34:        {
                     35:         ssize_t len = loop_make_probe(serv->uid);
                     36:         int fd;
                     37:         struct randfd *rfd = NULL;
                     38:         
                     39:         if (serv->sfd)
                     40:           fd = serv->sfd->fd;
                     41:         else 
                     42:           {
                     43:             if (!(rfd = allocate_rfd(serv->addr.sa.sa_family)))
                     44:               continue;
                     45:             fd = rfd->fd;
                     46:           }
                     47: 
                     48:         while (retry_send(sendto(fd, daemon->packet, len, 0, 
                     49:                                  &serv->addr.sa, sa_len(&serv->addr))));
                     50:         
                     51:         free_rfd(rfd);
                     52:        }
                     53: }
                     54:   
                     55: static ssize_t loop_make_probe(u32 uid)
                     56: {
                     57:   struct dns_header *header = (struct dns_header *)daemon->packet;
                     58:   unsigned char *p = (unsigned char *)(header+1);
                     59: 
                     60:   /* packet buffer overwritten */
                     61:   daemon->srv_save = NULL;
                     62:   
                     63:   header->id = rand16();
                     64:   header->ancount = header->nscount = header->arcount = htons(0);
                     65:   header->qdcount = htons(1);
                     66:   header->hb3 = HB3_RD;
                     67:   header->hb4 = 0;
                     68:   SET_OPCODE(header, QUERY);
                     69: 
                     70:   *p++ = 8;
                     71:   sprintf((char *)p, "%.8x", uid);
                     72:   p += 8;
                     73:   *p++ = strlen(LOOP_TEST_DOMAIN);
                     74:   strcpy((char *)p, LOOP_TEST_DOMAIN); /* Add terminating zero */
                     75:   p += strlen(LOOP_TEST_DOMAIN) + 1;
                     76: 
                     77:   PUTSHORT(LOOP_TEST_TYPE, p);
                     78:   PUTSHORT(C_IN, p);
                     79: 
                     80:   return p - (unsigned char *)header;
                     81: }
                     82:   
                     83: 
                     84: int detect_loop(char *query, int type)
                     85: {
                     86:   int i;
                     87:   u32 uid;
                     88:   struct server *serv;
                     89:   
                     90:   if (!option_bool(OPT_LOOP_DETECT))
                     91:     return 0;
                     92: 
                     93:   if (type != LOOP_TEST_TYPE ||
                     94:       strlen(LOOP_TEST_DOMAIN) + 9 != strlen(query) ||
                     95:       strstr(query, LOOP_TEST_DOMAIN) != query + 9)
                     96:     return 0;
                     97: 
                     98:   for (i = 0; i < 8; i++)
                     99:     if (!isxdigit(query[i]))
                    100:       return 0;
                    101: 
                    102:   uid = strtol(query, NULL, 16);
                    103: 
                    104:   for (serv = daemon->servers; serv; serv = serv->next)
                    105:      if (!(serv->flags & 
                    106:           (SERV_LITERAL_ADDRESS | SERV_NO_ADDR | SERV_USE_RESOLV | SERV_NO_REBIND | SERV_HAS_DOMAIN | SERV_FOR_NODOTS | SERV_LOOP)) &&
                    107:         uid == serv->uid)
                    108:        {
                    109:         serv->flags |= SERV_LOOP;
                    110:         check_servers(); /* log new state */
                    111:         return 1;
                    112:        }
                    113: 
                    114:   return 0;
                    115: }
                    116: 
                    117: #endif