#include "ares_dns.h"
#ifndef INADDR_NONE
-#define INADDR_NONE 0xffffffff
+#define INADDR_NONE 0xffffffff
#endif
/* Mac OS X portability check */
};
static const struct nv flags[] = {
- { "usevc", ARES_FLAG_USEVC },
- { "primary", ARES_FLAG_PRIMARY },
- { "igntc", ARES_FLAG_IGNTC },
- { "norecurse", ARES_FLAG_NORECURSE },
- { "stayopen", ARES_FLAG_STAYOPEN },
- { "noaliases", ARES_FLAG_NOALIASES }
+ { "usevc", ARES_FLAG_USEVC },
+ { "primary", ARES_FLAG_PRIMARY },
+ { "igntc", ARES_FLAG_IGNTC },
+ { "norecurse", ARES_FLAG_NORECURSE },
+ { "stayopen", ARES_FLAG_STAYOPEN },
+ { "noaliases", ARES_FLAG_NOALIASES }
};
static const int nflags = sizeof(flags) / sizeof(flags[0]);
static const struct nv classes[] = {
- { "IN", C_IN },
- { "CHAOS", C_CHAOS },
- { "HS", C_HS },
- { "ANY", C_ANY }
+ { "IN", C_IN },
+ { "CHAOS", C_CHAOS },
+ { "HS", C_HS },
+ { "ANY", C_ANY }
};
static const int nclasses = sizeof(classes) / sizeof(classes[0]);
static const struct nv types[] = {
- { "A", T_A },
- { "NS", T_NS },
- { "MD", T_MD },
- { "MF", T_MF },
- { "CNAME", T_CNAME },
- { "SOA", T_SOA },
- { "MB", T_MB },
- { "MG", T_MG },
- { "MR", T_MR },
- { "NULL", T_NULL },
- { "WKS", T_WKS },
- { "PTR", T_PTR },
- { "HINFO", T_HINFO },
- { "MINFO", T_MINFO },
- { "MX", T_MX },
- { "TXT", T_TXT },
- { "RP", T_RP },
- { "AFSDB", T_AFSDB },
- { "X25", T_X25 },
- { "ISDN", T_ISDN },
- { "RT", T_RT },
- { "NSAP", T_NSAP },
- { "NSAP_PTR", T_NSAP_PTR },
- { "SIG", T_SIG },
- { "KEY", T_KEY },
- { "PX", T_PX },
- { "GPOS", T_GPOS },
- { "AAAA", T_AAAA },
- { "LOC", T_LOC },
- { "SRV", T_SRV },
- { "AXFR", T_AXFR },
- { "MAILB", T_MAILB },
- { "MAILA", T_MAILA },
- { "ANY", T_ANY }
+ { "A", T_A },
+ { "NS", T_NS },
+ { "MD", T_MD },
+ { "MF", T_MF },
+ { "CNAME", T_CNAME },
+ { "SOA", T_SOA },
+ { "MB", T_MB },
+ { "MG", T_MG },
+ { "MR", T_MR },
+ { "NULL", T_NULL },
+ { "WKS", T_WKS },
+ { "PTR", T_PTR },
+ { "HINFO", T_HINFO },
+ { "MINFO", T_MINFO },
+ { "MX", T_MX },
+ { "TXT", T_TXT },
+ { "RP", T_RP },
+ { "AFSDB", T_AFSDB },
+ { "X25", T_X25 },
+ { "ISDN", T_ISDN },
+ { "RT", T_RT },
+ { "NSAP", T_NSAP },
+ { "NSAP_PTR", T_NSAP_PTR },
+ { "SIG", T_SIG },
+ { "KEY", T_KEY },
+ { "PX", T_PX },
+ { "GPOS", T_GPOS },
+ { "AAAA", T_AAAA },
+ { "LOC", T_LOC },
+ { "SRV", T_SRV },
+ { "AXFR", T_AXFR },
+ { "MAILB", T_MAILB },
+ { "MAILA", T_MAILA },
+ { "ANY", T_ANY }
};
static const int ntypes = sizeof(types) / sizeof(types[0]);
static void callback(void *arg, int status, unsigned char *abuf, int alen);
static const unsigned char *display_question(const unsigned char *aptr,
- const unsigned char *abuf,
- int alen);
+ const unsigned char *abuf,
+ int alen);
static const unsigned char *display_rr(const unsigned char *aptr,
- const unsigned char *abuf, int alen);
+ const unsigned char *abuf, int alen);
static const char *type_name(int type);
static const char *class_name(int dnsclass);
static void usage(void);
WORD wVersionRequested = MAKEWORD(1,1);
WSADATA wsaData;
WSAStartup(wVersionRequested, &wsaData);
-#endif
+#endif
options.flags = ARES_FLAG_NOCHECKRESP;
options.servers = NULL;
while ((c = getopt(argc, argv, "f:s:c:t:T:U:")) != -1)
{
switch (c)
- {
- case 'f':
- /* Add a flag. */
- for (i = 0; i < nflags; i++)
- {
- if (strcmp(flags[i].name, optarg) == 0)
- break;
- }
- if (i == nflags)
- usage();
- options.flags |= flags[i].value;
- break;
-
- case 's':
- /* Add a server, and specify servers in the option mask. */
- hostent = gethostbyname(optarg);
- if (!hostent || hostent->h_addrtype != AF_INET)
- {
- fprintf(stderr, "adig: server %s not found.\n", optarg);
- return 1;
- }
- options.servers = realloc(options.servers, (options.nservers + 1)
- * sizeof(struct in_addr));
- if (!options.servers)
- {
- fprintf(stderr, "Out of memory!\n");
- return 1;
- }
- memcpy(&options.servers[options.nservers], hostent->h_addr,
- sizeof(struct in_addr));
- options.nservers++;
- optmask |= ARES_OPT_SERVERS;
- break;
-
- case 'c':
- /* Set the query class. */
- for (i = 0; i < nclasses; i++)
- {
- if (strcasecmp(classes[i].name, optarg) == 0)
- break;
- }
- if (i == nclasses)
- usage();
- dnsclass = classes[i].value;
- break;
-
- case 't':
- /* Set the query type. */
- for (i = 0; i < ntypes; i++)
- {
- if (strcasecmp(types[i].name, optarg) == 0)
- break;
- }
- if (i == ntypes)
- usage();
- type = types[i].value;
- break;
-
- case 'T':
- /* Set the TCP port number. */
- if (!isdigit((unsigned char)*optarg))
- usage();
- options.tcp_port = strtol(optarg, NULL, 0);
- optmask |= ARES_OPT_TCP_PORT;
- break;
-
- case 'U':
- /* Set the UDP port number. */
- if (!isdigit((unsigned char)*optarg))
- usage();
- options.udp_port = strtol(optarg, NULL, 0);
- optmask |= ARES_OPT_UDP_PORT;
- break;
- }
+ {
+ case 'f':
+ /* Add a flag. */
+ for (i = 0; i < nflags; i++)
+ {
+ if (strcmp(flags[i].name, optarg) == 0)
+ break;
+ }
+ if (i == nflags)
+ usage();
+ options.flags |= flags[i].value;
+ break;
+
+ case 's':
+ /* Add a server, and specify servers in the option mask. */
+ hostent = gethostbyname(optarg);
+ if (!hostent || hostent->h_addrtype != AF_INET)
+ {
+ fprintf(stderr, "adig: server %s not found.\n", optarg);
+ return 1;
+ }
+ options.servers = realloc(options.servers, (options.nservers + 1)
+ * sizeof(struct in_addr));
+ if (!options.servers)
+ {
+ fprintf(stderr, "Out of memory!\n");
+ return 1;
+ }
+ memcpy(&options.servers[options.nservers], hostent->h_addr,
+ sizeof(struct in_addr));
+ options.nservers++;
+ optmask |= ARES_OPT_SERVERS;
+ break;
+
+ case 'c':
+ /* Set the query class. */
+ for (i = 0; i < nclasses; i++)
+ {
+ if (strcasecmp(classes[i].name, optarg) == 0)
+ break;
+ }
+ if (i == nclasses)
+ usage();
+ dnsclass = classes[i].value;
+ break;
+
+ case 't':
+ /* Set the query type. */
+ for (i = 0; i < ntypes; i++)
+ {
+ if (strcasecmp(types[i].name, optarg) == 0)
+ break;
+ }
+ if (i == ntypes)
+ usage();
+ type = types[i].value;
+ break;
+
+ case 'T':
+ /* Set the TCP port number. */
+ if (!isdigit((unsigned char)*optarg))
+ usage();
+ options.tcp_port = strtol(optarg, NULL, 0);
+ optmask |= ARES_OPT_TCP_PORT;
+ break;
+
+ case 'U':
+ /* Set the UDP port number. */
+ if (!isdigit((unsigned char)*optarg))
+ usage();
+ options.udp_port = strtol(optarg, NULL, 0);
+ optmask |= ARES_OPT_UDP_PORT;
+ break;
+ }
}
argc -= optind;
argv += optind;
if (status != ARES_SUCCESS)
{
fprintf(stderr, "ares_init_options: %s\n",
- ares_strerror(status));
+ ares_strerror(status));
return 1;
}
else
{
for (; *argv; argv++)
- ares_query(channel, *argv, dnsclass, type, callback, *argv);
+ ares_query(channel, *argv, dnsclass, type, callback, *argv);
}
/* Wait for all queries to complete. */
FD_ZERO(&write_fds);
nfds = ares_fds(channel, &read_fds, &write_fds);
if (nfds == 0)
- break;
+ break;
tvp = ares_timeout(channel, NULL, &tv);
count = select(nfds, &read_fds, &write_fds, NULL, tvp);
if (count < 0 && errno != EINVAL)
- {
- perror("select");
- return 1;
- }
+ {
+ perror("select");
+ return 1;
+ }
ares_process(channel, &read_fds, &write_fds);
}
{
printf("%s\n", ares_strerror(status));
if (!abuf)
- return;
+ return;
}
/* Won't happen, but check anyway, for safety. */
/* Display the answer header. */
printf("id: %d\n", id);
printf("flags: %s%s%s%s%s\n",
- qr ? "qr " : "",
- aa ? "aa " : "",
- tc ? "tc " : "",
- rd ? "rd " : "",
- ra ? "ra " : "");
+ qr ? "qr " : "",
+ aa ? "aa " : "",
+ tc ? "tc " : "",
+ rd ? "rd " : "",
+ ra ? "ra " : "");
printf("opcode: %s\n", opcodes[opcode]);
printf("rcode: %s\n", rcodes[rcode]);
{
aptr = display_question(aptr, abuf, alen);
if (aptr == NULL)
- return;
+ return;
}
/* Display the answers. */
{
aptr = display_rr(aptr, abuf, alen);
if (aptr == NULL)
- return;
+ return;
}
/* Display the NS records. */
{
aptr = display_rr(aptr, abuf, alen);
if (aptr == NULL)
- return;
+ return;
}
/* Display the additional records. */
{
aptr = display_rr(aptr, abuf, alen);
if (aptr == NULL)
- return;
+ return;
}
}
static const unsigned char *display_question(const unsigned char *aptr,
- const unsigned char *abuf,
- int alen)
+ const unsigned char *abuf,
+ int alen)
{
char *name;
int type, dnsclass, status;
}
static const unsigned char *display_rr(const unsigned char *aptr,
- const unsigned char *abuf, int alen)
+ const unsigned char *abuf, int alen)
{
const unsigned char *p;
char *name;
/* For these types, the RR data is just a domain name. */
status = ares_expand_name(aptr, abuf, alen, &name, &len);
if (status != ARES_SUCCESS)
- return NULL;
+ return NULL;
printf("\t%s.", name);
free(name);
break;
p = aptr;
len = *p;
if (p + len + 1 > aptr + dlen)
- return NULL;
+ return NULL;
printf("\t%.*s", len, p + 1);
p += len + 1;
len = *p;
if (p + len + 1 > aptr + dlen)
- return NULL;
+ return NULL;
printf("\t%.*s", len, p + 1);
break;
p = aptr;
status = ares_expand_name(p, abuf, alen, &name, &len);
if (status != ARES_SUCCESS)
- return NULL;
+ return NULL;
printf("\t%s.", name);
free(name);
p += len;
status = ares_expand_name(p, abuf, alen, &name, &len);
if (status != ARES_SUCCESS)
- return NULL;
+ return NULL;
printf("\t%s.", name);
free(name);
break;
* then a domain name.
*/
if (dlen < 2)
- return NULL;
+ return NULL;
printf("\t%d", (aptr[0] << 8) | aptr[1]);
status = ares_expand_name(aptr + 2, abuf, alen, &name, &len);
if (status != ARES_SUCCESS)
- return NULL;
+ return NULL;
printf("\t%s.", name);
free(name);
break;
p = aptr;
status = ares_expand_name(p, abuf, alen, &name, &len);
if (status != ARES_SUCCESS)
- return NULL;
+ return NULL;
printf("\t%s.\n", name);
free(name);
p += len;
status = ares_expand_name(p, abuf, alen, &name, &len);
if (status != ARES_SUCCESS)
- return NULL;
+ return NULL;
printf("\t\t\t\t\t\t%s.\n", name);
free(name);
p += len;
if (p + 20 > aptr + dlen)
- return NULL;
+ return NULL;
printf("\t\t\t\t\t\t( %d %d %d %d %d )",
- (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3],
- (p[4] << 24) | (p[5] << 16) | (p[6] << 8) | p[7],
- (p[8] << 24) | (p[9] << 16) | (p[10] << 8) | p[11],
- (p[12] << 24) | (p[13] << 16) | (p[14] << 8) | p[15],
- (p[16] << 24) | (p[17] << 16) | (p[18] << 8) | p[19]);
+ (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3],
+ (p[4] << 24) | (p[5] << 16) | (p[6] << 8) | p[7],
+ (p[8] << 24) | (p[9] << 16) | (p[10] << 8) | p[11],
+ (p[12] << 24) | (p[13] << 16) | (p[14] << 8) | p[15],
+ (p[16] << 24) | (p[17] << 16) | (p[18] << 8) | p[19]);
break;
case T_TXT:
* strings. */
p = aptr;
while (p < aptr + dlen)
- {
- len = *p;
- if (p + len + 1 > aptr + dlen)
- return NULL;
- printf("\t%.*s", len, p + 1);
- p += len + 1;
- }
+ {
+ len = *p;
+ if (p + len + 1 > aptr + dlen)
+ return NULL;
+ printf("\t%.*s", len, p + 1);
+ p += len + 1;
+ }
break;
case T_A:
/* The RR data is a four-byte Internet address. */
if (dlen != 4)
- return NULL;
+ return NULL;
memcpy(&addr, aptr, sizeof(struct in_addr));
printf("\t%s", inet_ntoa(addr));
break;
/* The RR data is three two-byte numbers representing the
* priority, weight, and port, followed by a domain name.
*/
-
+
printf("\t%d", DNS__16BIT(aptr));
printf(" %d", DNS__16BIT(aptr + 2));
printf(" %d", DNS__16BIT(aptr + 4));
-
+
status = ares_expand_name(aptr + 6, abuf, alen, &name, &len);
if (status != ARES_SUCCESS)
return NULL;
printf("\t%s.", name);
free(name);
break;
-
+
default:
printf("\t[Unknown RR; cannot parse]");
}
for (i = 0; i < ntypes; i++)
{
if (types[i].value == type)
- return types[i].name;
+ return types[i].name;
}
return "(unknown)";
}
for (i = 0; i < nclasses; i++)
{
if (classes[i].value == dnsclass)
- return classes[i].name;
+ return classes[i].name;
}
return "(unknown)";
}
static void usage(void)
{
fprintf(stderr, "usage: adig [-f flag] [-s server] [-c class] "
- "[-t type] [-p port] name ...\n");
+ "[-t type] [-p port] name ...\n");
exit(1);
}
#include "ares_dns.h"
#ifndef INADDR_NONE
-#define INADDR_NONE 0xffffffff
+#define INADDR_NONE 0xffffffff
#endif
static void callback(void *arg, int status, struct hostent *host);
WORD wVersionRequested = MAKEWORD(1,1);
WSADATA wsaData;
WSAStartup(wVersionRequested, &wsaData);
-#endif
+#endif
if (argc <= 1)
usage();
{
addr.s_addr = inet_addr(*argv);
if (addr.s_addr == INADDR_NONE)
- ares_gethostbyname(channel, *argv, AF_INET, callback, *argv);
+ ares_gethostbyname(channel, *argv, AF_INET, callback, *argv);
else
- {
- ares_gethostbyaddr(channel, &addr, sizeof(addr), AF_INET, callback,
- *argv);
- }
+ {
+ ares_gethostbyaddr(channel, &addr, sizeof(addr), AF_INET, callback,
+ *argv);
+ }
}
/* Wait for all queries to complete. */
FD_ZERO(&write_fds);
nfds = ares_fds(channel, &read_fds, &write_fds);
if (nfds == 0)
- break;
+ break;
tvp = ares_timeout(channel, NULL, &tv);
select(nfds, &read_fds, &write_fds, NULL, tvp);
ares_process(channel, &read_fds, &write_fds);
#include <netinet/in.h>
#endif
-#define ARES_SUCCESS 0
+#define ARES_SUCCESS 0
/* Server error codes (ARES_ENODATA indicates no relevant answer) */
-#define ARES_ENODATA 1
-#define ARES_EFORMERR 2
-#define ARES_ESERVFAIL 3
-#define ARES_ENOTFOUND 4
-#define ARES_ENOTIMP 5
-#define ARES_EREFUSED 6
+#define ARES_ENODATA 1
+#define ARES_EFORMERR 2
+#define ARES_ESERVFAIL 3
+#define ARES_ENOTFOUND 4
+#define ARES_ENOTIMP 5
+#define ARES_EREFUSED 6
/* Locally generated error codes */
-#define ARES_EBADQUERY 7
-#define ARES_EBADNAME 8
-#define ARES_EBADFAMILY 9
-#define ARES_EBADRESP 10
-#define ARES_ECONNREFUSED 11
-#define ARES_ETIMEOUT 12
-#define ARES_EOF 13
-#define ARES_EFILE 14
-#define ARES_ENOMEM 15
-#define ARES_EDESTRUCTION 16
-#define ARES_EBADSTR 17
+#define ARES_EBADQUERY 7
+#define ARES_EBADNAME 8
+#define ARES_EBADFAMILY 9
+#define ARES_EBADRESP 10
+#define ARES_ECONNREFUSED 11
+#define ARES_ETIMEOUT 12
+#define ARES_EOF 13
+#define ARES_EFILE 14
+#define ARES_ENOMEM 15
+#define ARES_EDESTRUCTION 16
+#define ARES_EBADSTR 17
/* Flag values */
-#define ARES_FLAG_USEVC (1 << 0)
-#define ARES_FLAG_PRIMARY (1 << 1)
-#define ARES_FLAG_IGNTC (1 << 2)
-#define ARES_FLAG_NORECURSE (1 << 3)
-#define ARES_FLAG_STAYOPEN (1 << 4)
-#define ARES_FLAG_NOSEARCH (1 << 5)
-#define ARES_FLAG_NOALIASES (1 << 6)
-#define ARES_FLAG_NOCHECKRESP (1 << 7)
+#define ARES_FLAG_USEVC (1 << 0)
+#define ARES_FLAG_PRIMARY (1 << 1)
+#define ARES_FLAG_IGNTC (1 << 2)
+#define ARES_FLAG_NORECURSE (1 << 3)
+#define ARES_FLAG_STAYOPEN (1 << 4)
+#define ARES_FLAG_NOSEARCH (1 << 5)
+#define ARES_FLAG_NOALIASES (1 << 6)
+#define ARES_FLAG_NOCHECKRESP (1 << 7)
/* Option mask values */
-#define ARES_OPT_FLAGS (1 << 0)
-#define ARES_OPT_TIMEOUT (1 << 1)
-#define ARES_OPT_TRIES (1 << 2)
-#define ARES_OPT_NDOTS (1 << 3)
-#define ARES_OPT_UDP_PORT (1 << 4)
-#define ARES_OPT_TCP_PORT (1 << 5)
-#define ARES_OPT_SERVERS (1 << 6)
-#define ARES_OPT_DOMAINS (1 << 7)
-#define ARES_OPT_LOOKUPS (1 << 8)
+#define ARES_OPT_FLAGS (1 << 0)
+#define ARES_OPT_TIMEOUT (1 << 1)
+#define ARES_OPT_TRIES (1 << 2)
+#define ARES_OPT_NDOTS (1 << 3)
+#define ARES_OPT_UDP_PORT (1 << 4)
+#define ARES_OPT_TCP_PORT (1 << 5)
+#define ARES_OPT_SERVERS (1 << 6)
+#define ARES_OPT_DOMAINS (1 << 7)
+#define ARES_OPT_LOOKUPS (1 << 8)
struct ares_options {
int flags;
struct ares_channeldata;
typedef struct ares_channeldata *ares_channel;
typedef void (*ares_callback)(void *arg, int status, unsigned char *abuf,
- int alen);
+ int alen);
typedef void (*ares_host_callback)(void *arg, int status,
- struct hostent *hostent);
+ struct hostent *hostent);
int ares_init(ares_channel *channelptr);
int ares_init_options(ares_channel *channelptr, struct ares_options *options,
- int optmask);
+ int optmask);
void ares_destroy(ares_channel channel);
void ares_cancel(ares_channel channel);
void ares_send(ares_channel channel, const unsigned char *qbuf, int qlen,
- ares_callback callback, void *arg);
+ ares_callback callback, void *arg);
void ares_query(ares_channel channel, const char *name, int dnsclass,
- int type, ares_callback callback, void *arg);
+ int type, ares_callback callback, void *arg);
void ares_search(ares_channel channel, const char *name, int dnsclass,
- int type, ares_callback callback, void *arg);
+ int type, ares_callback callback, void *arg);
void ares_gethostbyname(ares_channel channel, const char *name, int family,
- ares_host_callback callback, void *arg);
+ ares_host_callback callback, void *arg);
void ares_gethostbyaddr(ares_channel channel, const void *addr, int addrlen,
- int family, ares_host_callback callback, void *arg);
+ int family, ares_host_callback callback, void *arg);
int ares_fds(ares_channel channel, fd_set *read_fds, fd_set *write_fds);
struct timeval *ares_timeout(ares_channel channel, struct timeval *maxtv,
- struct timeval *tv);
+ struct timeval *tv);
void ares_process(ares_channel channel, fd_set *read_fds, fd_set *write_fds);
int ares_mkquery(const char *name, int dnsclass, int type, unsigned short id,
- int rd, unsigned char **buf, int *buflen);
+ int rd, unsigned char **buf, int *buflen);
int ares_expand_name(const unsigned char *encoded, const unsigned char *abuf,
- int alen, char **s, long *enclen);
+ int alen, char **s, long *enclen);
int ares_expand_string(const unsigned char *encoded, const unsigned char *abuf,
- int alen, unsigned char **s, long *enclen);
+ int alen, unsigned char **s, long *enclen);
int ares_parse_a_reply(const unsigned char *abuf, int alen,
- struct hostent **host);
+ struct hostent **host);
int ares_parse_ptr_reply(const unsigned char *abuf, int alen, const void *addr,
- int addrlen, int family, struct hostent **host);
+ int addrlen, int family, struct hostent **host);
void ares_free_string(void *str);
void ares_free_hostent(struct hostent *host);
const char *ares_strerror(int code);
{
/* Skip comment lines; terminate line at comment character. */
if (*line == '#' || !*line)
- continue;
+ continue;
p = strchr(line, '#');
if (p)
- *p = 0;
+ *p = 0;
/* Get the address part. */
p = line;
while (*p && !isspace((unsigned char)*p))
- p++;
+ p++;
if (!*p)
- continue;
+ continue;
*p = 0;
addr.s_addr = inet_addr(line);
if (addr.s_addr == INADDR_NONE)
- continue;
+ continue;
/* Get the canonical hostname. */
p++;
while (isspace((unsigned char)*p))
- p++;
+ p++;
if (!*p)
- continue;
+ continue;
q = p;
while (*q && !isspace((unsigned char)*q))
- q++;
+ q++;
end_at_hostname = (*q == 0);
*q = 0;
canonical = p;
naliases = 0;
if (!end_at_hostname)
- {
- /* Count the aliases. */
- p = q + 1;
- while (isspace((unsigned char)*p))
- p++;
- while (*p)
- {
- while (*p && !isspace((unsigned char)*p))
- p++;
- while (isspace((unsigned char)*p))
- p++;
- naliases++;
- }
- }
+ {
+ /* Count the aliases. */
+ p = q + 1;
+ while (isspace((unsigned char)*p))
+ p++;
+ while (*p)
+ {
+ while (*p && !isspace((unsigned char)*p))
+ p++;
+ while (isspace((unsigned char)*p))
+ p++;
+ naliases++;
+ }
+ }
/* Allocate memory for the host structure. */
hostent = malloc(sizeof(struct hostent));
if (!hostent)
- break;
+ break;
hostent->h_aliases = NULL;
hostent->h_addr_list = NULL;
hostent->h_name = strdup(canonical);
if (!hostent->h_name)
- break;
+ break;
hostent->h_addr_list = malloc(2 * sizeof(char *));
if (!hostent->h_addr_list)
- break;
+ break;
hostent->h_addr_list[0] = malloc(sizeof(struct in_addr));
if (!hostent->h_addr_list[0])
- break;
+ break;
hostent->h_aliases = malloc((naliases + 1) * sizeof(char *));
if (!hostent->h_aliases)
- break;
+ break;
/* Copy in aliases. */
naliases = 0;
if (!end_at_hostname)
- {
- p = canonical + strlen(canonical) + 1;
- while (isspace((unsigned char)*p))
- p++;
- while (*p)
- {
- q = p;
- while (*q && !isspace((unsigned char)*q))
- q++;
- hostent->h_aliases[naliases] = malloc(q - p + 1);
- if (hostent->h_aliases[naliases] == NULL)
- break;
- memcpy(hostent->h_aliases[naliases], p, q - p);
- hostent->h_aliases[naliases][q - p] = 0;
- p = q;
- while (isspace((unsigned char)*p))
- p++;
- naliases++;
- }
- if (*p)
- break;
- }
+ {
+ p = canonical + strlen(canonical) + 1;
+ while (isspace((unsigned char)*p))
+ p++;
+ while (*p)
+ {
+ q = p;
+ while (*q && !isspace((unsigned char)*q))
+ q++;
+ hostent->h_aliases[naliases] = malloc(q - p + 1);
+ if (hostent->h_aliases[naliases] == NULL)
+ break;
+ memcpy(hostent->h_aliases[naliases], p, q - p);
+ hostent->h_aliases[naliases][q - p] = 0;
+ p = q;
+ while (isspace((unsigned char)*p))
+ p++;
+ naliases++;
+ }
+ if (*p)
+ break;
+ }
hostent->h_aliases[naliases] = NULL;
hostent->h_addrtype = AF_INET;
{
/* Memory allocation failure; clean up. */
if (hostent)
- {
+ {
if(hostent->h_name)
free((char *) hostent->h_name);
- if (hostent->h_aliases)
- {
- for (alias = hostent->h_aliases; *alias; alias++)
- free(*alias);
- }
+ if (hostent->h_aliases)
+ {
+ for (alias = hostent->h_aliases; *alias; alias++)
+ free(*alias);
+ }
if(hostent->h_aliases)
free(hostent->h_aliases);
- if (hostent->h_addr_list && hostent->h_addr_list[0])
- free(hostent->h_addr_list[0]);
+ if (hostent->h_addr_list && hostent->h_addr_list[0])
+ free(hostent->h_addr_list[0]);
if(hostent->h_addr_list)
free(hostent->h_addr_list);
free(hostent);
- }
+ }
return ARES_ENOMEM;
}
{
*buf = malloc(128);
if (!*buf)
- return ARES_ENOMEM;
+ return ARES_ENOMEM;
*bufsize = 128;
}
while (1)
{
if (!fgets(*buf + offset, *bufsize - (int)offset, fp))
- return (offset != 0) ? 0 : (ferror(fp)) ? ARES_EFILE : ARES_EOF;
+ return (offset != 0) ? 0 : (ferror(fp)) ? ARES_EFILE : ARES_EOF;
len = offset + strlen(*buf + offset);
if ((*buf)[len - 1] == '\n')
- {
- (*buf)[len - 1] = 0;
- return ARES_SUCCESS;
- }
+ {
+ (*buf)[len - 1] = 0;
+ return ARES_SUCCESS;
+ }
offset = len;
/* Allocate more space. */
newbuf = realloc(*buf, *bufsize * 2);
if (!newbuf)
- return ARES_ENOMEM;
+ return ARES_ENOMEM;
*buf = newbuf;
*bufsize *= 2;
}
#ifndef ARES__DNS_H
#define ARES__DNS_H
-#define DNS__16BIT(p) (((p)[0] << 8) | (p)[1])
-#define DNS__32BIT(p) (((p)[0] << 24) | ((p)[1] << 16) | \
- ((p)[2] << 8) | (p)[3])
-#define DNS__SET16BIT(p, v) (((p)[0] = ((v) >> 8) & 0xff), \
- ((p)[1] = (v) & 0xff))
-#define DNS__SET32BIT(p, v) (((p)[0] = ((v) >> 24) & 0xff), \
- ((p)[1] = ((v) >> 16) & 0xff), \
- ((p)[2] = ((v) >> 8) & 0xff), \
- ((p)[3] = (v) & 0xff))
+#define DNS__16BIT(p) (((p)[0] << 8) | (p)[1])
+#define DNS__32BIT(p) (((p)[0] << 24) | ((p)[1] << 16) | \
+ ((p)[2] << 8) | (p)[3])
+#define DNS__SET16BIT(p, v) (((p)[0] = ((v) >> 8) & 0xff), \
+ ((p)[1] = (v) & 0xff))
+#define DNS__SET32BIT(p, v) (((p)[0] = ((v) >> 24) & 0xff), \
+ ((p)[1] = ((v) >> 16) & 0xff), \
+ ((p)[2] = ((v) >> 8) & 0xff), \
+ ((p)[3] = (v) & 0xff))
/* Macros for parsing a DNS header */
-#define DNS_HEADER_QID(h) DNS__16BIT(h)
-#define DNS_HEADER_QR(h) (((h)[2] >> 7) & 0x1)
-#define DNS_HEADER_OPCODE(h) (((h)[2] >> 3) & 0xf)
-#define DNS_HEADER_AA(h) (((h)[2] >> 2) & 0x1)
-#define DNS_HEADER_TC(h) (((h)[2] >> 1) & 0x1)
-#define DNS_HEADER_RD(h) ((h)[2] & 0x1)
-#define DNS_HEADER_RA(h) (((h)[3] >> 7) & 0x1)
-#define DNS_HEADER_Z(h) (((h)[3] >> 4) & 0x7)
-#define DNS_HEADER_RCODE(h) ((h)[3] & 0xf)
-#define DNS_HEADER_QDCOUNT(h) DNS__16BIT((h) + 4)
-#define DNS_HEADER_ANCOUNT(h) DNS__16BIT((h) + 6)
-#define DNS_HEADER_NSCOUNT(h) DNS__16BIT((h) + 8)
-#define DNS_HEADER_ARCOUNT(h) DNS__16BIT((h) + 10)
+#define DNS_HEADER_QID(h) DNS__16BIT(h)
+#define DNS_HEADER_QR(h) (((h)[2] >> 7) & 0x1)
+#define DNS_HEADER_OPCODE(h) (((h)[2] >> 3) & 0xf)
+#define DNS_HEADER_AA(h) (((h)[2] >> 2) & 0x1)
+#define DNS_HEADER_TC(h) (((h)[2] >> 1) & 0x1)
+#define DNS_HEADER_RD(h) ((h)[2] & 0x1)
+#define DNS_HEADER_RA(h) (((h)[3] >> 7) & 0x1)
+#define DNS_HEADER_Z(h) (((h)[3] >> 4) & 0x7)
+#define DNS_HEADER_RCODE(h) ((h)[3] & 0xf)
+#define DNS_HEADER_QDCOUNT(h) DNS__16BIT((h) + 4)
+#define DNS_HEADER_ANCOUNT(h) DNS__16BIT((h) + 6)
+#define DNS_HEADER_NSCOUNT(h) DNS__16BIT((h) + 8)
+#define DNS_HEADER_ARCOUNT(h) DNS__16BIT((h) + 10)
/* Macros for constructing a DNS header */
-#define DNS_HEADER_SET_QID(h, v) DNS__SET16BIT(h, v)
-#define DNS_HEADER_SET_QR(h, v) ((h)[2] |= (((v) & 0x1) << 7))
-#define DNS_HEADER_SET_OPCODE(h, v) ((h)[2] |= (((v) & 0xf) << 3))
-#define DNS_HEADER_SET_AA(h, v) ((h)[2] |= (((v) & 0x1) << 2))
-#define DNS_HEADER_SET_TC(h, v) ((h)[2] |= (((v) & 0x1) << 1))
-#define DNS_HEADER_SET_RD(h, v) ((h)[2] |= (((v) & 0x1)))
-#define DNS_HEADER_SET_RA(h, v) ((h)[3] |= (((v) & 0x1) << 7))
-#define DNS_HEADER_SET_Z(h, v) ((h)[3] |= (((v) & 0x7) << 4))
-#define DNS_HEADER_SET_RCODE(h, v) ((h)[3] |= (((v) & 0xf)))
-#define DNS_HEADER_SET_QDCOUNT(h, v) DNS__SET16BIT((h) + 4, v)
-#define DNS_HEADER_SET_ANCOUNT(h, v) DNS__SET16BIT((h) + 6, v)
-#define DNS_HEADER_SET_NSCOUNT(h, v) DNS__SET16BIT((h) + 8, v)
-#define DNS_HEADER_SET_ARCOUNT(h, v) DNS__SET16BIT((h) + 10, v)
+#define DNS_HEADER_SET_QID(h, v) DNS__SET16BIT(h, v)
+#define DNS_HEADER_SET_QR(h, v) ((h)[2] |= (((v) & 0x1) << 7))
+#define DNS_HEADER_SET_OPCODE(h, v) ((h)[2] |= (((v) & 0xf) << 3))
+#define DNS_HEADER_SET_AA(h, v) ((h)[2] |= (((v) & 0x1) << 2))
+#define DNS_HEADER_SET_TC(h, v) ((h)[2] |= (((v) & 0x1) << 1))
+#define DNS_HEADER_SET_RD(h, v) ((h)[2] |= (((v) & 0x1)))
+#define DNS_HEADER_SET_RA(h, v) ((h)[3] |= (((v) & 0x1) << 7))
+#define DNS_HEADER_SET_Z(h, v) ((h)[3] |= (((v) & 0x7) << 4))
+#define DNS_HEADER_SET_RCODE(h, v) ((h)[3] |= (((v) & 0xf)))
+#define DNS_HEADER_SET_QDCOUNT(h, v) DNS__SET16BIT((h) + 4, v)
+#define DNS_HEADER_SET_ANCOUNT(h, v) DNS__SET16BIT((h) + 6, v)
+#define DNS_HEADER_SET_NSCOUNT(h, v) DNS__SET16BIT((h) + 8, v)
+#define DNS_HEADER_SET_ARCOUNT(h, v) DNS__SET16BIT((h) + 10, v)
/* Macros for parsing the fixed part of a DNS question */
-#define DNS_QUESTION_TYPE(q) DNS__16BIT(q)
-#define DNS_QUESTION_CLASS(q) DNS__16BIT((q) + 2)
+#define DNS_QUESTION_TYPE(q) DNS__16BIT(q)
+#define DNS_QUESTION_CLASS(q) DNS__16BIT((q) + 2)
/* Macros for constructing the fixed part of a DNS question */
-#define DNS_QUESTION_SET_TYPE(q, v) DNS__SET16BIT(q, v)
-#define DNS_QUESTION_SET_CLASS(q, v) DNS__SET16BIT((q) + 2, v)
+#define DNS_QUESTION_SET_TYPE(q, v) DNS__SET16BIT(q, v)
+#define DNS_QUESTION_SET_CLASS(q, v) DNS__SET16BIT((q) + 2, v)
/* Macros for parsing the fixed part of a DNS resource record */
-#define DNS_RR_TYPE(r) DNS__16BIT(r)
-#define DNS_RR_CLASS(r) DNS__16BIT((r) + 2)
-#define DNS_RR_TTL(r) DNS__32BIT((r) + 4)
-#define DNS_RR_LEN(r) DNS__16BIT((r) + 8)
+#define DNS_RR_TYPE(r) DNS__16BIT(r)
+#define DNS_RR_CLASS(r) DNS__16BIT((r) + 2)
+#define DNS_RR_TTL(r) DNS__32BIT((r) + 4)
+#define DNS_RR_LEN(r) DNS__16BIT((r) + 8)
/* Macros for constructing the fixed part of a DNS resource record */
-#define DNS_RR_SET_TYPE(r) DNS__SET16BIT(r, v)
-#define DNS_RR_SET_CLASS(r) DNS__SET16BIT((r) + 2, v)
-#define DNS_RR_SET_TTL(r) DNS__SET32BIT((r) + 4, v)
-#define DNS_RR_SET_LEN(r) DNS__SET16BIT((r) + 8, v)
+#define DNS_RR_SET_TYPE(r) DNS__SET16BIT(r, v)
+#define DNS_RR_SET_CLASS(r) DNS__SET16BIT((r) + 2, v)
+#define DNS_RR_SET_TTL(r) DNS__SET32BIT((r) + 4, v)
+#define DNS_RR_SET_LEN(r) DNS__SET16BIT((r) + 8, v)
#endif /* ARES__DNS_H */
#include "ares_private.h" /* for the memdebug */
static int name_length(const unsigned char *encoded, const unsigned char *abuf,
- int alen);
+ int alen);
/* Expand an RFC1035-encoded domain name given by encoded. The
* containing message is given by abuf and alen. The result given by
*/
int ares_expand_name(const unsigned char *encoded, const unsigned char *abuf,
- int alen, char **s, long *enclen)
+ int alen, char **s, long *enclen)
{
int len, indir = 0;
char *q;
while (*p)
{
if ((*p & INDIR_MASK) == INDIR_MASK)
- {
- if (!indir)
- {
- *enclen = p + 2 - encoded;
- indir = 1;
- }
- p = abuf + ((*p & ~INDIR_MASK) << 8 | *(p + 1));
- }
+ {
+ if (!indir)
+ {
+ *enclen = p + 2 - encoded;
+ indir = 1;
+ }
+ p = abuf + ((*p & ~INDIR_MASK) << 8 | *(p + 1));
+ }
else
- {
- len = *p;
- p++;
- while (len--)
- {
- if (*p == '.' || *p == '\\')
- *q++ = '\\';
- *q++ = *p;
- p++;
- }
- *q++ = '.';
- }
+ {
+ len = *p;
+ p++;
+ while (len--)
+ {
+ if (*p == '.' || *p == '\\')
+ *q++ = '\\';
+ *q++ = *p;
+ p++;
+ }
+ *q++ = '.';
+ }
}
if (!indir)
*enclen = p + 1 - encoded;
* -1 if the encoding is invalid.
*/
static int name_length(const unsigned char *encoded, const unsigned char *abuf,
- int alen)
+ int alen)
{
int n = 0, offset, indir = 0;
while (*encoded)
{
if ((*encoded & INDIR_MASK) == INDIR_MASK)
- {
- /* Check the offset and go there. */
- if (encoded + 1 >= abuf + alen)
- return -1;
- offset = (*encoded & ~INDIR_MASK) << 8 | *(encoded + 1);
- if (offset >= alen)
- return -1;
- encoded = abuf + offset;
-
- /* If we've seen more indirects than the message length,
- * then there's a loop.
- */
- if (++indir > alen)
- return -1;
- }
+ {
+ /* Check the offset and go there. */
+ if (encoded + 1 >= abuf + alen)
+ return -1;
+ offset = (*encoded & ~INDIR_MASK) << 8 | *(encoded + 1);
+ if (offset >= alen)
+ return -1;
+ encoded = abuf + offset;
+
+ /* If we've seen more indirects than the message length,
+ * then there's a loop.
+ */
+ if (++indir > alen)
+ return -1;
+ }
else
- {
- offset = *encoded;
- if (encoded + offset + 1 >= abuf + alen)
- return -1;
- encoded++;
- while (offset--)
- {
- n += (*encoded == '.' || *encoded == '\\') ? 2 : 1;
- encoded++;
- }
- n++;
- }
+ {
+ offset = *encoded;
+ if (encoded + offset + 1 >= abuf + alen)
+ return -1;
+ encoded++;
+ while (offset--)
+ {
+ n += (*encoded == '.' || *encoded == '\\') ? 2 : 1;
+ encoded++;
+ }
+ n++;
+ }
}
/* If there were any labels at all, then the number of dots is one
{
server = &channel->servers[i];
if (server->udp_socket != ARES_SOCKET_BAD)
- {
- FD_SET(server->udp_socket, read_fds);
- if (server->udp_socket >= nfds)
- nfds = server->udp_socket + 1;
- }
+ {
+ FD_SET(server->udp_socket, read_fds);
+ if (server->udp_socket >= nfds)
+ nfds = server->udp_socket + 1;
+ }
if (server->tcp_socket != ARES_SOCKET_BAD)
- {
- FD_SET(server->tcp_socket, read_fds);
- if (server->qhead)
- FD_SET(server->tcp_socket, write_fds);
- if (server->tcp_socket >= nfds)
- nfds = server->tcp_socket + 1;
- }
+ {
+ FD_SET(server->tcp_socket, read_fds);
+ if (server->qhead)
+ FD_SET(server->tcp_socket, write_fds);
+ if (server->tcp_socket >= nfds)
+ nfds = server->tcp_socket + 1;
+ }
}
return nfds;
}
static void next_lookup(struct addr_query *aquery);
static void addr_callback(void *arg, int status, unsigned char *abuf,
- int alen);
+ int alen);
static void end_aquery(struct addr_query *aquery, int status,
- struct hostent *host);
+ struct hostent *host);
static int file_lookup(struct in_addr *addr, struct hostent **host);
void ares_gethostbyaddr(ares_channel channel, const void *addr, int addrlen,
- int family, ares_host_callback callback, void *arg)
+ int family, ares_host_callback callback, void *arg)
{
struct addr_query *aquery;
for (p = aquery->remaining_lookups; *p; p++)
{
switch (*p)
- {
- case 'b':
- addr = ntohl(aquery->addr.s_addr);
- a1 = (int)((addr >> 24) & 0xff);
- a2 = (int)((addr >> 16) & 0xff);
- a3 = (int)((addr >> 8) & 0xff);
- a4 = (int)(addr & 0xff);
- sprintf(name, "%d.%d.%d.%d.in-addr.arpa", a4, a3, a2, a1);
- aquery->remaining_lookups = p + 1;
- ares_query(aquery->channel, name, C_IN, T_PTR, addr_callback,
- aquery);
- return;
- case 'f':
- status = file_lookup(&aquery->addr, &host);
- if (status != ARES_ENOTFOUND)
- {
- end_aquery(aquery, status, host);
- return;
- }
- break;
- }
+ {
+ case 'b':
+ addr = ntohl(aquery->addr.s_addr);
+ a1 = (int)((addr >> 24) & 0xff);
+ a2 = (int)((addr >> 16) & 0xff);
+ a3 = (int)((addr >> 8) & 0xff);
+ a4 = (int)(addr & 0xff);
+ sprintf(name, "%d.%d.%d.%d.in-addr.arpa", a4, a3, a2, a1);
+ aquery->remaining_lookups = p + 1;
+ ares_query(aquery->channel, name, C_IN, T_PTR, addr_callback,
+ aquery);
+ return;
+ case 'f':
+ status = file_lookup(&aquery->addr, &host);
+ if (status != ARES_ENOTFOUND)
+ {
+ end_aquery(aquery, status, host);
+ return;
+ }
+ break;
+ }
}
end_aquery(aquery, ARES_ENOTFOUND, NULL);
}
if (status == ARES_SUCCESS)
{
status = ares_parse_ptr_reply(abuf, alen, &aquery->addr,
- sizeof(struct in_addr), AF_INET, &host);
+ sizeof(struct in_addr), AF_INET, &host);
end_aquery(aquery, status, host);
}
else if (status == ARES_EDESTRUCTION)
}
static void end_aquery(struct addr_query *aquery, int status,
- struct hostent *host)
+ struct hostent *host)
{
aquery->callback(aquery->arg, status, host);
if (host)
char PATH_HOSTS[MAX_PATH];
if (IsNT) {
- char tmp[MAX_PATH];
- HKEY hkeyHosts;
-
- if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, WIN_NS_NT_KEY, 0, KEY_READ, &hkeyHosts)
- == ERROR_SUCCESS)
- {
- DWORD dwLength = MAX_PATH;
- RegQueryValueEx(hkeyHosts, DATABASEPATH, NULL, NULL, tmp,
- &dwLength);
- ExpandEnvironmentStrings(tmp, PATH_HOSTS, MAX_PATH);
- RegCloseKey(hkeyHosts);
- }
- }
+ char tmp[MAX_PATH];
+ HKEY hkeyHosts;
+
+ if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, WIN_NS_NT_KEY, 0, KEY_READ, &hkeyHosts)
+ == ERROR_SUCCESS)
+ {
+ DWORD dwLength = MAX_PATH;
+ RegQueryValueEx(hkeyHosts, DATABASEPATH, NULL, NULL, tmp,
+ &dwLength);
+ ExpandEnvironmentStrings(tmp, PATH_HOSTS, MAX_PATH);
+ RegCloseKey(hkeyHosts);
+ }
+ }
else
GetWindowsDirectory(PATH_HOSTS, MAX_PATH);
while ((status = ares__get_hostent(fp, host)) == ARES_SUCCESS)
{
if (memcmp((*host)->h_addr, addr, sizeof(struct in_addr)) == 0)
- break;
+ break;
ares_free_hostent(*host);
}
fclose(fp);
static void next_lookup(struct host_query *hquery);
static void host_callback(void *arg, int status, unsigned char *abuf,
- int alen);
+ int alen);
static void end_hquery(struct host_query *hquery, int status,
- struct hostent *host);
+ struct hostent *host);
static int fake_hostent(const char *name, ares_host_callback callback,
- void *arg);
+ void *arg);
static int file_lookup(const char *name, struct hostent **host);
static void sort_addresses(struct hostent *host, struct apattern *sortlist,
- int nsort);
+ int nsort);
static int get_address_index(struct in_addr *addr, struct apattern *sortlist,
- int nsort);
+ int nsort);
void ares_gethostbyname(ares_channel channel, const char *name, int family,
- ares_host_callback callback, void *arg)
+ ares_host_callback callback, void *arg)
{
struct host_query *hquery;
struct hostent *host;
for (p = hquery->remaining_lookups; *p; p++)
- {
+ {
switch (*p)
- {
- case 'b':
- /* DNS lookup */
- hquery->remaining_lookups = p + 1;
- ares_search(hquery->channel, hquery->name, C_IN, T_A, host_callback,
- hquery);
- return;
-
- case 'f':
- /* Host file lookup */
- status = file_lookup(hquery->name, &host);
- if (status != ARES_ENOTFOUND)
- {
- end_hquery(hquery, status, host);
- return;
- }
- break;
- }
+ {
+ case 'b':
+ /* DNS lookup */
+ hquery->remaining_lookups = p + 1;
+ ares_search(hquery->channel, hquery->name, C_IN, T_A, host_callback,
+ hquery);
+ return;
+
+ case 'f':
+ /* Host file lookup */
+ status = file_lookup(hquery->name, &host);
+ if (status != ARES_ENOTFOUND)
+ {
+ end_hquery(hquery, status, host);
+ return;
+ }
+ break;
+ }
}
end_hquery(hquery, ARES_ENOTFOUND, NULL);
}
{
status = ares_parse_a_reply(abuf, alen, &host);
if (host && channel->nsort)
- sort_addresses(host, channel->sortlist, channel->nsort);
+ sort_addresses(host, channel->sortlist, channel->nsort);
end_hquery(hquery, status, host);
}
else if (status == ARES_EDESTRUCTION)
}
static void end_hquery(struct host_query *hquery, int status,
- struct hostent *host)
+ struct hostent *host)
{
hquery->callback(hquery->arg, status, host);
if (host)
* query immediately, and return true. Otherwise return false.
*/
static int fake_hostent(const char *name, ares_host_callback callback,
- void *arg)
+ void *arg)
{
struct in_addr addr;
struct hostent hostent;
for (p = name; *p; p++)
{
if (!isdigit((unsigned char)*p) && *p != '.')
- return 0;
+ return 0;
}
/* It also only looks like an IP address if it's non-zero-length and
#ifdef WIN32
char PATH_HOSTS[MAX_PATH];
if (IsNT) {
- char tmp[MAX_PATH];
- HKEY hkeyHosts;
-
- if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, WIN_NS_NT_KEY, 0, KEY_READ, &hkeyHosts)
- == ERROR_SUCCESS)
- {
- DWORD dwLength = MAX_PATH;
- RegQueryValueEx(hkeyHosts, DATABASEPATH, NULL, NULL, tmp,
- &dwLength);
- ExpandEnvironmentStrings(tmp, PATH_HOSTS, MAX_PATH);
- RegCloseKey(hkeyHosts);
- }
- }
+ char tmp[MAX_PATH];
+ HKEY hkeyHosts;
+
+ if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, WIN_NS_NT_KEY, 0, KEY_READ, &hkeyHosts)
+ == ERROR_SUCCESS)
+ {
+ DWORD dwLength = MAX_PATH;
+ RegQueryValueEx(hkeyHosts, DATABASEPATH, NULL, NULL, tmp,
+ &dwLength);
+ ExpandEnvironmentStrings(tmp, PATH_HOSTS, MAX_PATH);
+ RegCloseKey(hkeyHosts);
+ }
+ }
else
GetWindowsDirectory(PATH_HOSTS, MAX_PATH);
while ((status = ares__get_hostent(fp, host)) == ARES_SUCCESS)
{
if (strcasecmp((*host)->h_name, name) == 0)
- break;
+ break;
for (alias = (*host)->h_aliases; *alias; alias++)
- {
- if (strcasecmp(*alias, name) == 0)
- break;
- }
+ {
+ if (strcasecmp(*alias, name) == 0)
+ break;
+ }
if (*alias)
- break;
+ break;
ares_free_hostent(*host);
}
fclose(fp);
}
static void sort_addresses(struct hostent *host, struct apattern *sortlist,
- int nsort)
+ int nsort)
{
struct in_addr a1, a2;
int i1, i2, ind1, ind2;
memcpy(&a1, host->h_addr_list[i1], sizeof(struct in_addr));
ind1 = get_address_index(&a1, sortlist, nsort);
for (i2 = i1 - 1; i2 >= 0; i2--)
- {
- memcpy(&a2, host->h_addr_list[i2], sizeof(struct in_addr));
- ind2 = get_address_index(&a2, sortlist, nsort);
- if (ind2 <= ind1)
- break;
- memcpy(host->h_addr_list[i2 + 1], &a2, sizeof(struct in_addr));
- }
+ {
+ memcpy(&a2, host->h_addr_list[i2], sizeof(struct in_addr));
+ ind2 = get_address_index(&a2, sortlist, nsort);
+ if (ind2 <= ind1)
+ break;
+ memcpy(host->h_addr_list[i2 + 1], &a2, sizeof(struct in_addr));
+ }
memcpy(host->h_addr_list[i2 + 1], &a1, sizeof(struct in_addr));
}
}
* if none of them match.
*/
static int get_address_index(struct in_addr *addr, struct apattern *sortlist,
- int nsort)
+ int nsort)
{
int i;
for (i = 0; i < nsort; i++)
{
if ((addr->s_addr & sortlist[i].mask.s_addr) == sortlist[i].addr.s_addr)
- break;
+ break;
}
return i;
}
#endif
static int init_by_options(ares_channel channel, struct ares_options *options,
- int optmask);
+ int optmask);
static int init_by_environment(ares_channel channel);
static int init_by_resolv_conf(ares_channel channel);
static int init_by_defaults(ares_channel channel);
static int config_lookup(ares_channel channel, const char *str,
const char *bindch, const char *filech);
static int config_nameserver(struct server_state **servers, int *nservers,
- char *str);
+ char *str);
static int config_sortlist(struct apattern **sortlist, int *nsort,
- const char *str);
+ const char *str);
static int set_search(ares_channel channel, const char *str);
static int set_options(ares_channel channel, const char *str);
static char *try_config(char *s, const char *opt);
}
int ares_init_options(ares_channel *channelptr, struct ares_options *options,
- int optmask)
+ int optmask)
{
ares_channel channel;
int i, status;
{
/* Something failed; clean up memory we may have allocated. */
if (channel->nservers != -1)
- free(channel->servers);
+ free(channel->servers);
if (channel->domains)
- {
- for (i = 0; i < channel->ndomains; i++)
- free(channel->domains[i]);
- free(channel->domains);
- }
+ {
+ for (i = 0; i < channel->ndomains; i++)
+ free(channel->domains[i]);
+ free(channel->domains);
+ }
if (channel->sortlist)
- free(channel->sortlist);
+ free(channel->sortlist);
if(channel->lookups)
free(channel->lookups);
free(channel);
}
static int init_by_options(ares_channel channel, struct ares_options *options,
- int optmask)
+ int optmask)
{
int i;
if ((optmask & ARES_OPT_SERVERS) && channel->nservers == -1)
{
channel->servers =
- malloc(options->nservers * sizeof(struct server_state));
+ malloc(options->nservers * sizeof(struct server_state));
if (!channel->servers && options->nservers != 0)
- return ARES_ENOMEM;
+ return ARES_ENOMEM;
for (i = 0; i < options->nservers; i++)
- channel->servers[i].addr = options->servers[i];
+ channel->servers[i].addr = options->servers[i];
channel->nservers = options->nservers;
}
{
channel->domains = malloc(options->ndomains * sizeof(char *));
if (!channel->domains && options->ndomains != 0)
- return ARES_ENOMEM;
+ return ARES_ENOMEM;
for (i = 0; i < options->ndomains; i++)
- {
- channel->ndomains = i;
- channel->domains[i] = strdup(options->domains[i]);
- if (!channel->domains[i])
- return ARES_ENOMEM;
- }
+ {
+ channel->ndomains = i;
+ channel->domains[i] = strdup(options->domains[i]);
+ if (!channel->domains[i])
+ return ARES_ENOMEM;
+ }
channel->ndomains = options->ndomains;
}
{
channel->lookups = strdup(options->lookups);
if (!channel->lookups)
- return ARES_ENOMEM;
+ return ARES_ENOMEM;
}
return ARES_SUCCESS;
{
status = set_search(channel, localdomain);
if (status != ARES_SUCCESS)
- return status;
+ return status;
}
res_options = getenv("RES_OPTIONS");
{
status = set_options(channel, res_options);
if (status != ARES_SUCCESS)
- return status;
+ return status;
}
return ARES_SUCCESS;
On Windows 9X, the DNS server can be found in:
HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\VxD\MSTCP\NameServer
- On Windows NT/2000/XP/2003:
+ On Windows NT/2000/XP/2003:
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\NameServer
- or
+ or
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\DhcpNameServer
- or
+ or
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\{AdapterID}\
NameServer
- or
+ or
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\{AdapterID}\
DhcpNameServer
*/
/* If nobody specified servers, try a local named. */
channel->servers = malloc(sizeof(struct server_state));
if (!channel->servers)
- return ARES_ENOMEM;
+ return ARES_ENOMEM;
channel->servers[0].addr.s_addr = htonl(INADDR_LOOPBACK);
channel->nservers = 1;
}
* or set it to empty if the hostname isn't helpful.
*/
if (gethostname(hostname, sizeof(hostname)) == -1
- || !strchr(hostname, '.'))
- {
- channel->domains = malloc(0);
- channel->ndomains = 0;
- }
+ || !strchr(hostname, '.'))
+ {
+ channel->domains = malloc(0);
+ channel->ndomains = 0;
+ }
else
- {
- channel->domains = malloc(sizeof(char *));
- if (!channel->domains)
- return ARES_ENOMEM;
- channel->ndomains = 0;
- channel->domains[0] = strdup(strchr(hostname, '.') + 1);
- if (!channel->domains[0])
- return ARES_ENOMEM;
- channel->ndomains = 1;
- }
+ {
+ channel->domains = malloc(sizeof(char *));
+ if (!channel->domains)
+ return ARES_ENOMEM;
+ channel->ndomains = 0;
+ channel->domains[0] = strdup(strchr(hostname, '.') + 1);
+ if (!channel->domains[0])
+ return ARES_ENOMEM;
+ channel->ndomains = 1;
+ }
}
if (channel->nsort == -1)
{
channel->lookups = strdup("fb");
if (!channel->lookups)
- return ARES_ENOMEM;
+ return ARES_ENOMEM;
}
return ARES_SUCCESS;
while (*p)
{
if ((*p == *bindch || *p == *filech) && l < lookups + 2) {
- if (*p == *bindch) *l++ = 'b';
+ if (*p == *bindch) *l++ = 'b';
else *l++ = 'f';
}
while (*p && !isspace((unsigned char)*p) && (*p != ','))
- p++;
+ p++;
while (*p && (isspace((unsigned char)*p) || (*p == ',')))
- p++;
+ p++;
}
*l = 0;
channel->lookups = strdup(lookups);
}
static int config_nameserver(struct server_state **servers, int *nservers,
- char *str)
+ char *str)
{
struct in_addr addr;
struct server_state *newserv;
}
static int config_sortlist(struct apattern **sortlist, int *nsort,
- const char *str)
+ const char *str)
{
struct apattern pat, *newsort;
const char *q;
{
q = str;
while (*q && *q != '/' && *q != ';' && !isspace((unsigned char)*q))
- q++;
+ q++;
if (ip_addr(str, (int)(q - str), &pat.addr) == 0)
- {
- /* We have a pattern address; now determine the mask. */
- if (*q == '/')
- {
- str = q + 1;
- while (*q && *q != ';' && !isspace((unsigned char)*q))
- q++;
- if (ip_addr(str, (int)(q - str), &pat.mask) != 0)
- natural_mask(&pat);
- }
- else
- natural_mask(&pat);
-
- /* Add this pattern to our list. */
- newsort = realloc(*sortlist, (*nsort + 1) * sizeof(struct apattern));
- if (!newsort)
- return ARES_ENOMEM;
- newsort[*nsort] = pat;
- *sortlist = newsort;
- (*nsort)++;
- }
+ {
+ /* We have a pattern address; now determine the mask. */
+ if (*q == '/')
+ {
+ str = q + 1;
+ while (*q && *q != ';' && !isspace((unsigned char)*q))
+ q++;
+ if (ip_addr(str, (int)(q - str), &pat.mask) != 0)
+ natural_mask(&pat);
+ }
+ else
+ natural_mask(&pat);
+
+ /* Add this pattern to our list. */
+ newsort = realloc(*sortlist, (*nsort + 1) * sizeof(struct apattern));
+ if (!newsort)
+ return ARES_ENOMEM;
+ newsort[*nsort] = pat;
+ *sortlist = newsort;
+ (*nsort)++;
+ }
else
- {
- while (*q && *q != ';' && !isspace((unsigned char)*q))
- q++;
- }
+ {
+ while (*q && *q != ';' && !isspace((unsigned char)*q))
+ q++;
+ }
str = q;
while (isspace((unsigned char)*str))
- str++;
+ str++;
}
return ARES_SUCCESS;
while (*p)
{
while (*p && !isspace((unsigned char)*p))
- p++;
+ p++;
while (isspace((unsigned char)*p))
- p++;
+ p++;
n++;
}
channel->ndomains = n;
q = p;
while (*q && !isspace((unsigned char)*q))
- q++;
+ q++;
channel->domains[n] = malloc(q - p + 1);
if (!channel->domains[n])
- return ARES_ENOMEM;
+ return ARES_ENOMEM;
memcpy(channel->domains[n], p, q - p);
channel->domains[n][q - p] = 0;
p = q;
while (isspace((unsigned char)*p))
- p++;
+ p++;
n++;
}
channel->ndomains = n;
{
q = p;
while (*q && !isspace((unsigned char)*q))
- q++;
+ q++;
val = try_option(p, q, "ndots:");
if (val && channel->ndots == -1)
- channel->ndots = atoi(val);
+ channel->ndots = atoi(val);
val = try_option(p, q, "retrans:");
if (val && channel->timeout == -1)
- channel->timeout = atoi(val);
+ channel->timeout = atoi(val);
val = try_option(p, q, "retry:");
if (val && channel->tries == -1)
- channel->tries = atoi(val);
+ channel->tries = atoi(val);
p = q;
while (isspace((unsigned char)*p))
- p++;
+ p++;
}
return ARES_SUCCESS;
*
* AA, TC, RA, and RCODE are only set in responses. Brief description
* of the remaining fields:
- * ID Identifier to match responses with queries
- * QR Query (0) or response (1)
- * Opcode For our purposes, always QUERY
- * RD Recursion desired
- * Z Reserved (zero)
- * QDCOUNT Number of queries
- * ANCOUNT Number of answers
- * NSCOUNT Number of name server records
- * ARCOUNT Number of additional records
+ * ID Identifier to match responses with queries
+ * QR Query (0) or response (1)
+ * Opcode For our purposes, always QUERY
+ * RD Recursion desired
+ * Z Reserved (zero)
+ * QDCOUNT Number of queries
+ * ANCOUNT Number of answers
+ * NSCOUNT Number of name server records
+ * ARCOUNT Number of additional records
*
* Question format, from RFC 1035:
* 1 1 1 1 1 1
*/
int ares_mkquery(const char *name, int dnsclass, int type, unsigned short id,
- int rd, unsigned char **buf, int *buflen)
+ int rd, unsigned char **buf, int *buflen)
{
int len;
unsigned char *q;
for (p = name; *p; p++)
{
if (*p == '\\' && *(p + 1) != 0)
- p++;
+ p++;
len++;
}
/* If there are n periods in the name, there are n + 1 labels, and
while (*name)
{
if (*name == '.')
- return ARES_EBADNAME;
+ return ARES_EBADNAME;
/* Count the number of bytes in this label. */
len = 0;
for (p = name; *p && *p != '.'; p++)
- {
- if (*p == '\\' && *(p + 1) != 0)
- p++;
- len++;
- }
+ {
+ if (*p == '\\' && *(p + 1) != 0)
+ p++;
+ len++;
+ }
if (len > MAXLABEL)
- return ARES_EBADNAME;
+ return ARES_EBADNAME;
/* Encode the length and copy the data. */
*q++ = len;
for (p = name; *p && *p != '.'; p++)
- {
- if (*p == '\\' && *(p + 1) != 0)
- p++;
- *q++ = *p;
- }
+ {
+ if (*p == '\\' && *(p + 1) != 0)
+ p++;
+ *q++ = *p;
+ }
/* Go to the next label and repeat, unless we hit the end. */
if (!*p)
- break;
+ break;
name = p + 1;
}
#include "ares_private.h"
int ares_parse_a_reply(const unsigned char *abuf, int alen,
- struct hostent **host)
+ struct hostent **host)
{
unsigned int qdcount, ancount;
int status, i, rr_type, rr_class, rr_len, naddrs;
/* Decode the RR up to the data field. */
status = ares_expand_name(aptr, abuf, alen, &rr_name, &len);
if (status != ARES_SUCCESS)
- break;
+ break;
aptr += len;
if (aptr + RRFIXEDSZ > abuf + alen)
- {
- status = ARES_EBADRESP;
- break;
- }
+ {
+ status = ARES_EBADRESP;
+ break;
+ }
rr_type = DNS_RR_TYPE(aptr);
rr_class = DNS_RR_CLASS(aptr);
rr_len = DNS_RR_LEN(aptr);
aptr += RRFIXEDSZ;
if (rr_class == C_IN && rr_type == T_A
- && rr_len == sizeof(struct in_addr)
- && strcasecmp(rr_name, hostname) == 0)
- {
- memcpy(&addrs[naddrs], aptr, sizeof(struct in_addr));
- naddrs++;
- status = ARES_SUCCESS;
- }
+ && rr_len == sizeof(struct in_addr)
+ && strcasecmp(rr_name, hostname) == 0)
+ {
+ memcpy(&addrs[naddrs], aptr, sizeof(struct in_addr));
+ naddrs++;
+ status = ARES_SUCCESS;
+ }
if (rr_class == C_IN && rr_type == T_CNAME)
- {
- /* Record the RR name as an alias. */
- aliases[naliases] = rr_name;
- naliases++;
+ {
+ /* Record the RR name as an alias. */
+ aliases[naliases] = rr_name;
+ naliases++;
- /* Decode the RR data and replace the hostname with it. */
- status = ares_expand_name(aptr, abuf, alen, &rr_data, &len);
- if (status != ARES_SUCCESS)
- break;
- free(hostname);
- hostname = rr_data;
- }
+ /* Decode the RR data and replace the hostname with it. */
+ status = ares_expand_name(aptr, abuf, alen, &rr_data, &len);
+ if (status != ARES_SUCCESS)
+ break;
+ free(hostname);
+ hostname = rr_data;
+ }
else
- free(rr_name);
+ free(rr_name);
aptr += rr_len;
if (aptr > abuf + alen)
- {
- status = ARES_EBADRESP;
- break;
- }
+ {
+ status = ARES_EBADRESP;
+ break;
+ }
}
if (status == ARES_SUCCESS && naddrs == 0)
aliases[naliases] = NULL;
hostent = malloc(sizeof(struct hostent));
if (hostent)
- {
- hostent->h_addr_list = malloc((naddrs + 1) * sizeof(char *));
- if (hostent->h_addr_list)
- {
- /* Fill in the hostent and return successfully. */
- hostent->h_name = hostname;
- hostent->h_aliases = aliases;
- hostent->h_addrtype = AF_INET;
- hostent->h_length = sizeof(struct in_addr);
- for (i = 0; i < naddrs; i++)
- hostent->h_addr_list[i] = (char *) &addrs[i];
- hostent->h_addr_list[naddrs] = NULL;
- *host = hostent;
- return ARES_SUCCESS;
- }
- free(hostent);
- }
+ {
+ hostent->h_addr_list = malloc((naddrs + 1) * sizeof(char *));
+ if (hostent->h_addr_list)
+ {
+ /* Fill in the hostent and return successfully. */
+ hostent->h_name = hostname;
+ hostent->h_aliases = aliases;
+ hostent->h_addrtype = AF_INET;
+ hostent->h_length = sizeof(struct in_addr);
+ for (i = 0; i < naddrs; i++)
+ hostent->h_addr_list[i] = (char *) &addrs[i];
+ hostent->h_addr_list[naddrs] = NULL;
+ *host = hostent;
+ return ARES_SUCCESS;
+ }
+ free(hostent);
+ }
status = ARES_ENOMEM;
}
for (i = 0; i < naliases; i++)
#include "ares_private.h"
int ares_parse_ptr_reply(const unsigned char *abuf, int alen, const void *addr,
- int addrlen, int family, struct hostent **host)
+ int addrlen, int family, struct hostent **host)
{
unsigned int qdcount, ancount;
int status, i, rr_type, rr_class, rr_len;
/* Decode the RR up to the data field. */
status = ares_expand_name(aptr, abuf, alen, &rr_name, &len);
if (status != ARES_SUCCESS)
- break;
+ break;
aptr += len;
if (aptr + RRFIXEDSZ > abuf + alen)
- {
- status = ARES_EBADRESP;
- break;
- }
+ {
+ status = ARES_EBADRESP;
+ break;
+ }
rr_type = DNS_RR_TYPE(aptr);
rr_class = DNS_RR_CLASS(aptr);
rr_len = DNS_RR_LEN(aptr);
aptr += RRFIXEDSZ;
if (rr_class == C_IN && rr_type == T_PTR
- && strcasecmp(rr_name, ptrname) == 0)
- {
- /* Decode the RR data and set hostname to it. */
- status = ares_expand_name(aptr, abuf, alen, &rr_data, &len);
- if (status != ARES_SUCCESS)
- break;
- if (hostname)
- free(hostname);
- hostname = rr_data;
- }
+ && strcasecmp(rr_name, ptrname) == 0)
+ {
+ /* Decode the RR data and set hostname to it. */
+ status = ares_expand_name(aptr, abuf, alen, &rr_data, &len);
+ if (status != ARES_SUCCESS)
+ break;
+ if (hostname)
+ free(hostname);
+ hostname = rr_data;
+ }
if (rr_class == C_IN && rr_type == T_CNAME)
- {
- /* Decode the RR data and replace ptrname with it. */
- status = ares_expand_name(aptr, abuf, alen, &rr_data, &len);
- if (status != ARES_SUCCESS)
- break;
- free(ptrname);
- ptrname = rr_data;
- }
+ {
+ /* Decode the RR data and replace ptrname with it. */
+ status = ares_expand_name(aptr, abuf, alen, &rr_data, &len);
+ if (status != ARES_SUCCESS)
+ break;
+ free(ptrname);
+ ptrname = rr_data;
+ }
free(rr_name);
aptr += rr_len;
if (aptr > abuf + alen)
- {
- status = ARES_EBADRESP;
- break;
- }
+ {
+ status = ARES_EBADRESP;
+ break;
+ }
}
if (status == ARES_SUCCESS && !hostname)
/* We got our answer. Allocate memory to build the host entry. */
hostent = malloc(sizeof(struct hostent));
if (hostent)
- {
- hostent->h_addr_list = malloc(2 * sizeof(char *));
- if (hostent->h_addr_list)
- {
- hostent->h_addr_list[0] = malloc(addrlen);
- if (hostent->h_addr_list[0])
- {
- hostent->h_aliases = malloc(sizeof (char *));
- if (hostent->h_aliases)
- {
- /* Fill in the hostent and return successfully. */
- hostent->h_name = hostname;
- hostent->h_aliases[0] = NULL;
- hostent->h_addrtype = family;
- hostent->h_length = addrlen;
- memcpy(hostent->h_addr_list[0], addr, addrlen);
- hostent->h_addr_list[1] = NULL;
- *host = hostent;
- free(ptrname);
- return ARES_SUCCESS;
- }
- free(hostent->h_addr_list[0]);
- }
- free(hostent->h_addr_list);
- }
- free(hostent);
- }
+ {
+ hostent->h_addr_list = malloc(2 * sizeof(char *));
+ if (hostent->h_addr_list)
+ {
+ hostent->h_addr_list[0] = malloc(addrlen);
+ if (hostent->h_addr_list[0])
+ {
+ hostent->h_aliases = malloc(sizeof (char *));
+ if (hostent->h_aliases)
+ {
+ /* Fill in the hostent and return successfully. */
+ hostent->h_name = hostname;
+ hostent->h_aliases[0] = NULL;
+ hostent->h_addrtype = family;
+ hostent->h_length = addrlen;
+ memcpy(hostent->h_addr_list[0], addr, addrlen);
+ hostent->h_addr_list[1] = NULL;
+ *host = hostent;
+ free(ptrname);
+ return ARES_SUCCESS;
+ }
+ free(hostent->h_addr_list[0]);
+ }
+ free(hostent->h_addr_list);
+ }
+ free(hostent);
+ }
status = ARES_ENOMEM;
}
if (hostname)
#define writev(s,v,c) writev_s(s,v,c)
#endif
-#define DEFAULT_TIMEOUT 5
-#define DEFAULT_TRIES 4
+#define DEFAULT_TIMEOUT 5
+#define DEFAULT_TRIES 4
#ifndef INADDR_NONE
-#define INADDR_NONE 0xffffffff
+#define INADDR_NONE 0xffffffff
#endif
#if defined(WIN32) && !defined(WATT32)
#elif defined(NETWARE)
#define PATH_RESOLV_CONF "sys:/etc/resolv.cfg"
-#define PATH_HOSTS "sys:/etc/hosts"
+#define PATH_HOSTS "sys:/etc/hosts"
#else
-#define PATH_RESOLV_CONF "/etc/resolv.conf"
+#define PATH_RESOLV_CONF "/etc/resolv.conf"
#ifdef ETC_INET
-#define PATH_HOSTS "/etc/inet/hosts"
+#define PATH_HOSTS "/etc/inet/hosts"
#else
-#define PATH_HOSTS "/etc/hosts"
+#define PATH_HOSTS "/etc/hosts"
#endif
#endif
#endif
static void write_tcp_data(ares_channel channel, fd_set *write_fds,
- time_t now);
+ time_t now);
static void read_tcp_data(ares_channel channel, fd_set *read_fds, time_t now);
static void read_udp_packets(ares_channel channel, fd_set *read_fds,
- time_t now);
+ time_t now);
static void process_timeouts(ares_channel channel, time_t now);
static void process_answer(ares_channel channel, unsigned char *abuf,
- int alen, int whichserver, int tcp, int now);
+ int alen, int whichserver, int tcp, int now);
static void handle_error(ares_channel channel, int whichserver, time_t now);
static struct query *next_server(ares_channel channel, struct query *query, time_t now);
static int open_tcp_socket(ares_channel channel, struct server_state *server);
static int open_udp_socket(ares_channel channel, struct server_state *server);
static int same_questions(const unsigned char *qbuf, int qlen,
- const unsigned char *abuf, int alen);
+ const unsigned char *abuf, int alen);
static struct query *end_query(ares_channel channel, struct query *query, int status,
- unsigned char *abuf, int alen);
+ unsigned char *abuf, int alen);
/* Something interesting happened on the wire, or there was a timeout.
* See what's up and respond accordingly.
/* Make sure server has data to send and is selected in write_fds. */
server = &channel->servers[i];
if (!server->qhead || server->tcp_socket == ARES_SOCKET_BAD
- || !FD_ISSET(server->tcp_socket, write_fds))
- continue;
+ || !FD_ISSET(server->tcp_socket, write_fds))
+ continue;
/* Count the number of send queue items. */
n = 0;
for (sendreq = server->qhead; sendreq; sendreq = sendreq->next)
- n++;
+ n++;
/* Allocate iovecs so we can send all our data at once. */
vec = malloc(n * sizeof(struct iovec));
if (vec)
- {
- /* Fill in the iovecs and send. */
- n = 0;
- for (sendreq = server->qhead; sendreq; sendreq = sendreq->next)
- {
- vec[n].iov_base = (char *) sendreq->data;
- vec[n].iov_len = sendreq->len;
- n++;
- }
- wcount = writev(server->tcp_socket, vec, n);
- free(vec);
- if (wcount < 0)
- {
- handle_error(channel, i, now);
- continue;
- }
-
- /* Advance the send queue by as many bytes as we sent. */
- while (wcount)
- {
- sendreq = server->qhead;
- if ((size_t)wcount >= sendreq->len)
- {
- wcount -= sendreq->len;
- server->qhead = sendreq->next;
- if (server->qhead == NULL)
- server->qtail = NULL;
- free(sendreq);
- }
- else
- {
- sendreq->data += wcount;
- sendreq->len -= wcount;
- break;
- }
- }
- }
+ {
+ /* Fill in the iovecs and send. */
+ n = 0;
+ for (sendreq = server->qhead; sendreq; sendreq = sendreq->next)
+ {
+ vec[n].iov_base = (char *) sendreq->data;
+ vec[n].iov_len = sendreq->len;
+ n++;
+ }
+ wcount = writev(server->tcp_socket, vec, n);
+ free(vec);
+ if (wcount < 0)
+ {
+ handle_error(channel, i, now);
+ continue;
+ }
+
+ /* Advance the send queue by as many bytes as we sent. */
+ while (wcount)
+ {
+ sendreq = server->qhead;
+ if ((size_t)wcount >= sendreq->len)
+ {
+ wcount -= sendreq->len;
+ server->qhead = sendreq->next;
+ if (server->qhead == NULL)
+ server->qtail = NULL;
+ free(sendreq);
+ }
+ else
+ {
+ sendreq->data += wcount;
+ sendreq->len -= wcount;
+ break;
+ }
+ }
+ }
else
- {
- /* Can't allocate iovecs; just send the first request. */
- sendreq = server->qhead;
+ {
+ /* Can't allocate iovecs; just send the first request. */
+ sendreq = server->qhead;
scount = send(server->tcp_socket, sendreq->data, sendreq->len, 0);
- if (scount < 0)
- {
- handle_error(channel, i, now);
- continue;
- }
-
- /* Advance the send queue by as many bytes as we sent. */
- if ((size_t)scount == sendreq->len)
- {
- server->qhead = sendreq->next;
- if (server->qhead == NULL)
- server->qtail = NULL;
- free(sendreq);
- }
- else
- {
- sendreq->data += scount;
- sendreq->len -= scount;
- }
- }
+ if (scount < 0)
+ {
+ handle_error(channel, i, now);
+ continue;
+ }
+
+ /* Advance the send queue by as many bytes as we sent. */
+ if ((size_t)scount == sendreq->len)
+ {
+ server->qhead = sendreq->next;
+ if (server->qhead == NULL)
+ server->qtail = NULL;
+ free(sendreq);
+ }
+ else
+ {
+ sendreq->data += scount;
+ sendreq->len -= scount;
+ }
+ }
}
}
server = &channel->servers[i];
if (server->tcp_socket == ARES_SOCKET_BAD ||
!FD_ISSET(server->tcp_socket, read_fds))
- continue;
+ continue;
if (server->tcp_lenbuf_pos != 2)
- {
- /* We haven't yet read a length word, so read that (or
- * what's left to read of it).
- */
+ {
+ /* We haven't yet read a length word, so read that (or
+ * what's left to read of it).
+ */
count = recv(server->tcp_socket,
server->tcp_lenbuf + server->tcp_buffer_pos,
2 - server->tcp_buffer_pos, 0);
- if (count <= 0)
- {
- handle_error(channel, i, now);
- continue;
- }
-
- server->tcp_lenbuf_pos += count;
- if (server->tcp_lenbuf_pos == 2)
- {
- /* We finished reading the length word. Decode the
+ if (count <= 0)
+ {
+ handle_error(channel, i, now);
+ continue;
+ }
+
+ server->tcp_lenbuf_pos += count;
+ if (server->tcp_lenbuf_pos == 2)
+ {
+ /* We finished reading the length word. Decode the
* length and allocate a buffer for the data.
- */
- server->tcp_length = server->tcp_lenbuf[0] << 8
- | server->tcp_lenbuf[1];
- server->tcp_buffer = malloc(server->tcp_length);
- if (!server->tcp_buffer)
- handle_error(channel, i, now);
- server->tcp_buffer_pos = 0;
- }
- }
+ */
+ server->tcp_length = server->tcp_lenbuf[0] << 8
+ | server->tcp_lenbuf[1];
+ server->tcp_buffer = malloc(server->tcp_length);
+ if (!server->tcp_buffer)
+ handle_error(channel, i, now);
+ server->tcp_buffer_pos = 0;
+ }
+ }
else
- {
- /* Read data into the allocated buffer. */
- count = recv(server->tcp_socket,
- server->tcp_buffer + server->tcp_buffer_pos,
- server->tcp_length - server->tcp_buffer_pos, 0);
- if (count <= 0)
- {
- handle_error(channel, i, now);
- continue;
- }
-
- server->tcp_buffer_pos += count;
- if (server->tcp_buffer_pos == server->tcp_length)
- {
- /* We finished reading this answer; process it and
+ {
+ /* Read data into the allocated buffer. */
+ count = recv(server->tcp_socket,
+ server->tcp_buffer + server->tcp_buffer_pos,
+ server->tcp_length - server->tcp_buffer_pos, 0);
+ if (count <= 0)
+ {
+ handle_error(channel, i, now);
+ continue;
+ }
+
+ server->tcp_buffer_pos += count;
+ if (server->tcp_buffer_pos == server->tcp_length)
+ {
+ /* We finished reading this answer; process it and
* prepare to read another length word.
- */
- process_answer(channel, server->tcp_buffer, server->tcp_length,
- i, 1, now);
+ */
+ process_answer(channel, server->tcp_buffer, server->tcp_length,
+ i, 1, now);
if (server->tcp_buffer)
- free(server->tcp_buffer);
- server->tcp_buffer = NULL;
- server->tcp_lenbuf_pos = 0;
- }
- }
+ free(server->tcp_buffer);
+ server->tcp_buffer = NULL;
+ server->tcp_lenbuf_pos = 0;
+ }
+ }
}
}
/* If any UDP sockets select true for reading, process them. */
static void read_udp_packets(ares_channel channel, fd_set *read_fds,
- time_t now)
+ time_t now)
{
struct server_state *server;
int i, count;
if (server->udp_socket == ARES_SOCKET_BAD ||
!FD_ISSET(server->udp_socket, read_fds))
- continue;
+ continue;
count = recv(server->udp_socket, buf, sizeof(buf), 0);
if (count <= 0)
- handle_error(channel, i, now);
+ handle_error(channel, i, now);
process_answer(channel, buf, count, i, 0, now);
}
{
next = query->next;
if (query->timeout != 0 && now >= query->timeout)
- {
- query->error_status = ARES_ETIMEOUT;
- next = next_server(channel, query, now);
- }
+ {
+ query->error_status = ARES_ETIMEOUT;
+ next = next_server(channel, query, now);
+ }
}
}
/* Handle an answer from a server. */
static void process_answer(ares_channel channel, unsigned char *abuf,
- int alen, int whichserver, int tcp, int now)
+ int alen, int whichserver, int tcp, int now)
{
int id, tc, rcode;
struct query *query;
for (query = channel->queries; query; query = query->next)
{
if (query->qid == id)
- break;
+ break;
}
if (!query)
return;
if ((tc || alen > PACKETSZ) && !tcp && !(channel->flags & ARES_FLAG_IGNTC))
{
if (!query->using_tcp)
- {
- query->using_tcp = 1;
- ares__send_query(channel, query, now);
- }
+ {
+ query->using_tcp = 1;
+ ares__send_query(channel, query, now);
+ }
return;
}
if (!(channel->flags & ARES_FLAG_NOCHECKRESP))
{
if (rcode == SERVFAIL || rcode == NOTIMP || rcode == REFUSED)
- {
- query->skip_server[whichserver] = 1;
- if (query->server == whichserver)
- next_server(channel, query, now);
- return;
- }
+ {
+ query->skip_server[whichserver] = 1;
+ if (query->server == whichserver)
+ next_server(channel, query, now);
+ return;
+ }
if (!same_questions(query->qbuf, query->qlen, abuf, alen))
- {
- if (query->server == whichserver)
- next_server(channel, query, now);
- return;
- }
+ {
+ if (query->server == whichserver)
+ next_server(channel, query, now);
+ return;
+ }
}
end_query(channel, query, ARES_SUCCESS, abuf, alen);
{
next = query->next;
if (query->server == whichserver)
- {
- query->skip_server[whichserver] = 1;
- next = next_server(channel, query, now);
- }
+ {
+ query->skip_server[whichserver] = 1;
+ next = next_server(channel, query, now);
+ }
}
}
for (; query->try < channel->tries; query->try++)
{
for (; query->server < channel->nservers; query->server++)
- {
- if (!query->skip_server[query->server])
- {
- ares__send_query(channel, query, now);
- return (query->next);
- }
- }
+ {
+ if (!query->skip_server[query->server])
+ {
+ ares__send_query(channel, query, now);
+ return (query->next);
+ }
+ }
query->server = 0;
/* Only one try if we're using TCP. */
if (query->using_tcp)
- break;
+ break;
}
return end_query(channel, query, query->error_status, NULL, 0);
}
* a send request.
*/
if (server->tcp_socket == ARES_SOCKET_BAD)
- {
- if (open_tcp_socket(channel, server) == -1)
- {
- query->skip_server[query->server] = 1;
- next_server(channel, query, now);
- return;
- }
- }
+ {
+ if (open_tcp_socket(channel, server) == -1)
+ {
+ query->skip_server[query->server] = 1;
+ next_server(channel, query, now);
+ return;
+ }
+ }
sendreq = calloc(sizeof(struct send_request), 1);
if (!sendreq)
{
- end_query(channel, query, ARES_ENOMEM, NULL, 0);
+ end_query(channel, query, ARES_ENOMEM, NULL, 0);
return;
}
sendreq->data = query->tcpbuf;
sendreq->len = query->tcplen;
sendreq->next = NULL;
if (server->qtail)
- server->qtail->next = sendreq;
+ server->qtail->next = sendreq;
else
- server->qhead = sendreq;
+ server->qhead = sendreq;
server->qtail = sendreq;
query->timeout = 0;
}
else
{
if (server->udp_socket == ARES_SOCKET_BAD)
- {
- if (open_udp_socket(channel, server) == -1)
- {
- query->skip_server[query->server] = 1;
- next_server(channel, query, now);
- return;
- }
- }
+ {
+ if (open_udp_socket(channel, server) == -1)
+ {
+ query->skip_server[query->server] = 1;
+ next_server(channel, query, now);
+ return;
+ }
+ }
if (send(server->udp_socket, query->qbuf, query->qlen, 0) == -1)
- {
- query->skip_server[query->server] = 1;
- next_server(channel, query, now);
- return;
- }
+ {
+ query->skip_server[query->server] = 1;
+ next_server(channel, query, now);
+ return;
+ }
query->timeout = now
- + ((query->try == 0) ? channel->timeout
- : channel->timeout << query->try / channel->nservers);
+ + ((query->try == 0) ? channel->timeout
+ : channel->timeout << query->try / channel->nservers);
}
}
}
static int same_questions(const unsigned char *qbuf, int qlen,
- const unsigned char *abuf, int alen)
+ const unsigned char *abuf, int alen)
{
struct {
const unsigned char *p;
{
/* Decode the question in the query. */
if (ares_expand_name(q.p, qbuf, qlen, &q.name, &q.namelen)
- != ARES_SUCCESS)
- return 0;
+ != ARES_SUCCESS)
+ return 0;
q.p += q.namelen;
if (q.p + QFIXEDSZ > qbuf + qlen)
- {
- free(q.name);
- return 0;
- }
+ {
+ free(q.name);
+ return 0;
+ }
q.type = DNS_QUESTION_TYPE(q.p);
q.dnsclass = DNS_QUESTION_CLASS(q.p);
q.p += QFIXEDSZ;
/* Search for this question in the answer. */
a.p = abuf + HFIXEDSZ;
for (j = 0; j < a.qdcount; j++)
- {
- /* Decode the question in the answer. */
- if (ares_expand_name(a.p, abuf, alen, &a.name, &a.namelen)
- != ARES_SUCCESS)
- {
- free(q.name);
- return 0;
- }
- a.p += a.namelen;
- if (a.p + QFIXEDSZ > abuf + alen)
- {
- free(q.name);
- free(a.name);
- return 0;
- }
- a.type = DNS_QUESTION_TYPE(a.p);
- a.dnsclass = DNS_QUESTION_CLASS(a.p);
- a.p += QFIXEDSZ;
-
- /* Compare the decoded questions. */
- if (strcasecmp(q.name, a.name) == 0 && q.type == a.type
- && q.dnsclass == a.dnsclass)
- {
- free(a.name);
- break;
- }
- free(a.name);
- }
+ {
+ /* Decode the question in the answer. */
+ if (ares_expand_name(a.p, abuf, alen, &a.name, &a.namelen)
+ != ARES_SUCCESS)
+ {
+ free(q.name);
+ return 0;
+ }
+ a.p += a.namelen;
+ if (a.p + QFIXEDSZ > abuf + alen)
+ {
+ free(q.name);
+ free(a.name);
+ return 0;
+ }
+ a.type = DNS_QUESTION_TYPE(a.p);
+ a.dnsclass = DNS_QUESTION_CLASS(a.p);
+ a.p += QFIXEDSZ;
+
+ /* Compare the decoded questions. */
+ if (strcasecmp(q.name, a.name) == 0 && q.type == a.type
+ && q.dnsclass == a.dnsclass)
+ {
+ free(a.name);
+ break;
+ }
+ free(a.name);
+ }
free(q.name);
if (j == a.qdcount)
- return 0;
+ return 0;
}
return 1;
}
static struct query *end_query (ares_channel channel, struct query *query, int status,
- unsigned char *abuf, int alen)
+ unsigned char *abuf, int alen)
{
struct query **q, *next;
int i;
for (q = &channel->queries; *q; q = &(*q)->next)
{
if (*q == query)
- break;
+ break;
}
*q = query->next;
if (*q)
if (!channel->queries && !(channel->flags & ARES_FLAG_STAYOPEN))
{
for (i = 0; i < channel->nservers; i++)
- ares__close_sockets(&channel->servers[i]);
+ ares__close_sockets(&channel->servers[i]);
}
return (next);
}
static void qcallback(void *arg, int status, unsigned char *abuf, int alen);
void ares_query(ares_channel channel, const char *name, int dnsclass,
- int type, ares_callback callback, void *arg)
+ int type, ares_callback callback, void *arg)
{
struct qquery *qquery;
unsigned char *qbuf;
/* Compose the query. */
rd = !(channel->flags & ARES_FLAG_NORECURSE);
status = ares_mkquery(name, dnsclass, type, channel->next_id, rd, &qbuf,
- &qlen);
+ &qlen);
channel->next_id++;
if (status != ARES_SUCCESS)
{
/* Convert errors. */
switch (rcode)
- {
- case NOERROR:
- status = (ancount > 0) ? ARES_SUCCESS : ARES_ENODATA;
- break;
- case FORMERR:
- status = ARES_EFORMERR;
- break;
- case SERVFAIL:
- status = ARES_ESERVFAIL;
- break;
- case NXDOMAIN:
- status = ARES_ENOTFOUND;
- break;
- case NOTIMP:
- status = ARES_ENOTIMP;
- break;
- case REFUSED:
- status = ARES_EREFUSED;
- break;
- }
+ {
+ case NOERROR:
+ status = (ancount > 0) ? ARES_SUCCESS : ARES_ENODATA;
+ break;
+ case FORMERR:
+ status = ARES_EFORMERR;
+ break;
+ case SERVFAIL:
+ status = ARES_ESERVFAIL;
+ break;
+ case NXDOMAIN:
+ status = ARES_ENOTFOUND;
+ break;
+ case NOTIMP:
+ status = ARES_ENOTIMP;
+ break;
+ case REFUSED:
+ status = ARES_EREFUSED;
+ break;
+ }
qquery->callback(qquery->arg, status, abuf, alen);
}
free(qquery);
struct search_query {
/* Arguments passed to ares_search */
ares_channel channel;
- char *name; /* copied into an allocated buffer */
+ char *name; /* copied into an allocated buffer */
int dnsclass;
int type;
ares_callback callback;
void *arg;
- int status_as_is; /* error status from trying as-is */
- int next_domain; /* next search domain to try */
- int trying_as_is; /* current query is for name as-is */
+ int status_as_is; /* error status from trying as-is */
+ int next_domain; /* next search domain to try */
+ int trying_as_is; /* current query is for name as-is */
};
static void search_callback(void *arg, int status, unsigned char *abuf,
- int alen);
+ int alen);
static void end_squery(struct search_query *squery, int status,
- unsigned char *abuf, int alen);
+ unsigned char *abuf, int alen);
static int cat_domain(const char *name, const char *domain, char **s);
static int single_domain(ares_channel channel, const char *name, char **s);
void ares_search(ares_channel channel, const char *name, int dnsclass,
- int type, ares_callback callback, void *arg)
+ int type, ares_callback callback, void *arg)
{
struct search_query *squery;
char *s;
for (p = name; *p; p++)
{
if (*p == '.')
- ndots++;
+ ndots++;
}
/* If ndots is at least the channel ndots threshold (usually 1),
squery->trying_as_is = 0;
status = cat_domain(name, channel->domains[0], &s);
if (status == ARES_SUCCESS)
- {
- ares_query(channel, s, dnsclass, type, search_callback, squery);
- free(s);
- }
+ {
+ ares_query(channel, s, dnsclass, type, search_callback, squery);
+ free(s);
+ }
else
{
/* failed, free the malloc()ed memory */
free(squery->name);
free(squery);
- callback(arg, status, NULL, 0);
+ callback(arg, status, NULL, 0);
}
}
}
static void search_callback(void *arg, int status, unsigned char *abuf,
- int alen)
+ int alen)
{
struct search_query *squery = (struct search_query *) arg;
ares_channel channel = squery->channel;
{
/* Save the status if we were trying as-is. */
if (squery->trying_as_is)
- squery->status_as_is = status;
+ squery->status_as_is = status;
if (squery->next_domain < channel->ndomains)
- {
- /* Try the next domain. */
- status = cat_domain(squery->name,
- channel->domains[squery->next_domain], &s);
- if (status != ARES_SUCCESS)
- end_squery(squery, status, NULL, 0);
- else
- {
- squery->trying_as_is = 0;
- squery->next_domain++;
- ares_query(channel, s, squery->dnsclass, squery->type,
- search_callback, squery);
- free(s);
- }
- }
+ {
+ /* Try the next domain. */
+ status = cat_domain(squery->name,
+ channel->domains[squery->next_domain], &s);
+ if (status != ARES_SUCCESS)
+ end_squery(squery, status, NULL, 0);
+ else
+ {
+ squery->trying_as_is = 0;
+ squery->next_domain++;
+ ares_query(channel, s, squery->dnsclass, squery->type,
+ search_callback, squery);
+ free(s);
+ }
+ }
else if (squery->status_as_is == -1)
- {
- /* Try the name as-is at the end. */
- squery->trying_as_is = 1;
- ares_query(channel, squery->name, squery->dnsclass, squery->type,
- search_callback, squery);
- }
+ {
+ /* Try the name as-is at the end. */
+ squery->trying_as_is = 1;
+ ares_query(channel, squery->name, squery->dnsclass, squery->type,
+ search_callback, squery);
+ }
else
- end_squery(squery, squery->status_as_is, NULL, 0);
+ end_squery(squery, squery->status_as_is, NULL, 0);
}
}
static void end_squery(struct search_query *squery, int status,
- unsigned char *abuf, int alen)
+ unsigned char *abuf, int alen)
{
squery->callback(squery->arg, status, abuf, alen);
free(squery->name);
/* The name might be a host alias. */
hostaliases = getenv("HOSTALIASES");
if (hostaliases)
- {
- fp = fopen(hostaliases, "r");
- if (fp)
- {
- while ((status = ares__read_line(fp, &line, &linesize))
- == ARES_SUCCESS)
- {
- if (strncasecmp(line, name, len) != 0 ||
- !isspace((unsigned char)line[len]))
- continue;
- p = line + len;
- while (isspace((unsigned char)*p))
- p++;
- if (*p)
- {
- q = p + 1;
- while (*q && !isspace((unsigned char)*q))
- q++;
- *s = malloc(q - p + 1);
- if (*s)
- {
- memcpy(*s, p, q - p);
- (*s)[q - p] = 0;
- }
- free(line);
- fclose(fp);
- return (*s) ? ARES_SUCCESS : ARES_ENOMEM;
- }
- }
- free(line);
- fclose(fp);
- if (status != ARES_SUCCESS)
- return status;
- }
- }
+ {
+ fp = fopen(hostaliases, "r");
+ if (fp)
+ {
+ while ((status = ares__read_line(fp, &line, &linesize))
+ == ARES_SUCCESS)
+ {
+ if (strncasecmp(line, name, len) != 0 ||
+ !isspace((unsigned char)line[len]))
+ continue;
+ p = line + len;
+ while (isspace((unsigned char)*p))
+ p++;
+ if (*p)
+ {
+ q = p + 1;
+ while (*q && !isspace((unsigned char)*q))
+ q++;
+ *s = malloc(q - p + 1);
+ if (*s)
+ {
+ memcpy(*s, p, q - p);
+ (*s)[q - p] = 0;
+ }
+ free(line);
+ fclose(fp);
+ return (*s) ? ARES_SUCCESS : ARES_ENOMEM;
+ }
+ }
+ free(line);
+ fclose(fp);
+ if (status != ARES_SUCCESS)
+ return status;
+ }
+ }
}
if (channel->flags & ARES_FLAG_NOSEARCH || channel->ndomains == 0)
#include "ares_private.h"
void ares_send(ares_channel channel, const unsigned char *qbuf, int qlen,
- ares_callback callback, void *arg)
+ ares_callback callback, void *arg)
{
struct query *query;
int i;
#include "ares_private.h"
struct timeval *ares_timeout(ares_channel channel, struct timeval *maxtv,
- struct timeval *tvbuf)
+ struct timeval *tvbuf)
{
struct query *query;
time_t now;
for (query = channel->queries; query; query = query->next)
{
if (query->timeout == 0)
- continue;
+ continue;
offset = query->timeout - now;
if (offset < 0)
- offset = 0;
+ offset = 0;
if (min_offset == -1 || offset < min_offset)
- min_offset = offset;
+ min_offset = offset;
}
/* If we found a minimum timeout and it's sooner than the one
projects / platform / upstream / c-ares.git / commitdiff