Lines Matching refs:reuse
91 struct reuse_tcp* reuse);
145 /** compare if the reuse element has the same address, port and same ssl-is
369 /** log reuse item addr and ptr with message */
371 log_reuse_tcp(enum verbosity_value v, const char* msg, struct reuse_tcp* reuse)
376 if(!reuse || !reuse->pending || !reuse->pending->c)
378 addr_to_str(&reuse->addr, reuse->addrlen, addrbuf, sizeof(addrbuf));
379 port = ntohs(((struct sockaddr_in*)&reuse->addr)->sin_port);
381 reuse->pending->c->fd);
386 reuse_write_wait_pop(struct reuse_tcp* reuse)
388 struct waiting_tcp* w = reuse->write_wait_first;
393 reuse->write_wait_first = w->write_wait_next;
396 else reuse->write_wait_last = NULL;
405 reuse_write_wait_remove(struct reuse_tcp* reuse, struct waiting_tcp* w)
415 else reuse->write_wait_first = w->write_wait_next;
420 else reuse->write_wait_last = w->write_wait_prev;
430 reuse_write_wait_push_back(struct reuse_tcp* reuse, struct waiting_tcp* w)
434 if(reuse->write_wait_last) {
435 reuse->write_wait_last->write_wait_next = w;
436 log_assert(reuse->write_wait_last->write_wait_next !=
437 reuse->write_wait_last);
438 w->write_wait_prev = reuse->write_wait_last;
440 reuse->write_wait_first = w;
444 reuse->write_wait_last = w;
450 reuse_tree_by_id_insert(struct reuse_tcp* reuse, struct waiting_tcp* w)
462 rbtree_insert(&reuse->tree_by_id, &w->id_node);
468 reuse_tcp_by_id_find(struct reuse_tcp* reuse, uint16_t id)
475 n = rbtree_search(&reuse->tree_by_id, &key_w);
488 /** insert into reuse tcp tree and LRU, false on failure (duplicate) */
492 log_reuse_tcp(VERB_CLIENT, "reuse_tcp_insert", &pend_tcp->reuse);
493 if(pend_tcp->reuse.item_on_lru_list) {
494 if(!pend_tcp->reuse.node.key)
499 pend_tcp->reuse.node.key = &pend_tcp->reuse;
500 pend_tcp->reuse.pending = pend_tcp;
501 if(!rbtree_insert(&outnet->tcp_reuse, &pend_tcp->reuse.node)) {
509 pend_tcp->reuse.lru_prev = NULL;
511 pend_tcp->reuse.lru_next = outnet->tcp_reuse_first;
512 log_assert(pend_tcp->reuse.lru_next != &pend_tcp->reuse);
513 outnet->tcp_reuse_first->lru_prev = &pend_tcp->reuse;
517 pend_tcp->reuse.lru_next = NULL;
518 outnet->tcp_reuse_last = &pend_tcp->reuse;
520 outnet->tcp_reuse_first = &pend_tcp->reuse;
521 pend_tcp->reuse.item_on_lru_list = 1;
531 /** find reuse tcp stream to destination for query, or NULL if none */
546 key_p.reuse.pending = &key_p;
547 key_p.reuse.node.key = &key_p.reuse;
549 key_p.reuse.is_ssl = 1;
550 if(addrlen > (socklen_t)sizeof(key_p.reuse.addr))
552 memmove(&key_p.reuse.addr, addr, addrlen);
553 key_p.reuse.addrlen = addrlen;
555 verbose(VERB_CLIENT, "reuse_tcp_find: num reuse streams %u",
560 if(rbtree_find_less_equal(&outnet->tcp_reuse, &key_p.reuse,
564 log_assert(&key_p.reuse != (struct reuse_tcp*)result);
584 if (reuse_cmp_addrportssl(result->key, &key_p.reuse) < 0) {
597 reuse_cmp_addrportssl(prev->key, &key_p.reuse) == 0) {
604 reuse_cmp_addrportssl(result->key, &key_p.reuse) == 0) {
765 pend->reuse.outnet = w->outnet;
767 pend->c->tcp_more_read_again = &pend->reuse.cp_more_read_again;
768 pend->c->tcp_more_write_again = &pend->reuse.cp_more_write_again;
769 pend->reuse.cp_more_read_again = 0;
770 pend->reuse.cp_more_write_again = 0;
772 pend->reuse.pending = pend;
778 if(pend->reuse.node.key)
779 reuse_tcp_remove_tree_list(w->outnet, &pend->reuse);
782 pend->reuse.is_ssl = 1;
783 else pend->reuse.is_ssl = 0;
784 /* insert in reuse by address tree if not already inserted there */
786 reuse_tree_by_id_insert(&pend->reuse, w);
795 reuse_tcp_lru_touch(struct outside_network* outnet, struct reuse_tcp* reuse)
797 if(!reuse->item_on_lru_list) {
801 log_assert(reuse->lru_prev ||
802 (!reuse->lru_prev && outnet->tcp_reuse_first == reuse));
803 if(!reuse->lru_prev)
807 reuse->lru_prev->lru_next = reuse->lru_next;
808 log_assert(reuse->lru_prev->lru_next != reuse->lru_prev);
809 if(reuse->lru_next)
810 reuse->lru_next->lru_prev = reuse->lru_prev;
811 else outnet->tcp_reuse_last = reuse->lru_prev;
812 log_assert(!reuse->lru_next || reuse->lru_next->lru_prev != reuse->lru_next);
816 reuse->lru_prev = NULL;
817 reuse->lru_next = outnet->tcp_reuse_first;
819 outnet->tcp_reuse_first->lru_prev = reuse;
821 log_assert(reuse->lru_next != reuse);
823 * lru_next is thus not NULL and thus reuse is now not the last in
825 outnet->tcp_reuse_first = reuse;
836 struct reuse_tcp* reuse = outnet->tcp_reuse_last;
837 if(!reuse) return NULL;
839 log_assert(reuse->lru_next == NULL);
840 if(reuse->lru_prev) {
841 outnet->tcp_reuse_last = reuse->lru_prev;
842 reuse->lru_prev->lru_next = NULL;
849 reuse->item_on_lru_list = 0;
850 reuse->lru_next = NULL;
851 reuse->lru_prev = NULL;
852 return reuse;
966 struct reuse_tcp* reuse = NULL;
971 reuse = reuse_tcp_find(outnet, &w->addr, w->addrlen,
974 w->id = tcp_select_id(outnet, reuse);
976 if(reuse) {
978 "found reuse", reuse);
980 pend_tcp = reuse->pending;
982 reuse_tcp_lru_touch(outnet, reuse);
984 w->next_waiting = (void*)reuse->pending;
985 reuse_tree_by_id_insert(reuse, w);
986 if(reuse->pending->query) {
988 reuse_write_wait_push_back(reuse, w);
992 comm_point_stop_listening(reuse->pending->c);
993 reuse->pending->query = w;
995 reuse->pending->c->fd, reuse->pending,
1000 rbtree_init(&pend->reuse.tree_by_id, reuse_id_cmp);
1001 pend->reuse.pending = pend;
1002 memcpy(&pend->reuse.addr, &w->addr, w->addrlen);
1003 pend->reuse.addrlen = w->addrlen;
1016 /* no reuse and no free buffer, put back at the start */
1036 reuse_tree_by_id_delete(struct reuse_tcp* reuse, struct waiting_tcp* w)
1047 rbtree_delete(&reuse->tree_by_id, w);
1080 pend->reuse.cp_more_read_again = 0;
1081 pend->reuse.cp_more_write_again = 0;
1090 reuse_tree_by_id_delete(&pend->reuse, w);
1093 while((w = reuse_write_wait_pop(&pend->reuse)) != NULL) {
1101 reuse_tree_by_id_delete(&pend->reuse, w);
1109 struct reuse_tcp* reuse)
1112 if(reuse->node.key) {
1113 /* delete it from reuse tree */
1114 if(!rbtree_delete(&outnet->tcp_reuse, reuse)) {
1117 addr_to_str(&reuse->addr, reuse->addrlen, buf,
1119 log_err("reuse tcp delete: node not present, internal error, %s ssl %d lru %d", buf, reuse->is_ssl, reuse->item_on_lru_list);
1121 reuse->node.key = NULL;
1124 memset(&reuse->node, 0, sizeof(reuse->node));
1126 /* delete from reuse list */
1127 if(reuse->item_on_lru_list) {
1128 if(reuse->lru_prev) {
1131 log_assert(reuse->lru_prev->pending);
1132 reuse->lru_prev->lru_next = reuse->lru_next;
1133 log_assert(reuse->lru_prev->lru_next != reuse->lru_prev);
1135 log_assert(!reuse->lru_next || reuse->lru_next->pending);
1136 outnet->tcp_reuse_first = reuse->lru_next;
1143 if(reuse->lru_next) {
1146 log_assert(reuse->lru_next->pending);
1147 reuse->lru_next->lru_prev = reuse->lru_prev;
1148 log_assert(reuse->lru_next->lru_prev != reuse->lru_next);
1150 log_assert(!reuse->lru_prev || reuse->lru_prev->pending);
1151 outnet->tcp_reuse_last = reuse->lru_prev;
1160 reuse->item_on_lru_list = 0;
1161 reuse->lru_next = NULL;
1162 reuse->lru_prev = NULL;
1164 reuse->pending = NULL;
1168 * elements in tcp reuse structure */
1197 if(pend->reuse.node.key) {
1198 /* needs unlink from the reuse tree to get deleted */
1199 reuse_tcp_remove_tree_list(outnet, &pend->reuse);
1201 /* free SSL structure after remove from outnet tcp reuse tree,
1211 pend->reuse.cp_more_read_again = 0;
1212 pend->reuse.cp_more_write_again = 0;
1216 pend->reuse.write_wait_first = NULL;
1217 pend->reuse.write_wait_last = NULL;
1218 reuse_del_readwait(&pend->reuse.tree_by_id);
1221 /** perform failure callbacks for waiting queries in reuse read rbtree */
1256 * the pending_tcp due to its reference in the outside_network reuse tree */
1261 store = pend->reuse.tree_by_id;
1263 rbtree_init(&pend->reuse.tree_by_id, reuse_id_cmp);
1264 pend->reuse.write_wait_first = NULL;
1265 pend->reuse.write_wait_last = NULL;
1278 log_reuse_tcp(VERB_CLIENT, "reuse_tcp_setup_timeout", &pend_tcp->reuse);
1286 log_reuse_tcp(VERB_CLIENT, "reuse_tcp_setup_readtimeout", &pend_tcp->reuse);
1299 struct outside_network* outnet = pend->reuse.outnet;
1301 log_assert(pend->reuse.item_on_lru_list && pend->reuse.node.key);
1312 (pend->reuse.tree_by_id.count?"for reading pkt":
1313 "for keepalive for reuse"));
1315 /* must be timeout for reading or keepalive reuse,
1317 reuse_tcp_remove_tree_list(outnet, &pend->reuse);
1330 if(pend->reuse.write_wait_first) {
1336 pend->reuse.cp_more_write_again = 1;
1337 pend->query = reuse_write_wait_pop(&pend->reuse);
1344 pend->reuse.cp_more_read_again = 0;
1345 pend->reuse.cp_more_write_again = 0;
1360 &pend->reuse.addr, pend->reuse.addrlen);
1366 w = reuse_tcp_by_id_find(&pend->reuse, id);
1378 &pend->reuse.addr, pend->reuse.addrlen);
1382 /* add to reuse tree so it can be reused, if not a failure.
1392 reuse_tree_by_id_delete(&pend->reuse, w);
1398 verbose(VERB_CLIENT, "outnet_tcp_cb reuse after cb");
1399 if(error == NETEVENT_NOERROR && pend->reuse.node.key) {
1400 verbose(VERB_CLIENT, "outnet_tcp_cb reuse after cb: keep it");
1407 if(pend->reuse.tree_by_id.count != 0)
1408 pend->reuse.cp_more_read_again = 1;
1412 verbose(VERB_CLIENT, "outnet_tcp_cb reuse after cb: decommission it");
1920 if(pend->reuse.item_on_lru_list) {
2130 /* if we connect() we cannot reuse fds for a port */
2347 struct reuse_tcp* reuse;
2349 reuse = reuse_tcp_lru_snip(outnet);
2350 if(!reuse) return;
2352 reuse_cb_and_decommission(outnet, reuse->pending, NETEVENT_CLOSED);
2356 tcp_select_id(struct outside_network* outnet, struct reuse_tcp* reuse)
2358 if(reuse)
2359 return reuse_tcp_select_id(reuse, outnet);
2363 /** find spare ID value for reuse tcp stream. That is random and also does
2366 reuse_tcp_select_id(struct reuse_tcp* reuse, struct outside_network* outnet)
2375 if(reuse->tree_by_id.count == 0) {
2383 if(!reuse_tcp_by_id_find(reuse, id)) {
2391 log_assert(reuse->tree_by_id.count < 0xffff);
2392 select = ub_random_max(outnet->rnd, 0xffff - reuse->tree_by_id.count);
2396 node = rbtree_first(&reuse->tree_by_id);
2426 node = rbtree_last(&reuse->tree_by_id);
2429 log_assert(count + (0xffff-curid) + reuse->tree_by_id.count == 0xffff);
2438 struct reuse_tcp* reuse = NULL;
2449 reuse = reuse_tcp_find(sq->outnet, &sq->addr, sq->addrlen,
2451 if(reuse) {
2452 log_reuse_tcp(VERB_CLIENT, "pending_tcp_query: found reuse", reuse);
2453 log_assert(reuse->pending);
2454 pend = reuse->pending;
2455 reuse_tcp_lru_touch(sq->outnet, reuse);
2458 log_assert(!reuse || (reuse && pend));
2459 /* if !pend but we have reuse streams, close a reuse stream
2461 * to reuse a file descriptor while another query needs to use
2466 log_assert(!reuse || (pend == reuse->pending));
2482 w->id = tcp_select_id(sq->outnet, reuse);
2505 if(reuse) {
2506 log_assert(reuse == &pend->reuse);
2507 /* reuse existing fd, write query and continue */
2509 verbose(VERB_CLIENT, "pending_tcp_query: reuse, store");
2511 reuse_tree_by_id_insert(&pend->reuse, w);
2523 reuse_write_wait_push_back(&pend->reuse, w);
2529 rbtree_init(&pend->reuse.tree_by_id, reuse_id_cmp);
2530 pend->reuse.pending = pend;
2531 memcpy(&pend->reuse.addr, &sq->addr, sq->addrlen);
2532 pend->reuse.addrlen = sq->addrlen;
2706 /** reuse tcp stream, remove serviced query from stream,
2719 /* see if can be entered in reuse tree
2726 if(pend_tcp->reuse.node.key) {
2779 reuse_tree_by_id_delete(&pend->reuse, w);
2780 reuse_write_wait_remove(&pend->reuse, w);