static FILE *logfp = NULL;
/* Managers */
-static isc_nm_t *netmgr = NULL;
static dns_dispatchmgr_t *dispatchmgr = NULL;
static dns_requestmgr_t *requestmgr = NULL;
static ns_interfacemgr_t *interfacemgr = NULL;
}
/* Create client */
- CHECK(dns_client_create(mctx, netmgr, 0, tlsctx_client_cache, &client,
- srcaddr4, srcaddr6));
+ CHECK(dns_client_create(mctx, 0, tlsctx_client_cache, &client, srcaddr4,
+ srcaddr6));
dns_client_setmaxrestarts(client, restarts);
dns_client_setmaxqueries(client, maxtotal);
dns_view_attach(view, &(dns_view_t *){ NULL });
- const unsigned int timeout = isc_nm_getinitialtimeout(netmgr) /
- MS_PER_SEC;
+ const unsigned int timeout = isc_nm_getinitialtimeout() / MS_PER_SEC;
CHECK(dns_request_create(requestmgr, message, NULL, &peer, NULL, NULL,
DNS_REQUESTOPT_TCP, NULL, timeout, timeout, 0,
0, isc_loop(), recvresponse, message,
ns_server_create(mctx, matchview, &sctx);
- CHECK(dns_dispatchmgr_create(mctx, netmgr, &dispatchmgr));
+ CHECK(dns_dispatchmgr_create(mctx, &dispatchmgr));
if (use_ipv4) {
isc_sockaddr_any(&any);
CHECK(dns_dispatch_createudp(dispatchmgr, a, &dispatch6));
}
- CHECK(ns_interfacemgr_create(mctx, sctx, netmgr, dispatchmgr, NULL,
+ CHECK(ns_interfacemgr_create(mctx, sctx, dispatchmgr, NULL,
&interfacemgr));
dns_view_create(mctx, dispatchmgr, dns_rdataclass_in, "_default",
dns_view_initsecroots(view);
CHECK(setup_dnsseckeys(NULL, view));
- CHECK(dns_view_createresolver(view, netmgr, 0, tlsctx_client_cache,
- dispatch4, dispatch6));
+ CHECK(dns_view_createresolver(view, 0, tlsctx_client_cache, dispatch4,
+ dispatch6));
dns_resolver_setmaxqueries(view->resolver, maxqueries);
isc_stats_create(mctx, &resstats, dns_resstatscounter_max);
ns_interface_create(interfacemgr, &addr, NULL, &ifp);
- CHECK(isc_nm_listenstreamdns(netmgr, ISC_NM_LISTEN_ONE, &addr,
- ns_client_request, ifp, accept_cb, ifp, 10,
- NULL, NULL, ISC_NM_PROXY_NONE,
- &ifp->tcplistensocket));
+ CHECK(isc_nm_listenstreamdns(
+ ISC_NM_LISTEN_ONE, &addr, ns_client_request, ifp, accept_cb,
+ ifp, 10, NULL, NULL, ISC_NM_PROXY_NONE, &ifp->tcplistensocket));
ifp->flags |= NS_INTERFACEFLAG_LISTENING;
isc_async_current(sendquery, ifp->tcplistensocket);
argc--;
argv++;
- isc_managers_create(&mctx, 1, &netmgr);
+ isc_managers_create(&mctx, 1);
loop = isc_loop_main();
parse_args(argc, argv);
dns_master_styledestroy(&style, mctx);
}
- isc_managers_destroy(&mctx, &netmgr);
+ isc_managers_destroy(&mctx);
return 0;
}
unsigned int timeout = 0;
unsigned int extrabytes;
isc_mem_t *mctx = NULL;
-isc_nm_t *netmgr = NULL;
isc_loop_t *mainloop = NULL;
isc_sockaddr_t localaddr;
isc_refcount_t sendcount = 0;
fatal("can't find either v4 or v6 networking");
}
- isc_managers_create(&mctx, 1, &netmgr);
+ isc_managers_create(&mctx, 1);
logconfig = isc_logconfig_get();
isc_log_createandusechannel(logconfig, "debug", ISC_LOG_TOFILEDESC,
if (tlsctx == NULL) {
goto failure_tls;
}
- isc_nm_streamdnsconnect(netmgr, &localaddr, &query->sockaddr,
+ isc_nm_streamdnsconnect(&localaddr, &query->sockaddr,
tcp_connected, connectquery,
local_timeout, tlsctx,
get_tls_sni_hostname(query), sess_cache,
}
}
- isc_nm_httpconnect(netmgr, &localaddr, &query->sockaddr, uri,
+ isc_nm_httpconnect(&localaddr, &query->sockaddr, uri,
!query->lookup->https_get, tcp_connected,
connectquery, tlsctx,
get_tls_sni_hostname(query), sess_cache,
local_timeout, proxy_type, ppi);
#endif
} else {
- isc_nm_streamdnsconnect(netmgr, &localaddr, &query->sockaddr,
+ isc_nm_streamdnsconnect(&localaddr, &query->sockaddr,
tcp_connected, connectquery,
local_timeout, NULL, NULL, NULL,
proxy_type, ppi);
&query->lookup->proxy_dst_addr, NULL);
ppi = &proxy_info;
}
- isc_nm_proxyudpconnect(netmgr, &localaddr, &query->sockaddr,
- udp_ready, connectquery,
- (timeout ? timeout : UDP_TIMEOUT) * 1000,
- ppi);
+ isc_nm_proxyudpconnect(
+ &localaddr, &query->sockaddr, udp_ready, connectquery,
+ (timeout ? timeout : UDP_TIMEOUT) * 1000, ppi);
} else {
- isc_nm_udpconnect(netmgr, &localaddr, &query->sockaddr,
- udp_ready, connectquery,
+ isc_nm_udpconnect(&localaddr, &query->sockaddr, udp_ready,
+ connectquery,
(timeout ? timeout : UDP_TIMEOUT) * 1000);
}
}
isc_mem_stats(mctx, stderr);
}
- isc_managers_destroy(&mctx, &netmgr);
+ isc_managers_destroy(&mctx);
#if ENABLE_LEAK_DETECTION
isc__crypto_setdestroycheck(true);
static atomic_uint_fast32_t nverified = 0, nverifyfailed = 0;
static const char *directory = NULL, *dsdir = NULL;
static isc_mutex_t namelock;
-static isc_nm_t *netmgr = NULL;
static dns_db_t *gdb; /* The database */
static dns_dbversion_t *gversion; /* The database version */
static dns_dbiterator_t *gdbiter; /* The database iterator */
directory = ".";
}
- isc_managers_create(&mctx, nloops, &netmgr);
+ isc_managers_create(&mctx, nloops);
setup_logging();
isc_mem_stats(mctx, stdout);
}
- isc_managers_destroy(&mctx, &netmgr);
+ isc_managers_destroy(&mctx);
if (printstats) {
timer_finish = isc_time_now();
CHECK(ISC_R_FAMILYNOSUPPORT);
}
- CHECK(isc_nm_listentcp(named_g_netmgr, ISC_NM_LISTEN_ONE,
- &listener->address, control_newconn, listener, 5,
- NULL, &listener->sock));
+ CHECK(isc_nm_listentcp(ISC_NM_LISTEN_ONE, &listener->address,
+ control_newconn, listener, 5, NULL,
+ &listener->sock));
isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_CONTROL,
ISC_LOG_NOTICE, "command channel listening on %s",
* for really short timers, another for client timers, and one
* for zone timers.
*/
-EXTERN isc_nm_t *named_g_netmgr INIT(NULL);
EXTERN cfg_parser_t *named_g_parser INIT(NULL);
EXTERN cfg_parser_t *named_g_addparser INIT(NULL);
EXTERN const char *named_g_version INIT(PACKAGE_VERSION);
"thread count limit)"
: "");
- isc_managers_create(&named_g_mctx, named_g_cpus, &named_g_netmgr);
+ isc_managers_create(&named_g_mctx, named_g_cpus);
- isc_nm_maxudp(named_g_netmgr, maxudp);
+ isc_nm_maxudp(maxudp);
return ISC_R_SUCCESS;
}
}
}
- isc_managers_destroy(&named_g_mctx, &named_g_netmgr);
+ isc_managers_destroy(&named_g_mctx);
#if ENABLE_LEAK_DETECTION
isc__crypto_setdestroycheck(true);
goto cleanup;
}
- CHECK(dns_view_createresolver(view, named_g_netmgr, resopts,
+ CHECK(dns_view_createresolver(view, resopts,
named_g_server->tlsctx_client_cache,
dispatch4, dispatch6));
primaries = MIN_PRIMARIES_TIMEOUT;
}
- isc_nm_setinitialtimeout(named_g_netmgr, initial);
- isc_nm_setprimariestimeout(named_g_netmgr, primaries);
- isc_nm_setidletimeout(named_g_netmgr, idle);
- isc_nm_setkeepalivetimeout(named_g_netmgr, keepalive);
- isc_nm_setadvertisedtimeout(named_g_netmgr, advertised);
+ isc_nm_setinitialtimeout(initial);
+ isc_nm_setprimariestimeout(primaries);
+ isc_nm_setidletimeout(idle);
+ isc_nm_setkeepalivetimeout(keepalive);
+ isc_nm_setadvertisedtimeout(advertised);
#define CAP_IF_NOT_ZERO(v, min, max) \
if (v > 0 && v < min) { \
send_udp_buffer_size = cfg_obj_asuint32(obj);
CAP_IF_NOT_ZERO(send_udp_buffer_size, 4096, INT32_MAX);
- isc_nm_setnetbuffers(named_g_netmgr, recv_tcp_buffer_size,
- send_tcp_buffer_size, recv_udp_buffer_size,
- send_udp_buffer_size);
+ isc_nm_setnetbuffers(recv_tcp_buffer_size, send_tcp_buffer_size,
+ recv_udp_buffer_size, send_udp_buffer_size);
#undef CAP_IF_NOT_ZERO
loadbalancesockets = cfg_obj_asboolean(obj);
#if HAVE_SO_REUSEPORT_LB
if (first_time) {
- isc_nm_setloadbalancesockets(named_g_netmgr,
- cfg_obj_asboolean(obj));
- } else if (loadbalancesockets !=
- isc_nm_getloadbalancesockets(named_g_netmgr))
- {
+ isc_nm_setloadbalancesockets(cfg_obj_asboolean(obj));
+ } else if (loadbalancesockets != isc_nm_getloadbalancesockets()) {
cfg_obj_log(obj, ISC_LOG_WARNING,
"changing reuseport value requires server restart");
}
named_server_t *server = (named_server_t *)arg;
dns_geoip_databases_t *geoip = NULL;
- dns_zonemgr_create(named_g_mctx, named_g_netmgr, &server->zonemgr);
+ dns_zonemgr_create(named_g_mctx, &server->zonemgr);
- CHECKFATAL(dns_dispatchmgr_create(named_g_mctx, named_g_netmgr,
- &named_g_dispatchmgr),
+ CHECKFATAL(dns_dispatchmgr_create(named_g_mctx, &named_g_dispatchmgr),
"creating dispatch manager");
dns_dispatchmgr_setstats(named_g_dispatchmgr, server->resolverstats);
#endif /* if defined(HAVE_GEOIP2) */
CHECKFATAL(ns_interfacemgr_create(named_g_mctx, server->sctx,
- named_g_netmgr, named_g_dispatchmgr,
- geoip, &server->interfacemgr),
+ named_g_dispatchmgr, geoip,
+ &server->interfacemgr),
"creating interface manager");
isc_timer_create(isc_loop_main(), interface_timer_tick, server,
isc_stats_create(server->mctx, &server->sockstats,
isc_sockstatscounter_max);
- isc_nm_setstats(named_g_netmgr, server->sockstats);
+ isc_nm_setstats(server->sockstats);
isc_stats_create(named_g_mctx, &server->zonestats,
dns_zonestatscounter_max);
return ISC_R_UNEXPECTEDEND;
}
- initial = isc_nm_getinitialtimeout(named_g_netmgr);
- primaries = isc_nm_getprimariestimeout(named_g_netmgr);
- idle = isc_nm_getidletimeout(named_g_netmgr);
- keepalive = isc_nm_getkeepalivetimeout(named_g_netmgr);
- advertised = isc_nm_getadvertisedtimeout(named_g_netmgr);
+ initial = isc_nm_getinitialtimeout();
+ primaries = isc_nm_getprimariestimeout();
+ idle = isc_nm_getidletimeout();
+ keepalive = isc_nm_getkeepalivetimeout();
+ advertised = isc_nm_getadvertisedtimeout();
/* Look for optional arguments. */
ptr = next_token(lex, NULL);
CHECK(ISC_R_RANGE);
}
- isc_nm_setinitialtimeout(named_g_netmgr, initial);
- isc_nm_setprimariestimeout(named_g_netmgr, primaries);
- isc_nm_setidletimeout(named_g_netmgr, idle);
- isc_nm_setkeepalivetimeout(named_g_netmgr, keepalive);
- isc_nm_setadvertisedtimeout(named_g_netmgr, advertised);
+ isc_nm_setinitialtimeout(initial);
+ isc_nm_setprimariestimeout(primaries);
+ isc_nm_setidletimeout(idle);
+ isc_nm_setkeepalivetimeout(keepalive);
+ isc_nm_setadvertisedtimeout(advertised);
}
snprintf(msg, sizeof(msg), "tcp-initial-timeout=%u\n", initial / 100);
CHECK(ISC_R_FAMILYNOSUPPORT);
}
- CHECK(isc_httpdmgr_create(named_g_netmgr, server->mctx, addr, client_ok,
+ CHECK(isc_httpdmgr_create(server->mctx, addr, client_ok,
destroy_listener, listener,
&listener->httpdmgr));
static bool usevc = false;
static bool usegsstsig = false;
static bool local_only = false;
-static isc_nm_t *netmgr = NULL;
static isc_mem_t *gmctx = NULL;
static dns_dispatchmgr_t *dispatchmgr = NULL;
static dns_requestmgr_t *requestmgr = NULL;
irs_resconf_destroy(&resconf);
- result = dns_dispatchmgr_create(gmctx, netmgr, &dispatchmgr);
+ result = dns_dispatchmgr_create(gmctx, &dispatchmgr);
check_result(result, "dns_dispatchmgr_create");
set_source_ports(dispatchmgr);
isc_mutex_destroy(&answer_lock);
ddebug("Shutting down managers");
- isc_managers_destroy(&gmctx, &netmgr);
+ isc_managers_destroy(&gmctx);
}
static void
pre_parse_args(argc, argv);
- isc_managers_create(&gmctx, 1, &netmgr);
+ isc_managers_create(&gmctx, 1);
parse_args(argc, argv);
/* Set the network manager timeouts in milliseconds. */
- isc_nm_setinitialtimeout(netmgr, timeoutms);
- isc_nm_setprimariestimeout(netmgr, timeoutms);
- isc_nm_setidletimeout(netmgr, timeoutms);
- isc_nm_setkeepalivetimeout(netmgr, timeoutms);
- isc_nm_setadvertisedtimeout(netmgr, timeoutms);
+ isc_nm_setinitialtimeout(timeoutms);
+ isc_nm_setprimariestimeout(timeoutms);
+ isc_nm_setidletimeout(timeoutms);
+ isc_nm_setkeepalivetimeout(timeoutms);
+ isc_nm_setadvertisedtimeout(timeoutms);
isc_loopmgr_setup(setup_system, NULL);
isc_loopmgr_setup(getinput, NULL);
bool verbose;
-static isc_nm_t *netmgr = NULL;
-
static const char *admin_conffile = NULL;
static const char *admin_keyfile = NULL;
static const char *version = PACKAGE_VERSION;
UNREACHABLE();
}
- isc_nm_tcpconnect(netmgr, local, addr, rndc_connected, &rndc_ccmsg,
- timeout);
+ isc_nm_tcpconnect(local, addr, rndc_connected, &rndc_ccmsg, timeout);
}
static void
serial = isc_random32();
- isc_managers_create(&rndc_mctx, 1, &netmgr);
+ isc_managers_create(&rndc_mctx, 1);
isc_loopmgr_setup(rndc_start, NULL);
- isc_nm_setinitialtimeout(netmgr, timeout);
- isc_nm_setprimariestimeout(netmgr, timeout);
- isc_nm_setidletimeout(netmgr, timeout);
- isc_nm_setkeepalivetimeout(netmgr, timeout);
+ isc_nm_setinitialtimeout(timeout);
+ isc_nm_setprimariestimeout(timeout);
+ isc_nm_setidletimeout(timeout);
+ isc_nm_setkeepalivetimeout(timeout);
logconfig = isc_logconfig_get();
isc_log_settag(logconfig, isc_commandline_progname);
isc_mem_stats(rndc_mctx, stderr);
}
- isc_managers_destroy(&rndc_mctx, &netmgr);
+ isc_managers_destroy(&rndc_mctx);
if (failed) {
return 1;
isc_sockaddr_t bind_any;
struct in_addr inaddr;
isc_result_t result;
- isc_nm_t *netmgr = NULL;
dns_dispatchmgr_t *dispatchmgr = NULL;
dns_dispatch_t *dispatchv4 = NULL;
dns_view_t *view = NULL;
}
isc_sockaddr_fromin(&dstaddr, &inaddr, port);
- isc_managers_create(&mctx, 1, &netmgr);
+ isc_managers_create(&mctx, 1);
- RUNCHECK(dns_dispatchmgr_create(mctx, netmgr, &dispatchmgr));
+ RUNCHECK(dns_dispatchmgr_create(mctx, &dispatchmgr));
RUNCHECK(dns_dispatch_createudp(
dispatchmgr, have_src ? &srcaddr : &bind_any, &dispatchv4));
isc_loopmgr_run();
- isc_managers_destroy(&mctx, &netmgr);
+ isc_managers_destroy(&mctx);
return 0;
}
"http-plain-get" };
static isc_mem_t *mctx = NULL;
-static isc_nm_t *netmgr = NULL;
static protocol_t protocol;
static const char *address;
static void
setup(void) {
- isc_managers_create(&mctx, workers, &netmgr);
+ isc_managers_create(&mctx, workers);
}
static void
isc_tlsctx_free(&tls_ctx);
}
- isc_managers_destroy(&mctx, &netmgr);
+ isc_managers_destroy(&mctx);
}
static void
run(void) {
switch (protocol) {
case UDP:
- isc_nm_udpconnect(netmgr, &sockaddr_local, &sockaddr_remote,
- connect_cb, NULL, timeout);
+ isc_nm_udpconnect(&sockaddr_local, &sockaddr_remote, connect_cb,
+ NULL, timeout);
break;
case TCP:
- isc_nm_streamdnsconnect(netmgr, &sockaddr_local,
- &sockaddr_remote, connect_cb, NULL,
- timeout, NULL, NULL, NULL,
- ISC_NM_PROXY_NONE, NULL);
+ isc_nm_streamdnsconnect(&sockaddr_local, &sockaddr_remote,
+ connect_cb, NULL, timeout, NULL, NULL,
+ NULL, ISC_NM_PROXY_NONE, NULL);
break;
case DOT: {
isc_tlsctx_createclient(&tls_ctx);
- isc_nm_streamdnsconnect(netmgr, &sockaddr_local,
- &sockaddr_remote, connect_cb, NULL,
- timeout, tls_ctx, NULL, NULL,
- ISC_NM_PROXY_NONE, NULL);
+ isc_nm_streamdnsconnect(&sockaddr_local, &sockaddr_remote,
+ connect_cb, NULL, timeout, tls_ctx,
+ NULL, NULL, ISC_NM_PROXY_NONE, NULL);
break;
}
#if HAVE_LIBNGHTTP2
if (is_https) {
isc_tlsctx_createclient(&tls_ctx);
}
- isc_nm_httpconnect(netmgr, &sockaddr_local, &sockaddr_remote,
- req_url, is_post, connect_cb, NULL, tls_ctx,
- NULL, NULL, timeout, ISC_NM_PROXY_NONE,
- NULL);
+ isc_nm_httpconnect(&sockaddr_local, &sockaddr_remote, req_url,
+ is_post, connect_cb, NULL, tls_ctx, NULL,
+ NULL, timeout, ISC_NM_PROXY_NONE, NULL);
} break;
#endif
default:
static const char *protocols[] = { "udp", "tcp", "dot", "https", "http-plain" };
static isc_mem_t *mctx = NULL;
-static isc_nm_t *netmgr = NULL;
static protocol_t protocol;
static in_port_t port;
static void
setup(void) {
- isc_managers_create(&mctx, workers, &netmgr);
+ isc_managers_create(&mctx, workers);
}
static void
isc_tlsctx_free(&tls_ctx);
}
- isc_managers_destroy(&mctx, &netmgr);
+ isc_managers_destroy(&mctx);
}
static void
switch (protocol) {
case UDP:
- result = isc_nm_listenudp(netmgr, ISC_NM_LISTEN_ALL, &sockaddr,
- read_cb, NULL, &sock);
+ result = isc_nm_listenudp(ISC_NM_LISTEN_ALL, &sockaddr, read_cb,
+ NULL, &sock);
break;
case TCP:
- result = isc_nm_listenstreamdns(netmgr, ISC_NM_LISTEN_ALL,
- &sockaddr, read_cb, NULL,
- accept_cb, NULL, 0, NULL, NULL,
- ISC_NM_PROXY_NONE, &sock);
+ result = isc_nm_listenstreamdns(
+ ISC_NM_LISTEN_ALL, &sockaddr, read_cb, NULL, accept_cb,
+ NULL, 0, NULL, NULL, ISC_NM_PROXY_NONE, &sock);
break;
case DOT: {
isc_tlsctx_createserver(NULL, NULL, &tls_ctx);
result = isc_nm_listenstreamdns(
- netmgr, ISC_NM_LISTEN_ALL, &sockaddr, read_cb, NULL,
- accept_cb, NULL, 0, NULL, tls_ctx, ISC_NM_PROXY_NONE,
- &sock);
+ ISC_NM_LISTEN_ALL, &sockaddr, read_cb, NULL, accept_cb,
+ NULL, 0, NULL, tls_ctx, ISC_NM_PROXY_NONE, &sock);
break;
}
#if HAVE_LIBNGHTTP2
eps, ISC_NM_HTTP_DEFAULT_PATH, read_cb, NULL);
if (result == ISC_R_SUCCESS) {
- result = isc_nm_listenhttp(
- netmgr, ISC_NM_LISTEN_ALL, &sockaddr, 0, NULL,
- tls_ctx, eps, 0, ISC_NM_PROXY_NONE, &sock);
+ result = isc_nm_listenhttp(ISC_NM_LISTEN_ALL, &sockaddr,
+ 0, NULL, tls_ctx, eps, 0,
+ ISC_NM_PROXY_NONE, &sock);
}
isc_nm_http_endpoints_detach(&eps);
} break;
static char hexcookie[81];
static isc_sockaddr_t bind_any;
-static isc_nm_t *netmgr = NULL;
static dns_dispatchmgr_t *dispatchmgr = NULL;
static dns_dispatch_t *dispatchvx = NULL;
static dns_view_t *view = NULL;
static void
setup(void *arg ISC_ATTR_UNUSED) {
- RUNCHECK(dns_dispatchmgr_create(mctx, netmgr, &dispatchmgr));
+ RUNCHECK(dns_dispatchmgr_create(mctx, &dispatchmgr));
set_source_ports(dispatchmgr);
preparse_args(argc, argv);
- isc_managers_create(&mctx, 1, &netmgr);
+ isc_managers_create(&mctx, 1);
isc_nonce_buf(cookie_secret, sizeof(cookie_secret));
isc_mem_free(mctx, default_query.ecs_addr);
}
- isc_managers_destroy(&mctx, &netmgr);
+ isc_managers_destroy(&mctx);
return 0;
}
unsigned int attributes;
isc_mem_t *mctx;
isc_loop_t *loop;
- isc_nm_t *nm;
dns_dispatchmgr_t *dispatchmgr;
dns_dispatch_t *dispatchv4;
dns_dispatch_t *dispatchv6;
}
static isc_result_t
-createview(isc_mem_t *mctx, dns_rdataclass_t rdclass, isc_nm_t *nm,
+createview(isc_mem_t *mctx, dns_rdataclass_t rdclass,
isc_tlsctx_cache_t *tlsctx_client_cache,
dns_dispatchmgr_t *dispatchmgr, dns_dispatch_t *dispatchv4,
dns_dispatch_t *dispatchv6, dns_view_t **viewp) {
/* Initialize view security roots */
dns_view_initsecroots(view);
- CHECK(dns_view_createresolver(view, nm, 0, tlsctx_client_cache,
- dispatchv4, dispatchv6));
+ CHECK(dns_view_createresolver(view, 0, tlsctx_client_cache, dispatchv4,
+ dispatchv6));
CHECK(dns_db_create(mctx, CACHEDB_DEFAULT, dns_rootname,
dns_dbtype_cache, rdclass, 0, NULL,
&view->cachedb));
}
isc_result_t
-dns_client_create(isc_mem_t *mctx, isc_nm_t *nm, unsigned int options,
+dns_client_create(isc_mem_t *mctx, unsigned int options,
isc_tlsctx_cache_t *tlsctx_client_cache,
dns_client_t **clientp, const isc_sockaddr_t *localaddr4,
const isc_sockaddr_t *localaddr6) {
dns_view_t *view = NULL;
REQUIRE(mctx != NULL);
- REQUIRE(nm != NULL);
REQUIRE(tlsctx_client_cache != NULL);
REQUIRE(clientp != NULL && *clientp == NULL);
client = isc_mem_get(mctx, sizeof(*client));
*client = (dns_client_t){
.loop = isc_loop_get(0),
- .nm = nm,
.max_restarts = DEF_MAX_RESTARTS,
.max_queries = DEF_MAX_QUERIES,
};
- result = dns_dispatchmgr_create(mctx, nm, &client->dispatchmgr);
+ result = dns_dispatchmgr_create(mctx, &client->dispatchmgr);
if (result != ISC_R_SUCCESS) {
goto cleanup_client;
}
isc_refcount_init(&client->references, 1);
/* Create the default view for class IN */
- result = createview(mctx, dns_rdataclass_in, nm, tlsctx_client_cache,
+ result = createview(mctx, dns_rdataclass_in, tlsctx_client_cache,
client->dispatchmgr, dispatchv4, dispatchv6, &view);
if (result != ISC_R_SUCCESS) {
goto cleanup_references;
/*! \file */
+/*
+ * FIXME: Might need dns_dispatch_shuttingdown()
+ */
+
#include <inttypes.h>
#include <stdbool.h>
#include <stdlib.h>
isc_mem_t *mctx;
dns_acl_t *blackhole;
isc_stats_t *stats;
- isc_nm_t *nm;
uint32_t nloops;
*/
isc_result_t
-dns_dispatchmgr_create(isc_mem_t *mctx, isc_nm_t *nm,
- dns_dispatchmgr_t **mgrp) {
+dns_dispatchmgr_create(isc_mem_t *mctx, dns_dispatchmgr_t **mgrp) {
dns_dispatchmgr_t *mgr = NULL;
isc_portset_t *v4portset = NULL;
isc_portset_t *v6portset = NULL;
isc_refcount_init(&mgr->references, 1);
isc_mem_attach(mctx, &mgr->mctx);
- isc_nm_attach(nm, &mgr->nm);
mgr->tcps = isc_mem_cget(mgr->mctx, mgr->nloops, sizeof(mgr->tcps[0]));
for (size_t i = 0; i < mgr->nloops; i++) {
sizeof(in_port_t));
}
- isc_nm_detach(&mgr->nm);
-
isc_mem_putanddetach(&mgr->mctx, mgr, sizeof(dns_dispatchmgr_t));
}
isc_stats_attach(stats, &mgr->stats);
}
-isc_nm_t *
-dns_dispatchmgr_getnetmgr(dns_dispatchmgr_t *mgr) {
- REQUIRE(VALID_DISPATCHMGR(mgr));
-
- return mgr->nm;
-}
-
/*
* Allocate and set important limits.
*/
dns_dispentry_ref(resp); /* DISPENTRY004 */
ISC_LIST_APPEND(disp->pending, resp, plink);
- isc_nm_udpconnect(disp->mgr->nm, &resp->local, &resp->peer,
- udp_connected, resp, resp->timeout);
+ isc_nm_udpconnect(&resp->local, &resp->peer, udp_connected, resp,
+ resp->timeout);
}
static inline const char *
const char *hostname = get_tls_sni_hostname(resp);
- isc_nm_streamdnsconnect(disp->mgr->nm, &disp->local,
- &disp->peer, tcp_connected, disp,
+ isc_nm_streamdnsconnect(&disp->local, &disp->peer,
+ tcp_connected, disp,
resp->connect_timeout, tlsctx, hostname,
sess_cache, ISC_NM_PROXY_NONE, NULL);
break;
} dns_clientresume_t; /* too long? */
isc_result_t
-dns_client_create(isc_mem_t *mctx, isc_nm_t *nm, unsigned int options,
+dns_client_create(isc_mem_t *mctx, unsigned int options,
isc_tlsctx_cache_t *tlsctx_client_cache,
dns_client_t **clientp, const isc_sockaddr_t *localaddr4,
const isc_sockaddr_t *localaddr6);
} dns_dispatchopt_t;
isc_result_t
-dns_dispatchmgr_create(isc_mem_t *mctx, isc_nm_t *nm, dns_dispatchmgr_t **mgrp);
+dns_dispatchmgr_create(isc_mem_t *mctx, dns_dispatchmgr_t **mgrp);
/*%<
* Creates a new dispatchmgr object, and sets the available ports
* to the default range (1024-65535).
* (see dns/stats.h).
*/
-isc_nm_t *
-dns_dispatchmgr_getnetmgr(dns_dispatchmgr_t *mgr);
-/*%<
- * Get the network manager object associated with the dispatch manager.
- *
- * Requires:
- *\li disp is valid
- */
-
isc_result_t
dns_dispatch_createudp(dns_dispatchmgr_t *mgr, const isc_sockaddr_t *localaddr,
dns_dispatch_t **dispp);
#define DNS_QMIN_MAX_NO_DELEGATION 3
isc_result_t
-dns_resolver_create(dns_view_t *view, isc_nm_t *nm, unsigned int options,
+dns_resolver_create(dns_view_t *view, unsigned int options,
isc_tlsctx_cache_t *tlsctx_cache,
dns_dispatch_t *dispatchv4, dns_dispatch_t *dispatchv6,
dns_resolver_t **resp);
*/
isc_result_t
-dns_view_createresolver(dns_view_t *view, isc_nm_t *netmgr,
- unsigned int options, isc_tlsctx_cache_t *tlsctx_cache,
+dns_view_createresolver(dns_view_t *view, unsigned int options,
+ isc_tlsctx_cache_t *tlsctx_cache,
dns_dispatch_t *dispatchv4, dns_dispatch_t *dispatchv6);
/*%<
* Create a resolver and address database for the view.
*/
void
-dns_zonemgr_create(isc_mem_t *mctx, isc_nm_t *netmgr, dns_zonemgr_t **zmgrp);
+dns_zonemgr_create(isc_mem_t *mctx, dns_zonemgr_t **zmgrp);
/*%<
* Create a zone manager.
*
isc_mutex_t lock;
isc_mutex_t primelock;
dns_rdataclass_t rdclass;
- isc_nm_t *nm;
dns_view_t *view;
bool frozen;
unsigned int options;
}
isc_result_t
-dns_resolver_create(dns_view_t *view, isc_nm_t *nm, unsigned int options,
+dns_resolver_create(dns_view_t *view, unsigned int options,
isc_tlsctx_cache_t *tlsctx_cache,
dns_dispatch_t *dispatchv4, dns_dispatch_t *dispatchv6,
dns_resolver_t **resp) {
res = isc_mem_get(view->mctx, sizeof(*res));
*res = (dns_resolver_t){
.rdclass = view->rdclass,
- .nm = nm,
.options = options,
.tlsctx_cache = tlsctx_cache,
.spillatmin = 10,
}
isc_result_t
-dns_view_createresolver(dns_view_t *view, isc_nm_t *netmgr,
- unsigned int options, isc_tlsctx_cache_t *tlsctx_cache,
+dns_view_createresolver(dns_view_t *view, unsigned int options,
+ isc_tlsctx_cache_t *tlsctx_cache,
dns_dispatch_t *dispatchv4,
dns_dispatch_t *dispatchv6) {
isc_result_t result;
REQUIRE(view->resolver == NULL);
REQUIRE(view->dispatchmgr != NULL);
- result = dns_resolver_create(view, netmgr, options, tlsctx_cache,
- dispatchv4, dispatchv6, &view->resolver);
+ result = dns_resolver_create(view, options, tlsctx_cache, dispatchv4,
+ dispatchv6, &view->resolver);
if (result != ISC_R_SUCCESS) {
return result;
}
goto failure;
}
- primaries_timeout =
- isc_nm_getprimariestimeout(dns_dispatchmgr_getnetmgr(dispmgr));
+ primaries_timeout = isc_nm_getprimariestimeout();
result = dns_dispatch_createtcp(dispmgr, &xfr->sourceaddr,
&xfr->primaryaddr, xfr->transport,
DNS_DISPATCHOPT_UNSHARED, &xfr->disp);
unsigned int magic;
isc_mem_t *mctx;
isc_refcount_t refs;
- isc_nm_t *netmgr;
uint32_t workers;
isc_mem_t **mctxpool;
isc_ratelimiter_t *checkdsrl;
zmgr_tlsctx_attach(notify->zone->zmgr, &zmgr_tlsctx_cache);
- const unsigned int connect_timeout =
- isc_nm_getinitialtimeout(notify->zone->zmgr->netmgr) /
- MS_PER_SEC;
+ const unsigned int connect_timeout = isc_nm_getinitialtimeout() /
+ MS_PER_SEC;
result = dns_request_create(
notify->zone->view->requestmgr, message, &src, ¬ify->dst,
notify->transport, zmgr_tlsctx_cache, options, key,
}
zone_iattach(zone, &(dns_zone_t *){ NULL });
- const unsigned int connect_timeout =
- isc_nm_getprimariestimeout(zone->zmgr->netmgr) / MS_PER_SEC;
+ const unsigned int connect_timeout = isc_nm_getprimariestimeout() /
+ MS_PER_SEC;
result = dns_request_create(
zone->view->requestmgr, message, &zone->sourceaddr, &curraddr,
NULL, NULL, options, key, connect_timeout, TCP_REQUEST_TIMEOUT,
cb_args->stub = stub;
cb_args->tsig_key = key;
cb_args->udpsize = udpsize;
- cb_args->connect_timeout =
- isc_nm_getprimariestimeout(zone->zmgr->netmgr) / MS_PER_SEC;
+ cb_args->connect_timeout = isc_nm_getprimariestimeout() / MS_PER_SEC;
cb_args->timeout = TCP_REQUEST_TIMEOUT;
cb_args->reqnsid = reqnsid;
}
zmgr_tlsctx_attach(zone->zmgr, &zmgr_tlsctx_cache);
- const unsigned int connect_timeout =
- isc_nm_getprimariestimeout(zone->zmgr->netmgr) / MS_PER_SEC;
+ const unsigned int connect_timeout = isc_nm_getprimariestimeout() /
+ MS_PER_SEC;
result = dns_request_createraw(
forward->zone->view->requestmgr, forward->msgbuf, &src,
&forward->addr, forward->transport, zmgr_tlsctx_cache,
}
void
-dns_zonemgr_create(isc_mem_t *mctx, isc_nm_t *netmgr, dns_zonemgr_t **zmgrp) {
+dns_zonemgr_create(isc_mem_t *mctx, dns_zonemgr_t **zmgrp) {
dns_zonemgr_t *zmgr = NULL;
isc_loop_t *loop = isc_loop();
REQUIRE(mctx != NULL);
- REQUIRE(netmgr != NULL);
REQUIRE(zmgrp != NULL && *zmgrp == NULL);
zmgr = isc_mem_get(mctx, sizeof(*zmgr));
*zmgr = (dns_zonemgr_t){
- .netmgr = netmgr,
.workers = isc_loopmgr_nloops(),
.transfersin = 10,
.transfersperns = 2,
"checkds: create request for DS query to %s", addrbuf);
options |= DNS_REQUESTOPT_TCP;
- const unsigned int connect_timeout =
- isc_nm_getinitialtimeout(checkds->zone->zmgr->netmgr) /
- MS_PER_SEC;
+ const unsigned int connect_timeout = isc_nm_getinitialtimeout() /
+ MS_PER_SEC;
result = dns_request_create(
checkds->zone->view->requestmgr, message, &src, &checkds->dst,
NULL, NULL, options, key, connect_timeout, TCP_REQUEST_TIMEOUT,
#endif /* ENABLE_AFL */
isc_result_t
-isc_httpdmgr_create(isc_nm_t *nm, isc_mem_t *mctx, isc_sockaddr_t *addr,
+isc_httpdmgr_create(isc_mem_t *mctx, isc_sockaddr_t *addr,
isc_httpdclientok_t *client_ok,
isc_httpdondestroy_t *ondestroy, void *cb_arg,
isc_httpdmgr_t **httpdmgrp) {
isc_result_t result;
isc_httpdmgr_t *httpdmgr = NULL;
- REQUIRE(nm != NULL);
REQUIRE(mctx != NULL);
REQUIRE(httpdmgrp != NULL && *httpdmgrp == NULL);
isc_refcount_init(&httpdmgr->references, 1);
- CHECK(isc_nm_listentcp(nm, ISC_NM_LISTEN_ONE, addr, httpd_newconn,
- httpdmgr, 5, NULL, &httpdmgr->sock));
+ CHECK(isc_nm_listentcp(ISC_NM_LISTEN_ONE, addr, httpd_newconn, httpdmgr,
+ 5, NULL, &httpdmgr->sock));
httpdmgr->magic = HTTPDMGR_MAGIC;
*httpdmgrp = httpdmgr;
typedef bool(isc_httpdclientok_t)(const isc_sockaddr_t *, void *);
isc_result_t
-isc_httpdmgr_create(isc_nm_t *nm, isc_mem_t *mctx, isc_sockaddr_t *addr,
+isc_httpdmgr_create(isc_mem_t *mctx, isc_sockaddr_t *addr,
isc_httpdclientok_t *client_ok,
isc_httpdondestroy_t *ondestroy, void *cb_arg,
isc_httpdmgr_t **httpdmgrp);
typedef struct isc_managers isc_managers_t;
void
-isc_managers_create(isc_mem_t **mctx, uint32_t workers, isc_nm_t **netmgrp);
+isc_managers_create(isc_mem_t **mctx, uint32_t workers);
void
-isc_managers_destroy(isc_mem_t **mctx, isc_nm_t **netmgrp);
+isc_managers_destroy(isc_mem_t **mctx);
*/
void
-isc_netmgr_create(isc_mem_t *mctx, isc_nm_t **netgmrp);
+isc_netmgr_create(isc_mem_t *mctx);
/*%<
* Creates a new network manager and starts it running when loopmgr is started.
*/
-#if ISC_NETMGR_TRACE
-#define isc_nm_ref(ptr) isc_nm__ref(ptr, __func__, __FILE__, __LINE__)
-#define isc_nm_unref(ptr) isc_nm__unref(ptr, __func__, __FILE__, __LINE__)
-#define isc_nm_attach(ptr, ptrp) \
- isc_nm__attach(ptr, ptrp, __func__, __FILE__, __LINE__)
-#define isc_nm_detach(ptrp) isc_nm__detach(ptrp, __func__, __FILE__, __LINE__)
-ISC_REFCOUNT_TRACE_DECL(isc_nm);
-#else
-ISC_REFCOUNT_DECL(isc_nm);
-#endif
-
+void
+isc_netmgr_destroy(void);
/*%<
- * Attach/detach a network manager. When all references have been
+ * Destroy a network manager. When all references have been
* released, the network manager is shut down, freeing all resources.
*/
* 'isc_nmhandle_localaddr()' instead.
*/
-isc_nm_t *
-isc_nmhandle_netmgr(isc_nmhandle_t *handle);
-/*%<
- * Return a pointer to the netmgr object for the given handle.
- */
-
isc_result_t
-isc_nm_listenudp(isc_nm_t *mgr, uint32_t workers, isc_sockaddr_t *iface,
- isc_nm_recv_cb_t cb, void *cbarg, isc_nmsocket_t **sockp);
+isc_nm_listenudp(uint32_t workers, isc_sockaddr_t *iface, isc_nm_recv_cb_t cb,
+ void *cbarg, isc_nmsocket_t **sockp);
/*%<
* Start listening for UDP packets on interface 'iface' using net manager
* 'mgr'.
*/
void
-isc_nm_udpconnect(isc_nm_t *mgr, isc_sockaddr_t *local, isc_sockaddr_t *peer,
- isc_nm_cb_t cb, void *cbarg, unsigned int timeout);
+isc_nm_udpconnect(isc_sockaddr_t *local, isc_sockaddr_t *peer, isc_nm_cb_t cb,
+ void *cbarg, unsigned int timeout);
/*%<
* Open a UDP socket, bind to 'local' and connect to 'peer', and
* immediately call 'cb' with a handle so that the caller can begin
*/
isc_result_t
-isc_nm_routeconnect(isc_nm_t *mgr, isc_nm_cb_t cb, void *cbarg);
+isc_nm_routeconnect(isc_nm_cb_t cb, void *cbarg);
/*%<
* Open a route/netlink socket and call 'cb', so the caller can be
* begin listening for interface changes. This behaves similarly to
*/
isc_result_t
-isc_nm_listenproxyudp(isc_nm_t *mgr, uint32_t workers, isc_sockaddr_t *iface,
+isc_nm_listenproxyudp(uint32_t workers, isc_sockaddr_t *iface,
isc_nm_recv_cb_t cb, void *cbarg, isc_nmsocket_t **sockp);
/*%<
* The same as `isc_nm_listenudp()`, but PROXYv2 headers are
*/
void
-isc_nm_proxyudpconnect(isc_nm_t *mgr, isc_sockaddr_t *local,
- isc_sockaddr_t *peer, isc_nm_cb_t cb, void *cbarg,
- unsigned int timeout,
+isc_nm_proxyudpconnect(isc_sockaddr_t *local, isc_sockaddr_t *peer,
+ isc_nm_cb_t cb, void *cbarg, unsigned int timeout,
isc_nm_proxyheader_info_t *proxy_info);
/*%<
* The same as `isc_nm_udpconnect()`, but PROXYv2 headers are added
*/
isc_result_t
-isc_nm_listentcp(isc_nm_t *mgr, uint32_t workers, isc_sockaddr_t *iface,
+isc_nm_listentcp(uint32_t workers, isc_sockaddr_t *iface,
isc_nm_accept_cb_t accept_cb, void *accept_cbarg, int backlog,
isc_quota_t *quota, isc_nmsocket_t **sockp);
/*%<
*/
void
-isc_nm_tcpconnect(isc_nm_t *mgr, isc_sockaddr_t *local, isc_sockaddr_t *peer,
+isc_nm_tcpconnect(isc_sockaddr_t *local, isc_sockaddr_t *peer,
isc_nm_cb_t connect_cb, void *connect_cbarg,
unsigned int timeout);
/*%<
*/
isc_result_t
-isc_nm_listenstreamdns(isc_nm_t *mgr, uint32_t workers, isc_sockaddr_t *iface,
+isc_nm_listenstreamdns(uint32_t workers, isc_sockaddr_t *iface,
isc_nm_recv_cb_t recv_cb, void *recv_cbarg,
isc_nm_accept_cb_t accept_cb, void *accept_cbarg,
int backlog, isc_quota_t *quota, isc_tlsctx_t *tlsctx,
*/
isc_result_t
-isc_nm_listenproxystream(isc_nm_t *mgr, uint32_t workers, isc_sockaddr_t *iface,
+isc_nm_listenproxystream(uint32_t workers, isc_sockaddr_t *iface,
isc_nm_accept_cb_t accept_cb, void *accept_cbarg,
int backlog, isc_quota_t *quota, isc_tlsctx_t *tlsctx,
isc_nmsocket_t **sockp);
*/
void
-isc_nm_proxystreamconnect(isc_nm_t *mgr, isc_sockaddr_t *local,
- isc_sockaddr_t *peer, isc_nm_cb_t cb, void *cbarg,
- unsigned int timeout, isc_tlsctx_t *tlsctx,
- const char *sni_hostname,
+isc_nm_proxystreamconnect(isc_sockaddr_t *local, isc_sockaddr_t *peer,
+ isc_nm_cb_t cb, void *cbarg, unsigned int timeout,
+ isc_tlsctx_t *tlsctx, const char *sni_hostname,
isc_tlsctx_client_session_cache_t *client_sess_cache,
isc_nm_proxyheader_info_t *proxy_info);
/*%<
*/
void
-isc_nm_setinitialtimeout(isc_nm_t *mgr, uint32_t timeout_ms);
+isc_nm_setinitialtimeout(uint32_t timeout_ms);
/*%<
* Sets the initial TCP timeout value (in milliseconds).
*
*/
void
-isc_nm_setprimariestimeout(isc_nm_t *mgr, uint32_t timeout_ms);
+isc_nm_setprimariestimeout(uint32_t timeout_ms);
/*%<
* Sets the primary servers connect TCP timeout value (in milliseconds).
*
*/
void
-isc_nm_setidletimeout(isc_nm_t *mgr, uint32_t timeout_ms);
+isc_nm_setidletimeout(uint32_t timeout_ms);
/*%<
* Sets the idle TCP timeout value (in milliseconds).
*
*/
void
-isc_nm_setkeepalivetimeout(isc_nm_t *mgr, uint32_t timeout_ms);
+isc_nm_setkeepalivetimeout(uint32_t timeout_ms);
/*%<
* Sets the keepalive TCP timeout value (in milliseconds), and the timeout value
* to advertise in responses using the EDNS TCP Keepalive option.
*/
void
-isc_nm_setadvertisedtimeout(isc_nm_t *mgr, uint32_t timeout_ms);
+isc_nm_setadvertisedtimeout(uint32_t timeout_ms);
/*%<
* Sets the advertised TCP timeout value (in milliseconds).
*
*/
void
-isc_nm_setnetbuffers(isc_nm_t *mgr, int32_t recv_tcp, int32_t send_tcp,
- int32_t recv_udp, int32_t send_udp);
+isc_nm_setnetbuffers(int32_t recv_tcp, int32_t send_tcp, int32_t recv_udp,
+ int32_t send_udp);
/*%<
* If not 0, sets the SO_RCVBUF and SO_SNDBUF socket options for TCP and UDP
* respectively.
*/
bool
-isc_nm_getloadbalancesockets(isc_nm_t *mgr);
+isc_nm_getloadbalancesockets(void);
void
-isc_nm_setloadbalancesockets(isc_nm_t *mgr, bool enabled);
+isc_nm_setloadbalancesockets(bool enabled);
/*%<
* Get and set value of load balancing of the sockets.
*
*/
uint32_t
-isc_nm_getinitialtimeout(isc_nm_t *mgr);
+isc_nm_getinitialtimeout(void);
/*%<
* Gets the initial TCP timeout value in milliseconds.
*
*/
uint32_t
-isc_nm_getprimariestimeout(isc_nm_t *mgr);
+isc_nm_getprimariestimeout(void);
/*%<
* Gets the primary servers connect TCP timeout value in milliseconds.
*
*/
uint32_t
-isc_nm_getidletimeout(isc_nm_t *mgr);
+isc_nm_getidletimeout(void);
/*%<
* Gets the idle TCP timeout value in milliseconds.
*
*/
uint32_t
-isc_nm_getkeepalivetimeout(isc_nm_t *mgr);
+isc_nm_getkeepalivetimeout(void);
/*%<
* Gets the keepalive TCP timeout value in milliseconds.
*
*/
uint32_t
-isc_nm_getadvertisedtimeout(isc_nm_t *mgr);
+isc_nm_getadvertisedtimeout(void);
/*%<
* Gets the advertised TCP timeout value in milliseconds.
*
*/
void
-isc_nm_maxudp(isc_nm_t *mgr, uint32_t maxudp);
+isc_nm_maxudp(uint32_t maxudp);
/*%<
* Simulate a broken firewall that blocks UDP messages larger than a given
* size.
*/
void
-isc_nm_setstats(isc_nm_t *mgr, isc_stats_t *stats);
+isc_nm_setstats(isc_stats_t *stats);
/*%<
* Set a socket statistics counter set 'stats' for 'mgr'.
*
*/
void
-isc_nm_streamdnsconnect(isc_nm_t *mgr, isc_sockaddr_t *local,
- isc_sockaddr_t *peer, isc_nm_cb_t cb, void *cbarg,
- unsigned int timeout, isc_tlsctx_t *tlsctx,
- const char *sni_hostname,
+isc_nm_streamdnsconnect(isc_sockaddr_t *local, isc_sockaddr_t *peer,
+ isc_nm_cb_t cb, void *cbarg, unsigned int timeout,
+ isc_tlsctx_t *tlsctx, const char *sni_hostname,
isc_tlsctx_client_session_cache_t *client_sess_cache,
isc_nm_proxy_type_t proxy_type,
isc_nm_proxyheader_info_t *proxy_info);
*/
isc_result_t
-isc_nm_listentls(isc_nm_t *mgr, uint32_t workers, isc_sockaddr_t *iface,
+isc_nm_listentls(uint32_t workers, isc_sockaddr_t *iface,
isc_nm_accept_cb_t accept_cb, void *accept_cbarg, int backlog,
isc_quota_t *quota, isc_tlsctx_t *sslctx, bool proxy,
isc_nmsocket_t **sockp);
void
-isc_nm_tlsconnect(isc_nm_t *mgr, isc_sockaddr_t *local, isc_sockaddr_t *peer,
+isc_nm_tlsconnect(isc_sockaddr_t *local, isc_sockaddr_t *peer,
isc_nm_cb_t connect_cb, void *connect_cbarg,
isc_tlsctx_t *ctx, const char *sni_hostname,
isc_tlsctx_client_session_cache_t *client_sess_cache,
#define ISC_NM_HTTP_DEFAULT_PATH "/dns-query"
void
-isc_nm_httpconnect(isc_nm_t *mgr, isc_sockaddr_t *local, isc_sockaddr_t *peer,
- const char *uri, bool POST, isc_nm_cb_t cb, void *cbarg,
- isc_tlsctx_t *ctx, const char *sni_hostname,
+isc_nm_httpconnect(isc_sockaddr_t *local, isc_sockaddr_t *peer, const char *uri,
+ bool POST, isc_nm_cb_t cb, void *cbarg, isc_tlsctx_t *ctx,
+ const char *sni_hostname,
isc_tlsctx_client_session_cache_t *client_sess_cache,
unsigned int timeout, isc_nm_proxy_type_t proxy_type,
isc_nm_proxyheader_info_t *proxy_info);
isc_result_t
-isc_nm_listenhttp(isc_nm_t *mgr, uint32_t workers, isc_sockaddr_t *iface,
- int backlog, isc_quota_t *quota, isc_tlsctx_t *ctx,
+isc_nm_listenhttp(uint32_t workers, isc_sockaddr_t *iface, int backlog,
+ isc_quota_t *quota, isc_tlsctx_t *ctx,
isc_nm_http_endpoints_t *eps, uint32_t max_concurrent_streams,
isc_nm_proxy_type_t proxy_type, isc_nmsocket_t **sockp);
typedef struct isc_mempool isc_mempool_t; /*%< Memory Pool */
typedef struct isc_netaddr isc_netaddr_t; /*%< Net Address */
typedef struct isc_netprefix isc_netprefix_t; /*%< Net Prefix */
-typedef struct isc_nm isc_nm_t; /*%< Network manager */
typedef struct isc_nmsocket isc_nmsocket_t; /*%< Network manager socket */
typedef struct isc_nmhandle isc_nmhandle_t; /*%< Network manager handle */
typedef struct isc_portset isc_portset_t; /*%< Port Set */
#include <isc/uv.h>
void
-isc_managers_create(isc_mem_t **mctxp, uint32_t workers, isc_nm_t **netmgrp) {
+isc_managers_create(isc_mem_t **mctxp, uint32_t workers) {
REQUIRE(mctxp != NULL && *mctxp == NULL);
isc_mem_create("managers", mctxp);
INSIST(*mctxp != NULL);
isc_loopmgr_create(*mctxp, workers);
- REQUIRE(netmgrp != NULL && *netmgrp == NULL);
- isc_netmgr_create(*mctxp, netmgrp);
- INSIST(*netmgrp != NULL);
+ isc_netmgr_create(*mctxp);
isc_rwlock_setworkers(workers);
}
void
-isc_managers_destroy(isc_mem_t **mctxp, isc_nm_t **netmgrp) {
+isc_managers_destroy(isc_mem_t **mctxp) {
REQUIRE(mctxp != NULL && *mctxp != NULL);
- REQUIRE(netmgrp != NULL && *netmgrp != NULL);
/*
* The sequence of operations here is important:
*/
- isc_nm_detach(netmgrp);
+ isc_netmgr_destroy();
isc_loopmgr_destroy();
isc_mem_detach(mctxp);
}
}
void
-isc_nm_httpconnect(isc_nm_t *mgr, isc_sockaddr_t *local, isc_sockaddr_t *peer,
- const char *uri, bool post, isc_nm_cb_t cb, void *cbarg,
- isc_tlsctx_t *tlsctx, const char *sni_hostname,
+isc_nm_httpconnect(isc_sockaddr_t *local, isc_sockaddr_t *peer, const char *uri,
+ bool post, isc_nm_cb_t cb, void *cbarg, isc_tlsctx_t *tlsctx,
+ const char *sni_hostname,
isc_tlsctx_client_session_cache_t *client_sess_cache,
unsigned int timeout, isc_nm_proxy_type_t proxy_type,
isc_nm_proxyheader_info_t *proxy_info) {
isc_sockaddr_t local_interface;
isc_nmsocket_t *sock = NULL;
- isc__networker_t *worker = NULL;
+ isc__networker_t *worker = isc__networker_current();
- REQUIRE(VALID_NM(mgr));
REQUIRE(cb != NULL);
REQUIRE(peer != NULL);
REQUIRE(uri != NULL);
REQUIRE(*uri != '\0');
- worker = &mgr->workers[isc_tid()];
-
if (isc__nm_closing(worker)) {
cb(NULL, ISC_R_SHUTTINGDOWN, cbarg);
return;
switch (proxy_type) {
case ISC_NM_PROXY_NONE:
if (tlsctx != NULL) {
- isc_nm_tlsconnect(mgr, local, peer,
- transport_connect_cb, sock, tlsctx,
- sni_hostname, client_sess_cache,
- timeout, false, NULL);
+ isc_nm_tlsconnect(local, peer, transport_connect_cb,
+ sock, tlsctx, sni_hostname,
+ client_sess_cache, timeout, false,
+ NULL);
} else {
- isc_nm_tcpconnect(mgr, local, peer,
- transport_connect_cb, sock, timeout);
+ isc_nm_tcpconnect(local, peer, transport_connect_cb,
+ sock, timeout);
}
break;
case ISC_NM_PROXY_PLAIN:
if (tlsctx != NULL) {
- isc_nm_tlsconnect(mgr, local, peer,
- transport_connect_cb, sock, tlsctx,
- sni_hostname, client_sess_cache,
- timeout, true, proxy_info);
+ isc_nm_tlsconnect(local, peer, transport_connect_cb,
+ sock, tlsctx, sni_hostname,
+ client_sess_cache, timeout, true,
+ proxy_info);
} else {
isc_nm_proxystreamconnect(
- mgr, local, peer, transport_connect_cb, sock,
+ local, peer, transport_connect_cb, sock,
timeout, NULL, NULL, NULL, proxy_info);
}
break;
case ISC_NM_PROXY_ENCRYPTED:
INSIST(tlsctx != NULL);
- isc_nm_proxystreamconnect(
- mgr, local, peer, transport_connect_cb, sock, timeout,
- tlsctx, sni_hostname, client_sess_cache, proxy_info);
+ isc_nm_proxystreamconnect(local, peer, transport_connect_cb,
+ sock, timeout, tlsctx, sni_hostname,
+ client_sess_cache, proxy_info);
break;
default:
UNREACHABLE();
}
isc_result_t
-isc_nm_listenhttp(isc_nm_t *mgr, uint32_t workers, isc_sockaddr_t *iface,
- int backlog, isc_quota_t *quota, isc_tlsctx_t *ctx,
+isc_nm_listenhttp(uint32_t workers, isc_sockaddr_t *iface, int backlog,
+ isc_quota_t *quota, isc_tlsctx_t *ctx,
isc_nm_http_endpoints_t *eps, uint32_t max_concurrent_streams,
isc_nm_proxy_type_t proxy_type, isc_nmsocket_t **sockp) {
isc_nmsocket_t *sock = NULL;
isc_result_t result = ISC_R_FAILURE;
- isc__networker_t *worker = NULL;
+ isc__networker_t *worker = isc__networker_current();
- REQUIRE(VALID_NM(mgr));
REQUIRE(!ISC_LIST_EMPTY(eps->handlers));
REQUIRE(atomic_load(&eps->in_use) == false);
REQUIRE(isc_tid() == 0);
- worker = &mgr->workers[isc_tid()];
sock = isc_mempool_get(worker->nmsocket_pool);
isc__nmsocket_init(sock, worker, isc_nm_httplistener, iface, NULL);
http_initsocket(sock);
case ISC_NM_PROXY_NONE:
if (ctx != NULL) {
result = isc_nm_listentls(
- mgr, workers, iface, httplisten_acceptcb, sock,
+ workers, iface, httplisten_acceptcb, sock,
backlog, quota, ctx, false, &sock->outer);
} else {
- result = isc_nm_listentcp(mgr, workers, iface,
+ result = isc_nm_listentcp(workers, iface,
httplisten_acceptcb, sock,
backlog, quota, &sock->outer);
}
case ISC_NM_PROXY_PLAIN:
if (ctx != NULL) {
result = isc_nm_listentls(
- mgr, workers, iface, httplisten_acceptcb, sock,
+ workers, iface, httplisten_acceptcb, sock,
backlog, quota, ctx, true, &sock->outer);
} else {
result = isc_nm_listenproxystream(
- mgr, workers, iface, httplisten_acceptcb, sock,
+ workers, iface, httplisten_acceptcb, sock,
backlog, quota, NULL, &sock->outer);
}
break;
case ISC_NM_PROXY_ENCRYPTED:
INSIST(ctx != NULL);
result = isc_nm_listenproxystream(
- mgr, workers, iface, httplisten_acceptcb, sock, backlog,
+ workers, iface, httplisten_acceptcb, sock, backlog,
quota, ctx, &sock->outer);
break;
default:
const isc_tid_t tid = isc_tid();
isc_nmsocket_t *listener = data->listener;
isc_nm_http_endpoints_t *endpoints = data->endpoints;
- isc__networker_t *worker = &listener->worker->netmgr->workers[tid];
+ isc__networker_t *worker = isc__networker_current();
isc_mem_put(worker->loop->mctx, data, sizeof(*data));
atomic_store(&eps->in_use, true);
for (size_t i = 0; i < isc_loopmgr_nloops(); i++) {
- isc__networker_t *worker =
- &listener->worker->netmgr->workers[i];
+ isc__networker_t *worker = isc__networker_get(i);
http_endpoints_data_t *data = isc_mem_cget(worker->loop->mctx,
1, sizeof(*data));
size_t nworkers;
REQUIRE(VALID_NMSOCK(listener));
- REQUIRE(listener->worker != NULL && VALID_NM(listener->worker->netmgr));
+ REQUIRE(listener->worker != NULL);
REQUIRE(VALID_HTTP_ENDPOINTS(epset));
nworkers = (size_t)isc_loopmgr_nloops();
static void
http_cleanup_listener_endpoints(isc_nmsocket_t *listener) {
- REQUIRE(listener->worker != NULL && VALID_NM(listener->worker->netmgr));
+ REQUIRE(listener->worker != NULL);
if (listener->h2->listener_endpoints == NULL) {
return;
isc_mem_t *mctx;
isc_refcount_t references;
isc_loop_t *loop;
- isc_nm_t *netmgr;
bool shuttingdown;
char *recvbuf;
isc__nm_dump_active(isc__networker_t *worker);
void
-isc__nm_dump_active_manager(isc_nm_t *netmgr);
+isc__nm_dump_active_manager(void);
#endif /* ISC_NETMGR_TRACE */
/*
isc_job_t job;
};
-/*
- * Network manager
- */
-#define NM_MAGIC ISC_MAGIC('N', 'E', 'T', 'M')
-#define VALID_NM(t) ISC_MAGIC_VALID(t, NM_MAGIC)
-
-struct isc_nm {
+typedef struct isc__netmgr {
int magic;
isc_refcount_t references;
isc_mem_t *mctx;
atomic_int_fast32_t send_udp_buffer_size;
atomic_int_fast32_t recv_tcp_buffer_size;
atomic_int_fast32_t send_tcp_buffer_size;
-};
+} isc__netmgr_t;
+
+extern isc__netmgr_t *isc__netmgr;
+
+/*
+ * Network manager
+ */
+#define NM_MAGIC ISC_MAGIC('N', 'E', 'T', 'M')
+#define VALID_NM(t) ISC_MAGIC_VALID(t, NM_MAGIC)
+
+#if ISC_NETMGR_TRACE
+#define isc__netmgr_ref(ptr) isc__netmgr__ref(ptr, __func__, __FILE__, __LINE__)
+#define isc__netmgr_unref(ptr) \
+ isc__netmgr__unref(ptr, __func__, __FILE__, __LINE__)
+#define isc__netmgr_attach(ptr, ptrp) \
+ isc__netmgr__attach(ptr, ptrp, __func__, __FILE__, __LINE__)
+#define isc__netmgr_detach(ptrp) \
+ isc__netmgr__detach(ptrp, __func__, __FILE__, __LINE__)
+ISC_REFCOUNT_TRACE_DECL(isc__netmgr);
+#else
+ISC_REFCOUNT_DECL(isc__netmgr);
+#endif
/*%
* A universal structure for either a single socket or a group of
*/
void
-isc__nm_set_network_buffers(isc_nm_t *nm, uv_handle_t *handle);
+isc__nm_set_network_buffers(uv_handle_t *handle);
/*%>
* Sets the pre-configured network buffers size on the handle.
*/
* Logging helpers
*/
void
-isc__netmgr_log(const isc_nm_t *netmgr, int level, const char *fmt, ...)
- ISC_FORMAT_PRINTF(3, 4);
+isc__netmgr_log(int level, const char *fmt, ...) ISC_FORMAT_PRINTF(2, 3);
void
isc__nmsocket_log(const isc_nmsocket_t *sock, int level, const char *fmt, ...)
ISC_FORMAT_PRINTF(3, 4);
* The same as 'isc_nm_send()', but with data length sent
* ahead of data (two bytes (16 bit) in big-endian format).
*/
+
+isc__networker_t *
+isc__networker_current(void);
+
+isc__networker_t *
+isc__networker_get(uint32_t tid);
#include "netmgr-int.h"
#include "openssl_shim.h"
+isc__netmgr_t *isc__netmgr = NULL;
+
/*%
* Shortcut index arrays to get access to statistics counters.
*/
worker->shuttingdown = true;
isc__netmgr_log(
- worker->netmgr, ISC_LOG_DEBUG(1),
+ ISC_LOG_DEBUG(1),
"Shutting down network manager worker on loop %p(%" PRItid ")",
loop, isc_tid());
}
static void
-netmgr_teardown(void *arg) {
- isc_nm_t *netmgr = (void *)arg;
-
- if (atomic_compare_exchange_strong_acq_rel(&netmgr->shuttingdown,
+netmgr_teardown(void *arg ISC_ATTR_UNUSED) {
+ if (atomic_compare_exchange_strong_acq_rel(&isc__netmgr->shuttingdown,
&(bool){ false }, true))
{
- isc__netmgr_log(netmgr, ISC_LOG_DEBUG(1),
+ isc__netmgr_log(ISC_LOG_DEBUG(1),
"Shutting down network manager");
}
}
#endif
void
-isc_netmgr_create(isc_mem_t *mctx, isc_nm_t **netmgrp) {
- isc_nm_t *netmgr = NULL;
+isc_netmgr_create(isc_mem_t *mctx) {
+ isc__netmgr_t *netmgr = NULL;
#ifdef MAXIMAL_UV_VERSION
if (uv_version() > MAXIMAL_UV_VERSION) {
}
netmgr = isc_mem_get(mctx, sizeof(*netmgr));
- *netmgr = (isc_nm_t){
+ *netmgr = (isc__netmgr_t){
.nloops = isc_loopmgr_nloops(),
};
.active_sockets = ISC_LIST_INITIALIZER,
};
- isc_nm_attach(netmgr, &worker->netmgr);
+ isc__netmgr_ref(netmgr);
isc_mem_attach(loop->mctx, &worker->mctx);
isc_refcount_init(&worker->references, 1);
}
- *netmgrp = netmgr;
+ isc__netmgr = netmgr;
}
/*
* Free the resources of the network manager.
*/
static void
-nm_destroy(isc_nm_t *netmgr) {
+netmgr_destroy(isc__netmgr_t *netmgr) {
REQUIRE(VALID_NM(netmgr));
isc_refcount_destroy(&netmgr->references);
}
#if ISC_NETMGR_TRACE
-ISC_REFCOUNT_TRACE_IMPL(isc_nm, nm_destroy)
+ISC_REFCOUNT_TRACE_IMPL(isc__netmgr, netmgr_destroy)
#else
-ISC_REFCOUNT_IMPL(isc_nm, nm_destroy);
+ISC_REFCOUNT_IMPL(isc__netmgr, netmgr_destroy);
#endif
void
-isc_nm_maxudp(isc_nm_t *mgr, uint32_t maxudp) {
- REQUIRE(VALID_NM(mgr));
+isc_netmgr_destroy(void) {
+ isc__netmgr_detach(&isc__netmgr);
+}
+
+void
+isc_nm_maxudp(uint32_t maxudp) {
+ REQUIRE(VALID_NM(isc__netmgr));
- atomic_store_relaxed(&mgr->maxudp, maxudp);
+ atomic_store_relaxed(&isc__netmgr->maxudp, maxudp);
}
void
}
void
-isc_nm_setinitialtimeout(isc_nm_t *mgr, uint32_t timeout_ms) {
- REQUIRE(VALID_NM(mgr));
+isc_nm_setinitialtimeout(uint32_t timeout_ms) {
+ REQUIRE(VALID_NM(isc__netmgr));
- atomic_store_relaxed(&mgr->init, timeout_ms);
+ atomic_store_relaxed(&isc__netmgr->init, timeout_ms);
}
void
-isc_nm_setprimariestimeout(isc_nm_t *mgr, uint32_t timeout_ms) {
- REQUIRE(VALID_NM(mgr));
+isc_nm_setprimariestimeout(uint32_t timeout_ms) {
+ REQUIRE(VALID_NM(isc__netmgr));
- atomic_store_relaxed(&mgr->primaries, timeout_ms);
+ atomic_store_relaxed(&isc__netmgr->primaries, timeout_ms);
}
void
-isc_nm_setidletimeout(isc_nm_t *mgr, uint32_t timeout_ms) {
- REQUIRE(VALID_NM(mgr));
+isc_nm_setidletimeout(uint32_t timeout_ms) {
+ REQUIRE(VALID_NM(isc__netmgr));
- atomic_store_relaxed(&mgr->idle, timeout_ms);
+ atomic_store_relaxed(&isc__netmgr->idle, timeout_ms);
}
void
-isc_nm_setkeepalivetimeout(isc_nm_t *mgr, uint32_t timeout_ms) {
- REQUIRE(VALID_NM(mgr));
+isc_nm_setkeepalivetimeout(uint32_t timeout_ms) {
+ REQUIRE(VALID_NM(isc__netmgr));
- atomic_store_relaxed(&mgr->keepalive, timeout_ms);
+ atomic_store_relaxed(&isc__netmgr->keepalive, timeout_ms);
}
void
-isc_nm_setadvertisedtimeout(isc_nm_t *mgr, uint32_t timeout_ms) {
- REQUIRE(VALID_NM(mgr));
+isc_nm_setadvertisedtimeout(uint32_t timeout_ms) {
+ REQUIRE(VALID_NM(isc__netmgr));
- atomic_store_relaxed(&mgr->advertised, timeout_ms);
+ atomic_store_relaxed(&isc__netmgr->advertised, timeout_ms);
}
void
-isc_nm_setnetbuffers(isc_nm_t *mgr, int32_t recv_tcp, int32_t send_tcp,
- int32_t recv_udp, int32_t send_udp) {
- REQUIRE(VALID_NM(mgr));
+isc_nm_setnetbuffers(int32_t recv_tcp, int32_t send_tcp, int32_t recv_udp,
+ int32_t send_udp) {
+ REQUIRE(VALID_NM(isc__netmgr));
- atomic_store_relaxed(&mgr->recv_tcp_buffer_size, recv_tcp);
- atomic_store_relaxed(&mgr->send_tcp_buffer_size, send_tcp);
- atomic_store_relaxed(&mgr->recv_udp_buffer_size, recv_udp);
- atomic_store_relaxed(&mgr->send_udp_buffer_size, send_udp);
+ atomic_store_relaxed(&isc__netmgr->recv_tcp_buffer_size, recv_tcp);
+ atomic_store_relaxed(&isc__netmgr->send_tcp_buffer_size, send_tcp);
+ atomic_store_relaxed(&isc__netmgr->recv_udp_buffer_size, recv_udp);
+ atomic_store_relaxed(&isc__netmgr->send_udp_buffer_size, send_udp);
}
bool
-isc_nm_getloadbalancesockets(isc_nm_t *mgr) {
- REQUIRE(VALID_NM(mgr));
+isc_nm_getloadbalancesockets(void) {
+ REQUIRE(VALID_NM(isc__netmgr));
- return mgr->load_balance_sockets;
+ return isc__netmgr->load_balance_sockets;
}
void
-isc_nm_setloadbalancesockets(isc_nm_t *mgr, ISC_ATTR_UNUSED bool enabled) {
- REQUIRE(VALID_NM(mgr));
+isc_nm_setloadbalancesockets(ISC_ATTR_UNUSED bool enabled) {
+ REQUIRE(VALID_NM(isc__netmgr));
#if HAVE_SO_REUSEPORT_LB
- mgr->load_balance_sockets = enabled;
+ isc__netmgr->load_balance_sockets = enabled;
#endif
}
uint32_t
-isc_nm_getinitialtimeout(isc_nm_t *mgr) {
- REQUIRE(VALID_NM(mgr));
+isc_nm_getinitialtimeout(void) {
+ REQUIRE(VALID_NM(isc__netmgr));
- return atomic_load_relaxed(&mgr->init);
+ return atomic_load_relaxed(&isc__netmgr->init);
}
uint32_t
-isc_nm_getprimariestimeout(isc_nm_t *mgr) {
- REQUIRE(VALID_NM(mgr));
+isc_nm_getprimariestimeout(void) {
+ REQUIRE(VALID_NM(isc__netmgr));
- return atomic_load_relaxed(&mgr->primaries);
+ return atomic_load_relaxed(&isc__netmgr->primaries);
}
uint32_t
-isc_nm_getidletimeout(isc_nm_t *mgr) {
- REQUIRE(VALID_NM(mgr));
+isc_nm_getidletimeout(void) {
+ REQUIRE(VALID_NM(isc__netmgr));
- return atomic_load_relaxed(&mgr->idle);
+ return atomic_load_relaxed(&isc__netmgr->idle);
}
uint32_t
-isc_nm_getkeepalivetimeout(isc_nm_t *mgr) {
- REQUIRE(VALID_NM(mgr));
+isc_nm_getkeepalivetimeout(void) {
+ REQUIRE(VALID_NM(isc__netmgr));
- return atomic_load_relaxed(&mgr->keepalive);
+ return atomic_load_relaxed(&isc__netmgr->keepalive);
}
uint32_t
-isc_nm_getadvertisedtimeout(isc_nm_t *mgr) {
- REQUIRE(VALID_NM(mgr));
+isc_nm_getadvertisedtimeout(void) {
+ REQUIRE(VALID_NM(isc__netmgr));
- return atomic_load_relaxed(&mgr->advertised);
+ return atomic_load_relaxed(&isc__netmgr->advertised);
}
bool
void
isc_nmhandle_keepalive(isc_nmhandle_t *handle, bool value) {
isc_nmsocket_t *sock = NULL;
- isc_nm_t *netmgr = NULL;
REQUIRE(VALID_NMHANDLE(handle));
REQUIRE(VALID_NMSOCK(handle->sock));
sock = handle->sock;
- netmgr = sock->worker->netmgr;
REQUIRE(sock->tid == isc_tid());
switch (sock->type) {
- case isc_nm_tcpsocket:
+ case isc_nm_tcpsocket:;
sock->keepalive = value;
- sock->read_timeout =
- value ? atomic_load_relaxed(&netmgr->keepalive)
- : atomic_load_relaxed(&netmgr->idle);
- sock->write_timeout =
- value ? atomic_load_relaxed(&netmgr->keepalive)
- : atomic_load_relaxed(&netmgr->idle);
+ sock->read_timeout = sock->write_timeout =
+ value ? atomic_load_relaxed(&isc__netmgr->keepalive)
+ : atomic_load_relaxed(&isc__netmgr->idle);
break;
case isc_nm_streamdnssocket:
isc__nmhandle_streamdns_keepalive(handle, value);
return addr;
}
-isc_nm_t *
-isc_nmhandle_netmgr(isc_nmhandle_t *handle) {
- REQUIRE(VALID_NMHANDLE(handle));
- REQUIRE(VALID_NMSOCK(handle->sock));
-
- return handle->sock->worker->netmgr;
-}
-
isc__nm_uvreq_t *
isc___nm_uvreq_get(isc_nmsocket_t *sock FLARG) {
REQUIRE(VALID_NMSOCK(sock));
}
void
-isc_nm_setstats(isc_nm_t *mgr, isc_stats_t *stats) {
- REQUIRE(VALID_NM(mgr));
- REQUIRE(mgr->stats == NULL);
+isc_nm_setstats(isc_stats_t *stats) {
+ REQUIRE(VALID_NM(isc__netmgr));
+ REQUIRE(isc__netmgr->stats == NULL);
REQUIRE(isc_stats_ncounters(stats) == isc_sockstatscounter_max);
- isc_stats_attach(stats, &mgr->stats);
+ isc_stats_attach(stats, &isc__netmgr->stats);
}
void
REQUIRE(VALID_NMSOCK(sock));
REQUIRE(id < STATID_MAX);
- if (sock->statsindex != NULL && sock->worker->netmgr->stats != NULL) {
- isc_stats_increment(sock->worker->netmgr->stats,
- sock->statsindex[id]);
+ if (sock->statsindex != NULL && isc__netmgr->stats != NULL) {
+ isc_stats_increment(isc__netmgr->stats, sock->statsindex[id]);
}
}
REQUIRE(VALID_NMSOCK(sock));
REQUIRE(id < STATID_MAX);
- if (sock->statsindex != NULL && sock->worker->netmgr->stats != NULL) {
- isc_stats_decrement(sock->worker->netmgr->stats,
- sock->statsindex[id]);
+ if (sock->statsindex != NULL && isc__netmgr->stats != NULL) {
+ isc_stats_decrement(isc__netmgr->stats, sock->statsindex[id]);
}
}
#endif
void
-isc__nm_set_network_buffers(isc_nm_t *nm, uv_handle_t *handle) {
+isc__nm_set_network_buffers(uv_handle_t *handle) {
int32_t recv_buffer_size = 0;
int32_t send_buffer_size = 0;
switch (handle->type) {
case UV_TCP:
recv_buffer_size =
- atomic_load_relaxed(&nm->recv_tcp_buffer_size);
+ atomic_load_relaxed(&isc__netmgr->recv_tcp_buffer_size);
send_buffer_size =
- atomic_load_relaxed(&nm->send_tcp_buffer_size);
+ atomic_load_relaxed(&isc__netmgr->send_tcp_buffer_size);
break;
case UV_UDP:
recv_buffer_size =
- atomic_load_relaxed(&nm->recv_udp_buffer_size);
+ atomic_load_relaxed(&isc__netmgr->recv_udp_buffer_size);
send_buffer_size =
- atomic_load_relaxed(&nm->send_udp_buffer_size);
+ atomic_load_relaxed(&isc__netmgr->send_udp_buffer_size);
break;
default:
UNREACHABLE();
const isc_tid_t tid = isc_tid();
isc_nmsocket_t *listener = data->listener;
isc_tlsctx_t *tlsctx = data->tlsctx;
- isc__networker_t *worker = &listener->worker->netmgr->workers[tid];
+ isc__networker_t *worker = isc__networker_current();
isc_mem_put(worker->loop->mctx, data, sizeof(*data));
const size_t nworkers = (size_t)isc_loopmgr_nloops();
/* Update the TLS context reference for every worker thread. */
for (size_t i = 0; i < nworkers; i++) {
- isc__networker_t *worker =
- &listener->worker->netmgr->workers[i];
+ isc__networker_t *worker = isc__networker_get(i);
settlsctx_data_t *data = isc_mem_cget(worker->loop->mctx, 1,
sizeof(*data));
static void
isc__networker_destroy(isc__networker_t *worker) {
- isc_nm_t *netmgr = worker->netmgr;
- worker->netmgr = NULL;
-
- isc__netmgr_log(netmgr, ISC_LOG_DEBUG(1),
+ isc__netmgr_log(ISC_LOG_DEBUG(1),
"Destroying network manager worker on loop %p(%" PRItid
")",
worker->loop, isc_tid());
isc_mem_putanddetach(&worker->mctx, worker->recvbuf,
ISC_NETMGR_RECVBUF_SIZE);
- isc_nm_detach(&netmgr);
+
+ isc__netmgr_unref(isc__netmgr);
}
ISC_REFCOUNT_IMPL(isc__networker, isc__networker_destroy);
void
-isc__netmgr_log(const isc_nm_t *netmgr, int level, const char *fmt, ...) {
+isc__netmgr_log(int level, const char *fmt, ...) {
char msgbuf[2048];
va_list ap;
va_end(ap);
isc_log_write(ISC_LOGCATEGORY_GENERAL, ISC_LOGMODULE_NETMGR, level,
- "netmgr %p: %s", netmgr, msgbuf);
+ "netmgr %p: %s", isc__netmgr, msgbuf);
}
void
.complete_header = *header_data };
}
+isc__networker_t *
+isc__networker_current(void) {
+ REQUIRE(VALID_NM(isc__netmgr));
+ return &isc__netmgr->workers[isc_tid()];
+}
+
+isc__networker_t *
+isc__networker_get(uint32_t tid) {
+ REQUIRE(VALID_NM(isc__netmgr));
+ return &isc__netmgr->workers[tid];
+}
+
#if ISC_NETMGR_TRACE
/*
* Dump all active sockets in netmgr. We output to stderr
}
void
-isc__nm_dump_active_manager(isc_nm_t *netmgr) {
- size_t i = 0;
-
- for (i = 0; i < netmgr->nloops; i++) {
- isc__networker_t *worker = &netmgr->workers[i];
+isc__nm_dump_active_manager(void) {
+ for (size_t i = 0; i < isc__netmgr->nloops; i++) {
+ isc__networker_t *worker = isc__networker_get(i);
if (!ISC_LIST_EMPTY(worker->active_sockets)) {
fprintf(stderr, "Worker #%zu (%p)\n", i, worker);
isc__nmsocket_init(sock, worker, type, addr, NULL);
sock->result = ISC_R_UNSET;
if (type == isc_nm_proxystreamsocket) {
- sock->read_timeout = isc_nm_getinitialtimeout(worker->netmgr);
+ sock->read_timeout = isc_nm_getinitialtimeout();
sock->client = !is_server;
sock->connecting = !is_server;
if (is_server) {
}
isc_result_t
-isc_nm_listenproxystream(isc_nm_t *mgr, uint32_t workers, isc_sockaddr_t *iface,
+isc_nm_listenproxystream(uint32_t workers, isc_sockaddr_t *iface,
isc_nm_accept_cb_t accept_cb, void *accept_cbarg,
int backlog, isc_quota_t *quota, isc_tlsctx_t *tlsctx,
isc_nmsocket_t **sockp) {
isc_result_t result;
isc_nmsocket_t *listener = NULL;
- isc__networker_t *worker = &mgr->workers[isc_tid()];
+ isc__networker_t *worker = isc__networker_current();
- REQUIRE(VALID_NM(mgr));
REQUIRE(isc_tid() == 0);
REQUIRE(sockp != NULL && *sockp == NULL);
listener->accept_cbarg = accept_cbarg;
if (tlsctx == NULL) {
- result = isc_nm_listentcp(mgr, workers, iface,
- proxystream_accept_cb, listener,
- backlog, quota, &listener->outer);
+ result = isc_nm_listentcp(workers, iface, proxystream_accept_cb,
+ listener, backlog, quota,
+ &listener->outer);
} else {
- result = isc_nm_listentls(
- mgr, workers, iface, proxystream_accept_cb, listener,
- backlog, quota, tlsctx, false, &listener->outer);
+ result = isc_nm_listentls(workers, iface, proxystream_accept_cb,
+ listener, backlog, quota, tlsctx,
+ false, &listener->outer);
}
if (result != ISC_R_SUCCESS) {
}
void
-isc_nm_proxystreamconnect(isc_nm_t *mgr, isc_sockaddr_t *local,
- isc_sockaddr_t *peer, isc_nm_cb_t cb, void *cbarg,
- unsigned int timeout, isc_tlsctx_t *tlsctx,
- const char *sni_hostname,
+isc_nm_proxystreamconnect(isc_sockaddr_t *local, isc_sockaddr_t *peer,
+ isc_nm_cb_t cb, void *cbarg, unsigned int timeout,
+ isc_tlsctx_t *tlsctx, const char *sni_hostname,
isc_tlsctx_client_session_cache_t *client_sess_cache,
isc_nm_proxyheader_info_t *proxy_info) {
isc_result_t result = ISC_R_FAILURE;
isc_nmsocket_t *nsock = NULL;
- isc__networker_t *worker = &mgr->workers[isc_tid()];
-
- REQUIRE(VALID_NM(mgr));
+ isc__networker_t *worker = isc__networker_current();
if (isc__nm_closing(worker)) {
cb(NULL, ISC_R_SHUTTINGDOWN, cbarg);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
if (tlsctx == NULL) {
- isc_nm_tcpconnect(mgr, local, peer, proxystream_connect_cb,
- nsock, nsock->connect_timeout);
+ isc_nm_tcpconnect(local, peer, proxystream_connect_cb, nsock,
+ nsock->connect_timeout);
} else {
- isc_nm_tlsconnect(mgr, local, peer, proxystream_connect_cb,
- nsock, tlsctx, sni_hostname,
- client_sess_cache, nsock->connect_timeout,
- false, NULL);
+ isc_nm_tlsconnect(local, peer, proxystream_connect_cb, nsock,
+ tlsctx, sni_hostname, client_sess_cache,
+ nsock->connect_timeout, false, NULL);
}
}
isc__nmsocket_init(sock, worker, type, addr, NULL);
sock->result = ISC_R_UNSET;
if (type == isc_nm_proxyudpsocket) {
- sock->read_timeout = isc_nm_getinitialtimeout(worker->netmgr);
+ sock->read_timeout = isc_nm_getinitialtimeout();
sock->client = !is_server;
sock->connecting = !is_server;
if (!is_server) {
ISC_NM_PROXY2_DEFAULT_BUFFER_SIZE);
}
} else if (type == isc_nm_proxyudplistener) {
- size_t nworkers = worker->netmgr->nloops;
+ size_t nworkers = isc_loopmgr_nloops();
sock->proxy.udp_server_socks_num = nworkers;
sock->proxy.udp_server_socks = isc_mem_cget(
worker->mctx, nworkers, sizeof(isc_nmsocket_t *));
}
isc_result_t
-isc_nm_listenproxyudp(isc_nm_t *mgr, uint32_t workers, isc_sockaddr_t *iface,
+isc_nm_listenproxyudp(uint32_t workers, isc_sockaddr_t *iface,
isc_nm_recv_cb_t cb, void *cbarg,
isc_nmsocket_t **sockp) {
isc_result_t result;
isc_nmsocket_t *listener = NULL;
- isc__networker_t *worker = &mgr->workers[isc_tid()];
+ isc__networker_t *worker = isc__networker_current();
- REQUIRE(VALID_NM(mgr));
REQUIRE(isc_tid() == 0);
REQUIRE(sockp != NULL && *sockp == NULL);
listener->recv_cbarg = cbarg;
for (size_t i = 0; i < listener->proxy.udp_server_socks_num; i++) {
- listener->proxy.udp_server_socks[i] = proxyudp_sock_new(
- &mgr->workers[i], isc_nm_proxyudpsocket, iface, true);
+ listener->proxy.udp_server_socks[i] =
+ proxyudp_sock_new(isc__networker_get(i),
+ isc_nm_proxyudpsocket, iface, true);
listener->proxy.udp_server_socks[i]->recv_cb =
listener->recv_cb;
&listener->proxy.udp_server_socks[i]->listener);
}
- result = isc_nm_listenudp(mgr, workers, iface, proxyudp_read_cb,
- listener, &listener->outer);
+ result = isc_nm_listenudp(workers, iface, proxyudp_read_cb, listener,
+ &listener->outer);
if (result == ISC_R_SUCCESS) {
listener->active = true;
}
void
-isc_nm_proxyudpconnect(isc_nm_t *mgr, isc_sockaddr_t *local,
- isc_sockaddr_t *peer, isc_nm_cb_t cb, void *cbarg,
- unsigned int timeout,
+isc_nm_proxyudpconnect(isc_sockaddr_t *local, isc_sockaddr_t *peer,
+ isc_nm_cb_t cb, void *cbarg, unsigned int timeout,
isc_nm_proxyheader_info_t *proxy_info) {
isc_result_t result = ISC_R_FAILURE;
isc_nmsocket_t *nsock = NULL;
- isc__networker_t *worker = &mgr->workers[isc_tid()];
-
- REQUIRE(VALID_NM(mgr));
+ isc__networker_t *worker = isc__networker_current();
if (isc__nm_closing(worker)) {
cb(NULL, ISC_R_SHUTTINGDOWN, cbarg);
}
RUNTIME_CHECK(result == ISC_R_SUCCESS);
- isc_nm_udpconnect(mgr, local, peer, proxyudp_connect_cb, nsock,
- timeout);
+ isc_nm_udpconnect(local, peer, proxyudp_connect_cb, nsock, timeout);
}
/*
isc__nmsocket_init(sock, worker, type, addr, NULL);
sock->result = ISC_R_UNSET;
if (type == isc_nm_streamdnssocket) {
- sock->read_timeout = isc_nm_getinitialtimeout(worker->netmgr);
+ sock->read_timeout = isc_nm_getinitialtimeout();
sock->client = !is_server;
sock->connecting = !is_server;
sock->streamdns.input = isc_dnsstream_assembler_new(
}
void
-isc_nm_streamdnsconnect(isc_nm_t *mgr, isc_sockaddr_t *local,
- isc_sockaddr_t *peer, isc_nm_cb_t cb, void *cbarg,
- unsigned int timeout, isc_tlsctx_t *tlsctx,
- const char *sni_hostname,
+isc_nm_streamdnsconnect(isc_sockaddr_t *local, isc_sockaddr_t *peer,
+ isc_nm_cb_t cb, void *cbarg, unsigned int timeout,
+ isc_tlsctx_t *tlsctx, const char *sni_hostname,
isc_tlsctx_client_session_cache_t *client_sess_cache,
isc_nm_proxy_type_t proxy_type,
isc_nm_proxyheader_info_t *proxy_info) {
isc_nmsocket_t *nsock = NULL;
- isc__networker_t *worker = NULL;
-
- REQUIRE(VALID_NM(mgr));
-
- worker = &mgr->workers[isc_tid()];
+ isc__networker_t *worker = isc__networker_current();
if (isc__nm_closing(worker)) {
cb(NULL, ISC_R_SHUTTINGDOWN, cbarg);
case ISC_NM_PROXY_NONE:
if (tlsctx == NULL) {
INSIST(client_sess_cache == NULL);
- isc_nm_tcpconnect(mgr, local, peer,
+ isc_nm_tcpconnect(local, peer,
streamdns_transport_connected, nsock,
nsock->connect_timeout);
} else {
isc_nm_tlsconnect(
- mgr, local, peer, streamdns_transport_connected,
+ local, peer, streamdns_transport_connected,
nsock, tlsctx, sni_hostname, client_sess_cache,
nsock->connect_timeout, false, proxy_info);
}
break;
case ISC_NM_PROXY_PLAIN:
if (tlsctx == NULL) {
- isc_nm_proxystreamconnect(mgr, local, peer,
+ isc_nm_proxystreamconnect(local, peer,
streamdns_transport_connected,
nsock, nsock->connect_timeout,
NULL, NULL, NULL, proxy_info);
} else {
isc_nm_tlsconnect(
- mgr, local, peer, streamdns_transport_connected,
+ local, peer, streamdns_transport_connected,
nsock, tlsctx, sni_hostname, client_sess_cache,
nsock->connect_timeout, true, proxy_info);
}
case ISC_NM_PROXY_ENCRYPTED:
INSIST(tlsctx != NULL);
isc_nm_proxystreamconnect(
- mgr, local, peer, streamdns_transport_connected, nsock,
+ local, peer, streamdns_transport_connected, nsock,
nsock->connect_timeout, tlsctx, sni_hostname,
client_sess_cache, proxy_info);
break;
nsock->peer = isc_nmhandle_peeraddr(handle);
nsock->tid = tid;
- nsock->read_timeout =
- isc_nm_getinitialtimeout(handle->sock->worker->netmgr);
+ nsock->read_timeout = isc_nm_getinitialtimeout();
nsock->accepting = true;
nsock->active = true;
nsock->closehandle_cb = streamdns_resume_processing;
isc__nmhandle_set_manual_timer(nsock->outerhandle, true);
/* settimeout restarts the timer */
- isc_nmhandle_settimeout(
- nsock->outerhandle,
- isc_nm_getinitialtimeout(nsock->worker->netmgr));
+ isc_nmhandle_settimeout(nsock->outerhandle, isc_nm_getinitialtimeout());
(void)isc_nmhandle_set_tcp_nodelay(nsock->outerhandle, true);
streamdns_handle_incoming_data(nsock, nsock->outerhandle, NULL, 0);
}
isc_result_t
-isc_nm_listenstreamdns(isc_nm_t *mgr, uint32_t workers, isc_sockaddr_t *iface,
+isc_nm_listenstreamdns(uint32_t workers, isc_sockaddr_t *iface,
isc_nm_recv_cb_t recv_cb, void *recv_cbarg,
isc_nm_accept_cb_t accept_cb, void *accept_cbarg,
int backlog, isc_quota_t *quota, isc_tlsctx_t *tlsctx,
isc_nm_proxy_type_t proxy_type, isc_nmsocket_t **sockp) {
isc_result_t result = ISC_R_FAILURE;
isc_nmsocket_t *listener = NULL;
- isc__networker_t *worker = NULL;
+ isc__networker_t *worker = isc__networker_current();
- REQUIRE(VALID_NM(mgr));
REQUIRE(isc_tid() == 0);
- worker = &mgr->workers[isc_tid()];
-
if (isc__nm_closing(worker)) {
return ISC_R_SHUTTINGDOWN;
}
case ISC_NM_PROXY_NONE:
if (tlsctx == NULL) {
result = isc_nm_listentcp(
- mgr, workers, iface, streamdns_accept_cb,
- listener, backlog, quota, &listener->outer);
+ workers, iface, streamdns_accept_cb, listener,
+ backlog, quota, &listener->outer);
} else {
- result = isc_nm_listentls(mgr, workers, iface,
+ result = isc_nm_listentls(workers, iface,
streamdns_accept_cb, listener,
backlog, quota, tlsctx, false,
&listener->outer);
case ISC_NM_PROXY_PLAIN:
if (tlsctx == NULL) {
result = isc_nm_listenproxystream(
- mgr, workers, iface, streamdns_accept_cb,
- listener, backlog, quota, NULL,
- &listener->outer);
+ workers, iface, streamdns_accept_cb, listener,
+ backlog, quota, NULL, &listener->outer);
} else {
- result = isc_nm_listentls(mgr, workers, iface,
- streamdns_accept_cb, listener,
- backlog, quota, tlsctx, true,
- &listener->outer);
+ result = isc_nm_listentls(
+ workers, iface, streamdns_accept_cb, listener,
+ backlog, quota, tlsctx, true, &listener->outer);
}
break;
case ISC_NM_PROXY_ENCRYPTED:
INSIST(tlsctx != NULL);
result = isc_nm_listenproxystream(
- mgr, workers, iface, streamdns_accept_cb, listener,
- backlog, quota, tlsctx, &listener->outer);
+ workers, iface, streamdns_accept_cb, listener, backlog,
+ quota, tlsctx, &listener->outer);
break;
default:
UNREACHABLE();
}
}
- isc__nm_set_network_buffers(sock->worker->netmgr,
- &sock->uv_handle.handle);
+ isc__nm_set_network_buffers(&sock->uv_handle.handle);
uv_handle_set_data(&req->uv_req.handle, req);
r = uv_tcp_connect(&req->uv_req.connect, &sock->uv_handle.tcp,
}
void
-isc_nm_tcpconnect(isc_nm_t *mgr, isc_sockaddr_t *local, isc_sockaddr_t *peer,
+isc_nm_tcpconnect(isc_sockaddr_t *local, isc_sockaddr_t *peer,
isc_nm_cb_t connect_cb, void *connect_cbarg,
unsigned int timeout) {
isc_result_t result = ISC_R_SUCCESS;
isc_nmsocket_t *sock = NULL;
isc__nm_uvreq_t *req = NULL;
sa_family_t sa_family;
- isc__networker_t *worker = NULL;
+ isc__networker_t *worker = isc__networker_current();
uv_os_sock_t fd = -1;
- REQUIRE(VALID_NM(mgr));
REQUIRE(local != NULL);
REQUIRE(peer != NULL);
- worker = &mgr->workers[isc_tid()];
-
if (isc__nm_closing(worker)) {
connect_cb(NULL, ISC_R_SHUTTINGDOWN, connect_cbarg);
return;
}
static uv_os_sock_t
-isc__nm_tcp_lb_socket(isc_nm_t *mgr, sa_family_t sa_family) {
+isc__nm_tcp_lb_socket(sa_family_t sa_family) {
isc_result_t result;
uv_os_sock_t sock;
result = isc__nm_socket_reuse(sock, 1);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
- if (mgr->load_balance_sockets) {
+ if (isc__netmgr->load_balance_sockets) {
result = isc__nm_socket_reuse_lb(sock);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
}
flags = UV_TCP_IPV6ONLY;
}
- if (sock->worker->netmgr->load_balance_sockets) {
+ if (isc__netmgr->load_balance_sockets) {
r = isc__nm_tcp_freebind(&sock->uv_handle.tcp,
&sock->iface.type.sa, flags);
if (r < 0) {
sock->uv_handle.tcp.flags = sock->parent->uv_handle.tcp.flags;
}
- isc__nm_set_network_buffers(sock->worker->netmgr,
- &sock->uv_handle.handle);
+ isc__nm_set_network_buffers(&sock->uv_handle.handle);
/*
* The callback will run in the same thread uv_listen() was called
}
static void
-start_tcp_child(isc_nm_t *mgr, isc_sockaddr_t *iface, isc_nmsocket_t *sock,
- uv_os_sock_t fd, isc_tid_t tid) {
+start_tcp_child(isc_sockaddr_t *iface, isc_nmsocket_t *sock, uv_os_sock_t fd,
+ isc_tid_t tid) {
isc_nmsocket_t *csock = &sock->children[tid];
- isc__networker_t *worker = &mgr->workers[tid];
+ isc__networker_t *worker = isc__networker_get(tid);
isc__nmsocket_init(csock, worker, isc_nm_tcpsocket, iface, sock);
csock->accept_cb = sock->accept_cb;
*/
csock->pquota = sock->pquota;
- if (mgr->load_balance_sockets) {
+ if (isc__netmgr->load_balance_sockets) {
UNUSED(fd);
- csock->fd = isc__nm_tcp_lb_socket(mgr,
- iface->type.sa.sa_family);
+ csock->fd = isc__nm_tcp_lb_socket(iface->type.sa.sa_family);
} else {
csock->fd = dup(fd);
}
}
isc_result_t
-isc_nm_listentcp(isc_nm_t *mgr, uint32_t workers, isc_sockaddr_t *iface,
+isc_nm_listentcp(uint32_t workers, isc_sockaddr_t *iface,
isc_nm_accept_cb_t accept_cb, void *accept_cbarg, int backlog,
isc_quota_t *quota, isc_nmsocket_t **sockp) {
isc_nmsocket_t *sock = NULL;
uv_os_sock_t fd = -1;
isc_result_t result = ISC_R_UNSET;
- isc__networker_t *worker = NULL;
+ isc__networker_t *worker = isc__networker_get(0);
- REQUIRE(VALID_NM(mgr));
REQUIRE(isc_tid() == 0);
if (workers == 0) {
- workers = mgr->nloops;
+ workers = isc__netmgr->nloops;
}
- REQUIRE(workers <= mgr->nloops);
+ REQUIRE(workers <= isc__netmgr->nloops);
- worker = &mgr->workers[0];
sock = isc_mempool_get(worker->nmsocket_pool);
isc__nmsocket_init(sock, worker, isc_nm_tcplistener, iface, NULL);
- sock->nchildren = (workers == ISC_NM_LISTEN_ALL) ? (uint32_t)mgr->nloops
- : workers;
+ sock->nchildren = (workers == ISC_NM_LISTEN_ALL)
+ ? (uint32_t)isc__netmgr->nloops
+ : workers;
sock->children = isc_mem_cget(worker->mctx, sock->nchildren,
sizeof(sock->children[0]));
sock->backlog = backlog;
sock->pquota = quota;
- if (!mgr->load_balance_sockets) {
- fd = isc__nm_tcp_lb_socket(mgr, iface->type.sa.sa_family);
+ if (!isc__netmgr->load_balance_sockets) {
+ fd = isc__nm_tcp_lb_socket(iface->type.sa.sa_family);
}
- start_tcp_child(mgr, iface, sock, fd, 0);
+ start_tcp_child(iface, sock, fd, 0);
result = sock->children[0].result;
INSIST(result != ISC_R_UNSET);
for (size_t i = 1; i < sock->nchildren; i++) {
- start_tcp_child(mgr, iface, sock, fd, i);
+ start_tcp_child(iface, sock, fd, i);
}
isc_barrier_wait(&sock->listen_barrier);
- if (!mgr->load_balance_sockets) {
+ if (!isc__netmgr->load_balance_sockets) {
isc__nm_closesocket(fd);
}
void
isc__nm_tcp_read(isc_nmhandle_t *handle, isc_nm_recv_cb_t cb, void *cbarg) {
isc_nmsocket_t *sock;
- isc_nm_t *netmgr;
isc_result_t result;
REQUIRE(VALID_NMHANDLE(handle));
REQUIRE(VALID_NMSOCK(handle->sock));
sock = handle->sock;
- netmgr = sock->worker->netmgr;
REQUIRE(sock->type == isc_nm_tcpsocket);
REQUIRE(sock->statichandle == handle);
if (sock->read_timeout == 0) {
sock->read_timeout =
sock->keepalive
- ? atomic_load_relaxed(&netmgr->keepalive)
- : atomic_load_relaxed(&netmgr->idle);
+ ? atomic_load_relaxed(&isc__netmgr->keepalive)
+ : atomic_load_relaxed(&isc__netmgr->idle);
}
if (isc__nmsocket_closing(sock)) {
isc__nm_tcp_read_cb(uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf) {
isc_nmsocket_t *sock = uv_handle_get_data((uv_handle_t *)stream);
isc__nm_uvreq_t *req = NULL;
- isc_nm_t *netmgr = NULL;
REQUIRE(VALID_NMSOCK(sock));
REQUIRE(sock->tid == isc_tid());
REQUIRE(buf != NULL);
- netmgr = sock->worker->netmgr;
-
if (isc__nmsocket_closing(sock)) {
isc__nm_tcp_failed_read_cb(sock, ISC_R_CANCELED, false);
goto free;
if (!sock->client) {
sock->read_timeout =
sock->keepalive
- ? atomic_load_relaxed(&netmgr->keepalive)
- : atomic_load_relaxed(&netmgr->idle);
+ ? atomic_load_relaxed(&isc__netmgr->keepalive)
+ : atomic_load_relaxed(&isc__netmgr->idle);
}
isc__nm_readcb(sock, req, ISC_R_SUCCESS, false);
csock->accept_cbarg = csock->server->accept_cbarg;
csock->recv_cb = csock->server->recv_cb;
csock->recv_cbarg = csock->server->recv_cbarg;
- csock->read_timeout = atomic_load_relaxed(&csock->worker->netmgr->init);
+ csock->read_timeout = atomic_load_relaxed(&isc__netmgr->init);
r = uv_tcp_init(&csock->worker->loop->loop, &csock->uv_handle.tcp);
UV_RUNTIME_CHECK(uv_tcp_init, r);
isc_nmsocket_t *sock = handle->sock;
isc_result_t result;
isc__nm_uvreq_t *uvreq = NULL;
- isc_nm_t *netmgr = sock->worker->netmgr;
REQUIRE(sock->type == isc_nm_tcpsocket);
REQUIRE(sock->tid == isc_tid());
if (sock->write_timeout == 0) {
sock->write_timeout =
sock->keepalive
- ? atomic_load_relaxed(&netmgr->keepalive)
- : atomic_load_relaxed(&netmgr->idle);
+ ? atomic_load_relaxed(&isc__netmgr->keepalive)
+ : atomic_load_relaxed(&isc__netmgr->idle);
}
result = tcp_send_direct(sock, uvreq);
isc__nmsocket_attach(handle->sock, &tlssock->listener);
isc_nmhandle_attach(handle, &tlssock->outerhandle);
tlssock->peer = isc_nmhandle_peeraddr(handle);
- tlssock->read_timeout =
- atomic_load_relaxed(&handle->sock->worker->netmgr->init);
+ tlssock->read_timeout = atomic_load_relaxed(&isc__netmgr->init);
/*
* Hold a reference to tlssock in the TCP socket: it will
}
isc_result_t
-isc_nm_listentls(isc_nm_t *mgr, uint32_t workers, isc_sockaddr_t *iface,
+isc_nm_listentls(uint32_t workers, isc_sockaddr_t *iface,
isc_nm_accept_cb_t accept_cb, void *accept_cbarg, int backlog,
isc_quota_t *quota, SSL_CTX *sslctx, bool proxy,
isc_nmsocket_t **sockp) {
isc_result_t result;
isc_nmsocket_t *tlssock = NULL;
isc_nmsocket_t *tsock = NULL;
- isc__networker_t *worker = NULL;
+ isc__networker_t *worker = isc__networker_current();
- REQUIRE(VALID_NM(mgr));
REQUIRE(isc_tid() == 0);
- worker = &mgr->workers[isc_tid()];
-
if (isc__nm_closing(worker)) {
return ISC_R_SHUTTINGDOWN;
}
if (workers == 0) {
- workers = mgr->nloops;
+ workers = isc__netmgr->nloops;
}
- REQUIRE(workers <= mgr->nloops);
+ REQUIRE(workers <= isc__netmgr->nloops);
tlssock = isc_mempool_get(worker->nmsocket_pool);
isc__nmsocket_init(tlssock, worker, isc_nm_tlslistener, iface, NULL);
*/
if (proxy) {
result = isc_nm_listenproxystream(
- mgr, workers, iface, tlslisten_acceptcb, tlssock,
- backlog, quota, NULL, &tlssock->outer);
+ workers, iface, tlslisten_acceptcb, tlssock, backlog,
+ quota, NULL, &tlssock->outer);
} else {
- result = isc_nm_listentcp(mgr, workers, iface,
- tlslisten_acceptcb, tlssock, backlog,
- quota, &tlssock->outer);
+ result = isc_nm_listentcp(workers, iface, tlslisten_acceptcb,
+ tlssock, backlog, quota,
+ &tlssock->outer);
}
if (result != ISC_R_SUCCESS) {
tlssock->closed = true;
tcp_connected(isc_nmhandle_t *handle, isc_result_t result, void *cbarg);
void
-isc_nm_tlsconnect(isc_nm_t *mgr, isc_sockaddr_t *local, isc_sockaddr_t *peer,
+isc_nm_tlsconnect(isc_sockaddr_t *local, isc_sockaddr_t *peer,
isc_nm_cb_t connect_cb, void *connect_cbarg,
isc_tlsctx_t *ctx, const char *sni_hostname,
isc_tlsctx_client_session_cache_t *client_sess_cache,
unsigned int timeout, bool proxy,
isc_nm_proxyheader_info_t *proxy_info) {
isc_nmsocket_t *sock = NULL;
- isc__networker_t *worker = NULL;
-
- REQUIRE(VALID_NM(mgr));
-
- worker = &mgr->workers[isc_tid()];
+ isc__networker_t *worker = isc__networker_current();
if (isc__nm_closing(worker)) {
connect_cb(NULL, ISC_R_SHUTTINGDOWN, connect_cbarg);
}
if (proxy) {
- isc_nm_proxystreamconnect(mgr, local, peer, tcp_connected, sock,
+ isc_nm_proxystreamconnect(local, peer, tcp_connected, sock,
sock->connect_timeout, NULL, NULL,
NULL, proxy_info);
} else {
- isc_nm_tcpconnect(mgr, local, peer, tcp_connected, sock,
+ isc_nm_tcpconnect(local, peer, tcp_connected, sock,
sock->connect_timeout);
}
}
udp_close_cb(uv_handle_t *handle);
static uv_os_sock_t
-isc__nm_udp_lb_socket(isc_nm_t *mgr, sa_family_t sa_family) {
+isc__nm_udp_lb_socket(sa_family_t sa_family) {
isc_result_t result;
uv_os_sock_t sock = -1;
result = isc__nm_socket_reuse(sock, 1);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
- if (mgr->load_balance_sockets) {
+ if (isc__netmgr->load_balance_sockets) {
result = isc__nm_socket_reuse_lb(sock);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
}
int uv_init_flags = 0;
sa_family_t sa_family = sock->iface.type.sa.sa_family;
isc_result_t result = ISC_R_UNSET;
- isc_nm_t *mgr = sock->worker->netmgr;
isc_loop_t *loop = sock->worker->loop;
(void)isc__nm_socket_min_mtu(sock->fd, sa_family);
uv_bind_flags |= UV_UDP_IPV6ONLY;
}
- if (mgr->load_balance_sockets) {
+ if (isc__netmgr->load_balance_sockets) {
r = isc__nm_udp_freebind(&sock->uv_handle.udp,
&sock->parent->iface.type.sa,
uv_bind_flags);
sock->uv_handle.udp.flags = sock->parent->uv_handle.udp.flags;
}
- isc__nm_set_network_buffers(mgr, &sock->uv_handle.handle);
+ isc__nm_set_network_buffers(&sock->uv_handle.handle);
r = uv_udp_recv_start(&sock->uv_handle.udp, isc__nm_alloc_cb,
isc__nm_udp_read_cb);
}
static void
-start_udp_child(isc_nm_t *mgr, isc_sockaddr_t *iface, isc_nmsocket_t *sock,
- uv_os_sock_t fd, isc_tid_t tid) {
- isc__networker_t *worker = &mgr->workers[tid];
+start_udp_child(isc_sockaddr_t *iface, isc_nmsocket_t *sock, uv_os_sock_t fd,
+ isc_tid_t tid) {
+ isc__networker_t *worker = isc__networker_get(tid);
isc_nmsocket_t *csock = &sock->children[tid];
isc__nmsocket_init(csock, worker, isc_nm_udpsocket, iface, sock);
csock->recv_cbarg = sock->recv_cbarg;
csock->inactive_handles_max = ISC_NM_NMHANDLES_MAX;
- if (mgr->load_balance_sockets) {
- csock->fd = isc__nm_udp_lb_socket(mgr,
- iface->type.sa.sa_family);
+ if (isc__netmgr->load_balance_sockets) {
+ csock->fd = isc__nm_udp_lb_socket(iface->type.sa.sa_family);
} else {
csock->fd = dup(fd);
}
}
isc_result_t
-isc_nm_listenudp(isc_nm_t *mgr, uint32_t workers, isc_sockaddr_t *iface,
- isc_nm_recv_cb_t cb, void *cbarg, isc_nmsocket_t **sockp) {
+isc_nm_listenudp(uint32_t workers, isc_sockaddr_t *iface, isc_nm_recv_cb_t cb,
+ void *cbarg, isc_nmsocket_t **sockp) {
isc_result_t result = ISC_R_UNSET;
isc_nmsocket_t *sock = NULL;
uv_os_sock_t fd = -1;
- isc__networker_t *worker = NULL;
+ isc__networker_t *worker = isc__networker_get(0);
- REQUIRE(VALID_NM(mgr));
REQUIRE(isc_tid() == 0);
- worker = &mgr->workers[0];
-
if (isc__nm_closing(worker)) {
return ISC_R_SHUTTINGDOWN;
}
if (workers == 0) {
- workers = mgr->nloops;
+ workers = isc__netmgr->nloops;
}
- REQUIRE(workers <= mgr->nloops);
+ REQUIRE(workers <= isc__netmgr->nloops);
sock = isc_mempool_get(worker->nmsocket_pool);
isc__nmsocket_init(sock, worker, isc_nm_udplistener, iface, NULL);
- sock->nchildren = (workers == ISC_NM_LISTEN_ALL) ? (uint32_t)mgr->nloops
- : workers;
+ sock->nchildren = (workers == ISC_NM_LISTEN_ALL)
+ ? (uint32_t)isc__netmgr->nloops
+ : workers;
sock->children = isc_mem_cget(worker->mctx, sock->nchildren,
sizeof(sock->children[0]));
sock->recv_cb = cb;
sock->recv_cbarg = cbarg;
- if (!mgr->load_balance_sockets) {
- fd = isc__nm_udp_lb_socket(mgr, iface->type.sa.sa_family);
+ if (!isc__netmgr->load_balance_sockets) {
+ fd = isc__nm_udp_lb_socket(iface->type.sa.sa_family);
}
- start_udp_child(mgr, iface, sock, fd, 0);
+ start_udp_child(iface, sock, fd, 0);
result = sock->children[0].result;
INSIST(result != ISC_R_UNSET);
for (size_t i = 1; i < sock->nchildren; i++) {
- start_udp_child(mgr, iface, sock, fd, i);
+ start_udp_child(iface, sock, fd, i);
}
isc_barrier_wait(&sock->listen_barrier);
- if (!mgr->load_balance_sockets) {
+ if (!isc__netmgr->load_balance_sockets) {
isc__nm_closesocket(fd);
}
return isc_uverr2result(r);
}
- isc__nm_set_network_buffers(sock->worker->netmgr,
- &sock->uv_handle.handle);
+ isc__nm_set_network_buffers(&sock->uv_handle.handle);
sock->connecting = false;
sock->connected = true;
#endif /* USE_ROUTE_SOCKET */
isc_result_t
-isc_nm_routeconnect(isc_nm_t *mgr, isc_nm_cb_t cb, void *cbarg) {
+isc_nm_routeconnect(isc_nm_cb_t cb, void *cbarg) {
#ifdef USE_ROUTE_SOCKET
isc_result_t result = ISC_R_SUCCESS;
isc_nmsocket_t *sock = NULL;
isc__nm_uvreq_t *req = NULL;
- isc__networker_t *worker = NULL;
+ isc__networker_t *worker = isc__networker_current();
uv_os_sock_t fd = -1;
- REQUIRE(VALID_NM(mgr));
REQUIRE(isc_tid() == 0);
- worker = &mgr->workers[isc_tid()];
-
if (isc__nm_closing(worker)) {
return ISC_R_SHUTTINGDOWN;
}
* - If we're simulating a firewall blocking UDP packets
* bigger than 'maxudp' bytes for testing purposes.
*/
- maxudp = atomic_load_relaxed(&sock->worker->netmgr->maxudp);
+ maxudp = atomic_load_relaxed(&isc__netmgr->maxudp);
if (maxudp != 0 && (uint32_t)nrecv > maxudp) {
/*
* We need to keep the read_cb intact in case, so the
REQUIRE(sock->tid == isc_tid());
worker = sock->worker;
- maxudp = atomic_load(&worker->netmgr->maxudp);
+ maxudp = atomic_load(&isc__netmgr->maxudp);
sa = sock->connected ? NULL : &peer->type.sa;
/*
if (r < 0) {
if (can_log_udp_sends()) {
isc__netmgr_log(
- worker->netmgr, ISC_LOG_ERROR,
+ ISC_LOG_ERROR,
"Sending UDP messages failed: %s",
isc_result_totext(isc_uverr2result(r)));
}
return isc_uverr2result(r);
}
- isc__nm_set_network_buffers(sock->worker->netmgr,
- &sock->uv_handle.handle);
+ isc__nm_set_network_buffers(&sock->uv_handle.handle);
/*
* On FreeBSD the UDP connect() call sometimes results in a
}
void
-isc_nm_udpconnect(isc_nm_t *mgr, isc_sockaddr_t *local, isc_sockaddr_t *peer,
- isc_nm_cb_t cb, void *cbarg, unsigned int timeout) {
+isc_nm_udpconnect(isc_sockaddr_t *local, isc_sockaddr_t *peer, isc_nm_cb_t cb,
+ void *cbarg, unsigned int timeout) {
isc_result_t result = ISC_R_SUCCESS;
isc_nmsocket_t *sock = NULL;
isc__nm_uvreq_t *req = NULL;
sa_family_t sa_family;
- isc__networker_t *worker = NULL;
+ isc__networker_t *worker = isc__networker_current();
uv_os_sock_t fd = -1;
- REQUIRE(VALID_NM(mgr));
REQUIRE(local != NULL);
REQUIRE(peer != NULL);
- worker = &mgr->workers[isc_tid()];
-
if (isc__nm_closing(worker)) {
cb(NULL, ISC_R_SHUTTINGDOWN, cbarg);
return;
}
if (TCP_CLIENT(client) && USEKEEPALIVE(client)) {
isc_buffer_t buf;
- uint32_t advertised_timeout = isc_nm_getadvertisedtimeout(
- isc_nmhandle_netmgr(client->inner.handle));
+ uint32_t advertised_timeout = isc_nm_getadvertisedtimeout();
INSIST(count < DNS_EDNSOPTIONS);
***/
isc_result_t
-ns_interfacemgr_create(isc_mem_t *mctx, ns_server_t *sctx, isc_nm_t *nm,
+ns_interfacemgr_create(isc_mem_t *mctx, ns_server_t *sctx,
dns_dispatchmgr_t *dispatchmgr,
dns_geoip_databases_t *geoip, ns_interfacemgr_t **mgrp);
/*%<
isc_mutex_t lock;
isc_mem_t *mctx; /*%< Memory context */
ns_server_t *sctx; /*%< Server context */
- isc_nm_t *nm; /*%< Net manager */
uint32_t ncpus; /*%< Number of workers */
dns_dispatchmgr_t *dispatchmgr;
unsigned int generation; /*%< Current generation no */
}
isc_result_t
-ns_interfacemgr_create(isc_mem_t *mctx, ns_server_t *sctx, isc_nm_t *nm,
+ns_interfacemgr_create(isc_mem_t *mctx, ns_server_t *sctx,
dns_dispatchmgr_t *dispatchmgr,
dns_geoip_databases_t *geoip, ns_interfacemgr_t **mgrp) {
isc_result_t result;
mgr = isc_mem_get(mctx, sizeof(*mgr));
*mgr = (ns_interfacemgr_t){
- .nm = nm,
.dispatchmgr = dispatchmgr,
.generation = 1,
.ncpus = isc_loopmgr_nloops(),
ns_interfacemgr_ref(mgr);
- isc_result_t result = isc_nm_routeconnect(mgr->nm, route_connected,
- mgr);
+ isc_result_t result = isc_nm_routeconnect(route_connected, mgr);
if (result != ISC_R_SUCCESS) {
isc_log_write(NS_LOGCATEGORY_NETWORK, NS_LOGMODULE_INTERFACEMGR,
ISC_LOG_INFO, "unable to open route socket: %s",
/* Reserve space for an ns_client_t with the netmgr handle */
if (proxy == ISC_NM_PROXY_NONE) {
- result = isc_nm_listenudp(ifp->mgr->nm, ISC_NM_LISTEN_ALL,
- &ifp->addr, ns_client_request, ifp,
+ result = isc_nm_listenudp(ISC_NM_LISTEN_ALL, &ifp->addr,
+ ns_client_request, ifp,
&ifp->udplistensocket);
} else {
INSIST(proxy == ISC_NM_PROXY_PLAIN);
- result = isc_nm_listenproxyudp(ifp->mgr->nm, ISC_NM_LISTEN_ALL,
- &ifp->addr, ns_client_request,
- ifp, &ifp->udplistensocket);
+ result = isc_nm_listenproxyudp(ISC_NM_LISTEN_ALL, &ifp->addr,
+ ns_client_request, ifp,
+ &ifp->udplistensocket);
}
return result;
}
isc_result_t result;
result = isc_nm_listenstreamdns(
- ifp->mgr->nm, ISC_NM_LISTEN_ALL, &ifp->addr, ns_client_request,
- ifp, ns__client_tcpconn, ifp, ifp->mgr->backlog,
+ ISC_NM_LISTEN_ALL, &ifp->addr, ns_client_request, ifp,
+ ns__client_tcpconn, ifp, ifp->mgr->backlog,
&ifp->mgr->sctx->tcpquota, NULL, proxy, &ifp->tcplistensocket);
if (result != ISC_R_SUCCESS) {
isc_log_write(NS_LOGCATEGORY_NETWORK, NS_LOGMODULE_INTERFACEMGR,
isc_result_t result;
result = isc_nm_listenstreamdns(
- ifp->mgr->nm, ISC_NM_LISTEN_ALL, &ifp->addr, ns_client_request,
- ifp, ns__client_tcpconn, ifp, ifp->mgr->backlog,
+ ISC_NM_LISTEN_ALL, &ifp->addr, ns_client_request, ifp,
+ ns__client_tcpconn, ifp, ifp->mgr->backlog,
&ifp->mgr->sctx->tcpquota, sslctx, proxy,
&ifp->tlslistensocket);
quota = isc_mem_get(ifp->mgr->mctx, sizeof(*quota));
isc_quota_init(quota, max_clients);
result = isc_nm_listenhttp(
- ifp->mgr->nm, ISC_NM_LISTEN_ALL, &ifp->addr,
- ifp->mgr->backlog, quota, sslctx, epset,
- max_concurrent_streams, proxy, &sock);
+ ISC_NM_LISTEN_ALL, &ifp->addr, ifp->mgr->backlog, quota,
+ sslctx, epset, max_concurrent_streams, proxy, &sock);
}
isc_nm_http_endpoints_detach(&epset);
static isc_nmsocket_t *sock = NULL;
-static isc_nm_t *connect_nm = NULL;
-
const struct in6_addr in6addr_blackhole = { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1 } } };
setup_netmgr(state);
- isc_netmgr_create(mctx, &connect_nm);
-
udp_connect_addr = (isc_sockaddr_t){ .length = 0 };
isc_sockaddr_fromin6(&udp_connect_addr, &in6addr_loopback, 0);
}
close(socket);
- isc_nm_setinitialtimeout(netmgr, T_SERVER_INIT);
- isc_nm_setprimariestimeout(netmgr, T_SERVER_PRIMARIES);
- isc_nm_setidletimeout(netmgr, T_SERVER_IDLE);
- isc_nm_setkeepalivetimeout(netmgr, T_SERVER_KEEPALIVE);
- isc_nm_setadvertisedtimeout(netmgr, T_SERVER_ADVERTISED);
+ isc_nm_setinitialtimeout(T_SERVER_INIT);
+ isc_nm_setprimariestimeout(T_SERVER_PRIMARIES);
+ isc_nm_setidletimeout(T_SERVER_IDLE);
+ isc_nm_setkeepalivetimeout(T_SERVER_KEEPALIVE);
+ isc_nm_setadvertisedtimeout(T_SERVER_ADVERTISED);
+
+ /*
+ * FIXME: This is not going to work now.
+ */
/*
* Use shorter client-side timeouts, to ensure that clients
* time out before the server.
*/
- isc_nm_setinitialtimeout(connect_nm, T_CLIENT_INIT);
- isc_nm_setprimariestimeout(connect_nm, T_CLIENT_PRIMARIES);
- isc_nm_setidletimeout(connect_nm, T_CLIENT_IDLE);
- isc_nm_setkeepalivetimeout(connect_nm, T_CLIENT_KEEPALIVE);
- isc_nm_setadvertisedtimeout(connect_nm, T_CLIENT_ADVERTISED);
+ isc_nm_setinitialtimeout(T_CLIENT_INIT);
+ isc_nm_setprimariestimeout(T_CLIENT_PRIMARIES);
+ isc_nm_setidletimeout(T_CLIENT_IDLE);
+ isc_nm_setkeepalivetimeout(T_CLIENT_KEEPALIVE);
+ isc_nm_setadvertisedtimeout(T_CLIENT_ADVERTISED);
memset(testdata.rbuf, 0, sizeof(testdata.rbuf));
testdata.region.base = testdata.rbuf;
isc_tlsctx_cache_detach(&tls_tlsctx_client_cache);
isc_tlsctx_free(&tls_listen_tlsctx);
- isc_nm_detach(&connect_nm);
-
teardown_netmgr(state);
teardown_loopmgr(state);
UNUSED(arg);
- result = dns_dispatchmgr_create(mctx, connect_nm, &dispatchmgr);
+ result = dns_dispatchmgr_create(mctx, &dispatchmgr);
assert_int_equal(result, ISC_R_SUCCESS);
result = make_dispatchset(dispatchmgr, 1, &dset);
UNUSED(arg);
- result = dns_dispatchmgr_create(mctx, connect_nm, &dispatchmgr);
+ result = dns_dispatchmgr_create(mctx, &dispatchmgr);
assert_int_equal(result, ISC_R_SUCCESS);
result = make_dispatchset(dispatchmgr, 1, &dset);
testdata.region.base = testdata.message;
testdata.region.length = sizeof(testdata.message);
- result = dns_dispatchmgr_create(mctx, connect_nm, &test->dispatchmgr);
+ result = dns_dispatchmgr_create(mctx, &test->dispatchmgr);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_dispatch_createtcp(test->dispatchmgr, &tcp_connect_addr,
/* Server */
result = isc_nm_listenstreamdns(
- netmgr, ISC_NM_LISTEN_ONE, &tcp_server_addr, noop_nameserver,
- NULL, accept_cb, NULL, 0, NULL, NULL, ISC_NM_PROXY_NONE, &sock);
+ ISC_NM_LISTEN_ONE, &tcp_server_addr, noop_nameserver, NULL,
+ accept_cb, NULL, 0, NULL, NULL, ISC_NM_PROXY_NONE, &sock);
assert_int_equal(result, ISC_R_SUCCESS);
/* ensure we stop listening after the test is done */
isc_loop_teardown(isc_loop_main(), stop_listening, sock);
/* Client */
- result = dns_dispatchmgr_create(mctx, connect_nm, &test->dispatchmgr);
+ result = dns_dispatchmgr_create(mctx, &test->dispatchmgr);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_dispatch_createtcp(test->dispatchmgr, &tcp_connect_addr,
*test = (test_dispatch_t){ 0 };
/* Server */
- result = isc_nm_listenstreamdns(
- netmgr, ISC_NM_LISTEN_ONE, &tcp_server_addr, nameserver, NULL,
- accept_cb, NULL, 0, NULL, NULL, ISC_NM_PROXY_NONE, &sock);
+ result = isc_nm_listenstreamdns(ISC_NM_LISTEN_ONE, &tcp_server_addr,
+ nameserver, NULL, accept_cb, NULL, 0,
+ NULL, NULL, ISC_NM_PROXY_NONE, &sock);
assert_int_equal(result, ISC_R_SUCCESS);
isc_loop_teardown(isc_loop_main(), stop_listening, sock);
testdata.region.base = testdata.message;
testdata.region.length = sizeof(testdata.message);
- result = dns_dispatchmgr_create(mctx, connect_nm, &test->dispatchmgr);
+ result = dns_dispatchmgr_create(mctx, &test->dispatchmgr);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_dispatch_createtcp(test->dispatchmgr, &tcp_connect_addr,
*test = (test_dispatch_t){ 0 };
/* Server */
- result = isc_nm_listenstreamdns(
- netmgr, ISC_NM_LISTEN_ONE, &tls_server_addr, nameserver, NULL,
- accept_cb, NULL, 0, NULL, tls_listen_tlsctx, ISC_NM_PROXY_NONE,
- &sock);
+ result = isc_nm_listenstreamdns(ISC_NM_LISTEN_ONE, &tls_server_addr,
+ nameserver, NULL, accept_cb, NULL, 0,
+ NULL, tls_listen_tlsctx,
+ ISC_NM_PROXY_NONE, &sock);
assert_int_equal(result, ISC_R_SUCCESS);
isc_loop_teardown(isc_loop_main(), stop_listening, sock);
testdata.region.base = testdata.message;
testdata.region.length = sizeof(testdata.message);
- result = dns_dispatchmgr_create(mctx, connect_nm, &test->dispatchmgr);
+ result = dns_dispatchmgr_create(mctx, &test->dispatchmgr);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_dispatch_createtcp(test->dispatchmgr, &tls_connect_addr,
*test = (test_dispatch_t){ 0 };
/* Server */
- result = isc_nm_listenudp(netmgr, ISC_NM_LISTEN_ONE, &udp_server_addr,
+ result = isc_nm_listenudp(ISC_NM_LISTEN_ONE, &udp_server_addr,
noop_nameserver, NULL, &sock);
assert_int_equal(result, ISC_R_SUCCESS);
isc_loop_teardown(isc_loop_main(), stop_listening, sock);
/* Client */
- result = dns_dispatchmgr_create(mctx, connect_nm, &test->dispatchmgr);
+ result = dns_dispatchmgr_create(mctx, &test->dispatchmgr);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_dispatch_createudp(test->dispatchmgr, &udp_connect_addr,
*test = (test_dispatch_t){ 0 };
/* Server */
- result = isc_nm_listenudp(netmgr, ISC_NM_LISTEN_ONE, &udp_server_addr,
+ result = isc_nm_listenudp(ISC_NM_LISTEN_ONE, &udp_server_addr,
nameserver, NULL, &sock);
assert_int_equal(result, ISC_R_SUCCESS);
testdata.region.base = testdata.message;
testdata.region.length = sizeof(testdata.message);
- result = dns_dispatchmgr_create(mctx, connect_nm, &test->dispatchmgr);
+ result = dns_dispatchmgr_create(mctx, &test->dispatchmgr);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_dispatch_createudp(test->dispatchmgr, &udp_connect_addr,
*test = (test_dispatch_t){ 0 };
/* Server */
- result = isc_nm_listenstreamdns(
- netmgr, ISC_NM_LISTEN_ONE, &tcp_server_addr, nameserver, NULL,
- accept_cb, NULL, 0, NULL, NULL, ISC_NM_PROXY_NONE, &sock);
+ result = isc_nm_listenstreamdns(ISC_NM_LISTEN_ONE, &tcp_server_addr,
+ nameserver, NULL, accept_cb, NULL, 0,
+ NULL, NULL, ISC_NM_PROXY_NONE, &sock);
assert_int_equal(result, ISC_R_SUCCESS);
/* ensure we stop listening after the test is done */
isc_loop_teardown(isc_loop_main(), stop_listening, sock);
- result = dns_dispatchmgr_create(mctx, connect_nm, &test->dispatchmgr);
+ result = dns_dispatchmgr_create(mctx, &test->dispatchmgr);
assert_int_equal(result, ISC_R_SUCCESS);
/* Client */
*test = (test_dispatch_t){ 0 };
/* Server */
- result = isc_nm_listenstreamdns(
- netmgr, ISC_NM_LISTEN_ONE, &tcp_server_addr, nameserver, NULL,
- accept_cb, NULL, 0, NULL, NULL, ISC_NM_PROXY_NONE, &sock);
+ result = isc_nm_listenstreamdns(ISC_NM_LISTEN_ONE, &tcp_server_addr,
+ nameserver, NULL, accept_cb, NULL, 0,
+ NULL, NULL, ISC_NM_PROXY_NONE, &sock);
assert_int_equal(result, ISC_R_SUCCESS);
/* ensure we stop listening after the test is done */
isc_loop_teardown(isc_loop_main(), stop_listening, sock);
/* Client - unshared */
- result = dns_dispatchmgr_create(mctx, connect_nm, &test->dispatchmgr);
+ result = dns_dispatchmgr_create(mctx, &test->dispatchmgr);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_dispatch_createtcp(
isc_result_t result;
isc_tlsctx_cache_create(mctx, &tlsctx_cache);
- result = dns_resolver_create(view, netmgr, 0, tlsctx_cache, dispatch,
- NULL, resolverp);
+ result = dns_resolver_create(view, 0, tlsctx_cache, dispatch, NULL,
+ resolverp);
assert_int_equal(result, ISC_R_SUCCESS);
}
UNUSED(arg);
- dns_zonemgr_create(mctx, netmgr, &myzonemgr);
+ dns_zonemgr_create(mctx, &myzonemgr);
dns_zonemgr_shutdown(myzonemgr);
dns_zonemgr_detach(&myzonemgr);
UNUSED(arg);
- dns_zonemgr_create(mctx, netmgr, &myzonemgr);
+ dns_zonemgr_create(mctx, &myzonemgr);
result = dns_test_makezone("foo", &zone, NULL, false);
assert_int_equal(result, ISC_R_SUCCESS);
UNUSED(arg);
- dns_zonemgr_create(mctx, netmgr, &myzonemgr);
+ dns_zonemgr_create(mctx, &myzonemgr);
result = dns_zonemgr_createzone(myzonemgr, &zone);
assert_int_equal(result, ISC_R_SUCCESS);
#include <isc/uv.h>
extern isc_mem_t *mctx;
-extern isc_nm_t *netmgr;
extern int ncpus;
extern unsigned int workers;
extern bool debug;
#include <tests/isc.h>
-#define MAX_NM 2
-
static isc_sockaddr_t tcp_listen_addr;
static uint64_t send_magic = 0;
static atomic_bool use_PROXY = false;
static atomic_bool use_PROXY_over_TLS = false;
-static isc_nm_t **nm = NULL;
-
/* Timeout for soft-timeout tests (0.05 seconds) */
#define T_SOFT 50
#define T_CONNECT 30 * 1000
}
static void
-connect_send_request(isc_nm_t *mgr, const char *uri, bool post,
- isc_region_t *region, isc_nm_recv_cb_t cb, void *cbarg,
- bool tls, unsigned int timeout) {
+connect_send_request(const char *uri, bool post, isc_region_t *region,
+ isc_nm_recv_cb_t cb, void *cbarg, bool tls,
+ unsigned int timeout) {
isc_region_t copy;
csdata_t *data = NULL;
isc_tlsctx_t *ctx = NULL;
- copy = (isc_region_t){ .base = isc_mem_get(mgr->mctx, region->length),
+ copy = (isc_region_t){ .base = isc_mem_get(mctx, region->length),
.length = region->length };
memmove(copy.base, region->base, region->length);
- data = isc_mem_get(mgr->mctx, sizeof(*data));
+ data = isc_mem_get(mctx, sizeof(*data));
*data = (csdata_t){ .reply_cb = cb, .cb_arg = cbarg, .region = copy };
- isc_mem_attach(mgr->mctx, &data->mctx);
+ isc_mem_attach(mctx, &data->mctx);
if (tls) {
ctx = client_tlsctx;
}
- isc_nm_httpconnect(mgr, NULL, &tcp_listen_addr, uri, post,
- connect_send_cb, data, ctx, NULL, client_sess_cache,
- timeout, get_proxy_type(), NULL);
+ isc_nm_httpconnect(NULL, &tcp_listen_addr, uri, post, connect_send_cb,
+ data, ctx, NULL, client_sess_cache, timeout,
+ get_proxy_type(), NULL);
}
static int
}
setup_loopmgr(state);
-
- nm = isc_mem_cget(mctx, MAX_NM, sizeof(nm[0]));
- for (size_t i = 0; i < MAX_NM; i++) {
- isc_netmgr_create(mctx, &nm[i]);
- assert_non_null(nm[i]);
- }
+ setup_netmgr(state);
server_tlsctx = NULL;
isc_tlsctx_createserver(NULL, NULL, &server_tlsctx);
INSIST(endpoints == NULL);
endpoints = isc_nm_http_endpoints_new(mctx);
- *state = nm;
-
return 0;
}
static int
teardown_test(void **state ISC_ATTR_UNUSED) {
- for (size_t i = 0; i < MAX_NM; i++) {
- isc_nm_detach(&nm[i]);
- assert_null(nm[i]);
- }
- isc_mem_cput(mctx, nm, MAX_NM, sizeof(nm[0]));
-
+ teardown_netmgr(state);
teardown_loopmgr(state);
if (server_tlsctx != NULL) {
}
ISC_LOOP_TEST_IMPL(mock_doh_uv_tcp_bind) {
- isc_nm_t *listen_nm = nm[0];
isc_result_t result = ISC_R_SUCCESS;
isc_nmsocket_t *listen_sock = NULL;
result = isc_nm_http_endpoints_add(endpoints, ISC_NM_HTTP_DEFAULT_PATH,
noop_read_cb, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
- result = isc_nm_listenhttp(listen_nm, ISC_NM_LISTEN_ALL,
- &tcp_listen_addr, 0, NULL, NULL, endpoints,
- 0, false, &listen_sock);
+ result = isc_nm_listenhttp(ISC_NM_LISTEN_ALL, &tcp_listen_addr, 0, NULL,
+ NULL, endpoints, 0, false, &listen_sock);
assert_int_not_equal(result, ISC_R_SUCCESS);
assert_null(listen_sock);
static void
doh_noop(void *arg ISC_ATTR_UNUSED) {
- isc_nm_t *listen_nm = nm[0];
- isc_nm_t *connect_nm = nm[1];
isc_result_t result = ISC_R_SUCCESS;
isc_nmsocket_t *listen_sock = NULL;
char req_url[256];
noop_read_cb, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
- result = isc_nm_listenhttp(listen_nm, ISC_NM_LISTEN_ALL,
- &tcp_listen_addr, 0, NULL, NULL, endpoints,
- 0, get_proxy_type(), &listen_sock);
+ result = isc_nm_listenhttp(ISC_NM_LISTEN_ALL, &tcp_listen_addr, 0, NULL,
+ NULL, endpoints, 0, get_proxy_type(),
+ &listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
isc_loop_teardown(isc_loop_main(), listen_sock_close, listen_sock);
sockaddr_to_url(&tcp_listen_addr, false, req_url, sizeof(req_url),
ISC_NM_HTTP_DEFAULT_PATH);
- connect_send_request(connect_nm, req_url, atomic_load(&POST),
+ connect_send_request(req_url, atomic_load(&POST),
&(isc_region_t){ .base = (uint8_t *)send_msg.base,
.length = send_msg.len },
noop_read_cb, NULL, atomic_load(&use_TLS), 30000);
static void
doh_noresponse(void *arg ISC_ATTR_UNUSED) {
- isc_nm_t *listen_nm = nm[0];
- isc_nm_t *connect_nm = nm[1];
isc_result_t result = ISC_R_SUCCESS;
isc_nmsocket_t *listen_sock = NULL;
char req_url[256];
noop_read_cb, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
- result = isc_nm_listenhttp(listen_nm, ISC_NM_LISTEN_ALL,
- &tcp_listen_addr, 0, NULL, NULL, endpoints,
- 0, get_proxy_type(), &listen_sock);
+ result = isc_nm_listenhttp(ISC_NM_LISTEN_ALL, &tcp_listen_addr, 0, NULL,
+ NULL, endpoints, 0, get_proxy_type(),
+ &listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
isc_loop_teardown(isc_loop_main(), listen_sock_close, listen_sock);
sockaddr_to_url(&tcp_listen_addr, false, req_url, sizeof(req_url),
ISC_NM_HTTP_DEFAULT_PATH);
- connect_send_request(connect_nm, req_url, atomic_load(&POST),
+ connect_send_request(req_url, atomic_load(&POST),
&(isc_region_t){ .base = (uint8_t *)send_msg.base,
.length = send_msg.len },
noop_read_cb, NULL, atomic_load(&use_TLS), 30000);
timeout_query_sent_cb, arg);
isc_nmhandle_attach(handle, &readhandle);
+ isc_nmhandle_settimeout(handle, T_SOFT);
isc_nm_read(handle, timeout_retry_cb, NULL);
}
static void
doh_timeout_recovery(void *arg ISC_ATTR_UNUSED) {
- isc_nm_t *listen_nm = nm[0];
isc_nmsocket_t *listen_sock = NULL;
- isc_nm_t *connect_nm = nm[1];
isc_result_t result = ISC_R_SUCCESS;
isc_tlsctx_t *ctx = atomic_load(&use_TLS) ? server_tlsctx : NULL;
char req_url[256];
doh_receive_request_cb, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
- result = isc_nm_listenhttp(listen_nm, ISC_NM_LISTEN_ALL,
- &tcp_listen_addr, 0, NULL, NULL, endpoints,
- 0, get_proxy_type(), &listen_sock);
+ result = isc_nm_listenhttp(ISC_NM_LISTEN_ALL, &tcp_listen_addr, 0, NULL,
+ NULL, endpoints, 0, get_proxy_type(),
+ &listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
isc_loop_teardown(isc_loop_main(), listen_sock_close, listen_sock);
noanswer = true;
/*
- * Shorten all the TCP client timeouts to 0.05 seconds.
* timeout_retry_cb() will give up after five timeouts.
*/
- isc_nm_setinitialtimeout(connect_nm, T_SOFT);
- isc_nm_setprimariestimeout(connect_nm, T_SOFT);
- isc_nm_setidletimeout(connect_nm, T_SOFT);
- isc_nm_setkeepalivetimeout(connect_nm, T_SOFT);
- isc_nm_setadvertisedtimeout(connect_nm, T_SOFT);
sockaddr_to_url(&tcp_listen_addr, false, req_url, sizeof(req_url),
ISC_NM_HTTP_DEFAULT_PATH);
- isc_nm_httpconnect(connect_nm, NULL, &tcp_listen_addr, req_url,
- atomic_load(&POST), timeout_request_cb, NULL, ctx,
- NULL, client_sess_cache, T_CONNECT, get_proxy_type(),
+ isc_nm_httpconnect(NULL, &tcp_listen_addr, req_url, atomic_load(&POST),
+ timeout_request_cb, NULL, ctx, NULL,
+ client_sess_cache, T_CONNECT, get_proxy_type(),
NULL);
}
static void
doh_receive_send_reply_cb(isc_nmhandle_t *handle, isc_result_t eresult,
- isc_region_t *region, void *cbarg) {
- isc_nm_t *connect_nm = (isc_nm_t *)cbarg;
-
+ isc_region_t *region, void *cbarg ISC_ATTR_UNUSED) {
if (eresult != ISC_R_SUCCESS) {
return;
}
int_fast64_t sends = atomic_fetch_sub(&nsends, 1);
atomic_fetch_add(&csends, 1);
atomic_fetch_add(&creads, 1);
- if (sends > 0 && connect_nm != NULL) {
+ if (sends > 0) {
size_t i;
for (i = 0; i < NWRITES / 2; i++) {
eresult = isc__nm_http_request(
assert_true(eresult == ISC_R_SUCCESS);
}
- isc_async_current(doh_connect_thread, connect_nm);
+ isc_async_current(doh_connect_thread, NULL);
}
if (sends <= 0) {
isc_loopmgr_shutdown();
}
static void
-doh_connect_thread(void *arg) {
- isc_nm_t *connect_nm = (isc_nm_t *)arg;
+doh_connect_thread(void *arg ISC_ATTR_UNUSED) {
char req_url[256];
int64_t sends = atomic_load(&nsends);
atomic_fetch_sub(&active_cconnects, 1);
return;
}
- connect_send_request(connect_nm, req_url, atomic_load(&POST),
+ connect_send_request(req_url, atomic_load(&POST),
&(isc_region_t){ .base = (uint8_t *)send_msg.base,
.length = send_msg.len },
- doh_receive_send_reply_cb, connect_nm,
+ doh_receive_send_reply_cb, NULL,
atomic_load(&use_TLS), 30000);
if (sends <= 0) {
static void
doh_recv_one(void *arg ISC_ATTR_UNUSED) {
- isc_nm_t *listen_nm = nm[0];
- isc_nm_t *connect_nm = nm[1];
isc_result_t result = ISC_R_SUCCESS;
isc_nmsocket_t *listen_sock = NULL;
char req_url[256];
assert_int_equal(result, ISC_R_SUCCESS);
result = isc_nm_listenhttp(
- listen_nm, ISC_NM_LISTEN_ALL, &tcp_listen_addr, 0, quotap,
+ ISC_NM_LISTEN_ALL, &tcp_listen_addr, 0, quotap,
atomic_load(&use_TLS) ? server_tlsctx : NULL, endpoints, 0,
get_proxy_type(), &listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
sockaddr_to_url(&tcp_listen_addr, atomic_load(&use_TLS), req_url,
sizeof(req_url), ISC_NM_HTTP_DEFAULT_PATH);
- connect_send_request(connect_nm, req_url, atomic_load(&POST),
+ connect_send_request(req_url, atomic_load(&POST),
&(isc_region_t){ .base = (uint8_t *)send_msg.base,
.length = send_msg.len },
doh_receive_reply_cb, NULL, atomic_load(&use_TLS),
static void
doh_recv_two(void *arg ISC_ATTR_UNUSED) {
- isc_nm_t *listen_nm = nm[0];
- isc_nm_t *connect_nm = nm[1];
isc_result_t result = ISC_R_SUCCESS;
isc_nmsocket_t *listen_sock = NULL;
char req_url[256];
assert_int_equal(result, ISC_R_SUCCESS);
result = isc_nm_listenhttp(
- listen_nm, ISC_NM_LISTEN_ALL, &tcp_listen_addr, 0, quotap,
+ ISC_NM_LISTEN_ALL, &tcp_listen_addr, 0, quotap,
atomic_load(&use_TLS) ? server_tlsctx : NULL, endpoints, 0,
get_proxy_type(), &listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
ctx = client_tlsctx;
}
- isc_nm_httpconnect(connect_nm, NULL, &tcp_listen_addr, req_url,
- atomic_load(&POST), doh_connect_send_two_requests_cb,
- NULL, ctx, NULL, client_sess_cache, 5000,
- get_proxy_type(), NULL);
+ isc_nm_httpconnect(NULL, &tcp_listen_addr, req_url, atomic_load(&POST),
+ doh_connect_send_two_requests_cb, NULL, ctx, NULL,
+ client_sess_cache, 5000, get_proxy_type(), NULL);
isc_loop_teardown(isc_loop_main(), listen_sock_close, listen_sock);
}
static void
doh_recv_send(void *arg ISC_ATTR_UNUSED) {
- isc_nm_t *listen_nm = nm[0];
- isc_nm_t *connect_nm = nm[1];
isc_result_t result = ISC_R_SUCCESS;
isc_nmsocket_t *listen_sock = NULL;
size_t nthreads = isc_loopmgr_nloops();
assert_int_equal(result, ISC_R_SUCCESS);
result = isc_nm_listenhttp(
- listen_nm, ISC_NM_LISTEN_ALL, &tcp_listen_addr, 0, quotap,
+ ISC_NM_LISTEN_ALL, &tcp_listen_addr, 0, quotap,
atomic_load(&use_TLS) ? server_tlsctx : NULL, endpoints, 0,
get_proxy_type(), &listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
for (size_t i = 0; i < nthreads; i++) {
- isc_async_run(isc_loop_get(i), doh_connect_thread, connect_nm);
+ isc_async_run(isc_loop_get(i), doh_connect_thread, NULL);
}
isc_loop_teardown(isc_loop_main(), listen_sock_close, listen_sock);
/* See: GL #2858, !5319 */
ISC_LOOP_TEST_IMPL(doh_bad_connect_uri) {
- isc_nm_t *listen_nm = nm[0];
- isc_nm_t *connect_nm = nm[1];
isc_result_t result = ISC_R_SUCCESS;
isc_nmsocket_t *listen_sock = NULL;
char req_url[256];
doh_receive_request_cb, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
- result = isc_nm_listenhttp(
- listen_nm, ISC_NM_LISTEN_ALL, &tcp_listen_addr, 0, quotap,
- server_tlsctx, endpoints, 0, get_proxy_type(), &listen_sock);
+ result = isc_nm_listenhttp(ISC_NM_LISTEN_ALL, &tcp_listen_addr, 0,
+ quotap, server_tlsctx, endpoints, 0,
+ get_proxy_type(), &listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
/*
(void)snprintf(req_url, sizeof(req_url), "https://::1:%u/%s",
isc_sockaddr_getport(&tcp_listen_addr),
ISC_NM_HTTP_DEFAULT_PATH);
- connect_send_request(connect_nm, req_url, atomic_load(&POST),
+ connect_send_request(req_url, atomic_load(&POST),
&(isc_region_t){ .base = (uint8_t *)send_msg.base,
.length = send_msg.len },
doh_receive_reply_cb, NULL, true, 30000);
#include <tests/isc.h>
-isc_nm_t *listen_nm = NULL;
-isc_nm_t *connect_nm = NULL;
-
isc_sockaddr_t tcp_listen_addr;
isc_sockaddr_t tcp_connect_addr;
isc_tlsctx_t *tcp_listen_tlsctx = NULL;
isc_nonce_buf(&send_magic, sizeof(send_magic));
setup_loopmgr(state);
- isc_netmgr_create(mctx, &listen_nm);
- assert_non_null(listen_nm);
- isc_nm_setinitialtimeout(listen_nm, T_INIT);
- isc_nm_setprimariestimeout(listen_nm, T_PRIMARIES);
- isc_nm_setidletimeout(listen_nm, T_IDLE);
- isc_nm_setkeepalivetimeout(listen_nm, T_KEEPALIVE);
- isc_nm_setadvertisedtimeout(listen_nm, T_ADVERTISED);
-
- isc_netmgr_create(mctx, &connect_nm);
- assert_non_null(connect_nm);
- isc_nm_setinitialtimeout(connect_nm, T_INIT);
- isc_nm_setprimariestimeout(connect_nm, T_PRIMARIES);
- isc_nm_setidletimeout(connect_nm, T_IDLE);
- isc_nm_setkeepalivetimeout(connect_nm, T_KEEPALIVE);
- isc_nm_setadvertisedtimeout(connect_nm, T_ADVERTISED);
+ isc_netmgr_create(mctx);
+ isc_nm_setinitialtimeout(T_INIT);
+ isc_nm_setprimariestimeout(T_PRIMARIES);
+ isc_nm_setidletimeout(T_IDLE);
+ isc_nm_setkeepalivetimeout(T_KEEPALIVE);
+ isc_nm_setadvertisedtimeout(T_ADVERTISED);
isc_quota_init(&listener_quota, 0);
atomic_store(&check_listener_quota, false);
isc_tlsctx_free(&tcp_connect_tlsctx);
isc_tlsctx_free(&tcp_listen_tlsctx);
- isc_nm_detach(&connect_nm);
- assert_null(connect_nm);
-
- isc_nm_detach(&listen_nm);
- assert_null(listen_nm);
+ isc_netmgr_destroy();
teardown_loopmgr(state);
isc_refcount_increment0(&active_creads);
isc_nmhandle_attach(handle, &readhandle);
+ /*
+ * Shorten all the client timeouts to 0.05 seconds.
+ */
+ isc_nmhandle_settimeout(handle, T_SOFT);
isc_nm_read(handle, connect_readcb, NULL);
connect_send(handle);
isc_sockaddr_fromin6(&connect_addr, &in6addr_loopback, 0);
isc_refcount_increment0(&active_cconnects);
- connect(connect_nm);
+ connect();
}
/* Common stream protocols code */
}
static void
-tcp_connect(isc_nm_t *nm) {
- isc_nm_tcpconnect(nm, &tcp_connect_addr, &tcp_listen_addr,
+tcp_connect(void) {
+ isc_nm_tcpconnect(&tcp_connect_addr, &tcp_listen_addr,
connect_connect_cb, NULL, T_CONNECT);
}
static void
-tls_connect(isc_nm_t *nm) {
- isc_nm_tlsconnect(nm, &tcp_connect_addr, &tcp_listen_addr,
+tls_connect(void) {
+ isc_nm_tlsconnect(&tcp_connect_addr, &tcp_listen_addr,
connect_connect_cb, NULL, tcp_connect_tlsctx, NULL,
tcp_tlsctx_client_sess_cache, T_CONNECT,
stream_use_PROXY, NULL);
}
static void
-proxystream_connect(isc_nm_t *nm) {
+proxystream_connect(void) {
isc_tlsctx_t *tlsctx = stream_PROXY_over_TLS ? tcp_connect_tlsctx
: NULL;
isc_tlsctx_client_session_cache_t *sess_cache =
stream_PROXY_over_TLS ? tcp_tlsctx_client_sess_cache : NULL;
- isc_nm_proxystreamconnect(nm, &tcp_connect_addr, &tcp_listen_addr,
+ isc_nm_proxystreamconnect(&tcp_connect_addr, &tcp_listen_addr,
connect_connect_cb, NULL, T_CONNECT, tlsctx,
NULL, sess_cache, get_proxyheader_info());
}
isc_result_t result = ISC_R_SUCCESS;
if (stream_use_TLS && !stream_PROXY_over_TLS) {
- result = isc_nm_listentls(
- listen_nm, ISC_NM_LISTEN_ALL, &tcp_listen_addr,
- accept_cb, accept_cbarg, backlog, quota,
- tcp_listen_tlsctx, stream_use_PROXY, sockp);
+ result = isc_nm_listentls(ISC_NM_LISTEN_ALL, &tcp_listen_addr,
+ accept_cb, accept_cbarg, backlog,
+ quota, tcp_listen_tlsctx,
+ stream_use_PROXY, sockp);
return result;
} else if (stream_use_PROXY) {
isc_tlsctx_t *tlsctx = stream_PROXY_over_TLS ? tcp_listen_tlsctx
: NULL;
result = isc_nm_listenproxystream(
- listen_nm, ISC_NM_LISTEN_ALL, &tcp_listen_addr,
- accept_cb, accept_cbarg, backlog, quota, tlsctx, sockp);
+ ISC_NM_LISTEN_ALL, &tcp_listen_addr, accept_cb,
+ accept_cbarg, backlog, quota, tlsctx, sockp);
return result;
} else {
- result = isc_nm_listentcp(listen_nm, ISC_NM_LISTEN_ALL,
- &tcp_listen_addr, accept_cb,
- accept_cbarg, backlog, quota, sockp);
+ result = isc_nm_listentcp(ISC_NM_LISTEN_ALL, &tcp_listen_addr,
+ accept_cb, accept_cbarg, backlog,
+ quota, sockp);
return result;
}
isc_refcount_increment0(&active_cconnects);
if (stream_use_TLS && !stream_PROXY_over_TLS) {
- isc_nm_tlsconnect(connect_nm, &tcp_connect_addr,
- &tcp_listen_addr, cb, cbarg,
- tcp_connect_tlsctx, NULL,
+ isc_nm_tlsconnect(&tcp_connect_addr, &tcp_listen_addr, cb,
+ cbarg, tcp_connect_tlsctx, NULL,
tcp_tlsctx_client_sess_cache, timeout,
stream_use_PROXY, NULL);
return;
isc_tlsctx_client_session_cache_t *sess_cache =
stream_PROXY_over_TLS ? tcp_tlsctx_client_sess_cache
: NULL;
- isc_nm_proxystreamconnect(connect_nm, &tcp_connect_addr,
- &tcp_listen_addr, cb, cbarg, timeout,
- tlsctx, NULL, sess_cache,
- get_proxyheader_info());
+ isc_nm_proxystreamconnect(&tcp_connect_addr, &tcp_listen_addr,
+ cb, cbarg, timeout, tlsctx, NULL,
+ sess_cache, get_proxyheader_info());
return;
} else {
- isc_nm_tcpconnect(connect_nm, &tcp_connect_addr,
- &tcp_listen_addr, cb, cbarg, timeout);
+ isc_nm_tcpconnect(&tcp_connect_addr, &tcp_listen_addr, cb,
+ cbarg, timeout);
return;
}
UNREACHABLE();
assert_int_equal(result, ISC_R_SUCCESS);
isc_loop_teardown(isc_loop_main(), stop_listening, listen_sock);
- /*
- * Shorten all the client timeouts to 0.05 seconds.
- */
- isc_nm_setinitialtimeout(connect_nm, T_SOFT);
- isc_nm_setprimariestimeout(connect_nm, T_SOFT);
- isc_nm_setidletimeout(connect_nm, T_SOFT);
- isc_nm_setkeepalivetimeout(connect_nm, T_SOFT);
- isc_nm_setadvertisedtimeout(connect_nm, T_SOFT);
+ // isc_nm_setinitialtimeout(T_SOFT);
connect_readcb = timeout_retry_cb;
stream_connect(connect_connect_cb, NULL, T_CONNECT);
}
static void
udp_connect(isc_nm_cb_t cb, void *cbarg, unsigned int timeout) {
if (udp_use_PROXY) {
- isc_nm_proxyudpconnect(netmgr, &udp_connect_addr,
- &udp_listen_addr, cb, cbarg, timeout,
- NULL);
+ isc_nm_proxyudpconnect(&udp_connect_addr, &udp_listen_addr, cb,
+ cbarg, timeout, NULL);
} else {
- isc_nm_udpconnect(netmgr, &udp_connect_addr, &udp_listen_addr,
- cb, cbarg, timeout);
+ isc_nm_udpconnect(&udp_connect_addr, &udp_listen_addr, cb,
+ cbarg, timeout);
}
}
isc_result_t result;
if (udp_use_PROXY) {
- result = isc_nm_listenproxyudp(netmgr, nworkers,
- &udp_listen_addr, cb, NULL,
- &listen_sock);
+ result = isc_nm_listenproxyudp(nworkers, &udp_listen_addr, cb,
+ NULL, &listen_sock);
} else {
- result = isc_nm_listenudp(netmgr, nworkers, &udp_listen_addr,
- cb, NULL, &listen_sock);
+ result = isc_nm_listenudp(nworkers, &udp_listen_addr, cb, NULL,
+ &listen_sock);
}
assert_int_equal(result, ISC_R_SUCCESS);
*/
if (atomic_fetch_add(&cconnects, 1) == 0) {
assert_int_equal(eresult, ISC_R_SUCCESS);
- isc_async_current(udp_shutdown_connect_async_cb, netmgr);
+ isc_async_current(udp_shutdown_connect_async_cb, NULL);
} else {
assert_int_equal(eresult, ISC_R_SHUTTINGDOWN);
}
* isc_nm_udpconnect() is synchronous, so we need to launch this on the
* async loop.
*/
- isc_async_current(udp_shutdown_connect_async_cb, netmgr);
+ isc_async_current(udp_shutdown_connect_async_cb, NULL);
}
int
#define PROXYSTREAM_TEST_PORT 9158
#define PROXYUDP_TEST_PORT 9159
-typedef void (*stream_connect_function)(isc_nm_t *nm);
-typedef void (*connect_func)(isc_nm_t *);
-
-extern isc_nm_t *listen_nm;
-extern isc_nm_t *connect_nm;
+typedef void (*stream_connect_function)(void);
+typedef void (*connect_func)(void);
extern isc_sockaddr_t tcp_listen_addr;
extern isc_sockaddr_t tcp_connect_addr;
start_listening(uint32_t nworkers, isc_nm_accept_cb_t accept_cb,
isc_nm_recv_cb_t recv_cb) {
isc_result_t result = isc_nm_listenstreamdns(
- listen_nm, nworkers, &tcp_listen_addr, recv_cb, NULL, accept_cb,
- NULL, 128, NULL, NULL, get_proxy_type(), &listen_sock);
+ nworkers, &tcp_listen_addr, recv_cb, NULL, accept_cb, NULL, 128,
+ NULL, NULL, get_proxy_type(), &listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
isc_loop_teardown(isc_loop_main(), stop_listening, listen_sock);
}
static void
-tcpdns_connect(isc_nm_t *nm) {
- isc_nm_streamdnsconnect(nm, &tcp_connect_addr, &tcp_listen_addr,
+tcpdns_connect(void) {
+ isc_nm_streamdnsconnect(&tcp_connect_addr, &tcp_listen_addr,
connect_connect_cb, tcpdns_connect, T_CONNECT,
NULL, NULL, NULL, get_proxy_type(), NULL);
}
connect_readcb = NULL;
isc_refcount_increment0(&active_cconnects);
- isc_nm_streamdnsconnect(connect_nm, &tcp_connect_addr, &tcp_listen_addr,
+ isc_nm_streamdnsconnect(&tcp_connect_addr, &tcp_listen_addr,
connect_success_cb, tcpdns_connect, T_CONNECT,
NULL, NULL, NULL, get_proxy_type(), NULL);
}
start_listening(ISC_NM_LISTEN_ALL, noop_accept_cb, noop_recv_cb);
isc_refcount_increment0(&active_cconnects);
- isc_nm_streamdnsconnect(connect_nm, &tcp_connect_addr, &tcp_listen_addr,
+ isc_nm_streamdnsconnect(&tcp_connect_addr, &tcp_listen_addr,
connect_connect_cb, tcpdns_connect, T_CONNECT,
NULL, NULL, NULL, get_proxy_type(), NULL);
}
* timeout_retry_cb() will give up after five timeouts.
*/
connect_readcb = timeout_retry_cb;
- isc_nm_setinitialtimeout(connect_nm, T_SOFT);
- isc_nm_setprimariestimeout(connect_nm, T_SOFT);
- isc_nm_setidletimeout(connect_nm, T_SOFT);
- isc_nm_setkeepalivetimeout(connect_nm, T_SOFT);
- isc_nm_setadvertisedtimeout(connect_nm, T_SOFT);
isc_async_current(stream_recv_send_connect, tcpdns_connect);
}
start_listening(uint32_t nworkers, isc_nm_accept_cb_t accept_cb,
isc_nm_recv_cb_t recv_cb) {
isc_result_t result = isc_nm_listenstreamdns(
- listen_nm, nworkers, &tcp_listen_addr, recv_cb, NULL, accept_cb,
- NULL, 128, NULL, tcp_listen_tlsctx, get_proxy_type(),
- &listen_sock);
+ nworkers, &tcp_listen_addr, recv_cb, NULL, accept_cb, NULL, 128,
+ NULL, tcp_listen_tlsctx, get_proxy_type(), &listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
isc_loop_teardown(isc_loop_main(), stop_listening, listen_sock);
}
static void
-tlsdns_connect(isc_nm_t *nm) {
+tlsdns_connect(void) {
isc_nm_streamdnsconnect(
- nm, &tcp_connect_addr, &tcp_listen_addr, connect_connect_cb,
+ &tcp_connect_addr, &tcp_listen_addr, connect_connect_cb,
tlsdns_connect, T_CONNECT, tcp_connect_tlsctx, NULL,
tcp_tlsctx_client_sess_cache, get_proxy_type(), NULL);
}
connect_readcb = NULL;
isc_refcount_increment0(&active_cconnects);
- isc_nm_streamdnsconnect(connect_nm, &tcp_connect_addr, &tcp_listen_addr,
- connect_success_cb, tlsdns_connect, T_CONNECT,
- tcp_connect_tlsctx, NULL,
- tcp_tlsctx_client_sess_cache, get_proxy_type(),
- NULL);
+ isc_nm_streamdnsconnect(
+ &tcp_connect_addr, &tcp_listen_addr, connect_success_cb,
+ tlsdns_connect, T_CONNECT, tcp_connect_tlsctx, NULL,
+ tcp_tlsctx_client_sess_cache, get_proxy_type(), NULL);
}
ISC_LOOP_TEST_IMPL(tlsdns_noresponse) {
start_listening(ISC_NM_LISTEN_ALL, noop_accept_cb, noop_recv_cb);
isc_refcount_increment0(&active_cconnects);
- isc_nm_streamdnsconnect(connect_nm, &tcp_connect_addr, &tcp_listen_addr,
- connect_connect_cb, tlsdns_connect, T_CONNECT,
- tcp_connect_tlsctx, NULL,
- tcp_tlsctx_client_sess_cache, get_proxy_type(),
- NULL);
+ isc_nm_streamdnsconnect(
+ &tcp_connect_addr, &tcp_listen_addr, connect_connect_cb,
+ tlsdns_connect, T_CONNECT, tcp_connect_tlsctx, NULL,
+ tcp_tlsctx_client_sess_cache, get_proxy_type(), NULL);
}
ISC_LOOP_TEST_IMPL(tlsdns_timeout_recovery) {
start_listening(ISC_NM_LISTEN_ONE, listen_accept_cb, listen_read_cb);
/*
- * Shorten all the TCP client timeouts to 0.05 seconds, connect,
- * then sleep for at least a second for each 'tick'.
* timeout_retry_cb() will give up after five timeouts.
*/
connect_readcb = timeout_retry_cb;
- isc_nm_setinitialtimeout(connect_nm, T_SOFT);
- isc_nm_setprimariestimeout(connect_nm, T_SOFT);
- isc_nm_setidletimeout(connect_nm, T_SOFT);
- isc_nm_setkeepalivetimeout(connect_nm, T_SOFT);
- isc_nm_setadvertisedtimeout(connect_nm, T_SOFT);
isc_refcount_increment0(&active_cconnects);
isc_nm_streamdnsconnect(
- connect_nm, &tcp_connect_addr, &tcp_listen_addr,
- connect_connect_cb, tlsdns_connect, T_SOFT, tcp_connect_tlsctx,
- NULL, tcp_tlsctx_client_sess_cache, get_proxy_type(), NULL);
+ &tcp_connect_addr, &tcp_listen_addr, connect_connect_cb,
+ tlsdns_connect, T_SOFT, tcp_connect_tlsctx, NULL,
+ tcp_tlsctx_client_sess_cache, get_proxy_type(), NULL);
}
ISC_LOOP_TEST_IMPL(tlsdns_recv_one) {
start_listening(ISC_NM_LISTEN_ONE, listen_accept_cb, listen_read_cb);
isc_refcount_increment0(&active_cconnects);
- tlsdns_connect(connect_nm);
+ tlsdns_connect();
}
ISC_LOOP_TEST_IMPL(tlsdns_recv_two) {
start_listening(ISC_NM_LISTEN_ONE, listen_accept_cb, listen_read_cb);
isc_refcount_increment0(&active_cconnects);
- tlsdns_connect(connect_nm);
+ tlsdns_connect();
isc_refcount_increment0(&active_cconnects);
- tlsdns_connect(connect_nm);
+ tlsdns_connect();
}
ISC_LOOP_TEST_IMPL(tlsdns_recv_send) {
WILL_RETURN(uv_udp_open, UV_ENOMEM);
- result = isc_nm_listenudp(netmgr, ISC_NM_LISTEN_ALL, &udp_listen_addr,
+ result = isc_nm_listenudp(ISC_NM_LISTEN_ALL, &udp_listen_addr,
mock_recv_cb, NULL, &listen_sock);
assert_int_not_equal(result, ISC_R_SUCCESS);
assert_null(listen_sock);
WILL_RETURN(uv_udp_bind, UV_EADDRINUSE);
- result = isc_nm_listenudp(netmgr, ISC_NM_LISTEN_ALL, &udp_listen_addr,
+ result = isc_nm_listenudp(ISC_NM_LISTEN_ALL, &udp_listen_addr,
mock_recv_cb, NULL, &listen_sock);
assert_int_not_equal(result, ISC_R_SUCCESS);
assert_null(listen_sock);
WILL_RETURN(uv_udp_recv_start, UV_EADDRINUSE);
- result = isc_nm_listenudp(netmgr, ISC_NM_LISTEN_ALL, &udp_listen_addr,
+ result = isc_nm_listenudp(ISC_NM_LISTEN_ALL, &udp_listen_addr,
mock_recv_cb, NULL, &listen_sock);
assert_int_not_equal(result, ISC_R_SUCCESS);
assert_null(listen_sock);
WILL_RETURN(uv_udp_open, UV_ENOMEM);
isc_refcount_increment0(&active_cconnects);
- isc_nm_udpconnect(netmgr, &udp_connect_addr, &udp_listen_addr,
+ isc_nm_udpconnect(&udp_connect_addr, &udp_listen_addr,
udp_connect_nomemory_cb, NULL, UDP_T_CONNECT);
isc_loopmgr_shutdown();
WILL_RETURN(uv_udp_bind, UV_ENOMEM);
isc_refcount_increment0(&active_cconnects);
- isc_nm_udpconnect(netmgr, &udp_connect_addr, &udp_listen_addr,
+ isc_nm_udpconnect(&udp_connect_addr, &udp_listen_addr,
udp_connect_nomemory_cb, NULL, UDP_T_CONNECT);
isc_loopmgr_shutdown();
WILL_RETURN(uv_udp_connect, UV_ENOMEM);
isc_refcount_increment0(&active_cconnects);
- isc_nm_udpconnect(netmgr, &udp_connect_addr, &udp_listen_addr,
+ isc_nm_udpconnect(&udp_connect_addr, &udp_listen_addr,
udp_connect_nomemory_cb, NULL, UDP_T_CONNECT);
isc_loopmgr_shutdown();
WILL_RETURN(uv_recv_buffer_size, UV_ENOMEM);
isc_refcount_increment0(&active_cconnects);
- isc_nm_udpconnect(netmgr, &udp_connect_addr, &udp_listen_addr,
+ isc_nm_udpconnect(&udp_connect_addr, &udp_listen_addr,
connect_success_cb, NULL, UDP_T_CONNECT);
isc_loopmgr_shutdown();
WILL_RETURN(uv_send_buffer_size, UV_ENOMEM);
isc_refcount_increment0(&active_cconnects);
- isc_nm_udpconnect(netmgr, &udp_connect_addr, &udp_listen_addr,
+ isc_nm_udpconnect(&udp_connect_addr, &udp_listen_addr,
connect_success_cb, NULL, UDP_T_CONNECT);
isc_loopmgr_shutdown();
dns_dispatchmgr_t *dispatchmgr = NULL;
if (with_dispatchmgr) {
- result = dns_dispatchmgr_create(mctx, netmgr, &dispatchmgr);
+ result = dns_dispatchmgr_create(mctx, &dispatchmgr);
if (result != ISC_R_SUCCESS) {
return result;
}
dns_test_setupzonemgr(void) {
REQUIRE(zonemgr == NULL);
- dns_zonemgr_create(mctx, netmgr, &zonemgr);
+ dns_zonemgr_create(mctx, &zonemgr);
}
isc_result_t
#include <tests/isc.h>
isc_mem_t *mctx = NULL;
-isc_nm_t *netmgr = NULL;
unsigned int workers = 0;
bool debug = false;
int
teardown_loopmgr(void **state ISC_ATTR_UNUSED) {
- REQUIRE(netmgr == NULL);
-
isc_loopmgr_destroy();
return 0;
setup_netmgr(void **state ISC_ATTR_UNUSED) {
adjustnofile();
- isc_netmgr_create(mctx, &netmgr);
+ isc_netmgr_create(mctx);
return 0;
}
int
teardown_netmgr(void **state ISC_ATTR_UNUSED) {
- isc_nm_detach(&netmgr);
+ isc_netmgr_destroy();
return 0;
}
ns_server_create(mctx, matchview, &sctx);
- result = dns_dispatchmgr_create(mctx, netmgr, &dispatchmgr);
+ result = dns_dispatchmgr_create(mctx, &dispatchmgr);
if (result != ISC_R_SUCCESS) {
goto cleanup;
}
- result = ns_interfacemgr_create(mctx, sctx, netmgr, dispatchmgr, NULL,
+ result = ns_interfacemgr_create(mctx, sctx, dispatchmgr, NULL,
&interfacemgr);
if (result != ISC_R_SUCCESS) {
goto cleanup;
projects / thirdparty / bind9.git / commitdiff
