unbound/services/outside_network.c

95 	struct reuse_tcp* reuse);
139 /** compare if the reuse element has the same address, port and same ssl-is
333 /** log reuse item addr and ptr with message */
335 log_reuse_tcp(enum verbosity_value v, const char* msg, struct reuse_tcp* reuse)
340 	addr_to_str(&reuse->addr, reuse->addrlen, addrbuf, sizeof(addrbuf));
341 	port = ntohs(((struct sockaddr_in*)&reuse->addr)->sin_port);
343 		reuse->pending->c->fd);
347 static struct waiting_tcp* reuse_write_wait_pop(struct reuse_tcp* reuse)
349 	struct waiting_tcp* w = reuse->write_wait_first;
354 	reuse->write_wait_first = w->write_wait_next;
357 	else	reuse->write_wait_last = NULL;
363 static void reuse_write_wait_remove(struct reuse_tcp* reuse,
372 	else	reuse->write_wait_first = w->write_wait_next;
375 	else	reuse->write_wait_last = w->write_wait_prev;
380 static void reuse_write_wait_push_back(struct reuse_tcp* reuse,
385 	if(reuse->write_wait_last) {
386 		reuse->write_wait_last->write_wait_next = w;
387 		w->write_wait_prev = reuse->write_wait_last;
389 		reuse->write_wait_first = w;
391 	reuse->write_wait_last = w;
397 reuse_tree_by_id_insert(struct reuse_tcp* reuse, struct waiting_tcp* w)
401 	rbtree_insert(&reuse->tree_by_id, &w->id_node);
406 reuse_tcp_by_id_find(struct reuse_tcp* reuse, uint16_t id)
413 	n = rbtree_search(&reuse->tree_by_id, &key_w);
426 /** insert into reuse tcp tree and LRU, false on failure (duplicate) */
430 	log_reuse_tcp(VERB_CLIENT, "reuse_tcp_insert", &pend_tcp->reuse);
431 	if(pend_tcp->reuse.item_on_lru_list) {
432 		if(!pend_tcp->reuse.node.key)
436 	pend_tcp->reuse.node.key = &pend_tcp->reuse;
437 	pend_tcp->reuse.pending = pend_tcp;
438 	if(!rbtree_insert(&outnet->tcp_reuse, &pend_tcp->reuse.node)) {
441 		pend_tcp->reuse.node.key = NULL;
445 	pend_tcp->reuse.lru_prev = NULL;
447 		pend_tcp->reuse.lru_next = outnet->tcp_reuse_first;
448 		outnet->tcp_reuse_first->lru_prev = &pend_tcp->reuse;
450 		pend_tcp->reuse.lru_next = NULL;
451 		outnet->tcp_reuse_last = &pend_tcp->reuse;
453 	outnet->tcp_reuse_first = &pend_tcp->reuse;
454 	pend_tcp->reuse.item_on_lru_list = 1;
458 /** find reuse tcp stream to destination for query, or NULL if none */
473 	key_p.reuse.pending = &key_p;
474 	key_p.reuse.node.key = &key_p.reuse;
476 		key_p.reuse.is_ssl = 1;
477 	if(addrlen > (socklen_t)sizeof(key_p.reuse.addr))
479 	memmove(&key_p.reuse.addr, addr, addrlen);
480 	key_p.reuse.addrlen = addrlen;
482 	verbose(VERB_CLIENT, "reuse_tcp_find: num reuse streams %u",
487 	if(rbtree_find_less_equal(&outnet->tcp_reuse, &key_p.reuse,
491 		log_assert(&key_p.reuse != (struct reuse_tcp*)result);
505 		reuse_cmp_addrportssl(prev->key, &key_p.reuse) == 0) {
512 		reuse_cmp_addrportssl(result->key, &key_p.reuse) == 0) {
663 	pend->reuse.outnet = w->outnet;
665 	pend->c->tcp_more_read_again = &pend->reuse.cp_more_read_again;
666 	pend->c->tcp_more_write_again = &pend->reuse.cp_more_write_again;
667 	pend->reuse.cp_more_read_again = 0;
668 	pend->reuse.cp_more_write_again = 0;
670 	pend->reuse.pending = pend;
676 	if(pend->reuse.node.key)
677 		reuse_tcp_remove_tree_list(w->outnet, &pend->reuse);
680 		pend->reuse.is_ssl = 1;
681 	else	pend->reuse.is_ssl = 0;
682 	/* insert in reuse by address tree if not already inserted there */
684 	reuse_tree_by_id_insert(&pend->reuse, w);
693 reuse_tcp_lru_touch(struct outside_network* outnet, struct reuse_tcp* reuse)
695 	if(!reuse->item_on_lru_list) {
699 	if(!reuse->lru_prev)
703 	reuse->lru_prev->lru_next = reuse->lru_next;
704 	if(reuse->lru_next)
705 		reuse->lru_next->lru_prev = reuse->lru_prev;
706 	else	outnet->tcp_reuse_last = reuse->lru_prev;
708 	reuse->lru_prev = NULL;
709 	reuse->lru_next = outnet->tcp_reuse_first;
711 	 * lru_next is thus not NULL and thus reuse is now not the last in
713 	outnet->tcp_reuse_first = reuse;
734 		struct reuse_tcp* reuse = NULL;
740 		reuse = reuse_tcp_find(outnet, &w->addr, w->addrlen,
742 		if(reuse) {
744 				"found reuse", reuse);
745 			reuse_tcp_lru_touch(outnet, reuse);
747 			w->next_waiting = (void*)reuse->pending;
748 			reuse_tree_by_id_insert(reuse, w);
749 			if(reuse->pending->query) {
751 				reuse_write_wait_push_back(reuse, w);
755 				comm_point_stop_listening(reuse->pending->c);
756 				reuse->pending->query = w;
758 					reuse->pending->c->fd, reuse->pending,
763 			rbtree_init(&pend->reuse.tree_by_id, reuse_id_cmp);
764 			pend->reuse.pending = pend;
765 			memcpy(&pend->reuse.addr, &w->addr, w->addrlen);
766 			pend->reuse.addrlen = w->addrlen;
798 reuse_tree_by_id_delete(struct reuse_tcp* reuse, struct waiting_tcp* w)
801 	rbtree_delete(&reuse->tree_by_id, w);
833 		pend->reuse.cp_more_read_again = 0;
834 		pend->reuse.cp_more_write_again = 0;
843 		reuse_tree_by_id_delete(&pend->reuse, w);
846 	while((w = reuse_write_wait_pop(&pend->reuse)) != NULL) {
854 		reuse_tree_by_id_delete(&pend->reuse, w);
862 	struct reuse_tcp* reuse)
865 	if(reuse->node.key) {
866 		/* delete it from reuse tree */
867 		(void)rbtree_delete(&outnet->tcp_reuse, reuse);
868 		reuse->node.key = NULL;
870 	/* delete from reuse list */
871 	if(reuse->item_on_lru_list) {
872 		if(reuse->lru_prev) {
875 			log_assert(reuse->lru_prev->pending);
876 			reuse->lru_prev->lru_next = reuse->lru_next;
878 			log_assert(!reuse->lru_next || reuse->lru_next->pending);
879 			outnet->tcp_reuse_first = reuse->lru_next;
881 		if(reuse->lru_next) {
884 			log_assert(reuse->lru_next->pending);
885 			reuse->lru_next->lru_prev = reuse->lru_prev;
887 			log_assert(!reuse->lru_prev || reuse->lru_prev->pending);
888 			outnet->tcp_reuse_last = reuse->lru_prev;
890 		reuse->item_on_lru_list = 0;
895  * elements in tcp reuse structure */
920 	if(pend->reuse.node.key) {
921 		/* needs unlink from the reuse tree to get deleted */
922 		reuse_tcp_remove_tree_list(outnet, &pend->reuse);
924 	/* free SSL structure after remove from outnet tcp reuse tree,
934 	pend->reuse.cp_more_read_again = 0;
935 	pend->reuse.cp_more_write_again = 0;
939 	pend->reuse.write_wait_first = NULL;
940 	pend->reuse.write_wait_last = NULL;
941 	reuse_del_readwait(&pend->reuse.tree_by_id);
944 /** perform failure callbacks for waiting queries in reuse read rbtree */
963  * the pending_tcp due to its reference in the outside_network reuse tree */
968 	store = pend->reuse.tree_by_id;
970 	rbtree_init(&pend->reuse.tree_by_id, reuse_id_cmp);
971 	pend->reuse.write_wait_first = NULL;
972 	pend->reuse.write_wait_last = NULL;
982 	log_reuse_tcp(VERB_CLIENT, "reuse_tcp_setup_timeout", &pend_tcp->reuse);
990 	log_reuse_tcp(VERB_CLIENT, "reuse_tcp_setup_readtimeout", &pend_tcp->reuse);
1003 	struct outside_network* outnet = pend->reuse.outnet;
1015 				(pend->reuse.tree_by_id.count?"for reading pkt":
1016 				"for keepalive for reuse"));
1018 		/* must be timeout for reading or keepalive reuse,
1020 		reuse_tcp_remove_tree_list(outnet, &pend->reuse);
1033 		if(pend->reuse.write_wait_first) {
1039 			pend->reuse.cp_more_write_again = 1;
1040 			pend->query = reuse_write_wait_pop(&pend->reuse);
1047 			pend->reuse.cp_more_read_again = 0;
1048 			pend->reuse.cp_more_write_again = 0;
1063 				&pend->reuse.addr, pend->reuse.addrlen);
1069 			w = reuse_tcp_by_id_find(&pend->reuse, id);
1075 			&pend->reuse.addr, pend->reuse.addrlen);
1079 		/* add to reuse tree so it can be reused, if not a failure.
1087 		reuse_tree_by_id_delete(&pend->reuse, w);
1093 	verbose(VERB_CLIENT, "outnet_tcp_cb reuse after cb");
1094 	if(error == NETEVENT_NOERROR && pend->reuse.node.key) {
1095 		verbose(VERB_CLIENT, "outnet_tcp_cb reuse after cb: keep it");
1102 		if(pend->reuse.tree_by_id.count != 0)
1103 			pend->reuse.cp_more_read_again = 1;
1107 	verbose(VERB_CLIENT, "outnet_tcp_cb reuse after cb: decommission it");
1812 			/* if we connect() we cannot reuse fds for a port */
2020 	log_assert(pend->reuse.lru_next == NULL);
2021 	if(pend->reuse.lru_prev) {
2022 		outnet->tcp_reuse_last = pend->reuse.lru_prev;
2023 		pend->reuse.lru_prev->lru_next = NULL;
2028 	pend->reuse.item_on_lru_list = 0;
2034 /** find spare ID value for reuse tcp stream.  That is random and also does
2037 reuse_tcp_select_id(struct reuse_tcp* reuse, struct outside_network* outnet)
2046 	if(reuse->tree_by_id.count == 0) {
2054 		if(!reuse_tcp_by_id_find(reuse, id)) {
2062 	log_assert(reuse->tree_by_id.count < 0xffff);
2063 	select = ub_random_max(outnet->rnd, 0xffff - reuse->tree_by_id.count);
2067 	node = rbtree_first(&reuse->tree_by_id);
2097 	node = rbtree_last(&reuse->tree_by_id);
2100 	log_assert(count + (0xffff-curid) + reuse->tree_by_id.count == 0xffff);
2109 	struct reuse_tcp* reuse = NULL;
2120 	reuse = reuse_tcp_find(sq->outnet, &sq->addr, sq->addrlen,
2122 	if(reuse) {
2123 		log_reuse_tcp(VERB_CLIENT, "pending_tcp_query: found reuse", reuse);
2124 		log_assert(reuse->pending);
2125 		pend = reuse->pending;
2126 		reuse_tcp_lru_touch(sq->outnet, reuse);
2129 	/* if !pend but we have reuse streams, close a reuse stream
2131 	 * to reuse a file descriptor while another query needs to use
2151 	if(reuse)
2152 		w->id = reuse_tcp_select_id(reuse, sq->outnet);
2172 		if(reuse) {
2173 			/* reuse existing fd, write query and continue */
2175 			verbose(VERB_CLIENT, "pending_tcp_query: reuse, store");
2177 			reuse_tree_by_id_insert(&pend->reuse, w);
2189 				reuse_write_wait_push_back(&pend->reuse, w);
2195 			rbtree_init(&pend->reuse.tree_by_id, reuse_id_cmp);
2196 			pend->reuse.pending = pend;
2197 			memcpy(&pend->reuse.addr, &sq->addr, sq->addrlen);
2198 			pend->reuse.addrlen = sq->addrlen;
2353 /** reuse tcp stream, remove serviced query from stream,
2366 	/* see if can be entered in reuse tree
2373 	if(pend_tcp->reuse.node.key) {
2424 				reuse_tree_by_id_delete(&pend->reuse, w);
2425 				reuse_write_wait_remove(&pend->reuse, w);