return NULL;
}
/* add address */
- if(!delegpt_add_addr(dp, region, &addr, addrlen, 0, 0, 1)) {
+ if(!delegpt_add_addr(dp, region, &addr, addrlen, 0, 0)) {
(void)ssl_printf(ssl, "error out of memory\n");
return NULL;
}
+ sizeof(*worker->env.scratch_buffer)
+ ldns_buffer_capacity(worker->env.scratch_buffer)
+ forwards_get_mem(worker->env.fwds);
+ if(worker->thread_num == 0)
+ me += acl_list_get_mem(worker->daemon->acl_list);
if(cur_serv) {
me += serviced_get_mem(cur_serv);
}
if(worker->thread_num == 0)
log_set_time(worker->env.now);
worker->env.worker = worker;
- worker->env.send_packet = &worker_send_packet;
worker->env.send_query = &worker_send_query;
worker->env.alloc = &worker->alloc;
worker->env.rnd = worker->rndstate;
free(worker);
}
-int
-worker_send_packet(ldns_buffer* pkt, struct sockaddr_storage* addr,
- socklen_t addrlen, int timeout, struct module_qstate* q, int use_tcp)
-{
- struct worker* worker = q->env->worker;
- if(use_tcp) {
- return pending_tcp_query(worker->back, pkt, addr, addrlen,
- timeout, worker_handle_reply, q) != 0;
- }
- return pending_udp_query(worker->back, pkt, addr, addrlen,
- timeout*1000, worker_handle_reply, q) != 0;
-}
-
/** compare outbound entry qstates */
static int
outbound_entry_compare(void* a, void* b)
*/
void worker_sighandler(int sig, void* arg);
-/**
- * Worker service routine to send udp messages for modules.
- * @param pkt: packet to send.
- * @param addr: where to.
- * @param addrlen: length of addr.
- * @param timeout: seconds to wait until timeout.
- * @param q: wich query state to reactivate upon return.
- * @param use_tcp: true to use TCP, false for UDP.
- * @return: false on failure (memory or socket related). no query was
- * sent.
- */
-int worker_send_packet(ldns_buffer* pkt, struct sockaddr_storage* addr,
- socklen_t addrlen, int timeout, struct module_qstate* q, int use_tcp);
-
/**
* Worker service routine to send serviced queries to authoritative servers.
* @param qname: query name. (host order)
+20 August 2010: Wouter
+ - openbsd-lint fixes: acl_list_get_mem used if debug-alloc enabled.
+ iterator get_mem includes priv_get_mem. delegpt nodup removed.
+ listen_pushback, query_info_allocqname, write_socket, send_packet,
+ comm_point_set_cb_arg and listen_resume removed.
+
19 August 2010: Wouter
- Fix bug#321: resolution of rs.ripe.net artifacts with 0x20.
Delegpt structures checked for duplicates always.
}
for(a = dp->target_list; a; a = a->next_target) {
if(!delegpt_add_addr(copy, region, &a->addr, a->addrlen,
- a->bogus, a->lame, 0))
+ a->bogus, a->lame))
return NULL;
}
return copy;
int
delegpt_add_target(struct delegpt* dp, struct regional* region,
uint8_t* name, size_t namelen, struct sockaddr_storage* addr,
- socklen_t addrlen, int bogus, int lame, int nodup)
+ socklen_t addrlen, int bogus, int lame)
{
struct delegpt_ns* ns = delegpt_find_ns(dp, name, namelen);
if(!ns) {
if(ns->got4 && ns->got6)
ns->resolved = 1;
}
- return delegpt_add_addr(dp, region, addr, addrlen, bogus, lame, nodup);
+ return delegpt_add_addr(dp, region, addr, addrlen, bogus, lame);
}
int
delegpt_add_addr(struct delegpt* dp, struct regional* region,
struct sockaddr_storage* addr, socklen_t addrlen, int bogus,
- int lame, int nodup)
+ int lame)
{
struct delegpt_addr* a;
- if(nodup) {
- if((a = delegpt_find_addr(dp, addr, addrlen))) {
- if(bogus)
- a->bogus = bogus;
- if(!lame)
- a->lame = 0;
- return 1;
- }
+ /* check for duplicates */
+ if((a = delegpt_find_addr(dp, addr, addrlen))) {
+ if(bogus)
+ a->bogus = bogus;
+ if(!lame)
+ a->lame = 0;
+ return 1;
}
a = (struct delegpt_addr*)regional_alloc(region,
continue;
if(ntohs(s->rk.type) == LDNS_RR_TYPE_A) {
- if(!delegpt_add_rrset_A(dp, region, s, 0, 1))
+ if(!delegpt_add_rrset_A(dp, region, s, 0))
return NULL;
} else if(ntohs(s->rk.type) == LDNS_RR_TYPE_AAAA) {
- if(!delegpt_add_rrset_AAAA(dp, region, s, 0, 1))
+ if(!delegpt_add_rrset_AAAA(dp, region, s, 0))
return NULL;
}
}
int
delegpt_add_rrset_A(struct delegpt* dp, struct regional* region,
- struct ub_packed_rrset_key* ak, int lame, int nodup)
+ struct ub_packed_rrset_key* ak, int lame)
{
struct packed_rrset_data* d=(struct packed_rrset_data*)ak->entry.data;
size_t i;
memmove(&sa.sin_addr, d->rr_data[i]+2, INET_SIZE);
if(!delegpt_add_target(dp, region, ak->rk.dname,
ak->rk.dname_len, (struct sockaddr_storage*)&sa,
- len, (d->security==sec_status_bogus), lame, nodup))
+ len, (d->security==sec_status_bogus), lame))
return 0;
}
return 1;
int
delegpt_add_rrset_AAAA(struct delegpt* dp, struct regional* region,
- struct ub_packed_rrset_key* ak, int lame, int nodup)
+ struct ub_packed_rrset_key* ak, int lame)
{
struct packed_rrset_data* d=(struct packed_rrset_data*)ak->entry.data;
size_t i;
memmove(&sa.sin6_addr, d->rr_data[i]+2, INET6_SIZE);
if(!delegpt_add_target(dp, region, ak->rk.dname,
ak->rk.dname_len, (struct sockaddr_storage*)&sa,
- len, (d->security==sec_status_bogus), lame, nodup))
+ len, (d->security==sec_status_bogus), lame))
return 0;
}
return 1;
if(ntohs(rrset->rk.type) == LDNS_RR_TYPE_NS)
return delegpt_rrset_add_ns(dp, region, rrset, lame);
else if(ntohs(rrset->rk.type) == LDNS_RR_TYPE_A)
- return delegpt_add_rrset_A(dp, region, rrset, lame, 1);
+ return delegpt_add_rrset_A(dp, region, rrset, lame);
else if(ntohs(rrset->rk.type) == LDNS_RR_TYPE_AAAA)
- return delegpt_add_rrset_AAAA(dp, region, rrset, lame, 1);
+ return delegpt_add_rrset_AAAA(dp, region, rrset, lame);
log_warn("Unknown rrset type added to delegpt");
return 1;
}
* @param addrlen: the length of addr.
* @param bogus: security status for the address, pass true if bogus.
* @param lame: address is lame.
- * @param nodup: if true, no address duplicates are made by this add.
- * name duplicates are always filtered.
* @return false on error.
*/
int delegpt_add_target(struct delegpt* dp, struct regional* regional,
uint8_t* name, size_t namelen, struct sockaddr_storage* addr,
- socklen_t addrlen, int bogus, int lame, int nodup);
+ socklen_t addrlen, int bogus, int lame);
/**
* Add A RRset to delegpt.
* @param regional: where to allocate the info.
* @param rrset: RRset A to add.
* @param lame: rrset is lame, disprefer it.
- * @param nodup: if true, no duplicates are made by this add. takes time.
* @return 0 on alloc error.
*/
int delegpt_add_rrset_A(struct delegpt* dp, struct regional* regional,
- struct ub_packed_rrset_key* rrset, int lame, int nodup);
+ struct ub_packed_rrset_key* rrset, int lame);
/**
* Add AAAA RRset to delegpt.
* @param regional: where to allocate the info.
* @param rrset: RRset AAAA to add.
* @param lame: rrset is lame, disprefer it.
- * @param nodup: if true, no duplicates are made by this add. takes time.
* @return 0 on alloc error.
*/
int delegpt_add_rrset_AAAA(struct delegpt* dp, struct regional* regional,
- struct ub_packed_rrset_key* rrset, int lame, int nodup);
+ struct ub_packed_rrset_key* rrset, int lame);
/**
* Add any RRset to delegpt.
* @param addrlen: the length of addr.
* @param bogus: if address is bogus.
* @param lame: if address is lame.
- * @param nodup: if true, no duplicates are made by this add. takes time.
* @return false on error.
*/
int delegpt_add_addr(struct delegpt* dp, struct regional* regional,
- struct sockaddr_storage* addr, socklen_t addrlen, int bogus,
- int lame, int nodup);
+ struct sockaddr_storage* addr, socklen_t addrlen, int bogus, int lame);
/**
* Find NS record in name list of delegation point.
s->name, p->str);
return 0;
}
- if(!delegpt_add_addr(dp, fwd->region, &addr, addrlen,
- 0, 0, 1)) {
+ if(!delegpt_add_addr(dp, fwd->region, &addr, addrlen, 0, 0)) {
log_err("out of memory");
return 0;
}
if(!delegpt_add_ns(dp, r, ldns_rdf_data(rdf), 0) ||
!extstrtoaddr(ip, &addr, &addrlen) ||
!delegpt_add_target(dp, r, ldns_rdf_data(rdf), ldns_rdf_size(rdf),
- &addr, addrlen, 0, 0, 1)) {
+ &addr, addrlen, 0, 0)) {
ldns_rdf_deep_free(rdf);
return 0;
}
s->name, p->str);
return 0;
}
- if(!delegpt_add_addr(dp, hints->region, &addr, addrlen,
- 0, 0, 1)) {
+ if(!delegpt_add_addr(dp, hints->region, &addr, addrlen, 0, 0)) {
log_err("out of memory");
return 0;
}
ldns_rdf_data(ldns_rr_owner(rr)),
ldns_rdf_size(ldns_rr_owner(rr)),
(struct sockaddr_storage*)&sa, len,
- 0, 0, 1)) {
+ 0, 0)) {
log_err("out of memory reading root hints");
goto stop_read;
}
ldns_rdf_data(ldns_rr_owner(rr)),
ldns_rdf_size(ldns_rr_owner(rr)),
(struct sockaddr_storage*)&sa, len,
- 0, 0, 1)) {
+ 0, 0)) {
log_err("out of memory reading root hints");
goto stop_read;
}
log_rrset_key(VERB_ALGO, "found parent-side", akey);
ns->done_pside4 = 1;
/* a negative-cache-element has no addresses it adds */
- if(!delegpt_add_rrset_A(dp, region, akey, 1, 1))
+ if(!delegpt_add_rrset_A(dp, region, akey, 1))
log_err("malloc failure in lookup_parent_glue");
lock_rw_unlock(&akey->entry.lock);
}
log_rrset_key(VERB_ALGO, "found parent-side", akey);
ns->done_pside6 = 1;
/* a negative-cache-element has no addresses it adds */
- if(!delegpt_add_rrset_AAAA(dp, region, akey, 1, 1))
+ if(!delegpt_add_rrset_AAAA(dp, region, akey, 1))
log_err("malloc failure in lookup_parent_glue");
lock_rw_unlock(&akey->entry.lock);
}
if(!ie)
return 0;
return sizeof(*ie) + sizeof(int)*((size_t)ie->max_dependency_depth+1)
- + hints_get_mem(ie->hints) + donotq_get_mem(ie->donotq);
+ + hints_get_mem(ie->hints) + donotq_get_mem(ie->donotq)
+ + priv_get_mem(ie->priv);
}
/**
libworker_delete(w);
return NULL;
}
- w->env->send_packet = &libworker_send_packet;
w->env->send_query = &libworker_send_query;
w->env->detach_subs = &mesh_detach_subs;
w->env->attach_sub = &mesh_attach_sub;
slabhash_clear(w->env->msg_cache);
}
-int libworker_send_packet(ldns_buffer* pkt, struct sockaddr_storage* addr,
- socklen_t addrlen, int timeout, struct module_qstate* q, int use_tcp)
-{
- struct libworker* w = (struct libworker*)q->env->worker;
- if(use_tcp) {
- return pending_tcp_query(w->back, pkt, addr, addrlen,
- timeout, libworker_handle_reply, q) != 0;
- }
- return pending_udp_query(w->back, pkt, addr, addrlen,
- timeout*1000, libworker_handle_reply, q) != 0;
-}
-
/** compare outbound entry qstates */
static int
outbound_entry_compare(void* a, void* b)
/** cleanup the cache to remove all rrset IDs from it, arg is libworker */
void libworker_alloc_cleanup(void* arg);
-/**
- * Worker service routine to send udp messages for modules.
- * @param pkt: packet to send.
- * @param addr: where to.
- * @param addrlen: length of addr.
- * @param timeout: seconds to wait until timeout.
- * @param q: wich query state to reactivate upon return.
- * @param use_tcp: true to use TCP, false for UDP.
- * @return: false on failure (memory or socket related). no query was
- * sent.
- */
-int libworker_send_packet(ldns_buffer* pkt, struct sockaddr_storage* addr,
- socklen_t addrlen, int timeout, struct module_qstate* q, int use_tcp);
-
/**
* Worker service routine to send serviced queries to authoritative servers.
* @param qname: query name. (host order)
akey = rrset_cache_lookup(env->rrset_cache, ns->name,
ns->namelen, LDNS_RR_TYPE_A, qclass, 0, now, 0);
if(akey) {
- if(!delegpt_add_rrset_A(dp, region, akey, 0, 1)) {
+ if(!delegpt_add_rrset_A(dp, region, akey, 0)) {
lock_rw_unlock(&akey->entry.lock);
return 0;
}
akey = rrset_cache_lookup(env->rrset_cache, ns->name,
ns->namelen, LDNS_RR_TYPE_AAAA, qclass, 0, now, 0);
if(akey) {
- if(!delegpt_add_rrset_AAAA(dp, region, akey, 0, 1)) {
+ if(!delegpt_add_rrset_AAAA(dp, region, akey, 0)) {
lock_rw_unlock(&akey->entry.lock);
return 0;
}
akey = rrset_cache_lookup(env->rrset_cache, ns->name,
ns->namelen, LDNS_RR_TYPE_A, qclass, 0, now, 0);
if(akey) {
- if(!delegpt_add_rrset_A(dp, region, akey, (int)ns->lame, 1)) {
+ if(!delegpt_add_rrset_A(dp, region, akey, (int)ns->lame)) {
lock_rw_unlock(&akey->entry.lock);
return 0;
}
akey = rrset_cache_lookup(env->rrset_cache, ns->name,
ns->namelen, LDNS_RR_TYPE_AAAA, qclass, 0, now, 0);
if(akey) {
- if(!delegpt_add_rrset_AAAA(dp, region, akey, (int)ns->lame, 1)) {
+ if(!delegpt_add_rrset_AAAA(dp, region, akey, (int)ns->lame)) {
lock_rw_unlock(&akey->entry.lock);
return 0;
}
free(front);
}
-void listen_pushback(struct listen_dnsport* listen)
-{
- struct listen_list *p;
- log_assert(listen);
- for(p = listen->cps; p; p = p->next)
- {
- if(p->com->type != comm_udp &&
- p->com->type != comm_tcp_accept)
- continue;
- comm_point_stop_listening(p->com);
- }
-}
-
-void listen_resume(struct listen_dnsport* listen)
-{
- struct listen_list *p;
- log_assert(listen);
- for(p = listen->cps; p; p = p->next)
- {
- if(p->com->type != comm_udp &&
- p->com->type != comm_tcp_accept)
- continue;
- comm_point_start_listening(p->com, -1, -1);
- }
-}
-
struct listen_port*
listening_ports_open(struct config_file* cfg)
{
struct listen_port* ports, size_t bufsize, int tcp_accept_count,
comm_point_callback_t* cb, void* cb_arg);
-/**
- * Stop listening to the dnsports. Ports are still open but not checked
- * for readability - performs pushback of the load.
- * @param listen: the listening structs to stop listening on. Note that
- * udp and tcp-accept handlers stop, but ongoing tcp-handlers are kept
- * going, since its rude to 'reset connection by peer' them, instead,
- * we keep them and the callback will be called when its ready. It can
- * be dropped at that time. New tcp and udp queries can be served by
- * other threads.
- */
-void listen_pushback(struct listen_dnsport* listen);
-
-/**
- * Start listening again to the dnsports.
- * Call after the listen_pushback has been called.
- * @param listen: the listening structs to stop listening on.
- */
-void listen_resume(struct listen_dnsport* listen);
-
/**
* delete the listening structure
* @param listen: listening structure.
free(list);
}
-void listen_pushback(struct listen_dnsport* ATTR_UNUSED(listen))
-{
-}
-
-void listen_resume(struct listen_dnsport* ATTR_UNUSED(listen))
-{
-}
-
struct comm_point* comm_point_create_local(struct comm_base* ATTR_UNUSED(base),
int ATTR_UNUSED(fd), size_t ATTR_UNUSED(bufsize),
comm_point_callback_t* ATTR_UNUSED(callback),
return 1;
}
-int
-query_info_allocqname(struct query_info* m)
-{
- uint8_t* q = m->qname;
- if(!(m->qname = (uint8_t*)malloc(m->qname_len))) {
- log_err("query_info_allocqname: out of memory");
- return 0; /* out of memory */
- }
- memcpy(m->qname, q, m->qname_len);
- return 1;
-}
-
/** tiny subroutine for msgreply_compare */
#define COMPARE_IT(x, y) \
if( (x) < (y) ) return -1; \
*/
void reply_info_parsedelete(struct reply_info* rep, struct alloc_cache* alloc);
-/**
- * Allocate and copy the qname (obtained from query_info_parse()).
- * @param m: the queryinfo structure.
- * @return: 0 on alloc failure.
- */
-int query_info_allocqname(struct query_info* m);
-
/**
* Compare two queryinfo structures, on query and type, class.
* It is _not_ sorted in canonical ordering.
return 0;
}
-int
-fptr_whitelist_modenv_send_packet(int (*fptr)(ldns_buffer* pkt,
- struct sockaddr_storage* addr, socklen_t addrlen, int timeout,
- struct module_qstate* q, int use_tcp))
-{
- if(fptr == &worker_send_packet) return 1;
- else if(fptr == &libworker_send_packet) return 1;
- return 0;
-}
-
/** whitelist env->send_query callbacks */
int
fptr_whitelist_modenv_send_query(struct outbound_entry* (*fptr)(
*/
int fptr_whitelist_hash_markdelfunc(lruhash_markdelfunc_t fptr);
-/**
- * Check function pointer whitelist for module_env send_packet callback values.
- *
- * @param fptr: function pointer to check.
- * @return false if not in whitelist.
- */
-int fptr_whitelist_modenv_send_packet(int (*fptr)(ldns_buffer* pkt,
- struct sockaddr_storage* addr, socklen_t addrlen, int timeout,
- struct module_qstate* q, int use_tcp));
-
/**
* Check function pointer whitelist for module_env send_query callback values.
*
struct key_cache* key_cache;
/* --- services --- */
- /**
- * Direct access to the network, this packet gets sent to destination.
- * Send DNS query to server. operate() should return with wait_reply.
- * Later on a callback will cause operate() to be called with event
- * timeout or reply. Replied packet is then in the query buffer.
- * @param pkt: packet to send.
- * @param addr: where to.
- * @param addrlen: length of addr.
- * @param timeout: seconds to wait until timeout.
- * @param q: wich query state to reactivate upon return.
- * @param use_tcp: set to true to send over TCP. 0 for UDP.
- * @return: false on failure (memory or socket related). no query was
- * sent.
- */
- int (*send_packet)(ldns_buffer* pkt, struct sockaddr_storage* addr,
- socklen_t addrlen, int timeout, struct module_qstate* q,
- int use_tcp);
-
/**
* Send serviced DNS query to server. UDP/TCP and EDNS is handled.
* operate() should return with wait_reply. Later on a callback
else return 0;
}
-int
-write_socket(int s, const void *buf, size_t size)
-{
- const char* data = (const char*)buf;
- size_t total_count = 0;
-
- fd_set_block(s);
- while (total_count < size) {
- ssize_t count
- = write(s, data + total_count, size - total_count);
- if (count == -1) {
- if (errno != EAGAIN && errno != EINTR) {
- fd_set_nonblock(s);
- return 0;
- } else {
- continue;
- }
- }
- total_count += count;
- }
- fd_set_nonblock(s);
- return 1;
-}
-
int
fd_set_nonblock(int s)
{
*/
int str_is_ip6(const char* str);
-/**
- * Write (blocking) to a nonblocking socket.
- * @param s: fd. Is set to be nonblocking at exit.
- * @param buf: data buffer.
- * @param size: length of data to send.
- * @return: 0 on error. errno is set.
- */
-int
-write_socket(int s, const void *buf, size_t size);
-
/**
* Set fd nonblocking.
* @param s: file descriptor.
free(c);
}
-void
-comm_point_set_cb_arg(struct comm_point* c, void *arg)
-{
- log_assert(c);
- c->cb_arg = arg;
-}
-
void
comm_point_send_reply(struct comm_reply *repinfo)
{
*/
void comm_point_delete(struct comm_point* c);
-/**
- * Reset the callback argument for a comm point.
- * @param c: the comm point to change.
- * @param arg: the new callback user argument.
- */
-void comm_point_set_cb_arg(struct comm_point* c, void* arg);
-
/**
* Send reply. Put message into commpoint buffer.
* @param repinfo: The reply info copied from a commpoint callback call.
projects / thirdparty / unbound.git / commitdiff
