#endif
/* for debugging possible memory leaks. */
-#define malloc(x) tor_malloc(x)
-#define realloc(x,y) tor_realloc((x),(y))
-#define free(x) tor_free(x)
-#define _free(x) _tor_free(x)
+#define mm_malloc(x) tor_malloc(x)
+#define mm_realloc(x,y) tor_realloc((x),(y))
+#define mm_free(x) tor_free(x)
+#define mm_strdup(x) tor_strdup(x)
+#define _mm_free(x) _tor_free(x)
#undef MIN
#define MIN(a,b) ((a)<(b)?(a):(b))
/* which we bother recording */
#define TYPE_A EVDNS_TYPE_A
+#define TYPE_CNAME 5
#define TYPE_PTR EVDNS_TYPE_PTR
#define TYPE_AAAA EVDNS_TYPE_AAAA
#define CLEAR(x) do { memset((x), 0, sizeof(*(x))); } while(0)
-struct request {
+struct evdns_request {
u8 *request; /* the dns packet data */
unsigned int request_len;
int reissue_count;
/* 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 mm_free()ed */
int search_flags;
/* these objects are kept in a circular list */
- struct request *next, *prev;
+ struct evdns_request *next, *prev;
struct event timeout_event;
char write_waiting; /* true if we are waiting for EV_WRITE events */
};
-static struct request *req_head = NULL, *req_waiting_head = NULL;
+static struct evdns_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, */
static const int global_nameserver_timeouts_length = (int)(sizeof(global_nameserver_timeouts)/sizeof(struct timeval));
static struct nameserver *nameserver_pick(void);
-static void evdns_request_insert(struct request *req, struct request **head);
+static void evdns_request_insert(struct evdns_request *req, struct evdns_request **head);
static void nameserver_ready_callback(int fd, short events, void *arg);
static int evdns_transmit(void);
-static int evdns_request_transmit(struct request *req);
+static int evdns_request_transmit(struct evdns_request *req);
static void nameserver_send_probe(struct nameserver *const ns);
-static void search_request_finished(struct request *const);
-static int search_try_next(struct request *const req);
+static void search_request_finished(struct evdns_request *const);
+static int search_try_next(struct evdns_request *const req);
static int search_request_new(int type, const char *const name, int flags, evdns_callback_type user_callback, void *user_arg);
static void evdns_requests_pump_waiting_queue(void);
static u16 transaction_id_pick(void);
-static struct request *request_new(int type, const char *name, int flags, evdns_callback_type callback, void *ptr);
-static void request_submit(struct request *req);
+static struct evdns_request *request_new(int type, const char *name, int flags, evdns_callback_type callback, void *ptr);
+static void request_submit(struct evdns_request *req);
static int server_request_free(struct server_request *req);
static void server_request_free_answers(struct server_request *req);
/* This walks the list of inflight requests to find the */
/* one with a matching transaction id. Returns NULL on */
/* failure */
-static struct request *
+static struct evdns_request *
request_find_from_trans_id(u16 trans_id) {
- struct request *req = req_head, *const started_at = req_head;
+ struct evdns_request *req = req_head, *const started_at = req_head;
if (req) {
do {
/* many packets have timed out etc */
static void
nameserver_failed(struct nameserver *const ns, const char *msg) {
- struct request *req, *started_at;
+ struct evdns_request *req, *started_at;
/* if this nameserver has already been marked as failed */
/* then don't do anything */
if (!ns->state) return;
}
static void
-request_trans_id_set(struct request *const req, const u16 trans_id) {
+request_trans_id_set(struct evdns_request *const req, const u16 trans_id) {
req->trans_id = trans_id;
*((u16 *) req->request) = htons(trans_id);
}
/* 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) {
+request_finished(struct evdns_request *const req, struct evdns_request **head) {
if (head) {
if (req->next == req) {
/* only item in the list */
if (!req->request_appended) {
/* need to free the request data on it's own */
- free(req->request);
+ mm_free(req->request);
} else {
/* the request data is appended onto the header */
- /* so everything gets free()ed when we: */
+ /* so everything gets mm_free()ed when we: */
}
CLEAR(req);
- _free(req);
+ _mm_free(req);
evdns_requests_pump_waiting_queue();
}
/* 0 ok */
/* 1 failed/reissue is pointless */
static int
-request_reissue(struct request *req) {
+request_reissue(struct evdns_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 */
evdns_requests_pump_waiting_queue(void) {
while (global_requests_inflight < global_max_requests_inflight &&
global_requests_waiting) {
- struct request *req;
+ struct evdns_request *req;
/* move a request from the waiting queue to the inflight queue */
assert(req_waiting_head);
if (req_waiting_head->next == req_waiting_head) {
}
static void
-reply_callback(struct request *const req, u32 ttl, u32 err, struct reply *reply) {
+reply_callback(struct evdns_request *const req, u32 ttl, u32 err, struct reply *reply) {
switch (req->request_type) {
case TYPE_A:
if (reply)
/* this processes a parsed reply packet */
static void
-reply_handle(struct request *const req, u16 flags, u32 ttl, struct reply *reply) {
+reply_handle(struct evdns_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};
u16 flags = 0;
u32 ttl, ttl_r = 0xffffffff;
struct reply reply;
- struct request *req = NULL;
+ struct evdns_request *req = NULL;
unsigned int i;
int name_matches = 0;
if (length > INT_MAX)
return -1;
- server_req = malloc(sizeof(struct server_request));
+ server_req = mm_malloc(sizeof(struct server_request));
if (server_req == NULL) return -1;
memset(server_req, 0, sizeof(struct server_request));
server_req->base.flags = flags;
server_req->base.nquestions = 0;
- server_req->base.questions = malloc(sizeof(struct evdns_server_question *) * questions);
+ server_req->base.questions = mm_malloc(sizeof(struct evdns_server_question *) * questions);
if (server_req->base.questions == NULL)
goto err;
GET16(type);
GET16(class);
namelen = strlen(tmp_name);
- q = malloc(sizeof(struct evdns_server_question) + namelen);
+ q = mm_malloc(sizeof(struct evdns_server_question) + namelen);
if (!q)
goto err;
q->type = type;
- q->class = class;
+ q->dns_question_class = class;
memcpy(q->name, tmp_name, namelen+1);
server_req->base.questions[server_req->base.nquestions++] = q;
}
if (server_req) {
if (server_req->base.questions) {
for (i = 0; i < server_req->base.nquestions; ++i)
- free(server_req->base.questions[i]);
- free(server_req->base.questions);
+ mm_free(server_req->base.questions[i]);
+ mm_free(server_req->base.questions);
}
CLEAR(server_req);
- free(server_req);
+ mm_free(server_req);
}
return -1;
static u16
transaction_id_pick(void) {
for (;;) {
- const struct request *req = req_head, *started_at;
+ const struct evdns_request *req = req_head, *started_at;
u16 trans_id = trans_id_function();
if (trans_id == 0xffff) continue;
{
int i;
for (i = 0; i < table->n_labels; ++i)
- free(table->labels[i].v);
+ mm_free(table->labels[i].v);
table->n_labels = 0;
}
int p;
if (table->n_labels == MAX_LABELS)
return (-1);
- v = strdup(label);
+ v = mm_strdup(label);
if (v == NULL)
return (-1);
p = table->n_labels++;
evdns_add_server_port(int socket, int is_tcp, evdns_request_callback_fn_type cb, void *user_data)
{
struct evdns_server_port *port;
- if (!(port = malloc(sizeof(struct evdns_server_port))))
+ if (!(port = mm_malloc(sizeof(struct evdns_server_port))))
return NULL;
memset(port, 0, sizeof(struct evdns_server_port));
event_set(&port->event, port->socket, EV_READ | EV_PERSIST,
server_port_ready_callback, port);
if (event_add(&port->event, NULL)<0) {
- free(port);
+ mm_free(port);
return NULL;
}
return port;
while (*itemp) {
itemp = &((*itemp)->next);
}
- item = malloc(sizeof(struct server_reply_item));
+ item = mm_malloc(sizeof(struct server_reply_item));
if (!item)
return -1;
CLEAR(item);
item->next = NULL;
- if (!(item->name = strdup(name))) {
+ if (!(item->name = mm_strdup(name))) {
CLEAR(item);
- free(item);
+ mm_free(item);
return -1;
}
item->type = type;
item->data = NULL;
if (data) {
if (item->is_name) {
- if (!(item->data = strdup(data))) {
- free(item->name);
+ if (!(item->data = mm_strdup(data))) {
+ mm_free(item->name);
CLEAR(item);
- free(item);
+ mm_free(item);
return -1;
}
item->datalen = (u16)-1;
} else {
- if (!(item->data = malloc(datalen))) {
- free(item->name);
+ if (!(item->data = mm_malloc(datalen))) {
+ mm_free(item->name);
CLEAR(item);
- free(item);
+ mm_free(item);
return -1;
}
item->datalen = datalen;
evdns_server_request_add_cname_reply(struct evdns_server_request *req, const char *name, const char *cname, int ttl)
{
return evdns_server_request_add_reply(
- req, EVDNS_ANSWER_SECTION, name, TYPE_A, CLASS_INET,
+ req, EVDNS_ANSWER_SECTION, name, TYPE_CNAME, CLASS_INET,
ttl, -1, 1, cname);
}
return (int) j;
}
APPEND16(req->base.questions[i]->type);
- APPEND16(req->base.questions[i]->class);
+ APPEND16(req->base.questions[i]->dns_question_class);
}
/* Add answer, authority, and additional sections. */
req->response_len = (size_t)j;
- if (!(req->response = malloc(req->response_len))) {
+ if (!(req->response = mm_malloc(req->response_len))) {
server_request_free_answers(req);
dnslabel_clear(&table);
return (-1);
victim = *list;
while (victim) {
next = victim->next;
- free(victim->name);
+ mm_free(victim->name);
if (victim->data)
- free(victim->data);
- free(victim);
+ mm_free(victim->data);
+ mm_free(victim);
victim = next;
}
*list = NULL;
int i, rc=1;
if (req->base.questions) {
for (i = 0; i < req->base.nquestions; ++i)
- free(req->base.questions[i]);
- free(req->base.questions);
+ mm_free(req->base.questions[i]);
+ mm_free(req->base.questions);
}
if (req->port) {
}
if (req->response) {
- free(req->response);
+ mm_free(req->response);
}
server_request_free_answers(req);
if (rc == 0) {
server_port_free(req->port);
CLEAR(req);
- free(req);
+ mm_free(req);
return (1);
}
CLEAR(req);
- free(req);
+ mm_free(req);
return (0);
}
(void) event_del(&port->event);
CLEAR(&port->event);
CLEAR(port);
- free(port);
+ mm_free(port);
}
/* exported function */
/* has timed out. */
static void
evdns_request_timeout_callback(int fd, short events, void *arg) {
- struct request *const req = (struct request *) arg;
+ struct evdns_request *const req = (struct evdns_request *) arg;
(void) fd;
(void) events;
/* 1 temporary failure */
/* 2 other failure */
static int
-evdns_request_transmit_to(struct request *req, struct nameserver *server) {
+evdns_request_transmit_to(struct evdns_request *req, struct nameserver *server) {
const ssize_t r = send(server->socket, req->request, req->request_len, 0);
if (r < 0) {
int err = last_error(server->socket);
/* 0 ok */
/* 1 failed */
static int
-evdns_request_transmit(struct request *req) {
+evdns_request_transmit(struct evdns_request *req) {
int retcode = 0, r;
/* if we fail to send this packet then this flag marks it */
break;
}
- free(addr);
+ mm_free(addr);
}
static void
nameserver_send_probe(struct nameserver *const ns) {
- struct request *req;
+ struct evdns_request *req;
struct sockaddr_storage *addr;
/* here we need to send a probe to a given nameserver */
/* in the hope that it is up now. */
/* We identify the nameserver by its address, in case it is removed before
* our probe comes back. */
- addr = malloc(sizeof(struct sockaddr_storage));
+ addr = mm_malloc(sizeof(struct sockaddr_storage));
memcpy(addr, &ns->address, sizeof(struct sockaddr_storage));
log(EVDNS_LOG_DEBUG, "Sending probe to %s", debug_ntop((struct sockaddr *)&ns->address));
req = request_new(TYPE_A, "www.google.com", DNS_QUERY_NO_SEARCH, nameserver_probe_callback, addr);
if (!req) {
- free(addr);
+ mm_free(addr);
return;
}
/* we force this into the inflight queue no matter what */
char did_try_to_transmit = 0;
if (req_head) {
- struct request *const started_at = req_head, *req = req_head;
+ struct evdns_request *const started_at = req_head, *req = req_head;
/* first transmit all the requests which are currently waiting */
do {
if (req->transmit_me) {
evdns_clear_nameservers_and_suspend(void)
{
struct nameserver *server = server_head, *started_at = server_head;
- struct request *req = req_head, *req_started_at = req_head;
+ struct evdns_request *req = req_head, *req_started_at = req_head;
if (!server)
return 0;
if (server->socket >= 0)
CLOSE_SOCKET(server->socket);
CLEAR(server);
- free(server);
+ mm_free(server);
if (next == started_at)
break;
server = next;
global_good_nameservers = 0;
while (req) {
- struct request *next = req->next;
+ struct evdns_request *next = req->next;
req->tx_count = req->reissue_count = 0;
req->ns = NULL;
/* ???? What to do about searches? */
return 2;
}
- ns = (struct nameserver *) malloc(sizeof(struct nameserver));
+ ns = (struct nameserver *) mm_malloc(sizeof(struct nameserver));
if (!ns) return -1;
memset(ns, 0, sizeof(struct nameserver));
CLOSE_SOCKET(ns->socket);
out1:
CLEAR(ns);
- free(ns);
+ mm_free(ns);
log(EVDNS_LOG_WARN, "Unable to add nameserver %s: error %d", debug_ntop(address), err);
return err;
}
/* insert into the tail of the queue */
static void
-evdns_request_insert(struct request *req, struct request **head) {
+evdns_request_insert(struct evdns_request *req, struct evdns_request **head) {
if (!*head) {
*head = req;
req->next = req->prev = req;
return count;
}
-static struct request *
+static struct evdns_request *
request_new(int type, const char *name, int flags,
evdns_callback_type callback, void *user_ptr) {
const char issuing_now =
const size_t 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 */
- struct request *const req =
- (struct request *) malloc(sizeof(struct request) + request_max_len);
+ struct evdns_request *const req =
+ (struct evdns_request *) mm_malloc(sizeof(struct evdns_request) + request_max_len);
char namebuf[256];
int rlen;
(void) flags;
if (!req) return NULL;
if (name_len >= sizeof(namebuf)) {
- _free(req);
+ _mm_free(req);
return NULL;
}
- memset(req, 0, sizeof(struct request));
+ memset(req, 0, sizeof(struct evdns_request));
if (global_randomize_case) {
unsigned i;
}
/* request data lives just after the header */
- req->request = ((u8 *) req) + sizeof(struct request);
- /* denotes that the request data shouldn't be free()ed */
+ req->request = ((u8 *) req) + sizeof(struct evdns_request);
+ /* denotes that the request data shouldn't be mm_free()ed */
req->request_appended = 1;
rlen = evdns_request_data_build(name, name_len, trans_id,
type, CLASS_INET, req->request, request_max_len);
return req;
err1:
CLEAR(req);
- _free(req);
+ _mm_free(req);
return NULL;
}
static void
-request_submit(struct request *const req) {
+request_submit(struct evdns_request *const req) {
if (req->ns) {
/* if it has a nameserver assigned then this is going */
/* straight into the inflight queue */
evdns_callback_type callback, void *ptr) {
log(EVDNS_LOG_DEBUG, "Resolve requested for %s", name);
if (flags & DNS_QUERY_NO_SEARCH) {
- struct request *const req =
+ struct evdns_request *const req =
request_new(TYPE_A, name, flags, callback, ptr);
if (req == NULL)
return (1);
evdns_callback_type callback, void *ptr) {
log(EVDNS_LOG_DEBUG, "Resolve requested for %s", name);
if (flags & DNS_QUERY_NO_SEARCH) {
- struct request *const req =
+ struct evdns_request *const req =
request_new(TYPE_AAAA, name, flags, callback, ptr);
if (req == NULL)
return (1);
int evdns_resolve_reverse(const struct in_addr *in, int flags, evdns_callback_type callback, void *ptr) {
char buf[32];
- struct request *req;
+ struct evdns_request *req;
u32 a;
assert(in);
a = ntohl(in->s_addr);
/* 32 nybbles, 32 periods, "ip6.arpa", NUL. */
char buf[73];
char *cp;
- struct request *req;
+ struct evdns_request *req;
int i;
assert(in);
cp = buf;
for (dom = state->head; dom; dom = next) {
next = dom->next;
CLEAR(dom);
- _free(dom);
+ _mm_free(dom);
}
CLEAR(state);
- _free(state);
+ _mm_free(state);
}
}
static struct search_state *
search_state_new(void) {
- struct search_state *state = (struct search_state *) malloc(sizeof(struct search_state));
+ struct search_state *state = (struct search_state *) mm_malloc(sizeof(struct search_state));
if (!state) return NULL;
memset(state, 0, sizeof(struct search_state));
state->refcount = 1;
if (!global_search_state) return;
global_search_state->num_domains++;
- sdomain = (struct search_domain *) malloc(sizeof(struct search_domain) + domain_len);
+ sdomain = (struct search_domain *) mm_malloc(sizeof(struct search_domain) + domain_len);
if (!sdomain) return;
memcpy( ((u8 *) sdomain) + sizeof(struct search_domain), domain, domain_len);
sdomain->next = global_search_state->head;
/* the actual postfix string is kept at the end of the structure */
const u8 *const postfix = ((u8 *) dom) + sizeof(struct search_domain);
const size_t postfix_len = dom->len;
- char *const newname = (char *) malloc(base_len + need_to_append_dot + postfix_len + 1);
+ char *const newname = (char *) mm_malloc(base_len + need_to_append_dot + postfix_len + 1);
if (!newname) return NULL;
memcpy(newname, base_name, base_len);
if (need_to_append_dot) newname[base_len] = '.';
global_search_state &&
global_search_state->num_domains) {
/* we have some domains to search */
- struct request *req;
+ struct evdns_request *req;
if (string_num_dots(name) >= global_search_state->ndots) {
req = request_new(type, name, flags, user_callback, user_arg);
if (!req) return 1;
char *const new_name = search_make_new(global_search_state, 0, name);
if (!new_name) return 1;
req = request_new(type, new_name, flags, user_callback, user_arg);
- _free(new_name);
+ _mm_free(new_name);
if (!req) return 1;
req->search_index = 0;
}
- req->search_origname = strdup(name);
+ req->search_origname = mm_strdup(name);
req->search_state = global_search_state;
req->search_flags = flags;
global_search_state->refcount++;
request_submit(req);
return 0;
} else {
- struct request *const req = request_new(type, name, flags, user_callback, user_arg);
+ struct evdns_request *const req = request_new(type, name, flags, user_callback, user_arg);
if (!req) return 1;
request_submit(req);
return 0;
/* 0 another request has been submitted */
/* 1 no more requests needed */
static int
-search_try_next(struct request *const req) {
+search_try_next(struct evdns_request *const req) {
if (req->search_state) {
/* it is part of a search */
char *new_name;
- struct request *newreq;
+ struct evdns_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 */
if (string_num_dots(req->search_origname) < req->search_state->ndots) {
/* 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);
+ struct evdns_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) {
request_submit(newreq);
if (!new_name) return 1;
log(EVDNS_LOG_DEBUG, "Search: now trying %s (%d)", new_name, req->search_index);
newreq = request_new(req->request_type, new_name, req->search_flags, req->user_callback, req->user_pointer);
- free(new_name);
+ mm_free(new_name);
if (!newreq) return 1;
newreq->search_origname = req->search_origname;
req->search_origname = NULL;
}
static void
-search_request_finished(struct request *const req) {
+search_request_finished(struct evdns_request *const req) {
if (req->search_state) {
search_state_decref(req->search_state);
req->search_state = NULL;
}
if (req->search_origname) {
- free(req->search_origname);
+ mm_free(req->search_origname);
req->search_origname = NULL;
}
}
}
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);
+ resolv = (u8 *) mm_malloc((size_t)st.st_size + 1);
if (!resolv) { err = 4; goto out1; }
n = 0;
}
out2:
- free(resolv);
+ mm_free(resolv);
out1:
close(fd);
return err;
addr = ips;
while (ISDIGIT(*ips) || *ips == '.' || *ips == ':' || *ips == '[' || *ips == ']')
++ips;
- buf = malloc(ips-addr+1);
+ buf = mm_malloc(ips-addr+1);
if (!buf) return 4;
memcpy(buf, addr, ips-addr);
buf[ips-addr] = '\0';
r = evdns_nameserver_ip_add(buf);
- free(buf);
+ mm_free(buf);
if (r) return r;
}
return 0;
goto done;
}
- buf = malloc(size);
+ buf = mm_malloc(size);
if (!buf) { status = 4; goto done; }
fixed = buf;
r = fn(fixed, &size);
goto done;
}
if (r != ERROR_SUCCESS) {
- free(buf);
- buf = malloc(size);
+ mm_free(buf);
+ buf = mm_malloc(size);
if (!buf) { status = 4; goto done; }
fixed = buf;
r = fn(fixed, &size);
done:
if (buf)
- free(buf);
+ mm_free(buf);
if (handle)
FreeLibrary(handle);
return status;
if (RegQueryValueEx(key, subkey, 0, &type, NULL, &bufsz)
!= ERROR_MORE_DATA)
return -1;
- if (!(buf = malloc(bufsz)))
+ if (!(buf = mm_malloc(bufsz)))
return -1;
if (RegQueryValueEx(key, subkey, 0, &type, (LPBYTE)buf, &bufsz)
status = evdns_nameserver_ip_add_line(buf);
}
- free(buf);
+ mm_free(buf);
return status;
}
if (server->state == 0)
(void) event_del(&server->timeout_event);
CLEAR(server);
- free(server);
+ mm_free(server);
if (server_next == server_head)
break;
}
for (dom = global_search_state->head; dom; dom = dom_next) {
dom_next = dom->next;
CLEAR(dom);
- free(dom);
+ mm_free(dom);
}
CLEAR(global_search_state);
- free(global_search_state);
+ mm_free(global_search_state);
global_search_state = NULL;
}
evdns_log_fn = NULL;
for (i = 0; i < req->nquestions; ++i) {
u32 ans = htonl(0xc0a80b0bUL);
if (req->questions[i]->type == EVDNS_TYPE_A &&
- req->questions[i]->class == EVDNS_CLASS_INET) {
+ req->questions[i]->dns_question_class == EVDNS_CLASS_INET) {
printf(" -- replying for %s (A)\n", req->questions[i]->name);
r = evdns_server_request_add_a_reply(req, req->questions[i]->name,
1, &ans, 10);
if (r<0)
printf("eeep, didn't work.\n");
} else if (req->questions[i]->type == EVDNS_TYPE_PTR &&
- req->questions[i]->class == EVDNS_CLASS_INET) {
+ req->questions[i]->dns_question_class == EVDNS_CLASS_INET) {
printf(" -- replying for %s (PTR)\n", req->questions[i]->name);
r = evdns_server_request_add_ptr_reply(req, NULL, req->questions[i]->name,
"foo.bar.example.com", 10);
} else {
printf(" -- skipping %s [%d %d]\n", req->questions[i]->name,
- req->questions[i]->type, req->questions[i]->class);
+ req->questions[i]->type, req->questions[i]->dns_question_class);
}
}
projects / thirdparty / tor.git / commitdiff
