static int
reuse_tcp_insert(struct outside_network* outnet, struct pending_tcp* pend_tcp)
{
- log_reuse_tcp(5, "reuse_tcp_insert", &pend_tcp->reuse);
+ log_reuse_tcp(VERB_CLIENT, "reuse_tcp_insert", &pend_tcp->reuse);
if(pend_tcp->reuse.item_on_lru_list)
return 1;
pend_tcp->reuse.node.key = &pend_tcp->reuse;
pend_tcp->reuse.pending = pend_tcp;
if(!rbtree_insert(&outnet->tcp_reuse, &pend_tcp->reuse.node)) {
/* this is a duplicate connection, close this one */
- verbose(5, "reuse_tcp_insert: duplicate connection");
+ verbose(VERB_CLIENT, "reuse_tcp_insert: duplicate connection");
pend_tcp->reuse.node.key = NULL;
return 0;
}
struct pending_tcp key_p;
struct comm_point c;
rbnode_type* result = NULL, *prev;
- verbose(5, "reuse_tcp_find");
+ verbose(VERB_CLIENT, "reuse_tcp_find");
memset(&key_w, 0, sizeof(key_w));
memset(&key_p, 0, sizeof(key_p));
memset(&c, 0, sizeof(c));
memmove(&key_p.reuse.addr, addr, addrlen);
key_p.reuse.addrlen = addrlen;
- verbose(5, "reuse_tcp_find: num reuse streams %u",
+ verbose(VERB_CLIENT, "reuse_tcp_find: num reuse streams %u",
(unsigned)outnet->tcp_reuse.count);
if(outnet->tcp_reuse.root == NULL ||
outnet->tcp_reuse.root == RBTREE_NULL)
/* not found, return null */
if(!result || result == RBTREE_NULL)
return NULL;
- verbose(5, "reuse_tcp_find check inexact match");
+ verbose(VERB_CLIENT, "reuse_tcp_find check inexact match");
/* inexact match, find one of possibly several connections to the
* same destination address, with the correct port, ssl, and
* also less than max number of open queries, or else, fail to open
struct waiting_tcp* w)
{
struct timeval tv;
- verbose(5, "outnet_tcp_take_query_setup: setup packet to write "
+ verbose(VERB_CLIENT, "outnet_tcp_take_query_setup: setup packet to write "
"len %d timeout %d msec",
(int)w->pkt_len, w->timeout);
pend->c->tcp_write_pkt = w->pkt;
reuse = reuse_tcp_find(outnet, &w->addr, w->addrlen,
w->ssl_upstream);
if(reuse) {
- log_reuse_tcp(5, "use free buffer for waiting tcp: "
+ log_reuse_tcp(VERB_CLIENT, "use free buffer for waiting tcp: "
"found reuse", reuse);
reuse_tcp_lru_touch(outnet, reuse);
comm_timer_disable(w->timer);
dname_valid(pend->query->pkt+12, pend->query->pkt_len-12)) {
char buf[LDNS_MAX_DOMAINLEN+1];
dname_str(pend->query->pkt+12, buf);
- verbose(5, "reuse_move_writewait_away current %s %d bytes were written",
+ verbose(VERB_CLIENT, "reuse_move_writewait_away current %s %d bytes were written",
buf, (int)pend->c->tcp_write_byte_count);
}
pend->c->tcp_write_pkt = NULL;
dname_valid(w->pkt+12, w->pkt_len-12)) {
char buf[LDNS_MAX_DOMAINLEN+1];
dname_str(w->pkt+12, buf);
- verbose(5, "reuse_move_writewait_away item %s", buf);
+ verbose(VERB_CLIENT, "reuse_move_writewait_away item %s", buf);
}
reuse_tree_by_id_delete(&pend->reuse, w);
outnet_add_tcp_waiting(outnet, w);
reuse_tcp_remove_tree_list(struct outside_network* outnet,
struct reuse_tcp* reuse)
{
- verbose(5, "reuse_tcp_remove_tree_list");
+ verbose(VERB_CLIENT, "reuse_tcp_remove_tree_list");
if(reuse->node.key) {
/* delete it from reuse tree */
(void)rbtree_delete(&outnet->tcp_reuse, &reuse->node);
decommission_pending_tcp(struct outside_network* outnet,
struct pending_tcp* pend)
{
- verbose(5, "decommission_pending_tcp");
+ verbose(VERB_CLIENT, "decommission_pending_tcp");
if(pend->c->ssl) {
#ifdef HAVE_SSL
SSL_shutdown(pend->c->ssl);
static void
reuse_tcp_setup_timeout(struct pending_tcp* pend_tcp)
{
- log_reuse_tcp(5, "reuse_tcp_setup_timeout", &pend_tcp->reuse);
+ log_reuse_tcp(VERB_CLIENT, "reuse_tcp_setup_timeout", &pend_tcp->reuse);
comm_point_start_listening(pend_tcp->c, -1, REUSE_TIMEOUT);
}
static void
reuse_tcp_setup_read_and_timeout(struct pending_tcp* pend_tcp)
{
- log_reuse_tcp(5, "reuse_tcp_setup_readtimeout", &pend_tcp->reuse);
+ log_reuse_tcp(VERB_CLIENT, "reuse_tcp_setup_readtimeout", &pend_tcp->reuse);
sldns_buffer_clear(pend_tcp->c->buffer);
pend_tcp->c->tcp_is_reading = 1;
pend_tcp->c->tcp_byte_count = 0;
}
if(w) {
reuse_tree_by_id_delete(&pend->reuse, w);
- verbose(5, "outnet tcp callback query err %d buflen %d",
+ verbose(VERB_CLIENT, "outnet tcp callback query err %d buflen %d",
error, (int)sldns_buffer_limit(c->buffer));
waiting_tcp_callback(w, c, error, reply_info);
waiting_tcp_delete(w);
}
- verbose(5, "outnet_tcp_cb reuse after cb");
+ verbose(VERB_CLIENT, "outnet_tcp_cb reuse after cb");
if(error == NETEVENT_NOERROR && pend->reuse.node.key) {
- verbose(5, "outnet_tcp_cb reuse after cb: keep it");
+ verbose(VERB_CLIENT, "outnet_tcp_cb reuse after cb: keep it");
/* it is in the reuse_tcp tree, with other queries, or
* on the empty list. do not decommission it */
/* if there are more outstanding queries, we could try to
reuse_tcp_setup_read_and_timeout(pend);
return 0;
}
- verbose(5, "outnet_tcp_cb reuse after cb: decommission it");
+ verbose(VERB_CLIENT, "outnet_tcp_cb reuse after cb: decommission it");
/* no queries on it, no space to keep it. or timeout or closed due
* to error. Close it */
reuse_cb_and_decommission(outnet, pend, (error==NETEVENT_TIMEOUT?
{
struct waiting_tcp* w = (struct waiting_tcp*)arg;
struct outside_network* outnet = w->outnet;
- verbose(5, "outnet_tcptimer");
+ verbose(VERB_CLIENT, "outnet_tcptimer");
if(w->on_tcp_waiting_list) {
/* it is on the waiting list */
waiting_list_remove(outnet, w);
reuse_tcp_close_oldest(struct outside_network* outnet)
{
struct pending_tcp* pend;
- verbose(5, "reuse_tcp_close_oldest");
+ verbose(VERB_CLIENT, "reuse_tcp_close_oldest");
if(!outnet->tcp_reuse_last) return;
pend = outnet->tcp_reuse_last->pending;
struct reuse_tcp* reuse = NULL;
struct waiting_tcp* w;
- verbose(5, "pending_tcp_query");
+ verbose(VERB_CLIENT, "pending_tcp_query");
if(sldns_buffer_limit(packet) < sizeof(uint16_t)) {
- verbose(4, "pending tcp query with too short buffer < 2");
+ verbose(VERB_ALGO, "pending tcp query with too short buffer < 2");
return NULL;
}
reuse = reuse_tcp_find(sq->outnet, &sq->addr, sq->addrlen,
sq->ssl_upstream);
if(reuse) {
- log_reuse_tcp(5, "pending_tcp_query: found reuse", reuse);
+ log_reuse_tcp(VERB_CLIENT, "pending_tcp_query: found reuse", reuse);
log_assert(reuse->pending);
pend = reuse->pending;
reuse_tcp_lru_touch(sq->outnet, reuse);
if(reuse) {
/* reuse existing fd, write query and continue */
/* store query in tree by id */
- verbose(5, "pending_tcp_query: reuse, store");
+ verbose(VERB_CLIENT, "pending_tcp_query: reuse, store");
w->next_waiting = (void*)pend;
reuse_tree_by_id_insert(&pend->reuse, w);
/* can we write right now? */
} else {
/* create new fd and connect to addr, setup to
* write query */
- verbose(5, "pending_tcp_query: new fd, connect");
+ verbose(VERB_CLIENT, "pending_tcp_query: new fd, connect");
rbtree_init(&pend->reuse.tree_by_id, reuse_id_cmp);
pend->reuse.pending = pend;
memcpy(&pend->reuse.addr, &sq->addr, sq->addrlen);
/* queue up */
/* waiting for a buffer on the outside network buffer wait
* list */
- verbose(5, "pending_tcp_query: queue to wait");
+ verbose(VERB_CLIENT, "pending_tcp_query: queue to wait");
outnet_add_tcp_waiting(sq->outnet, w);
}
#ifdef USE_DNSTAP
struct serviced_query* sq)
{
struct pending_tcp* pend_tcp = (struct pending_tcp*)w->next_waiting;
- verbose(5, "reuse_tcp_remove_serviced_keep");
+ verbose(VERB_CLIENT, "reuse_tcp_remove_serviced_keep");
/* remove the callback. let query continue to write to not cancel
* the stream itself. also keep it as an entry in the tree_by_id,
* in case the answer returns (that we no longer want), but we cannot
/* see if can be entered in reuse tree
* for that the FD has to be non-1 */
if(pend_tcp->c->fd == -1) {
- verbose(5, "reuse_tcp_remove_serviced_keep: -1 fd");
+ verbose(VERB_CLIENT, "reuse_tcp_remove_serviced_keep: -1 fd");
return 0;
}
/* if in tree and used by other queries */
if(pend_tcp->reuse.node.key) {
- verbose(5, "reuse_tcp_remove_serviced_keep: in use by other queries");
+ verbose(VERB_CLIENT, "reuse_tcp_remove_serviced_keep: in use by other queries");
/* do not reset the keepalive timer, for that
* we'd need traffic, and this is where the serviced is
* removed due to state machine internal reasons,
/* if still open and want to keep it open */
if(pend_tcp->c->fd != -1 && sq->outnet->tcp_reuse.count <
sq->outnet->tcp_reuse_max) {
- verbose(5, "reuse_tcp_remove_serviced_keep: keep open");
+ verbose(VERB_CLIENT, "reuse_tcp_remove_serviced_keep: keep open");
/* set a keepalive timer on it */
if(!reuse_tcp_insert(sq->outnet, pend_tcp)) {
return 0;
static void
serviced_delete(struct serviced_query* sq)
{
- verbose(5, "serviced_delete");
+ verbose(VERB_CLIENT, "serviced_delete");
if(sq->pending) {
/* clear up the pending query */
if(sq->status == serviced_query_UDP_EDNS ||
sq->status == serviced_query_UDP_EDNS_FRAG ||
sq->status == serviced_query_UDP_EDNS_fallback) {
struct pending* p = (struct pending*)sq->pending;
- verbose(5, "serviced_delete: UDP");
+ verbose(VERB_CLIENT, "serviced_delete: UDP");
if(p->pc)
portcomm_loweruse(sq->outnet, p->pc);
pending_delete(sq->outnet, p);
} else {
struct waiting_tcp* w = (struct waiting_tcp*)
sq->pending;
- verbose(5, "serviced_delete: TCP");
+ verbose(VERB_CLIENT, "serviced_delete: TCP");
/* if on stream-write-waiting list then
* remove from waiting list and waiting_tcp_delete */
if(w->write_wait_queued) {
struct pending_tcp* pend =
(struct pending_tcp*)w->next_waiting;
- verbose(5, "serviced_delete: writewait");
+ verbose(VERB_CLIENT, "serviced_delete: writewait");
reuse_tree_by_id_delete(&pend->reuse, w);
reuse_write_wait_remove(&pend->reuse, w);
waiting_tcp_delete(w);
} else if(!w->on_tcp_waiting_list) {
struct pending_tcp* pend =
(struct pending_tcp*)w->next_waiting;
- verbose(5, "serviced_delete: tcpreusekeep");
+ verbose(VERB_CLIENT, "serviced_delete: tcpreusekeep");
if(!reuse_tcp_remove_serviced_keep(w, sq)) {
reuse_cb_and_decommission(sq->outnet,
pend, NETEVENT_CLOSED);
}
sq->pending = NULL;
} else {
- verbose(5, "serviced_delete: tcpwait");
+ verbose(VERB_CLIENT, "serviced_delete: tcpwait");
waiting_list_remove(sq->outnet, w);
waiting_tcp_delete(w);
}
projects / thirdparty / unbound.git / commitdiff
