#include "misc.h"
#endif
-//#define NDEBUG
+/* #define NDEBUG */
#ifndef DNS_USE_CPU_CLOCK_FOR_ID
#ifndef DNS_USE_GETTIMEOFDAY_FOR_ID
#endif
#endif
-// #define _POSIX_C_SOURCE 200507
+/* #define _POSIX_C_SOURCE 200507 */
#define _GNU_SOURCE
#ifdef DNS_USE_CPU_CLOCK_FOR_ID
#define MIN(a,b) ((a)<(b)?(a):(b))
#ifdef __USE_ISOC99B
-// libevent doesn't work without this
+/* libevent doesn't work without this */
typedef uint8_t u_char;
typedef unsigned int uint;
#endif
#define u16 uint16_t
#define u8 uint8_t
-#define MAX_ADDRS 4 // maximum number of addresses from a single packet
-// which we bother recording
+#define MAX_ADDRS 4 /* maximum number of addresses from a single packet */
+/* which we bother recording */
#define TYPE_A EVDNS_TYPE_A
#define TYPE_CNAME 5
#define CLASS_INET EVDNS_CLASS_INET
struct request {
- u8 *request; // the dns packet data
+ u8 *request; /* the dns packet data */
unsigned int request_len;
int reissue_count;
- int tx_count; // the number of times that this packet has been sent
- unsigned int request_type; // TYPE_PTR or TYPE_A
- void *user_pointer; // the pointer given to us for this request
+ int tx_count; /* the number of times that this packet has been sent */
+ unsigned int request_type; /* TYPE_PTR or TYPE_A */
+ void *user_pointer; /* the pointer given to us for this request */
evdns_callback_type user_callback;
- struct nameserver *ns; // the server which we last sent it
+ struct nameserver *ns; /* the server which we last sent it */
- // elements used by the searching code
+ /* elements used by the searching code */
int search_index;
struct search_state *search_state;
- char *search_origname; // needs to be free()ed
+ char *search_origname; /* needs to be free()ed */
int search_flags;
- // these objects are kept in a circular list
+ /* these objects are kept in a circular list */
struct request *next, *prev;
struct event timeout_event;
- u16 trans_id; // the transaction id
- char request_appended; // true if the request pointer is data which follows this struct
- char transmit_me; // needs to be transmitted
+ u16 trans_id; /* the transaction id */
+ char request_appended; /* true if the request pointer is data which follows this struct */
+ char transmit_me; /* needs to be transmitted */
};
#ifndef HAVE_STRUCT_IN6_ADDR
};
struct nameserver {
- int socket; // a connected UDP socket
+ int socket; /* a connected UDP socket */
u32 address;
- int failed_times; // number of times which we have given this server a chance
- int timedout; // number of times in a row a request has timed out
+ int failed_times; /* number of times which we have given this server a chance */
+ int timedout; /* number of times in a row a request has timed out */
struct event event;
- // these objects are kept in a circular list
+ /* these objects are kept in a circular list */
struct nameserver *next, *prev;
- struct event timeout_event; // used to keep the timeout for
- // when we next probe this server.
- // Valid if state == 0
- char state; // zero if we think that this server is down
- char choked; // true if we have an EAGAIN from this server's socket
- char write_waiting; // true if we are waiting for EV_WRITE events
+ struct event timeout_event; /* used to keep the timeout for */
+ /* when we next probe this server. */
+ /* Valid if state == 0 */
+ char state; /* zero if we think that this server is down */
+ char choked; /* true if we have an EAGAIN from this server's socket */
+ char write_waiting; /* true if we are waiting for EV_WRITE events */
};
static struct request *req_head = NULL, *req_waiting_head = NULL;
static struct nameserver *server_head = NULL;
-// Represents a local port where we're listening for DNS requests. Right now,
-// only UDP is supported.
+/* Represents a local port where we're listening for DNS requests. Right now, */
+/* only UDP is supported. */
struct evdns_server_port {
- int socket; // socket we use to read queries and write replies.
- int refcnt; // reference count.
- char choked; // Are we currently blocked from writing?
- char closing; // Are we trying to close this port, pending writes?
- evdns_request_callback_fn_type user_callback; // Fn to handle requests
- void *user_data; // Opaque pointer passed to user_callback
- struct event event; // Read/write event
- // circular list of replies that we want to write.
+ int socket; /* socket we use to read queries and write replies. */
+ int refcnt; /* reference count. */
+ char choked; /* Are we currently blocked from writing? */
+ char closing; /* Are we trying to close this port, pending writes? */
+ evdns_request_callback_fn_type user_callback; /* Fn to handle requests */
+ void *user_data; /* Opaque pointer passed to user_callback */
+ struct event event; /* Read/write event */
+ /* circular list of replies that we want to write. */
struct server_request *pending_replies;
};
-// Represents part of a reply being built. (That is, a single RR.)
+/* Represents part of a reply being built. (That is, a single RR.) */
struct server_reply_item {
- struct server_reply_item *next; // next item in sequence.
- char *name; // name part of the RR
- u16 type : 16; // The RR type
- u16 class : 16; // The RR class (usually CLASS_INET)
- u32 ttl; // The RR TTL
- char is_name; // True iff data is a label
- u16 datalen; // Length of data; -1 if data is a label
- void *data; // The contents of the RR
+ struct server_reply_item *next; /* next item in sequence. */
+ char *name; /* name part of the RR */
+ u16 type : 16; /* The RR type */
+ u16 class : 16; /* The RR class (usually CLASS_INET) */
+ u32 ttl; /* The RR TTL */
+ char is_name; /* True iff data is a label */
+ u16 datalen; /* Length of data; -1 if data is a label */
+ void *data; /* The contents of the RR */
};
-// Represents a request that we've received as a DNS server, and holds
-// the components of the reply as we're constructing it.
+/* Represents a request that we've received as a DNS server, and holds */
+/* the components of the reply as we're constructing it. */
struct server_request {
- // Pointers to the next and previous entries on the list of replies
- // that we're waiting to write. Only set if we have tried to respond
- // and gotten EAGAIN.
+ /* Pointers to the next and previous entries on the list of replies */
+ /* that we're waiting to write. Only set if we have tried to respond */
+ /* and gotten EAGAIN. */
struct server_request *next_pending;
struct server_request *prev_pending;
- u16 trans_id; // Transaction id.
- struct evdns_server_port *port; // Which port received this request on?
- struct sockaddr_storage addr; // Where to send the response
- socklen_t addrlen; // length of addr
+ u16 trans_id; /* Transaction id. */
+ struct evdns_server_port *port; /* Which port received this request on? */
+ struct sockaddr_storage addr; /* Where to send the response */
+ socklen_t addrlen; /* length of addr */
- int n_answer; // how many answer RRs have been set?
- int n_authority; // how many authority RRs have been set?
- int n_additional; // how many additional RRs have been set?
+ int n_answer; /* how many answer RRs have been set? */
+ int n_authority; /* how many authority RRs have been set? */
+ int n_additional; /* how many additional RRs have been set? */
- struct server_reply_item *answer; // linked list of answer RRs
- struct server_reply_item *authority; // linked list of authority RRs
- struct server_reply_item *additional; // linked list of additional RRs
+ struct server_reply_item *answer; /* linked list of answer RRs */
+ struct server_reply_item *authority; /* linked list of authority RRs */
+ struct server_reply_item *additional; /* linked list of additional RRs */
- // Constructed response. Only set once we're ready to send a reply.
- // Once this is set, the RR fields are cleared, and no more should be set.
+ /* Constructed response. Only set once we're ready to send a reply. */
+ /* Once this is set, the RR fields are cleared, and no more should be set. */
char *response;
size_t response_len;
- // Caller-visible fields: flags, questions.
+ /* Caller-visible fields: flags, questions. */
struct evdns_server_request base;
};
-// helper macro
+/* helper macro */
#define OFFSET_OF(st, member) ((off_t) (((char*)&((st*)0)->member)-(char*)0))
-// Given a pointer to an evdns_server_request, get the corresponding
-// server_request.
+/* Given a pointer to an evdns_server_request, get the corresponding */
+/* server_request. */
#define TO_SERVER_REQUEST(base_ptr) \
((struct server_request*) \
(((char*)(base_ptr) - OFFSET_OF(struct server_request, base))))
-// The number of good nameservers that we have
+/* The number of good nameservers that we have */
static int global_good_nameservers = 0;
-// inflight requests are contained in the req_head list
-// and are actually going out across the network
+/* inflight requests are contained in the req_head list */
+/* and are actually going out across the network */
static int global_requests_inflight = 0;
-// requests which aren't inflight are in the waiting list
-// and are counted here
+/* requests which aren't inflight are in the waiting list */
+/* and are counted here */
static int global_requests_waiting = 0;
static int global_max_requests_inflight = 64;
-static struct timeval global_timeout = {5, 0}; // 5 seconds
-static int global_max_reissues = 1; // a reissue occurs when we get some errors from the server
-static int global_max_retransmits = 3; // number of times we'll retransmit a request which timed out
-// number of timeouts in a row before we consider this server to be down
+static struct timeval global_timeout = {5, 0}; /* 5 seconds */
+static int global_max_reissues = 1; /* a reissue occurs when we get some errors from the server */
+static int global_max_retransmits = 3; /* number of times we'll retransmit a request which timed out */
+/* number of timeouts in a row before we consider this server to be down */
static int global_max_nameserver_timeout = 3;
-// These are the timeout values for nameservers. If we find a nameserver is down
-// we try to probe it at intervals as given below. Values are in seconds.
+/* These are the timeout values for nameservers. If we find a nameserver is down */
+/* we try to probe it at intervals as given below. Values are in seconds. */
static const struct timeval global_nameserver_timeouts[] = {{10, 0}, {60, 0}, {300, 0}, {900, 0}, {3600, 0}};
static const int global_nameserver_timeouts_length = sizeof(global_nameserver_timeouts)/sizeof(struct timeval);
#define log _evdns_log
-// This walks the list of inflight requests to find the
-// one with a matching transaction id. Returns NULL on
-// failure
+/* This walks the list of inflight requests to find the */
+/* one with a matching transaction id. Returns NULL on */
+/* failure */
static struct request *
request_find_from_trans_id(u16 trans_id) {
struct request *req = req_head, *const started_at = req_head;
return NULL;
}
-// a libevent callback function which is called when a nameserver
-// has gone down and we want to test if it has came back to life yet
+/* a libevent callback function which is called when a nameserver */
+/* has gone down and we want to test if it has came back to life yet */
static void
nameserver_prod_callback(int fd, short events, void *arg) {
struct nameserver *const ns = (struct nameserver *) arg;
nameserver_send_probe(ns);
}
-// a libevent callback which is called when a nameserver probe (to see if
-// it has come back to life) times out. We increment the count of failed_times
-// and wait longer to send the next probe packet.
+/* a libevent callback which is called when a nameserver probe (to see if */
+/* it has come back to life) times out. We increment the count of failed_times */
+/* and wait longer to send the next probe packet. */
static void
nameserver_probe_failed(struct nameserver *const ns) {
const struct timeval * timeout;
(void) evtimer_del(&ns->timeout_event);
if (ns->state == 1) {
- // This can happen if the nameserver acts in a way which makes us mark
- // it as bad and then starts sending good replies.
+ /* This can happen if the nameserver acts in a way which makes us mark */
+ /* it as bad and then starts sending good replies. */
return;
}
log(EVDNS_LOG_WARN,
"Error from libevent when adding timer event for %s",
debug_ntoa(ns->address));
- // ???? Do more?
+ /* ???? Do more? */
}
}
-// called when a nameserver has been deemed to have failed. For example, too
-// many packets have timed out etc
+/* called when a nameserver has been deemed to have failed. For example, too */
+/* many packets have timed out etc */
static void
nameserver_failed(struct nameserver *const ns, const char *msg) {
struct request *req, *started_at;
- // if this nameserver has already been marked as failed
- // then don't do anything
+ /* if this nameserver has already been marked as failed */
+ /* then don't do anything */
if (!ns->state) return;
log(EVDNS_LOG_WARN, "Nameserver %s has failed: %s",
log(EVDNS_LOG_WARN,
"Error from libevent when adding timer event for %s",
debug_ntoa(ns->address));
- // ???? Do more?
+ /* ???? Do more? */
}
- // walk the list of inflight requests to see if any can be reassigned to
- // a different server. Requests in the waiting queue don't have a
- // nameserver assigned yet
+ /* walk the list of inflight requests to see if any can be reassigned to */
+ /* a different server. Requests in the waiting queue don't have a */
+ /* nameserver assigned yet */
- // if we don't have *any* good nameservers then there's no point
- // trying to reassign requests to one
+ /* if we don't have *any* good nameservers then there's no point */
+ /* trying to reassign requests to one */
if (!global_good_nameservers) return;
req = req_head;
if (req) {
do {
if (req->tx_count == 0 && req->ns == ns) {
- // still waiting to go out, can be moved
- // to another server
+ /* still waiting to go out, can be moved */
+ /* to another server */
req->ns = nameserver_pick();
}
req = req->next;
*((u16 *) req->request) = htons(trans_id);
}
-// Called to remove a request from a list and dealloc it.
-// head is a pointer to the head of the list it should be
-// removed from or NULL if the request isn't in a list.
+/* Called to remove a request from a list and dealloc it. */
+/* head is a pointer to the head of the list it should be */
+/* removed from or NULL if the request isn't in a list. */
static void
request_finished(struct request *const req, struct request **head) {
if (head) {
if (req->next == req) {
- // only item in the list
+ /* only item in the list */
*head = NULL;
} else {
req->next->prev = req->prev;
global_requests_inflight--;
if (!req->request_appended) {
- // need to free the request data on it's own
+ /* need to free the request data on it's own */
free(req->request);
} else {
- // the request data is appended onto the header
- // so everything gets free()ed when we:
+ /* the request data is appended onto the header */
+ /* so everything gets free()ed when we: */
}
free(req);
evdns_requests_pump_waiting_queue();
}
-// This is called when a server returns a funny error code.
-// We try the request again with another server.
-//
-// return:
-// 0 ok
-// 1 failed/reissue is pointless
+/* This is called when a server returns a funny error code. */
+/* We try the request again with another server. */
+/* */
+/* return: */
+/* 0 ok */
+/* 1 failed/reissue is pointless */
static int
request_reissue(struct request *req) {
const struct nameserver *const last_ns = req->ns;
- // the last nameserver should have been marked as failing
- // by the caller of this function, therefore pick will try
- // not to return it
+ /* the last nameserver should have been marked as failing */
+ /* by the caller of this function, therefore pick will try */
+ /* not to return it */
req->ns = nameserver_pick();
if (req->ns == last_ns) {
- // ... but pick did return it
- // not a lot of point in trying again with the
- // same server
+ /* ... but pick did return it */
+ /* not a lot of point in trying again with the */
+ /* same server */
return 1;
}
return 0;
}
-// this function looks for space on the inflight queue and promotes
-// requests from the waiting queue if it can.
+/* this function looks for space on the inflight queue and promotes */
+/* requests from the waiting queue if it can. */
static void
evdns_requests_pump_waiting_queue(void) {
while (global_requests_inflight < global_max_requests_inflight &&
global_requests_waiting) {
struct request *req;
- // move a request from the waiting queue to the inflight queue
+ /* move a request from the waiting queue to the inflight queue */
assert(req_waiting_head);
if (req_waiting_head->next == req_waiting_head) {
- // only one item in the queue
+ /* only one item in the queue */
req = req_waiting_head;
req_waiting_head = NULL;
} else {
assert(0);
}
-// this processes a parsed reply packet
+/* this processes a parsed reply packet */
static void
reply_handle(struct request *const req, u16 flags, u32 ttl, struct reply *reply) {
int error;
static const int error_codes[] = {DNS_ERR_FORMAT, DNS_ERR_SERVERFAILED, DNS_ERR_NOTEXIST, DNS_ERR_NOTIMPL, DNS_ERR_REFUSED};
if (flags & 0x020f || !reply || !reply->have_answer) {
- // there was an error
+ /* there was an error */
if (flags & 0x0200) {
error = DNS_ERR_TRUNCATED;
} else {
switch(error) {
case DNS_ERR_NOTIMPL:
case DNS_ERR_REFUSED:
- // we regard these errors as marking a bad nameserver
+ /* we regard these errors as marking a bad nameserver */
if (req->reissue_count < global_max_reissues) {
char msg[64];
snprintf(msg, sizeof(msg), "Bad response %d (%s)",
}
break;
case DNS_ERR_SERVERFAILED:
- // rcode 2 (servfailed) sometimes means "we are broken" and
- // sometimes (with some binds) means "that request was very
- // confusing." Treat this as a timeout, not a failure.
+ /* rcode 2 (servfailed) sometimes means "we are broken" and
+ * sometimes (with some binds) means "that request was very
+ * confusing." Treat this as a timeout, not a failure.
+ */
log(EVDNS_LOG_DEBUG, "Got a SERVERFAILED from nameserver %s; "
"will allow the request to time out.",
debug_ntoa(req->ns->address));
break;
default:
- // we got a good reply from the nameserver
+ /* we got a good reply from the nameserver */
nameserver_up(req->ns);
}
if (req->search_state && req->request_type != TYPE_PTR) {
- // if we have a list of domains to search in, try the next one
+ /* if we have a list of domains to search in, try the next one */
if (!search_try_next(req)) {
- // a new request was issued so this request is finished and
- // the user callback will be made when that request (or a
- // child of it) finishes.
+ /* a new request was issued so this request is finished and */
+ /* the user callback will be made when that request (or a */
+ /* child of it) finishes. */
request_finished(req, &req_head);
return;
}
}
- // all else failed. Pass the failure up
+ /* all else failed. Pass the failure up */
reply_callback(req, 0, error, NULL);
request_finished(req, &req_head);
} else {
- // all ok, tell the user
+ /* all ok, tell the user */
reply_callback(req, ttl, 0, reply);
nameserver_up(req->ns);
request_finished(req, &req_head);
char *cp = name_out;
const char *const end = name_out + name_out_len;
- // Normally, names are a series of length prefixed strings terminated
- // with a length of 0 (the lengths are u8's < 63).
- // However, the length can start with a pair of 1 bits and that
- // means that the next 14 bits are a pointer within the current
- // packet.
+ /* Normally, names are a series of length prefixed strings terminated */
+ /* with a length of 0 (the lengths are u8's < 63). */
+ /* However, the length can start with a pair of 1 bits and that */
+ /* means that the next 14 bits are a pointer within the current */
+ /* packet. */
for(;;) {
u8 label_len;
return -1;
}
-// parses a raw request from a nameserver
+/* parses a raw request from a nameserver */
static int
reply_parse(u8 *packet, int length) {
- int j = 0; // index into packet
- u16 _t; // used by the macros
- u32 _t32; // used by the macros
- char tmp_name[256]; // used by the macros
+ int j = 0; /* index into packet */
+ u16 _t; /* used by the macros */
+ u32 _t32; /* used by the macros */
+ char tmp_name[256]; /* used by the macros */
u16 trans_id, questions, answers, authority, additional, datalength;
u16 flags = 0;
memset(&reply, 0, sizeof(reply));
- // If it's not an answer, it doesn't correspond to any request.
- if (!(flags & 0x8000)) return -1; // must be an answer
+ /* If it's not an answer, it doesn't correspond to any request. */
+ if (!(flags & 0x8000)) return -1; /* must be an answer */
if (flags & 0x020f) {
- // there was an error
+ /* there was an error */
goto err;
}
- // if (!answers) return; // must have an answer of some form
+ /* if (!answers) return; */ /* must have an answer of some form */
- // This macro skips a name in the DNS reply.
+ /* This macro skips a name in the DNS reply. */
#define SKIP_NAME \
do { tmp_name[0] = '\0'; \
if (name_parse(packet, length, &j, tmp_name, sizeof(tmp_name))<0) \
reply.type = req->request_type;
- // skip over each question in the reply
+ /* skip over each question in the reply */
for (i = 0; i < questions; ++i) {
- // the question looks like
- // <label:name><u16:type><u16:class>
+ /* the question looks like
+ * <label:name><u16:type><u16:class>
+ */
SKIP_NAME;
j += 4;
if (j >= length) goto err;
}
- // now we have the answer section which looks like
- // <label:name><u16:type><u16:class><u32:ttl><u16:len><data...>
+ /* now we have the answer section which looks like
+ * <label:name><u16:type><u16:class><u32:ttl><u16:len><data...>
+ */
for (i = 0; i < answers; ++i) {
u16 type, class;
addrtocopy = MIN(MAX_ADDRS - reply.data.a.addrcount, (unsigned)addrcount);
ttl_r = MIN(ttl_r, ttl);
- // we only bother with the first four addresses.
+ /* we only bother with the first four addresses. */
if (j + 4*addrtocopy > length) goto err;
memcpy(&reply.data.a.addresses[reply.data.a.addrcount],
packet + j, 4*addrtocopy);
}
if ((datalength & 15) != 0) /* not an even number of AAAAs. */
goto err;
- addrcount = datalength >> 4; // each address is 16 bytes long
+ addrcount = datalength >> 4; /* each address is 16 bytes long */
addrtocopy = MIN(MAX_ADDRS - reply.data.aaaa.addrcount, (unsigned)addrcount);
ttl_r = MIN(ttl_r, ttl);
- // we only bother with the first four addresses.
+ /* we only bother with the first four addresses. */
if (j + 16*addrtocopy > length) goto err;
memcpy(&reply.data.aaaa.addresses[reply.data.aaaa.addrcount],
packet + j, 16*addrtocopy);
reply.have_answer = 1;
if (reply.data.aaaa.addrcount == MAX_ADDRS) break;
} else {
- // skip over any other type of resource
+ /* skip over any other type of resource */
j += datalength;
}
}
return -1;
}
-// Parse a raw request (packet,length) sent to a nameserver port (port) from
-// a DNS client (addr,addrlen), and if it's well-formed, call the corresponding
-// callback.
+/* Parse a raw request (packet,length) sent to a nameserver port (port) from */
+/* a DNS client (addr,addrlen), and if it's well-formed, call the corresponding */
+/* callback. */
static int
request_parse(u8 *packet, int length, struct evdns_server_port *port, struct sockaddr *addr, socklen_t addrlen)
{
- int j = 0; // index into packet
- u16 _t; // used by the macros
- char tmp_name[256]; // used by the macros
+ int j = 0; /* index into packet */
+ u16 _t; /* used by the macros */
+ char tmp_name[256]; /* used by the macros */
int i;
u16 trans_id, flags, questions, answers, authority, additional;
struct server_request *server_req = NULL;
- // Get the header fields
+ /* Get the header fields */
GET16(trans_id);
GET16(flags);
GET16(questions);
GET16(authority);
GET16(additional);
- if (flags & 0x8000) return -1; // Must not be an answer.
- if (flags & 0x7800) return -1; // only standard queries are supported
- flags &= 0x0300; // Only TC and RD get preserved.
+ if (flags & 0x8000) return -1; /* Must not be an answer. */
+ if (flags & 0x7800) return -1; /* only standard queries are supported */
+ flags &= 0x0300; /* Only TC and RD get preserved. */
server_req = malloc(sizeof(struct server_request));
if (server_req == NULL) return -1;
server_req->base.questions[server_req->base.nquestions++] = q;
}
- // Ignore answers, authority, and additional.
+ /* Ignore answers, authority, and additional. */
server_req->port = port;
port->refcnt++;
#undef GET8
}
-// Try to choose a strong transaction id which isn't already in flight
+/* Try to choose a strong transaction id which isn't already in flight */
static u16
transaction_id_pick(void) {
for (;;) {
#ifdef DNS_USE_OPENSSL_FOR_ID
u16 trans_id;
if (RAND_pseudo_bytes((u8 *) &trans_id, 2) == -1) {
- /* // in the case that the RAND call fails we back
- // down to using gettimeofday.
+ /* in the case that the RAND call fails we back */
+ /* down to using gettimeofday. */
struct timeval tv;
gettimeofday(&tv, NULL);
trans_id = tv.tv_usec & 0xffff; */
#endif
if (trans_id == 0xffff) continue;
- // now check to see if that id is already inflight
+ /* now check to see if that id is already inflight */
req = started_at = req_head;
if (req) {
do {
req = req->next;
} while (req != started_at);
}
- // we didn't find it, so this is a good id
+ /* we didn't find it, so this is a good id */
if (req == started_at) return trans_id;
}
}
-// choose a namesever to use. This function will try to ignore
-// nameservers which we think are down and load balance across the rest
-// by updating the server_head global each time.
+/* choose a namesever to use. This function will try to ignore */
+/* nameservers which we think are down and load balance across the rest */
+/* by updating the server_head global each time. */
static struct nameserver *
nameserver_pick(void) {
struct nameserver *started_at = server_head, *picked;
if (!server_head) return NULL;
- // if we don't have any good nameservers then there's no
- // point in trying to find one.
+ /* if we don't have any good nameservers then there's no */
+ /* point in trying to find one. */
if (!global_good_nameservers) {
server_head = server_head->next;
return server_head;
}
- // remember that nameservers are in a circular list
+ /* remember that nameservers are in a circular list */
for (;;) {
if (server_head->state) {
- // we think this server is currently good
+ /* we think this server is currently good */
picked = server_head;
server_head = server_head->next;
return picked;
server_head = server_head->next;
if (server_head == started_at) {
- // all the nameservers seem to be down
- // so we just return this one and hope for the
- // best
+ /* all the nameservers seem to be down */
+ /* so we just return this one and hope for the */
+ /* best */
assert(global_good_nameservers == 0);
picked = server_head;
server_head = server_head->next;
}
}
-// this is called when a namesever socket is ready for reading
+/* this is called when a namesever socket is ready for reading */
static void
nameserver_read(struct nameserver *ns) {
u8 packet[1500];
}
}
-// Read a packet from a DNS client on a server port s, parse it, and
-// act accordingly.
+/* Read a packet from a DNS client on a server port s, parse it, and */
+/* act accordingly. */
static void
server_port_read(struct evdns_server_port *s) {
u8 packet[1500];
}
}
-// Try to write all pending replies on a given DNS server port.
+/* Try to write all pending replies on a given DNS server port. */
static void
server_port_flush(struct evdns_server_port *port)
{
log(EVDNS_LOG_WARN, "Error %s (%d) while writing response to port; dropping", strerror(err), err);
}
if (server_request_free(req)) {
- // we released the last reference to req->port.
+ /* we released the last reference to req->port. */
return;
}
}
- // We have no more pending requests; stop listening for 'writeable' events.
+ /* We have no more pending requests; stop listening for 'writeable' events. */
(void) event_del(&port->event);
event_set(&port->event, port->socket, EV_READ | EV_PERSIST,
server_port_ready_callback, port);
if (event_add(&port->event, NULL) < 0) {
log(EVDNS_LOG_WARN, "Error from libevent when adding event for DNS server.");
- // ???? Do more?
+ /* ???? Do more? */
}
}
-// set if we are waiting for the ability to write to this server.
-// if waiting is true then we ask libevent for EV_WRITE events, otherwise
-// we stop these events.
+/* set if we are waiting for the ability to write to this server. */
+/* if waiting is true then we ask libevent for EV_WRITE events, otherwise */
+/* we stop these events. */
static void
nameserver_write_waiting(struct nameserver *ns, char waiting) {
if (ns->write_waiting == waiting) return;
if (event_add(&ns->event, NULL) < 0) {
log(EVDNS_LOG_WARN, "Error from libevent when adding event for %s",
debug_ntoa(ns->address));
- // ???? Do more?
+ /* ???? Do more? */
}
}
-// a callback function. Called by libevent when the kernel says that
-// a nameserver socket is ready for writing or reading
+/* a callback function. Called by libevent when the kernel says that */
+/* a nameserver socket is ready for writing or reading */
static void
nameserver_ready_callback(int fd, short events, void *arg) {
struct nameserver *ns = (struct nameserver *) arg;
}
}
-// a callback function. Called by libevent when the kernel says that
-// a server socket is ready for writing or reading.
+/* a callback function. Called by libevent when the kernel says that */
+/* a server socket is ready for writing or reading. */
static void
server_port_ready_callback(int fd, short events, void *arg) {
struct evdns_server_port *port = (struct evdns_server_port *) arg;
/* This is an inefficient representation; only use it via the dnslabel_table_*
* functions, so that is can be safely replaced with something smarter later. */
#define MAX_LABELS 128
-// Structures used to implement name compression
+/* Structures used to implement name compression */
struct dnslabel_entry { char *v; off_t pos; };
struct dnslabel_table {
- int n_labels; // number of current entries
- // map from name to position in message
+ int n_labels; /* number of current entries */
+ /* map from name to position in message */
struct dnslabel_entry labels[MAX_LABELS];
};
-// Initialize dnslabel_table.
+/* Initialize dnslabel_table. */
static void
dnslabel_table_init(struct dnslabel_table *table)
{
table->n_labels = 0;
}
-// Free all storage held by table, but not the table itself.
+/* Free all storage held by table, but not the table itself. */
static void
dnslabel_clear(struct dnslabel_table *table)
{
table->n_labels = 0;
}
-// return the position of the label in the current message, or -1 if the label
-// hasn't been used yet.
+/* return the position of the label in the current message, or -1 if the label */
+/* hasn't been used yet. */
static int
dnslabel_table_get_pos(const struct dnslabel_table *table, const char *label)
{
return -1;
}
-// remember that we've used the label at position pos
+/* remember that we've used the label at position pos */
static int
dnslabel_table_add(struct dnslabel_table *table, const char *label, off_t pos)
{
return (0);
}
-// Converts a string to a length-prefixed set of DNS labels, starting
-// at buf[j]. name and buf must not overlap. name_len should be the length
-// of name. table is optional, and is used for compression.
-//
-// Input: abc.def
-// Output: <3>abc<3>def<0>
-//
-// Returns the first index after the encoded name, or negative on error.
-// -1 label was > 63 bytes
-// -2 name too long to fit in buffer.
-//
+/* Converts a string to a length-prefixed set of DNS labels, starting */
+/* at buf[j]. name and buf must not overlap. name_len should be the length */
+/* of name. table is optional, and is used for compression. */
+/* */
+/* Input: abc.def */
+/* Output: <3>abc<3>def<0> */
+/* */
+/* Returns the first index after the encoded name, or negative on error. */
+/* -1 label was > 63 bytes */
+/* -2 name too long to fit in buffer. */
+/* */
static off_t
dnsname_to_labels(u8 *const buf, size_t buf_len, off_t j,
const char *name, const int name_len,
j += end - start;
break;
} else {
- // append length of the label.
+ /* append length of the label. */
const unsigned int label_len = name - start;
if (label_len > 63) return -1;
if ((size_t)(j+label_len+1) > buf_len) return -2;
memcpy(buf + j, start, name - start);
j += name - start;
- // hop over the '.'
+ /* hop over the '.' */
name++;
}
}
- // the labels must be terminated by a 0.
- // It's possible that the name ended in a .
- // in which case the zero is already there
+ /* the labels must be terminated by a 0. */
+ /* It's possible that the name ended in a . */
+ /* in which case the zero is already there */
if (!j || buf[j-1]) buf[j++] = 0;
return j;
overflow:
return (-2);
}
-// Finds the length of a dns request for a DNS name of the given
-// length. The actual request may be smaller than the value returned
-// here
+/* Finds the length of a dns request for a DNS name of the given */
+/* length. The actual request may be smaller than the value returned */
+/* here */
static int
evdns_request_len(const int name_len) {
- return 96 + // length of the DNS standard header
+ return 96 + /* length of the DNS standard header */
name_len + 2 +
- 4; // space for the resource type
+ 4; /* space for the resource type */
}
-// build a dns request packet into buf. buf should be at least as long
-// as evdns_request_len told you it should be.
-//
-// Returns the amount of space used. Negative on error.
+/* build a dns request packet into buf. buf should be at least as long */
+/* as evdns_request_len told you it should be. */
+/* */
+/* Returns the amount of space used. Negative on error. */
static int
evdns_request_data_build(const char *const name, const int name_len,
const u16 trans_id, const u16 type, const u16 class,
u8 *const buf, size_t buf_len) {
- off_t j = 0; // current offset into buf
- u16 _t; // used by the macros
+ off_t j = 0; /* current offset into buf */
+ u16 _t; /* used by the macros */
APPEND16(trans_id);
- APPEND16(0x0100); // standard query, recusion needed
- APPEND16(1); // one question
- APPEND16(0); // no answers
- APPEND16(0); // no authority
- APPEND16(0); // no additional
+ APPEND16(0x0100); /* standard query, recusion needed */
+ APPEND16(1); /* one question */
+ APPEND16(0); /* no answers */
+ APPEND16(0); /* no authority */
+ APPEND16(0); /* no additional */
j = dnsname_to_labels(buf, buf_len, j, name, name_len, NULL);
if (j < 0) {
return (-1);
}
-// exported function
+/* exported function */
struct evdns_server_port *
evdns_add_server_port(int socket, int is_tcp, evdns_request_callback_fn_type cb, void *user_data)
{
return NULL;
memset(port, 0, sizeof(struct evdns_server_port));
- assert(!is_tcp); // TCP sockets not yet implemented
+ assert(!is_tcp); /* TCP sockets not yet implemented */
port->socket = socket;
port->refcnt = 1;
port->choked = 0;
event_set(&port->event, port->socket, EV_READ | EV_PERSIST,
server_port_ready_callback, port);
- event_add(&port->event, NULL); // check return.
+ event_add(&port->event, NULL); /* check return. */
return port;
}
-// exported function
+/* exported function */
void
evdns_close_server_port(struct evdns_server_port *port)
{
port->closing = 1;
}
-// exported function
+/* exported function */
int
evdns_server_request_add_reply(struct evdns_server_request *_req, int section, const char *name, int type, int class, int ttl, int datalen, int is_name, const char *data)
{
return 0;
}
-// exported function
+/* exported function */
int
evdns_server_request_add_a_reply(struct evdns_server_request *req, const char *name, int n, void *addrs, int ttl)
{
ttl, n*4, 0, addrs);
}
-// exported function
+/* exported function */
int
evdns_server_request_add_aaaa_reply(struct evdns_server_request *req, const char *name, int n, void *addrs, int ttl)
{
ttl, n*16, 0, addrs);
}
-// exported function
+/* exported function */
int
evdns_server_request_add_ptr_reply(struct evdns_server_request *req, struct in_addr *in, const char *inaddr_name, const char *hostname, int ttl)
{
ttl, -1, 1, hostname);
}
-// exported function
+/* exported function */
int
evdns_server_request_add_cname_reply(struct evdns_server_request *req, const char *name, const char *cname, int ttl)
{
return (0);
}
-// exported function
+/* exported function */
int
evdns_server_request_respond(struct evdns_server_request *_req, int err)
{
return 0;
}
-// Free all storage held by RRs in req.
+/* Free all storage held by RRs in req. */
static void
server_request_free_answers(struct server_request *req)
{
}
}
-// Free all storage held by req, and remove links to it.
-// return true iff we just wound up freeing the server_port.
+/* Free all storage held by req, and remove links to it. */
+/* return true iff we just wound up freeing the server_port. */
static int
server_request_free(struct server_request *req)
{
return (0);
}
-// Free all storage held by an evdns_server_port. Only called when
+/* Free all storage held by an evdns_server_port. Only called when */
static void
server_port_free(struct evdns_server_port *port)
{
port->socket = -1;
}
(void) event_del(&port->event);
- // XXXX actually free the port? -NM
+ /* XXXX actually free the port? -NM */
}
-// exported function
+/* exported function */
int
evdns_server_request_drop(struct evdns_server_request *_req)
{
return 0;
}
-// exported function
+/* exported function */
int
evdns_server_request_get_requesting_addr(struct evdns_server_request *_req, struct sockaddr *sa, int addr_len)
{
#undef APPEND16
#undef APPEND32
-// this is a libevent callback function which is called when a request
-// has timed out.
+/* this is a libevent callback function which is called when a request */
+/* has timed out. */
static void
evdns_request_timeout_callback(int fd, short events, void *arg) {
struct request *const req = (struct request *) arg;
(void) evtimer_del(&req->timeout_event);
if (req->tx_count >= global_max_retransmits) {
- // this request has failed
+ /* this request has failed */
reply_callback(req, 0, DNS_ERR_TIMEOUT, NULL);
request_finished(req, &req_head);
} else {
- // retransmit it
+ /* retransmit it */
evdns_request_transmit(req);
}
}
-// try to send a request to a given server.
-//
-// return:
-// 0 ok
-// 1 temporary failure
-// 2 other failure
+/* try to send a request to a given server. */
+/* */
+/* return: */
+/* 0 ok */
+/* 1 temporary failure */
+/* 2 other failure */
static int
evdns_request_transmit_to(struct request *req, struct nameserver *server) {
const int r = send(server->socket, req->request, req->request_len, 0);
nameserver_failed(req->ns, strerror(err));
return 2;
} else if (r != (int)req->request_len) {
- return 1; // short write
+ return 1; /* short write */
} else {
return 0;
}
}
-// try to send a request, updating the fields of the request
-// as needed
-//
-// return:
-// 0 ok
-// 1 failed
+/* try to send a request, updating the fields of the request */
+/* as needed */
+/* */
+/* return: */
+/* 0 ok */
+/* 1 failed */
static int
evdns_request_transmit(struct request *req) {
int retcode = 0, r;
- // if we fail to send this packet then this flag marks it
- // for evdns_transmit
+ /* if we fail to send this packet then this flag marks it */
+ /* for evdns_transmit */
req->transmit_me = 1;
if (req->trans_id == 0xffff) abort();
if (req->ns->choked) {
- // don't bother trying to write to a socket
- // which we have had EAGAIN from
+ /* don't bother trying to write to a socket */
+ /* which we have had EAGAIN from */
return 1;
}
r = evdns_request_transmit_to(req, req->ns);
switch (r) {
case 1:
- // temp failure
+ /* temp failure */
req->ns->choked = 1;
nameserver_write_waiting(req->ns, 1);
return 1;
case 2:
- // failed in some other way
+ /* failed in some other way */
retcode = 1;
- // fall through
+ /* fall through */
default:
- // all ok
+ /* all ok */
log(EVDNS_LOG_DEBUG,
"Setting timeout for request %lx", (unsigned long) req);
evtimer_set(&req->timeout_event, evdns_request_timeout_callback, req);
log(EVDNS_LOG_WARN,
"Error from libevent when adding timer for request %lx",
(unsigned long) req);
- // ???? Do more?
+ /* ???? Do more? */
}
req->tx_count++;
req->transmit_me = 0;
(void) addresses;
if (result == DNS_ERR_NONE || result == DNS_ERR_NOTEXIST) {
- // this is a good reply
+ /* this is a good reply */
nameserver_up(ns);
} else nameserver_probe_failed(ns);
}
static void
nameserver_send_probe(struct nameserver *const ns) {
struct request *req;
- // here we need to send a probe to a given nameserver
- // in the hope that it is up now.
+ /* here we need to send a probe to a given nameserver */
+ /* in the hope that it is up now. */
log(EVDNS_LOG_DEBUG, "Sending probe to %s", debug_ntoa(ns->address));
req = request_new(TYPE_A, "www.google.com", DNS_QUERY_NO_SEARCH, nameserver_probe_callback, ns);
if (!req) return;
- // we force this into the inflight queue no matter what
+ /* we force this into the inflight queue no matter what */
request_trans_id_set(req, transaction_id_pick());
req->ns = ns;
request_submit(req);
}
-// returns:
-// 0 didn't try to transmit anything
-// 1 tried to transmit something
+/* returns: */
+/* 0 didn't try to transmit anything */
+/* 1 tried to transmit something */
static int
evdns_transmit(void) {
char did_try_to_transmit = 0;
if (req_head) {
struct request *const started_at = req_head, *req = req_head;
- // first transmit all the requests which are currently waiting
+ /* first transmit all the requests which are currently waiting */
do {
if (req->transmit_me) {
did_try_to_transmit = 1;
return did_try_to_transmit;
}
-// exported function
+/* exported function */
int
evdns_count_nameservers(void)
{
return n;
}
-// exported function
+/* exported function */
int
evdns_clear_nameservers_and_suspend(void)
{
struct request *next = req->next;
req->tx_count = req->reissue_count = 0;
req->ns = NULL;
- // ???? What to do about searches?
+ /* ???? What to do about searches? */
(void) evtimer_del(&req->timeout_event);
req->trans_id = 0;
req->transmit_me = 0;
}
-// exported function
+/* exported function */
int
evdns_resume(void)
{
static int
_evdns_nameserver_add_impl(unsigned long int address, int port) {
- // first check to see if we already have this nameserver
+ /* first check to see if we already have this nameserver */
const struct nameserver *server = server_head, *const started_at = server_head;
struct nameserver *ns;
log(EVDNS_LOG_DEBUG, "Added nameserver %s", debug_ntoa(address));
- // insert this nameserver into the list of them
+ /* insert this nameserver into the list of them */
if (!server_head) {
ns->next = ns->prev = ns;
server_head = ns;
return err;
}
-// exported function
+/* exported function */
int
evdns_nameserver_add(unsigned long int address) {
return _evdns_nameserver_add_impl(address, 53);
}
-// exported function
+/* exported function */
int
evdns_nameserver_ip_add(const char *ip_as_string) {
struct in_addr ina;
return _evdns_nameserver_add_impl(ina.s_addr, port);
}
-// insert into the tail of the queue
+/* insert into the tail of the queue */
static void
evdns_request_insert(struct request *req, struct request **head) {
if (!*head) {
const int name_len = strlen(name);
const int request_max_len = evdns_request_len(name_len);
const u16 trans_id = issuing_now ? transaction_id_pick() : 0xffff;
- // the request data is alloced in a single block with the header
+ /* the request data is alloced in a single block with the header */
struct request *const req =
(struct request *) malloc(sizeof(struct request) + request_max_len);
int rlen;
if (!req) return NULL;
memset(req, 0, sizeof(struct request));
- // request data lives just after the header
+ /* request data lives just after the header */
req->request = ((u8 *) req) + sizeof(struct request);
- // denotes that the request data shouldn't be free()ed
+ /* denotes that the request data shouldn't be free()ed */
req->request_appended = 1;
rlen = evdns_request_data_build(name, name_len, trans_id,
type, CLASS_INET, req->request, request_max_len);
static void
request_submit(struct request *const req) {
if (req->ns) {
- // if it has a nameserver assigned then this is going
- // straight into the inflight queue
+ /* if it has a nameserver assigned then this is going */
+ /* straight into the inflight queue */
evdns_request_insert(req, &req_head);
global_requests_inflight++;
evdns_request_transmit(req);
}
}
-// exported function
+/* exported function */
int evdns_resolve_ipv4(const char *name, int flags,
evdns_callback_type callback, void *ptr) {
log(EVDNS_LOG_DEBUG, "Resolve requested for %s", name);
}
}
-// exported function
+/* exported function */
int evdns_resolve_ipv6(const char *name, int flags,
evdns_callback_type callback, void *ptr) {
log(EVDNS_LOG_DEBUG, "Resolve requested for %s", name);
return 0;
}
-/////////////////////////////////////////////////////////////////////
-// Search support
-//
-// the libc resolver has support for searching a number of domains
-// to find a name. If nothing else then it takes the single domain
-// from the gethostname() call.
-//
-// It can also be configured via the domain and search options in a
-// resolv.conf.
-//
-// The ndots option controls how many dots it takes for the resolver
-// to decide that a name is non-local and so try a raw lookup first.
+/*/////////////////////////////////////////////////////////////////// */
+/* Search support */
+/* */
+/* the libc resolver has support for searching a number of domains */
+/* to find a name. If nothing else then it takes the single domain */
+/* from the gethostname() call. */
+/* */
+/* It can also be configured via the domain and search options in a */
+/* resolv.conf. */
+/* */
+/* The ndots option controls how many dots it takes for the resolver */
+/* to decide that a name is non-local and so try a raw lookup first. */
struct search_domain {
int len;
struct search_domain *next;
- // the text string is appended to this structure
+ /* the text string is appended to this structure */
};
struct search_state {
global_search_state = search_state_new();
}
-// exported function
+/* exported function */
void
evdns_search_clear(void) {
search_postfix_clear();
global_search_state->head = sdomain;
}
-// reverse the order of members in the postfix list. This is needed because,
-// when parsing resolv.conf we push elements in the wrong order
+/* reverse the order of members in the postfix list. This is needed because, */
+/* when parsing resolv.conf we push elements in the wrong order */
static void
search_reverse(void) {
struct search_domain *cur, *prev = NULL, *next;
global_search_state->head = prev;
}
-// exported function
+/* exported function */
void
evdns_search_add(const char *domain) {
search_postfix_add(domain);
}
-// exported function
+/* exported function */
void
evdns_search_ndots_set(const int ndots) {
if (!global_search_state) global_search_state = search_state_new();
search_postfix_add(domainname);
}
-// warning: returns malloced string
+/* warning: returns malloced string */
static char *
search_make_new(const struct search_state *const state, int n, const char *const base_name) {
const int base_len = strlen(base_name);
for (dom = state->head; dom; dom = dom->next) {
if (!n--) {
- // this is the postfix we want
- // the actual postfix string is kept at the end of the structure
+ /* this is the postfix we want */
+ /* the actual postfix string is kept at the end of the structure */
const u8 *const postfix = ((u8 *) dom) + sizeof(struct search_domain);
const int postfix_len = dom->len;
char *const newname = (char *) malloc(base_len + need_to_append_dot + postfix_len + 1);
}
}
- // we ran off the end of the list and still didn't find the requested string
+ /* we ran off the end of the list and still didn't find the requested string */
abort();
return NULL; /* unreachable; stops warnings in some compilers. */
}
if ( ((flags & DNS_QUERY_NO_SEARCH) == 0) &&
global_search_state &&
global_search_state->num_domains) {
- // we have some domains to search
+ /* we have some domains to search */
struct request *req;
if (string_num_dots(name) >= global_search_state->ndots) {
req = request_new(type, name, flags, user_callback, user_arg);
}
}
-// this is called when a request has failed to find a name. We need to check
-// if it is part of a search and, if so, try the next name in the list
-// returns:
-// 0 another request has been submitted
-// 1 no more requests needed
+/* this is called when a request has failed to find a name. We need to check */
+/* if it is part of a search and, if so, try the next name in the list */
+/* returns: */
+/* 0 another request has been submitted */
+/* 1 no more requests needed */
static int
search_try_next(struct request *const req) {
if (req->search_state) {
- // it is part of a search
+ /* it is part of a search */
char *new_name;
struct request *newreq;
req->search_index++;
if (req->search_index >= req->search_state->num_domains) {
- // no more postfixes to try, however we may need to try
- // this name without a postfix
+ /* no more postfixes to try, however we may need to try */
+ /* this name without a postfix */
if (string_num_dots(req->search_origname) < req->search_state->ndots) {
- // yep, we need to try it raw
+ /* yep, we need to try it raw */
struct request *const newreq = request_new(req->request_type, req->search_origname, req->search_flags, req->user_callback, req->user_pointer);
log(EVDNS_LOG_DEBUG, "Search: trying raw query %s", req->search_origname);
if (newreq) {
}
}
-/////////////////////////////////////////////////////////////////////
-// Parsing resolv.conf files
+/*/////////////////////////////////////////////////////////////////// */
+/* Parsing resolv.conf files */
static void
evdns_resolv_set_defaults(int flags) {
- // if the file isn't found then we assume a local resolver
+ /* if the file isn't found then we assume a local resolver */
if (flags & DNS_OPTION_SEARCH) search_set_from_hostname();
if (flags & DNS_OPTION_NAMESERVERS) evdns_nameserver_ip_add("127.0.0.1");
}
}
#endif
-// helper version of atoi which returns -1 on error
+/* helper version of atoi which returns -1 on error */
static int
strtoint(const char *const str) {
char *endptr;
return r;
}
-// helper version of atoi that returns -1 on error and clips to bounds.
+/* helper version of atoi that returns -1 on error and clips to bounds. */
static int
strtoint_clipped(const char *const str, int min, int max)
{
return r;
}
-// exported function
+/* exported function */
int
evdns_set_option(const char *option, const char *val, int flags)
{
struct in_addr ina;
if (inet_aton(nameserver, &ina)) {
- // address is valid
+ /* address is valid */
evdns_nameserver_add(ina.s_addr);
}
} else if (!strcmp(first_token, "domain") && (flags & DNS_OPTION_SEARCH)) {
#undef NEXT_TOKEN
}
-// exported function
-// returns:
-// 0 no errors
-// 1 failed to open file
-// 2 failed to stat file
-// 3 file too large
-// 4 out of memory
-// 5 short read from file
+/* exported function */
+/* returns: */
+/* 0 no errors */
+/* 1 failed to open file */
+/* 2 failed to stat file */
+/* 3 file too large */
+/* 4 out of memory */
+/* 5 short read from file */
int
evdns_resolv_conf_parse(int flags, const char *const filename) {
struct stat st;
err = (flags & DNS_OPTION_NAMESERVERS) ? 6 : 0;
goto out1;
}
- if (st.st_size > 65535) { err = 3; goto out1; } // no resolv.conf should be any bigger
+ if (st.st_size > 65535) { err = 3; goto out1; } /* no resolv.conf should be any bigger */
resolv = (u8 *) malloc((size_t)st.st_size + 1);
if (!resolv) { err = 4; goto out1; }
assert(n < st.st_size);
}
if (r < 0) { err = 5; goto out2; }
- resolv[n] = 0; // we malloced an extra byte; this should be fine.
+ resolv[n] = 0; /* we malloced an extra byte; this should be fine. */
start = (char *) resolv;
for (;;) {
}
if (!server_head && (flags & DNS_OPTION_NAMESERVERS)) {
- // no nameservers were configured.
+ /* no nameservers were configured. */
evdns_nameserver_ip_add("127.0.0.1");
err = 6;
}
}
#ifdef WIN32
-// Add multiple nameservers from a space-or-comma-separated list.
+/* Add multiple nameservers from a space-or-comma-separated list. */
static int
evdns_nameserver_ip_add_line(const char *ips) {
const char *addr;
typedef DWORD(WINAPI *GetNetworkParams_fn_t)(FIXED_INFO *, DWORD*);
-// Use the windows GetNetworkParams interface in iphlpapi.dll to
-// figure out what our nameservers are.
+/* Use the windows GetNetworkParams interface in iphlpapi.dll to */
+/* figure out what our nameservers are. */
static int
load_nameservers_with_getnetworkparams(void)
{
- // Based on MSDN examples and inspection of c-ares code.
+ /* Based on MSDN examples and inspection of c-ares code. */
FIXED_INFO *fixed;
HMODULE handle = 0;
ULONG size = sizeof(FIXED_INFO);
projects / libevent / commitdiff