Lines Matching defs:reuse
91 struct reuse_tcp* reuse);
145 /** compare if the reuse element has the same address, port and same ssl-is
355 /** log reuse item addr and ptr with message */
357 log_reuse_tcp(enum verbosity_value v, const char* msg, struct reuse_tcp* reuse)
362 if(!reuse || !reuse->pending || !reuse->pending->c)
364 addr_to_str(&reuse->addr, reuse->addrlen, addrbuf, sizeof(addrbuf));
365 port = ntohs(((struct sockaddr_in*)&reuse->addr)->sin_port);
367 reuse->pending->c->fd);
372 reuse_write_wait_pop(struct reuse_tcp* reuse)
374 struct waiting_tcp* w = reuse->write_wait_first;
379 reuse->write_wait_first = w->write_wait_next;
382 else reuse->write_wait_last = NULL;
391 reuse_write_wait_remove(struct reuse_tcp* reuse, struct waiting_tcp* w)
401 else reuse->write_wait_first = w->write_wait_next;
406 else reuse->write_wait_last = w->write_wait_prev;
416 reuse_write_wait_push_back(struct reuse_tcp* reuse, struct waiting_tcp* w)
420 if(reuse->write_wait_last) {
421 reuse->write_wait_last->write_wait_next = w;
422 log_assert(reuse->write_wait_last->write_wait_next !=
423 reuse->write_wait_last);
424 w->write_wait_prev = reuse->write_wait_last;
426 reuse->write_wait_first = w;
430 reuse->write_wait_last = w;
436 reuse_tree_by_id_insert(struct reuse_tcp* reuse, struct waiting_tcp* w)
448 rbtree_insert(&reuse->tree_by_id, &w->id_node);
454 reuse_tcp_by_id_find(struct reuse_tcp* reuse, uint16_t id)
461 n = rbtree_search(&reuse->tree_by_id, &key_w);
474 /** insert into reuse tcp tree and LRU, false on failure (duplicate) */
478 log_reuse_tcp(VERB_CLIENT, "reuse_tcp_insert", &pend_tcp->reuse);
479 if(pend_tcp->reuse.item_on_lru_list) {
480 if(!pend_tcp->reuse.node.key)
485 pend_tcp->reuse.node.key = &pend_tcp->reuse;
486 pend_tcp->reuse.pending = pend_tcp;
487 if(!rbtree_insert(&outnet->tcp_reuse, &pend_tcp->reuse.node)) {
495 pend_tcp->reuse.lru_prev = NULL;
497 pend_tcp->reuse.lru_next = outnet->tcp_reuse_first;
498 log_assert(pend_tcp->reuse.lru_next != &pend_tcp->reuse);
499 outnet->tcp_reuse_first->lru_prev = &pend_tcp->reuse;
503 pend_tcp->reuse.lru_next = NULL;
504 outnet->tcp_reuse_last = &pend_tcp->reuse;
506 outnet->tcp_reuse_first = &pend_tcp->reuse;
507 pend_tcp->reuse.item_on_lru_list = 1;
517 /** find reuse tcp stream to destination for query, or NULL if none */
532 key_p.reuse.pending = &key_p;
533 key_p.reuse.node.key = &key_p.reuse;
535 key_p.reuse.is_ssl = 1;
536 if(addrlen > (socklen_t)sizeof(key_p.reuse.addr))
538 memmove(&key_p.reuse.addr, addr, addrlen);
539 key_p.reuse.addrlen = addrlen;
541 verbose(VERB_CLIENT, "reuse_tcp_find: num reuse streams %u",
546 if(rbtree_find_less_equal(&outnet->tcp_reuse, &key_p.reuse,
550 log_assert(&key_p.reuse != (struct reuse_tcp*)result);
570 if (reuse_cmp_addrportssl(result->key, &key_p.reuse) < 0) {
583 reuse_cmp_addrportssl(prev->key, &key_p.reuse) == 0) {
590 reuse_cmp_addrportssl(result->key, &key_p.reuse) == 0) {
750 pend->reuse.outnet = w->outnet;
752 pend->c->tcp_more_read_again = &pend->reuse.cp_more_read_again;
753 pend->c->tcp_more_write_again = &pend->reuse.cp_more_write_again;
754 pend->reuse.cp_more_read_again = 0;
755 pend->reuse.cp_more_write_again = 0;
757 pend->reuse.pending = pend;
763 if(pend->reuse.node.key)
764 reuse_tcp_remove_tree_list(w->outnet, &pend->reuse);
767 pend->reuse.is_ssl = 1;
768 else pend->reuse.is_ssl = 0;
769 /* insert in reuse by address tree if not already inserted there */
771 reuse_tree_by_id_insert(&pend->reuse, w);
780 reuse_tcp_lru_touch(struct outside_network* outnet, struct reuse_tcp* reuse)
782 if(!reuse->item_on_lru_list) {
786 log_assert(reuse->lru_prev ||
787 (!reuse->lru_prev && outnet->tcp_reuse_first == reuse));
788 if(!reuse->lru_prev)
792 reuse->lru_prev->lru_next = reuse->lru_next;
793 log_assert(reuse->lru_prev->lru_next != reuse->lru_prev);
794 if(reuse->lru_next)
795 reuse->lru_next->lru_prev = reuse->lru_prev;
796 else outnet->tcp_reuse_last = reuse->lru_prev;
797 log_assert(!reuse->lru_next || reuse->lru_next->lru_prev != reuse->lru_next);
801 reuse->lru_prev = NULL;
802 reuse->lru_next = outnet->tcp_reuse_first;
804 outnet->tcp_reuse_first->lru_prev = reuse;
806 log_assert(reuse->lru_next != reuse);
808 * lru_next is thus not NULL and thus reuse is now not the last in
810 outnet->tcp_reuse_first = reuse;
821 struct reuse_tcp* reuse = outnet->tcp_reuse_last;
822 if(!reuse) return NULL;
824 log_assert(reuse->lru_next == NULL);
825 if(reuse->lru_prev) {
826 outnet->tcp_reuse_last = reuse->lru_prev;
827 reuse->lru_prev->lru_next = NULL;
834 reuse->item_on_lru_list = 0;
835 reuse->lru_next = NULL;
836 reuse->lru_prev = NULL;
837 return reuse;
951 struct reuse_tcp* reuse = NULL;
956 reuse = reuse_tcp_find(outnet, &w->addr, w->addrlen,
959 w->id = tcp_select_id(outnet, reuse);
961 if(reuse) {
963 "found reuse", reuse);
965 pend_tcp = reuse->pending;
967 reuse_tcp_lru_touch(outnet, reuse);
969 w->next_waiting = (void*)reuse->pending;
970 reuse_tree_by_id_insert(reuse, w);
971 if(reuse->pending->query) {
973 reuse_write_wait_push_back(reuse, w);
977 comm_point_stop_listening(reuse->pending->c);
978 reuse->pending->query = w;
980 reuse->pending->c->fd, reuse->pending,
985 rbtree_init(&pend->reuse.tree_by_id, reuse_id_cmp);
986 pend->reuse.pending = pend;
987 memcpy(&pend->reuse.addr, &w->addr, w->addrlen);
988 pend->reuse.addrlen = w->addrlen;
1001 /* no reuse and no free buffer, put back at the start */
1021 reuse_tree_by_id_delete(struct reuse_tcp* reuse, struct waiting_tcp* w)
1032 rbtree_delete(&reuse->tree_by_id, w);
1065 pend->reuse.cp_more_read_again = 0;
1066 pend->reuse.cp_more_write_again = 0;
1075 reuse_tree_by_id_delete(&pend->reuse, w);
1078 while((w = reuse_write_wait_pop(&pend->reuse)) != NULL) {
1086 reuse_tree_by_id_delete(&pend->reuse, w);
1094 struct reuse_tcp* reuse)
1097 if(reuse->node.key) {
1098 /* delete it from reuse tree */
1099 if(!rbtree_delete(&outnet->tcp_reuse, reuse)) {
1102 addr_to_str(&reuse->addr, reuse->addrlen, buf,
1104 log_err("reuse tcp delete: node not present, internal error, %s ssl %d lru %d", buf, reuse->is_ssl, reuse->item_on_lru_list);
1106 reuse->node.key = NULL;
1109 memset(&reuse->node, 0, sizeof(reuse->node));
1111 /* delete from reuse list */
1112 if(reuse->item_on_lru_list) {
1113 if(reuse->lru_prev) {
1116 log_assert(reuse->lru_prev->pending);
1117 reuse->lru_prev->lru_next = reuse->lru_next;
1118 log_assert(reuse->lru_prev->lru_next != reuse->lru_prev);
1120 log_assert(!reuse->lru_next || reuse->lru_next->pending);
1121 outnet->tcp_reuse_first = reuse->lru_next;
1128 if(reuse->lru_next) {
1131 log_assert(reuse->lru_next->pending);
1132 reuse->lru_next->lru_prev = reuse->lru_prev;
1133 log_assert(reuse->lru_next->lru_prev != reuse->lru_next);
1135 log_assert(!reuse->lru_prev || reuse->lru_prev->pending);
1136 outnet->tcp_reuse_last = reuse->lru_prev;
1145 reuse->item_on_lru_list = 0;
1146 reuse->lru_next = NULL;
1147 reuse->lru_prev = NULL;
1149 reuse->pending = NULL;
1153 * elements in tcp reuse structure */
1182 if(pend->reuse.node.key) {
1183 /* needs unlink from the reuse tree to get deleted */
1184 reuse_tcp_remove_tree_list(outnet, &pend->reuse);
1186 /* free SSL structure after remove from outnet tcp reuse tree,
1196 pend->reuse.cp_more_read_again = 0;
1197 pend->reuse.cp_more_write_again = 0;
1201 pend->reuse.write_wait_first = NULL;
1202 pend->reuse.write_wait_last = NULL;
1203 reuse_del_readwait(&pend->reuse.tree_by_id);
1206 /** perform failure callbacks for waiting queries in reuse read rbtree */
1241 * the pending_tcp due to its reference in the outside_network reuse tree */
1246 store = pend->reuse.tree_by_id;
1248 rbtree_init(&pend->reuse.tree_by_id, reuse_id_cmp);
1249 pend->reuse.write_wait_first = NULL;
1250 pend->reuse.write_wait_last = NULL;
1263 log_reuse_tcp(VERB_CLIENT, "reuse_tcp_setup_timeout", &pend_tcp->reuse);
1271 log_reuse_tcp(VERB_CLIENT, "reuse_tcp_setup_readtimeout", &pend_tcp->reuse);
1284 struct outside_network* outnet = pend->reuse.outnet;
1286 log_assert(pend->reuse.item_on_lru_list && pend->reuse.node.key);
1297 (pend->reuse.tree_by_id.count?"for reading pkt":
1298 "for keepalive for reuse"));
1300 /* must be timeout for reading or keepalive reuse,
1302 reuse_tcp_remove_tree_list(outnet, &pend->reuse);
1315 if(pend->reuse.write_wait_first) {
1321 pend->reuse.cp_more_write_again = 1;
1322 pend->query = reuse_write_wait_pop(&pend->reuse);
1329 pend->reuse.cp_more_read_again = 0;
1330 pend->reuse.cp_more_write_again = 0;
1345 &pend->reuse.addr, pend->reuse.addrlen);
1351 w = reuse_tcp_by_id_find(&pend->reuse, id);
1363 &pend->reuse.addr, pend->reuse.addrlen);
1367 /* add to reuse tree so it can be reused, if not a failure.
1377 reuse_tree_by_id_delete(&pend->reuse, w);
1383 verbose(VERB_CLIENT, "outnet_tcp_cb reuse after cb");
1384 if(error == NETEVENT_NOERROR && pend->reuse.node.key) {
1385 verbose(VERB_CLIENT, "outnet_tcp_cb reuse after cb: keep it");
1392 if(pend->reuse.tree_by_id.count != 0)
1393 pend->reuse.cp_more_read_again = 1;
1397 verbose(VERB_CLIENT, "outnet_tcp_cb reuse after cb: decommission it");
1905 if(pend->reuse.item_on_lru_list) {
2115 /* if we connect() we cannot reuse fds for a port */
2332 struct reuse_tcp* reuse;
2334 reuse = reuse_tcp_lru_snip(outnet);
2335 if(!reuse) return;
2337 reuse_cb_and_decommission(outnet, reuse->pending, NETEVENT_CLOSED);
2341 tcp_select_id(struct outside_network* outnet, struct reuse_tcp* reuse)
2343 if(reuse)
2344 return reuse_tcp_select_id(reuse, outnet);
2348 /** find spare ID value for reuse tcp stream. That is random and also does
2351 reuse_tcp_select_id(struct reuse_tcp* reuse, struct outside_network* outnet)
2360 if(reuse->tree_by_id.count == 0) {
2368 if(!reuse_tcp_by_id_find(reuse, id)) {
2376 log_assert(reuse->tree_by_id.count < 0xffff);
2377 select = ub_random_max(outnet->rnd, 0xffff - reuse->tree_by_id.count);
2381 node = rbtree_first(&reuse->tree_by_id);
2411 node = rbtree_last(&reuse->tree_by_id);
2414 log_assert(count + (0xffff-curid) + reuse->tree_by_id.count == 0xffff);
2423 struct reuse_tcp* reuse = NULL;
2434 reuse = reuse_tcp_find(sq->outnet, &sq->addr, sq->addrlen,
2436 if(reuse) {
2437 log_reuse_tcp(VERB_CLIENT, "pending_tcp_query: found reuse", reuse);
2438 log_assert(reuse->pending);
2439 pend = reuse->pending;
2440 reuse_tcp_lru_touch(sq->outnet, reuse);
2443 log_assert(!reuse || (reuse && pend));
2444 /* if !pend but we have reuse streams, close a reuse stream
2446 * to reuse a file descriptor while another query needs to use
2451 log_assert(!reuse || (pend == reuse->pending));
2467 w->id = tcp_select_id(sq->outnet, reuse);
2490 if(reuse) {
2491 log_assert(reuse == &pend->reuse);
2492 /* reuse existing fd, write query and continue */
2494 verbose(VERB_CLIENT, "pending_tcp_query: reuse, store");
2496 reuse_tree_by_id_insert(&pend->reuse, w);
2508 reuse_write_wait_push_back(&pend->reuse, w);
2514 rbtree_init(&pend->reuse.tree_by_id, reuse_id_cmp);
2515 pend->reuse.pending = pend;
2516 memcpy(&pend->reuse.addr, &sq->addr, sq->addrlen);
2517 pend->reuse.addrlen = sq->addrlen;
2691 /** reuse tcp stream, remove serviced query from stream,
2704 /* see if can be entered in reuse tree
2711 if(pend_tcp->reuse.node.key) {
2764 reuse_tree_by_id_delete(&pend->reuse, w);
2765 reuse_write_wait_remove(&pend->reuse, w);