mirror of
https://github.com/pi-hole/dnsmasq.git
synced 2025-12-19 18:28:25 +00:00
import of dnsmasq-2.0.tar.gz
This commit is contained in:
Simon Kelley
625
src/network.c
Normal file
625
src/network.c
Normal file
@@ -0,0 +1,625 @@
|
||||
/* dnsmasq is Copyright (c) 2000 - 2003 Simon Kelley
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; version 2 dated June, 1991.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
*/
|
||||
|
||||
/* Author's email: simon@thekelleys.org.uk */
|
||||
|
||||
#include "dnsmasq.h"
|
||||
|
||||
static char *add_iface(struct irec **list, unsigned int flags,
|
||||
char *name, union mysockaddr *addr,
|
||||
struct iname *names, struct iname *addrs,
|
||||
struct iname *except)
|
||||
{
|
||||
struct irec *iface;
|
||||
int fd, opt;
|
||||
struct iname *tmp;
|
||||
|
||||
/* we may need to check the whitelist */
|
||||
if (names)
|
||||
{
|
||||
for (tmp = names; tmp; tmp = tmp->next)
|
||||
if (tmp->name && (strcmp(tmp->name, name) == 0))
|
||||
{
|
||||
tmp->found = 1;
|
||||
break;
|
||||
}
|
||||
if (!(flags & IFF_LOOPBACK) && !tmp)
|
||||
/* not on whitelist and not loopback */
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (addrs)
|
||||
{
|
||||
for (tmp = addrs; tmp; tmp = tmp->next)
|
||||
if (sockaddr_isequal(&tmp->addr, addr))
|
||||
{
|
||||
tmp->found = 1;
|
||||
break;
|
||||
}
|
||||
|
||||
if (!tmp)
|
||||
/* not on whitelist */
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* check blacklist */
|
||||
if (except)
|
||||
for (tmp = except; tmp; tmp = tmp->next)
|
||||
if (tmp->name && strcmp(tmp->name, name) == 0)
|
||||
return NULL;
|
||||
|
||||
/* check whether the interface IP has been added already
|
||||
it is possible to have multiple interfaces with the same address
|
||||
and we may be re-scanning. */
|
||||
for (iface = *list; iface; iface = iface->next)
|
||||
if (sockaddr_isequal(&iface->addr, addr))
|
||||
break;
|
||||
if (iface)
|
||||
{
|
||||
iface->valid = 1;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if ((fd = socket(addr->sa.sa_family, SOCK_DGRAM, 0)) == -1)
|
||||
return "failed to create socket: %s";
|
||||
|
||||
/* Set SO_REUSEADDR on the socket, this allows is to bind
|
||||
specific addresses even if BIND is running and has bound *:53 */
|
||||
opt = 1;
|
||||
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) == -1 ||
|
||||
bind(fd, &addr->sa, sa_len(addr)))
|
||||
{
|
||||
int errsave = errno;
|
||||
close(fd);
|
||||
errno = errsave;
|
||||
return "failed to bind socket: %s";
|
||||
}
|
||||
|
||||
/* If OK, add it to the head of the list */
|
||||
if (!(iface = malloc(sizeof(struct irec))))
|
||||
{
|
||||
close(fd);
|
||||
return "cannot allocate interface";
|
||||
}
|
||||
|
||||
iface->fd = fd;
|
||||
iface->addr = *addr;
|
||||
iface->next = *list;
|
||||
iface->valid = 1;
|
||||
*list = iface;
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* get all interfaces in system and for each one allowed add it to the chain
|
||||
at interfacep. May be called more that once: interfaces which still exist
|
||||
are left on the chain, those which have gone have sockets close()ed an are
|
||||
unlinked. Return value is NULL if OK, an error string and the value of errno
|
||||
on error. */
|
||||
char *enumerate_interfaces(struct irec **interfacep,
|
||||
struct iname *names,
|
||||
struct iname *addrs,
|
||||
struct iname *except,
|
||||
struct dhcp_context *dhcp,
|
||||
int port)
|
||||
{
|
||||
/* this code is adapted from Stevens, page 434. It finally
|
||||
destroyed my faith in the C/unix API */
|
||||
int len = 100 * sizeof(struct ifreq);
|
||||
int errsave, lastlen = 0;
|
||||
struct irec *iface, *prev;
|
||||
char *buf, *ptr, *err = NULL;
|
||||
struct ifconf ifc;
|
||||
int fd = socket(PF_INET, SOCK_DGRAM, 0);
|
||||
int rawfd = -1;
|
||||
|
||||
if (fd == -1)
|
||||
return "cannot create socket to enumerate interfaces: %s";
|
||||
|
||||
/* make all interfaces as old. Any left that way after the scan are reaped. */
|
||||
for (iface = *interfacep; iface; iface = iface->next)
|
||||
iface->valid = 0;
|
||||
|
||||
while (1)
|
||||
{
|
||||
if (!(buf = malloc(len)))
|
||||
{
|
||||
err = "cannot allocate buffer";
|
||||
goto end;
|
||||
}
|
||||
ifc.ifc_len = len;
|
||||
ifc.ifc_buf = buf;
|
||||
if (ioctl(fd, SIOCGIFCONF, &ifc) < 0)
|
||||
{
|
||||
if (errno != EINVAL || lastlen != 0)
|
||||
{
|
||||
err = "ioctl error while enumerating interfaces: %s";
|
||||
goto end;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (ifc.ifc_len == lastlen)
|
||||
break; /* got a big enough buffer now */
|
||||
lastlen = ifc.ifc_len;
|
||||
}
|
||||
len += 10*sizeof(struct ifreq);
|
||||
free(buf);
|
||||
}
|
||||
|
||||
for (ptr = buf; ptr < buf + ifc.ifc_len; )
|
||||
{
|
||||
struct ifreq *ifr = (struct ifreq *) ptr;
|
||||
union mysockaddr addr;
|
||||
|
||||
#ifdef HAVE_SOCKADDR_SA_LEN
|
||||
ptr += ifr->ifr_addr.sa_len + IF_NAMESIZE;
|
||||
#else
|
||||
ptr += sizeof(struct ifreq);
|
||||
#endif
|
||||
|
||||
/* copy address since getting flags overwrites */
|
||||
if (ifr->ifr_addr.sa_family == AF_INET)
|
||||
{
|
||||
addr.in = *((struct sockaddr_in *) &ifr->ifr_addr);
|
||||
addr.in.sin_port = htons(port);
|
||||
}
|
||||
#ifdef HAVE_IPV6
|
||||
else if (ifr->ifr_addr.sa_family == AF_INET6)
|
||||
{
|
||||
#ifdef HAVE_BROKEN_SOCKADDR_IN6
|
||||
addr.in6 = *((struct my_sockaddr_in6 *) &ifr->ifr_addr);
|
||||
#else
|
||||
addr.in6 = *((struct sockaddr_in6 *) &ifr->ifr_addr);
|
||||
#endif
|
||||
addr.in6.sin6_port = htons(port);
|
||||
addr.in6.sin6_flowinfo = htonl(0);
|
||||
}
|
||||
#endif
|
||||
else
|
||||
continue; /* unknown address family */
|
||||
|
||||
if (ioctl(fd, SIOCGIFFLAGS, ifr) < 0)
|
||||
{
|
||||
err = "ioctl error getting interface flags: %m";
|
||||
goto end;
|
||||
}
|
||||
|
||||
if ((err = add_iface(interfacep, ifr->ifr_flags, ifr->ifr_name,
|
||||
&addr, names, addrs, except)))
|
||||
goto end;
|
||||
|
||||
/* dhcp is non-null only on the first call: set up the relevant
|
||||
interface-related DHCP stuff here. DHCP is IPv4 only.
|
||||
Because errors here are ultimately fatal we can return directly and not bother
|
||||
closing the descriptor.
|
||||
*/
|
||||
if (dhcp && addr.sa.sa_family == AF_INET &&
|
||||
!(ifr->ifr_flags & (IFF_LOOPBACK | IFF_POINTOPOINT)))
|
||||
{
|
||||
struct in_addr netmask, broadcast;
|
||||
struct dhcp_context *context;
|
||||
int opt = 1;
|
||||
|
||||
if (ioctl(fd, SIOCGIFNETMASK, ifr) < 0)
|
||||
return "ioctl error getting interface netmask: %s";
|
||||
|
||||
netmask = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr;
|
||||
|
||||
if (ioctl(fd, SIOCGIFBRDADDR, ifr) < 0)
|
||||
return "ioctl error getting interface broadcast address: %s";
|
||||
|
||||
broadcast = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr;
|
||||
|
||||
for (context = dhcp; context; context = context->next)
|
||||
if (!context->iface && /* may be more than one iface with same addr */
|
||||
((addr.in.sin_addr.s_addr & netmask.s_addr) == (context->start.s_addr & netmask.s_addr)) &&
|
||||
((addr.in.sin_addr.s_addr & netmask.s_addr) == (context->end.s_addr & netmask.s_addr)))
|
||||
{
|
||||
struct sockaddr_in saddr;
|
||||
#ifdef HAVE_BPF
|
||||
char filename[50];
|
||||
int b = 0;
|
||||
|
||||
while (1)
|
||||
{
|
||||
sprintf(filename, "/dev/bpf%d", b);
|
||||
if ((rawfd = open(filename, O_RDWR, 0)) == -1)
|
||||
{
|
||||
if (errno != EBUSY)
|
||||
return"Cannot create DHCP BPF socket: %s";
|
||||
b++;
|
||||
}
|
||||
else if (ioctl(rawfd, BIOCSETIF, ifr) < 0)
|
||||
return "Can't attach interface to BPF device: %s";
|
||||
else
|
||||
break;
|
||||
}
|
||||
|
||||
if (context->next)
|
||||
return "no support for DHCP on multiple networks under this OS";
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PF_PACKET
|
||||
if (rawfd == -1 && /* same packet socket for all interfaces */
|
||||
(rawfd = socket(PF_PACKET, SOCK_DGRAM, htons(ETHERTYPE_IP))) == -1)
|
||||
return "Cannot create DHCP packet socket: %s";
|
||||
|
||||
/* do this last so that the index is still in ifr for the
|
||||
call to setsockopt(SO_BINDTODEVICE) */
|
||||
if (ioctl(fd, SIOCGIFINDEX, ifr) < 0)
|
||||
return "ioctl error getting interface index: %m";
|
||||
context->ifindex = ifr->ifr_ifindex;
|
||||
#endif
|
||||
|
||||
context->rawfd = rawfd;
|
||||
context->serv_addr = addr.in.sin_addr;
|
||||
context->netmask = netmask;
|
||||
context->broadcast = broadcast;
|
||||
if (!(context->iface = malloc(strlen(ifr->ifr_name) + 1)))
|
||||
return "cannot allocate interface name";
|
||||
|
||||
strcpy(context->iface, ifr->ifr_name);
|
||||
saddr.sin_family = AF_INET;
|
||||
saddr.sin_port = htons(DHCP_SERVER_PORT);
|
||||
saddr.sin_addr.s_addr = INADDR_ANY;
|
||||
|
||||
if ((context->fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1)
|
||||
return "cannot create DHCP server socket: %s";
|
||||
|
||||
if (setsockopt(context->fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) == -1 ||
|
||||
#ifdef HAVE_PF_PACKET
|
||||
setsockopt(context->fd, SOL_SOCKET, SO_BINDTODEVICE, ifr, sizeof(*ifr)) == -1 ||
|
||||
#endif
|
||||
setsockopt(context->fd, SOL_SOCKET, SO_BROADCAST, &opt, sizeof(opt)) == -1)
|
||||
return "failed to set options on DHCP socket: %s";
|
||||
|
||||
if (bind(context->fd, (struct sockaddr *)&saddr, sizeof(struct sockaddr_in)))
|
||||
return "failed to bind DHCP server socket: %s";
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef HAVE_BPF
|
||||
/* now go through the interfaces again, looking for AF_LINK records
|
||||
to get hardware addresses from */
|
||||
for (ptr = buf; ptr < buf + ifc.ifc_len; )
|
||||
{
|
||||
struct ifreq *ifr = (struct ifreq *) ptr;
|
||||
struct dhcp_context *context;
|
||||
|
||||
#ifdef HAVE_SOCKADDR_SA_LEN
|
||||
ptr += ifr->ifr_addr.sa_len + IF_NAMESIZE;
|
||||
#else
|
||||
ptr += sizeof(struct ifreq);
|
||||
#endif
|
||||
if (ifr->ifr_addr.sa_family == AF_LINK)
|
||||
for (context = dhcp; context; context = context->next)
|
||||
if (context->iface && strcmp(context->iface, ifr->ifr_name) == 0)
|
||||
memcpy(context->hwaddr, LLADDR((struct sockaddr_dl *)&ifr->ifr_addr), ETHER_ADDR_LEN);
|
||||
}
|
||||
#endif
|
||||
|
||||
end:
|
||||
errsave = errno; /* since errno gets overwritten by close */
|
||||
if (buf)
|
||||
free(buf);
|
||||
close(fd);
|
||||
if (err)
|
||||
{
|
||||
errno = errsave;
|
||||
return err;
|
||||
}
|
||||
|
||||
#if defined(HAVE_LINUX_IPV6_PROC) && defined(HAVE_IPV6)
|
||||
/* IPv6 addresses don't seem to work with SIOCGIFCONF. Barf */
|
||||
/* This code snarfed from net-tools 1.60 and certainly linux specific, though
|
||||
it shouldn't break on other Unices, and their SIOGIFCONF might work. */
|
||||
{
|
||||
FILE *f = fopen(IP6INTERFACES, "r");
|
||||
|
||||
if (f)
|
||||
{
|
||||
union mysockaddr addr;
|
||||
unsigned int plen, scope, flags, if_idx;
|
||||
char devname[20], addrstring[32];
|
||||
|
||||
while (fscanf(f, "%32s %02x %02x %02x %02x %20s\n",
|
||||
addrstring, &if_idx, &plen, &scope, &flags, devname) != EOF)
|
||||
{
|
||||
int i;
|
||||
unsigned char *addr6p = (unsigned char *) &addr.in6.sin6_addr;
|
||||
memset(&addr, 0, sizeof(addr));
|
||||
addr.sa.sa_family = AF_INET6;
|
||||
for (i=0; i<16; i++)
|
||||
{
|
||||
unsigned int byte;
|
||||
sscanf(addrstring+i+i, "%02x", &byte);
|
||||
addr6p[i] = byte;
|
||||
}
|
||||
#ifdef HAVE_SOCKADDR_SA_LEN
|
||||
/* For completeness - should never be defined on Linux. */
|
||||
addr.in6.sin6_len = sizeof(struct sockaddr_in6);
|
||||
#endif
|
||||
addr.in6.sin6_port = htons(port);
|
||||
addr.in6.sin6_flowinfo = htonl(0);
|
||||
addr.in6.sin6_scope_id = htonl(scope);
|
||||
|
||||
if ((err = add_iface(interfacep, flags, devname, &addr, names, addrs, except)))
|
||||
{
|
||||
errsave = errno;
|
||||
fclose(f);
|
||||
errno = errsave;
|
||||
return err;
|
||||
}
|
||||
}
|
||||
|
||||
fclose(f);
|
||||
}
|
||||
}
|
||||
#endif /* LINUX */
|
||||
|
||||
/* now remove interfaces which were not found on this scan */
|
||||
for(prev = NULL, iface = *interfacep; iface; )
|
||||
{
|
||||
if (iface->valid)
|
||||
{
|
||||
prev = iface;
|
||||
iface = iface->next;
|
||||
}
|
||||
else
|
||||
{
|
||||
struct irec *tmp = iface;
|
||||
close(iface->fd);
|
||||
/* remove pending queries from this interface */
|
||||
reap_forward(iface->fd);
|
||||
/* unlink */
|
||||
if (prev)
|
||||
prev->next = iface->next;
|
||||
else
|
||||
*interfacep = iface->next;
|
||||
iface = iface->next;
|
||||
free(tmp);
|
||||
}
|
||||
}
|
||||
|
||||
return NULL; /* no error */
|
||||
}
|
||||
|
||||
static struct serverfd *allocate_sfd(union mysockaddr *addr, struct serverfd **sfds)
|
||||
{
|
||||
struct serverfd *sfd;
|
||||
|
||||
/* may have a suitable one already */
|
||||
for (sfd = *sfds; sfd; sfd = sfd->next )
|
||||
if (sockaddr_isequal(&sfd->source_addr, addr))
|
||||
return sfd;
|
||||
|
||||
/* need to make a new one. */
|
||||
errno = ENOMEM; /* in case malloc fails. */
|
||||
if (!(sfd = malloc(sizeof(struct serverfd))))
|
||||
return NULL;
|
||||
|
||||
if ((sfd->fd = socket(addr->sa.sa_family, SOCK_DGRAM, 0)) == -1)
|
||||
{
|
||||
free(sfd);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (bind(sfd->fd, (struct sockaddr *)addr, sa_len(addr)) == -1)
|
||||
{
|
||||
int errsave = errno; /* save error from bind. */
|
||||
close(sfd->fd);
|
||||
free(sfd);
|
||||
errno = errsave;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
sfd->source_addr = *addr;
|
||||
sfd->next = *sfds;
|
||||
*sfds = sfd;
|
||||
|
||||
return sfd;
|
||||
}
|
||||
|
||||
struct server *check_servers(struct server *new, struct irec *interfaces, struct serverfd **sfds)
|
||||
{
|
||||
char addrbuff[ADDRSTRLEN];
|
||||
struct irec *iface;
|
||||
struct server *tmp, *ret = NULL;
|
||||
int port = 0;
|
||||
|
||||
/* forward table rules reference servers, so have to blow them away */
|
||||
forward_init(0);
|
||||
|
||||
for (;new; new = tmp)
|
||||
{
|
||||
tmp = new->next;
|
||||
|
||||
if (!(new->flags & (SERV_LITERAL_ADDRESS | SERV_NO_ADDR)))
|
||||
{
|
||||
#ifdef HAVE_IPV6
|
||||
if (new->addr.sa.sa_family == AF_INET)
|
||||
{
|
||||
inet_ntop(AF_INET, &new->addr.in.sin_addr, addrbuff, ADDRSTRLEN);
|
||||
port = ntohs(new->addr.in.sin_port);
|
||||
}
|
||||
else if (new->addr.sa.sa_family == AF_INET6)
|
||||
{
|
||||
inet_ntop(AF_INET6, &new->addr.in6.sin6_addr, addrbuff, ADDRSTRLEN);
|
||||
port = ntohs(new->addr.in6.sin6_port);
|
||||
}
|
||||
#else
|
||||
strcpy(addrbuff, inet_ntoa(new->addr.in.sin_addr));
|
||||
port = ntohs(new->addr.in.sin_port);
|
||||
#endif
|
||||
for (iface = interfaces; iface; iface = iface->next)
|
||||
if (sockaddr_isequal(&new->addr, &iface->addr))
|
||||
break;
|
||||
if (iface)
|
||||
{
|
||||
syslog(LOG_WARNING, "ignoring nameserver %s - local interface", addrbuff);
|
||||
free(new);
|
||||
continue;
|
||||
}
|
||||
|
||||
/* Do we need a socket set? */
|
||||
if (!new->sfd && !(new->sfd = allocate_sfd(&new->source_addr, sfds)))
|
||||
{
|
||||
syslog(LOG_WARNING,
|
||||
"ignoring nameserver %s - cannot make/bind socket: %m", addrbuff);
|
||||
free(new);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
/* reverse order - gets it right. */
|
||||
new->next = ret;
|
||||
ret = new;
|
||||
|
||||
if (new->flags & (SERV_HAS_DOMAIN | SERV_FOR_NODOTS))
|
||||
{
|
||||
char *s1, *s2;
|
||||
if (new->flags & SERV_HAS_DOMAIN)
|
||||
s1 = "domain", s2 = new->domain;
|
||||
else
|
||||
s1 = "unqualified", s2 = "domains";
|
||||
|
||||
if (new->flags & SERV_NO_ADDR)
|
||||
syslog(LOG_INFO, "using local addresses only for %s %s", s1, s2);
|
||||
else if (!(new->flags & SERV_LITERAL_ADDRESS))
|
||||
syslog(LOG_INFO, "using nameserver %s#%d for %s %s", addrbuff, port, s1, s2);
|
||||
}
|
||||
else
|
||||
syslog(LOG_INFO, "using nameserver %s#%d", addrbuff, port);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
struct server *reload_servers(char *fname, char *buff, struct server *serv, int query_port)
|
||||
{
|
||||
FILE *f;
|
||||
char *line;
|
||||
struct server *old_servers = NULL;
|
||||
struct server *new_servers = NULL;
|
||||
|
||||
/* move old servers to free list - we can reuse the memory
|
||||
and not risk malloc if there are the same or fewer new servers.
|
||||
Servers which were specced on the command line go to the new list. */
|
||||
while (serv)
|
||||
{
|
||||
struct server *tmp = serv->next;
|
||||
if (serv->flags & SERV_FROM_RESOLV)
|
||||
{
|
||||
serv->next = old_servers;
|
||||
old_servers = serv;
|
||||
}
|
||||
else
|
||||
{
|
||||
serv->next = new_servers;
|
||||
new_servers = serv;
|
||||
}
|
||||
serv = tmp;
|
||||
}
|
||||
|
||||
/* buff happens to be NAXDNAME long... */
|
||||
f = fopen(fname, "r");
|
||||
if (!f)
|
||||
{
|
||||
syslog(LOG_ERR, "failed to read %s: %m", fname);
|
||||
}
|
||||
else
|
||||
{
|
||||
syslog(LOG_INFO, "reading %s", fname);
|
||||
while ((line = fgets(buff, MAXDNAME, f)))
|
||||
{
|
||||
union mysockaddr addr, source_addr;
|
||||
char *token = strtok(line, " \t\n\r");
|
||||
struct server *serv;
|
||||
|
||||
if (!token || strcmp(token, "nameserver") != 0)
|
||||
continue;
|
||||
if (!(token = strtok(NULL, " \t\n")))
|
||||
continue;
|
||||
|
||||
#ifdef HAVE_IPV6
|
||||
if (inet_pton(AF_INET, token, &addr.in.sin_addr))
|
||||
#else
|
||||
if ((addr.in.sin_addr.s_addr = inet_addr(token)) != (in_addr_t) -1)
|
||||
#endif
|
||||
{
|
||||
#ifdef HAVE_SOCKADDR_SA_LEN
|
||||
source_addr.in.sin_len = addr.in.sin_len = sizeof(struct sockaddr_in);
|
||||
#endif
|
||||
source_addr.in.sin_family = addr.in.sin_family = AF_INET;
|
||||
addr.in.sin_port = htons(NAMESERVER_PORT);
|
||||
source_addr.in.sin_addr.s_addr = INADDR_ANY;
|
||||
source_addr.in.sin_port = htons(query_port);
|
||||
}
|
||||
#ifdef HAVE_IPV6
|
||||
else if (inet_pton(AF_INET6, token, &addr.in6.sin6_addr))
|
||||
{
|
||||
#ifdef HAVE_SOCKADDR_SA_LEN
|
||||
source_addr.in6.sin6_len = addr.in6.sin6_len = sizeof(struct sockaddr_in6);
|
||||
#endif
|
||||
source_addr.in6.sin6_family = addr.in6.sin6_family = AF_INET6;
|
||||
addr.in6.sin6_port = htons(NAMESERVER_PORT);
|
||||
source_addr.in6.sin6_flowinfo = addr.in6.sin6_flowinfo = htonl(0);
|
||||
source_addr.in6.sin6_addr= in6addr_any;
|
||||
source_addr.in6.sin6_port = htons(query_port);
|
||||
}
|
||||
#endif /* IPV6 */
|
||||
else
|
||||
continue;
|
||||
|
||||
if (old_servers)
|
||||
{
|
||||
serv = old_servers;
|
||||
old_servers = old_servers->next;
|
||||
}
|
||||
else if (!(serv = malloc(sizeof (struct server))))
|
||||
continue;
|
||||
|
||||
/* this list is reverse ordered:
|
||||
it gets reversed again in check_servers */
|
||||
serv->next = new_servers;
|
||||
new_servers = serv;
|
||||
serv->addr = addr;
|
||||
serv->source_addr = source_addr;
|
||||
serv->domain = NULL;
|
||||
serv->sfd = NULL;
|
||||
serv->flags = SERV_FROM_RESOLV;
|
||||
}
|
||||
|
||||
fclose(f);
|
||||
}
|
||||
|
||||
/* Free any memory not used. */
|
||||
while(old_servers)
|
||||
{
|
||||
struct server *tmp = old_servers->next;
|
||||
free(old_servers);
|
||||
old_servers = tmp;
|
||||
}
|
||||
|
||||
return new_servers;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user