/* dnsmasq is Copyright (c) 2000-2009 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, or
|
(at your option) version 3 dated 29 June, 2007.
|
|
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.
|
|
You should have received a copy of the GNU General Public License
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
*/
|
|
/* The SURF random number generator was taken from djbdns-1.05, by
|
Daniel J Bernstein, which is public domain. */
|
|
#include "dnsmasq.h"
|
|
#include <netdb.h>
|
|
#ifdef HAVE_BROKEN_RTC
|
#include <sys/times.h>
|
#endif
|
|
#ifdef LOCALEDIR
|
#include <idna.h>
|
#endif
|
|
#ifdef HAVE_ARC4RANDOM
|
void rand_init(void) {
|
return;
|
}
|
|
unsigned short rand16(void) {
|
return (unsigned short) (arc4random() >> 15);
|
}
|
|
#else
|
|
/* SURF random number generator */
|
|
typedef unsigned int uint32;
|
|
static uint32 seed[32];
|
static uint32 in[12];
|
static uint32 out[8];
|
|
void rand_init() {
|
int fd = open(RANDFILE, O_RDONLY);
|
|
if (fd == -1 || !read_write(fd, (unsigned char*) &seed, sizeof(seed), 1) ||
|
!read_write(fd, (unsigned char*) &in, sizeof(in), 1))
|
die(_("failed to seed the random number generator: %s"), NULL, EC_MISC);
|
|
close(fd);
|
}
|
|
#define ROTATE(x, b) (((x) << (b)) | ((x) >> (32 - (b))))
|
#define MUSH(i, b) x = t[i] += (((x ^ seed[i]) + sum) ^ ROTATE(x, b));
|
|
static void surf(void) {
|
uint32 t[12];
|
uint32 x;
|
uint32 sum = 0;
|
int r;
|
int i;
|
int loop;
|
|
for (i = 0; i < 12; ++i) t[i] = in[i] ^ seed[12 + i];
|
for (i = 0; i < 8; ++i) out[i] = seed[24 + i];
|
x = t[11];
|
for (loop = 0; loop < 2; ++loop) {
|
for (r = 0; r < 16; ++r) {
|
sum += 0x9e3779b9;
|
MUSH(0, 5)
|
MUSH(1, 7) MUSH(2, 9) MUSH(3, 13) MUSH(4, 5) MUSH(5, 7) MUSH(6, 9) MUSH(7, 13)
|
MUSH(8, 5) MUSH(9, 7) MUSH(10, 9) MUSH(11, 13)
|
}
|
for (i = 0; i < 8; ++i) out[i] ^= t[i + 4];
|
}
|
}
|
|
unsigned short rand16(void) {
|
static int outleft = 0;
|
|
if (!outleft) {
|
if (!++in[0])
|
if (!++in[1])
|
if (!++in[2]) ++in[3];
|
surf();
|
outleft = 8;
|
}
|
|
return (unsigned short) out[--outleft];
|
}
|
|
#endif
|
|
static int check_name(char* in) {
|
/* remove trailing .
|
also fail empty string and label > 63 chars */
|
size_t dotgap = 0, l = strlen(in);
|
char c;
|
int nowhite = 0;
|
|
if (l == 0 || l > MAXDNAME) return 0;
|
|
if (in[l - 1] == '.') {
|
if (l == 1) return 0;
|
in[l - 1] = 0;
|
}
|
|
for (; (c = *in); in++) {
|
if (c == '.')
|
dotgap = 0;
|
else if (++dotgap > MAXLABEL)
|
return 0;
|
else if (isascii(c) && iscntrl(c))
|
/* iscntrl only gives expected results for ascii */
|
return 0;
|
#ifndef LOCALEDIR
|
else if (!isascii(c))
|
return 0;
|
#endif
|
else if (c != ' ')
|
nowhite = 1;
|
}
|
|
if (!nowhite) return 0;
|
|
return 1;
|
}
|
|
/* Hostnames have a more limited valid charset than domain names
|
so check for legal char a-z A-Z 0-9 - _
|
Note that this may receive a FQDN, so only check the first label
|
for the tighter criteria. */
|
int legal_hostname(char* name) {
|
char c;
|
|
if (!check_name(name)) return 0;
|
|
for (; (c = *name); name++)
|
/* check for legal char a-z A-Z 0-9 - _ . */
|
{
|
if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') ||
|
c == '-' || c == '_')
|
continue;
|
|
/* end of hostname part */
|
if (c == '.') return 1;
|
|
return 0;
|
}
|
|
return 1;
|
}
|
|
char* canonicalise(char* in, int* nomem) {
|
char* ret = NULL;
|
#ifdef LOCALEDIR
|
int rc;
|
#endif
|
|
if (nomem) *nomem = 0;
|
|
if (!check_name(in)) return NULL;
|
|
#ifdef LOCALEDIR
|
if ((rc = idna_to_ascii_lz(in, &ret, 0)) != IDNA_SUCCESS) {
|
if (ret) free(ret);
|
|
if (nomem && (rc == IDNA_MALLOC_ERROR || rc == IDNA_DLOPEN_ERROR)) {
|
my_syslog(LOG_ERR, _("failed to allocate memory"));
|
*nomem = 1;
|
}
|
|
return NULL;
|
}
|
#else
|
if ((ret = whine_malloc(strlen(in) + 1)))
|
strcpy(ret, in);
|
else if (nomem)
|
*nomem = 1;
|
#endif
|
|
return ret;
|
}
|
|
unsigned char* do_rfc1035_name(unsigned char* p, char* sval) {
|
int j;
|
|
while (sval && *sval) {
|
unsigned char* cp = p++;
|
for (j = 0; *sval && (*sval != '.'); sval++, j++) *p++ = *sval;
|
*cp = j;
|
if (*sval) sval++;
|
}
|
return p;
|
}
|
|
/* for use during startup */
|
void* safe_malloc(size_t size) {
|
void* ret = malloc(size);
|
|
if (!ret) die(_("could not get memory"), NULL, EC_NOMEM);
|
|
return ret;
|
}
|
|
void safe_pipe(int* fd, int read_noblock) {
|
if (pipe(fd) == -1 || !fix_fd(fd[1]) || (read_noblock && !fix_fd(fd[0])))
|
die(_("cannot create pipe: %s"), NULL, EC_MISC);
|
}
|
|
void* whine_malloc(size_t size) {
|
void* ret = malloc(size);
|
|
if (!ret) my_syslog(LOG_ERR, _("failed to allocate %d bytes"), (int) size);
|
|
return ret;
|
}
|
|
int sockaddr_isequal(union mysockaddr* s1, union mysockaddr* s2) {
|
if (s1->sa.sa_family == s2->sa.sa_family) {
|
if (s1->sa.sa_family == AF_INET && s1->in.sin_port == s2->in.sin_port &&
|
s1->in.sin_addr.s_addr == s2->in.sin_addr.s_addr)
|
return 1;
|
#ifdef HAVE_IPV6
|
if (s1->sa.sa_family == AF_INET6 && s1->in6.sin6_port == s2->in6.sin6_port &&
|
IN6_ARE_ADDR_EQUAL(&s1->in6.sin6_addr, &s2->in6.sin6_addr) &&
|
(!IN6_IS_ADDR_LINKLOCAL(&s1->in6.sin6_addr) ||
|
(s1->in6.sin6_scope_id == s2->in6.sin6_scope_id)))
|
return 1;
|
#endif
|
}
|
return 0;
|
}
|
|
int sa_len(union mysockaddr* addr) {
|
if (addr->sa.sa_family == AF_INET6)
|
return sizeof(addr->in6);
|
else
|
return sizeof(addr->in);
|
}
|
|
/* don't use strcasecmp and friends here - they may be messed up by LOCALE */
|
int hostname_isequal(char* a, char* b) {
|
unsigned int c1, c2;
|
|
do {
|
c1 = (unsigned char) *a++;
|
c2 = (unsigned char) *b++;
|
|
if (c1 >= 'A' && c1 <= 'Z') c1 += 'a' - 'A';
|
if (c2 >= 'A' && c2 <= 'Z') c2 += 'a' - 'A';
|
|
if (c1 != c2) return 0;
|
} while (c1);
|
|
return 1;
|
}
|
|
time_t dnsmasq_time(void) {
|
#ifdef HAVE_BROKEN_RTC
|
struct tms dummy;
|
static long tps = 0;
|
|
if (tps == 0) tps = sysconf(_SC_CLK_TCK);
|
|
return (time_t)(times(&dummy) / tps);
|
#else
|
return time(NULL);
|
#endif
|
}
|
|
int is_same_net(struct in_addr a, struct in_addr b, struct in_addr mask) {
|
return (a.s_addr & mask.s_addr) == (b.s_addr & mask.s_addr);
|
}
|
|
int parse_addr(int family, const char* addrstr, union mysockaddr* addr) {
|
struct addrinfo *res, hints = {
|
.ai_flags = AI_NUMERICHOST,
|
.ai_family = family,
|
.ai_socktype = SOCK_DGRAM,
|
};
|
|
int ret = getaddrinfo(addrstr, NULL, &hints, &res);
|
if (ret) {
|
return ret;
|
}
|
|
switch (res->ai_family) {
|
case AF_INET:
|
addr->in = *((struct sockaddr_in*) res->ai_addr);
|
break;
|
#ifdef HAVE_IPV6
|
case AF_INET6:
|
addr->in6 = *((struct sockaddr_in6*) res->ai_addr);
|
break;
|
#endif
|
default:
|
errno = EAFNOSUPPORT;
|
ret = -1;
|
break;
|
}
|
freeaddrinfo(res);
|
return ret;
|
}
|
|
/* returns port number from address */
|
int prettyprint_addr(const union mysockaddr* addr, char* buf) {
|
int port = 0;
|
|
#ifdef HAVE_IPV6
|
char portstr[strlen("65535")];
|
getnameinfo((const struct sockaddr*) addr, sizeof(*addr), buf, ADDRSTRLEN, portstr,
|
sizeof(portstr), NI_NUMERICHOST | NI_NUMERICSERV);
|
port = atoi(portstr);
|
#else
|
strcpy(buf, inet_ntoa(addr->in.sin_addr));
|
port = ntohs(addr->in.sin_port);
|
#endif
|
|
return port;
|
}
|
|
void prettyprint_time(char* buf, unsigned int t) {
|
if (t == 0xffffffff)
|
sprintf(buf, _("infinite"));
|
else {
|
unsigned int x, p = 0;
|
if ((x = t / 86400)) p += sprintf(&buf[p], "%dd", x);
|
if ((x = (t / 3600) % 24)) p += sprintf(&buf[p], "%dh", x);
|
if ((x = (t / 60) % 60)) p += sprintf(&buf[p], "%dm", x);
|
if ((x = t % 60)) p += sprintf(&buf[p], "%ds", x);
|
}
|
}
|
|
/* in may equal out, when maxlen may be -1 (No max len). */
|
int parse_hex(char* in, unsigned char* out, int maxlen, unsigned int* wildcard_mask, int* mac_type) {
|
int mask = 0, i = 0;
|
char* r;
|
|
if (mac_type) *mac_type = 0;
|
|
while (maxlen == -1 || i < maxlen) {
|
for (r = in; *r != 0 && *r != ':' && *r != '-'; r++)
|
;
|
if (*r == 0) maxlen = i;
|
|
if (r != in) {
|
if (*r == '-' && i == 0 && mac_type) {
|
*r = 0;
|
*mac_type = strtol(in, NULL, 16);
|
mac_type = NULL;
|
} else {
|
*r = 0;
|
mask = mask << 1;
|
if (strcmp(in, "*") == 0)
|
mask |= 1;
|
else
|
out[i] = strtol(in, NULL, 16);
|
i++;
|
}
|
}
|
in = r + 1;
|
}
|
|
if (wildcard_mask) *wildcard_mask = mask;
|
|
return i;
|
}
|
|
/* return 0 for no match, or (no matched octets) + 1 */
|
int memcmp_masked(unsigned char* a, unsigned char* b, int len, unsigned int mask) {
|
int i, count;
|
for (count = 1, i = len - 1; i >= 0; i--, mask = mask >> 1)
|
if (!(mask & 1)) {
|
if (a[i] == b[i])
|
count++;
|
else
|
return 0;
|
}
|
return count;
|
}
|
|
/* _note_ may copy buffer */
|
int expand_buf(struct iovec* iov, size_t size) {
|
void* new;
|
|
if (size <= (size_t) iov->iov_len) return 1;
|
|
if (!(new = whine_malloc(size))) {
|
errno = ENOMEM;
|
return 0;
|
}
|
|
if (iov->iov_base) {
|
memcpy(new, iov->iov_base, iov->iov_len);
|
free(iov->iov_base);
|
}
|
|
iov->iov_base = new;
|
iov->iov_len = size;
|
|
return 1;
|
}
|
|
char* print_mac(char* buff, unsigned char* mac, int len) {
|
char* p = buff;
|
int i;
|
|
if (len == 0)
|
sprintf(p, "<null>");
|
else
|
for (i = 0; i < len; i++) p += sprintf(p, "%.2x%s", mac[i], (i == len - 1) ? "" : ":");
|
|
return buff;
|
}
|
|
void bump_maxfd(int fd, int* max) {
|
if (fd > *max) *max = fd;
|
}
|
|
int retry_send(void) {
|
struct timespec waiter;
|
if (errno == EAGAIN) {
|
waiter.tv_sec = 0;
|
waiter.tv_nsec = 10000;
|
nanosleep(&waiter, NULL);
|
return 1;
|
}
|
|
if (errno == EINTR) return 1;
|
|
return 0;
|
}
|
|
int read_write(int fd, unsigned char* packet, int size, int rw) {
|
ssize_t n, done;
|
|
for (done = 0; done < size; done += n) {
|
retry:
|
if (rw)
|
n = read(fd, &packet[done], (size_t)(size - done));
|
else
|
n = write(fd, &packet[done], (size_t)(size - done));
|
|
if (n == 0)
|
return 0;
|
else if (n == -1) {
|
if (retry_send() || errno == ENOMEM || errno == ENOBUFS)
|
goto retry;
|
else
|
return 0;
|
}
|
}
|
return 1;
|
}
|
