isc_nmhandle_detach(&conn->sendhandle);
- result = isccc_ccmsg_readmessage(&conn->ccmsg, control_recvmessage,
- conn);
- if (result != ISC_R_SUCCESS) {
- conn->reading = false;
- isc_nmhandle_detach(&conn->readhandle);
- return;
- }
-
+ isccc_ccmsg_readmessage(&conn->ccmsg, control_recvmessage, conn);
return;
cleanup_sendhandle:
isc_nmhandle_detach(&conn->cmdhandle);
- result = isc_nm_send(conn->sendhandle, &r, control_senddone, conn);
- if (result != ISC_R_SUCCESS) {
- isc_nmhandle_detach(&conn->sendhandle);
- conn->sending = false;
- }
+ isc_nm_send(conn->sendhandle, &r, control_senddone, conn);
return;
maybe_free_listener(listener);
}
-static isc_result_t
+static void
newconnection(controllistener_t *listener, isc_nmhandle_t *handle) {
controlconnection_t *conn = NULL;
- isc_result_t result;
conn = isc_nmhandle_getdata(handle);
if (conn == NULL) {
isc_nmhandle_attach(handle, &conn->readhandle);
conn->reading = true;
- result = isccc_ccmsg_readmessage(&conn->ccmsg, control_recvmessage,
- conn);
- if (result != ISC_R_SUCCESS) {
- isc_nmhandle_detach(&conn->readhandle);
- conn->reading = false;
- goto cleanup;
- }
-
- return (ISC_R_SUCCESS);
-
-cleanup:
- /*
- * conn_reset() handles the cleanup.
- */
-#ifdef ENABLE_AFL
- if (named_g_fuzz_type == isc_fuzz_rndc) {
- named_fuzz_notify();
- }
-#endif /* ifdef ENABLE_AFL */
- return (result);
+ isccc_ccmsg_readmessage(&conn->ccmsg, control_recvmessage, conn);
}
static isc_result_t
return (ISC_R_FAILURE);
}
- result = newconnection(listener, handle);
- if (result != ISC_R_SUCCESS) {
- char socktext[ISC_SOCKADDR_FORMATSIZE];
- isc_sockaddr_format(&peeraddr, socktext, sizeof(socktext));
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_CONTROL, ISC_LOG_WARNING,
- "dropped command channel from %s: %s", socktext,
- isc_result_totext(result));
- return (result);
- }
-
+ newconnection(listener, handle);
return (ISC_R_SUCCESS);
}
rndc_recvnonce(isc_nmhandle_t *handle, isc_result_t result, void *arg) {
isccc_ccmsg_t *ccmsg = (isccc_ccmsg_t *)arg;
isccc_sexpr_t *response = NULL;
- isccc_sexpr_t *_ctrl;
+ isc_nmhandle_t *sendhandle = NULL;
+ isccc_sexpr_t *_ctrl = NULL;
isccc_region_t source;
uint32_t nonce;
isccc_sexpr_t *request = NULL;
isccc_time_t now;
isc_region_t r;
- isccc_sexpr_t *data;
+ isccc_sexpr_t *data = NULL;
isc_buffer_t b;
REQUIRE(ccmsg != NULL);
isc_nmhandle_attach(handle, &recvdone_handle);
atomic_fetch_add_relaxed(&recvs, 1);
- DO("schedule recv",
- isccc_ccmsg_readmessage(ccmsg, rndc_recvdone, ccmsg));
+ isccc_ccmsg_readmessage(ccmsg, rndc_recvdone, ccmsg);
- isc_nmhandle_t *sendhandle = NULL;
isc_nmhandle_attach(handle, &sendhandle);
atomic_fetch_add_relaxed(&sends, 1);
- DO("send message", isc_nm_send(handle, &r, rndc_senddone, sendhandle));
+ isc_nm_send(handle, &r, rndc_senddone, sendhandle);
REQUIRE(recvnonce_handle == handle);
isc_nmhandle_detach(&recvnonce_handle);
isccc_ccmsg_t *ccmsg = (isccc_ccmsg_t *)arg;
char socktext[ISC_SOCKADDR_FORMATSIZE];
isccc_sexpr_t *request = NULL;
- isccc_sexpr_t *data;
+ isccc_sexpr_t *data = NULL;
isccc_time_t now;
isc_region_t r;
isc_buffer_t b;
isc_nmhandle_t *connhandle = NULL;
+ isc_nmhandle_t *sendhandle = NULL;
REQUIRE(ccmsg != NULL);
isc_nmhandle_attach(handle, &recvnonce_handle);
atomic_fetch_add_relaxed(&recvs, 1);
- DO("schedule recv",
- isccc_ccmsg_readmessage(ccmsg, rndc_recvnonce, ccmsg));
+ isccc_ccmsg_readmessage(ccmsg, rndc_recvnonce, ccmsg);
- isc_nmhandle_t *sendhandle = NULL;
isc_nmhandle_attach(handle, &sendhandle);
atomic_fetch_add_relaxed(&sends, 1);
- DO("send message", isc_nm_send(handle, &r, rndc_senddone, sendhandle));
+ isc_nm_send(handle, &r, rndc_senddone, sendhandle);
isc_nmhandle_detach(&connhandle);
atomic_fetch_sub_release(&connects, 1);
#endif /* ENABLE_AFL */
}
-static isc_result_t
+static void
new_httpd(isc_httpdmgr_t *httpdmgr, isc_nmhandle_t *handle) {
- isc_result_t result;
isc_httpd_t *httpd = NULL;
char *headerdata = NULL;
UNLOCK(&httpdmgr->lock);
isc_nmhandle_attach(handle, &httpd->readhandle);
- result = isc_nm_read(handle, httpd_request, httpdmgr);
- if (result != ISC_R_SUCCESS) {
- isc_nmhandle_detach(&httpd->readhandle);
- }
-
- return (result);
+ isc_nm_read(handle, httpd_request, httpdmgr);
}
static isc_result_t
return (ISC_R_FAILURE);
}
- return (new_httpd(httpdmgr, handle));
+ new_httpd(httpdmgr, handle);
+
+ return (ISC_R_SUCCESS);
}
static isc_result_t
httpd->state = SEND;
isc_nmhandle_attach(handle, &httpd->sendhandle);
- result = isc_nm_send(handle, &r, httpd_senddone, httpd);
- if (result != ISC_R_SUCCESS) {
- isc_nmhandle_detach(&httpd->sendhandle);
-
- httpd->state = RECV;
- isc_nm_resumeread(handle);
- }
+ isc_nm_send(handle, &r, httpd_senddone, httpd);
return;
cleanup_readhandle:
}
}
+ isc_nmhandle_detach(&httpd->sendhandle);
+
if (result != ISC_R_SUCCESS) {
return;
}
- isc_nmhandle_detach(&httpd->sendhandle);
-
httpd->state = RECV;
isc_nm_resumeread(handle);
}
* workers to resume.
*/
-isc_result_t
+void
isc_nm_read(isc_nmhandle_t *handle, isc_nm_recv_cb_t cb, void *cbarg);
/*
* Begin (or continue) reading on the socket associated with 'handle', and
* \li ...for which a read/recv callback has been defined.
*/
-isc_result_t
+void
isc_nm_resumeread(isc_nmhandle_t *handle);
/*%<
* Resume reading on the handle's socket.
* \li ...for a socket with a defined read/recv callback.
*/
-isc_result_t
+void
isc_nm_send(isc_nmhandle_t *handle, isc_region_t *region, isc_nm_cb_t cb,
void *cbarg);
/*%<
* close on them.
*/
-isc_result_t
+void
isc__nm_udp_send(isc_nmhandle_t *handle, isc_region_t *region, isc_nm_cb_t cb,
void *cbarg);
/*%<
* Callback handlers for asynchronous UDP events (listen, stoplisten, send).
*/
-isc_result_t
+void
isc__nm_tcp_send(isc_nmhandle_t *handle, isc_region_t *region, isc_nm_cb_t cb,
void *cbarg);
/*%<
* Back-end implementation of isc_nm_send() for TCP handles.
*/
-isc_result_t
+void
isc__nm_tcp_read(isc_nmhandle_t *handle, isc_nm_recv_cb_t cb, void *cbarg);
/*
* Back-end implementation of isc_nm_read() for TCP handles.
* Pause reading on this socket, while still remembering the callback.
*/
-isc_result_t
+void
isc__nm_tcp_resumeread(isc_nmsocket_t *sock);
/*%<
* Resume reading from socket.
* stoplisten, send, read, pause, close).
*/
-isc_result_t
+void
isc__nm_tcpdns_send(isc_nmhandle_t *handle, isc_region_t *region,
isc_nm_cb_t cb, void *cbarg);
/*%<
#endif /* ifdef WIN32 */
}
+#ifdef NETMGR_TRACE
+ isc__nm_dump_active(mgr);
+#endif
INSIST(references == 1);
/*
isc__nmsocket_detach(&sock);
}
-isc_result_t
+void
isc_nm_send(isc_nmhandle_t *handle, isc_region_t *region, isc_nm_cb_t cb,
void *cbarg) {
REQUIRE(VALID_NMHANDLE(handle));
switch (handle->sock->type) {
case isc_nm_udpsocket:
case isc_nm_udplistener:
- return (isc__nm_udp_send(handle, region, cb, cbarg));
+ isc__nm_udp_send(handle, region, cb, cbarg);
+ break;
case isc_nm_tcpsocket:
- return (isc__nm_tcp_send(handle, region, cb, cbarg));
+ isc__nm_tcp_send(handle, region, cb, cbarg);
+ break;
case isc_nm_tcpdnssocket:
- return (isc__nm_tcpdns_send(handle, region, cb, cbarg));
+ isc__nm_tcpdns_send(handle, region, cb, cbarg);
+ break;
default:
INSIST(0);
ISC_UNREACHABLE();
}
}
-isc_result_t
+void
isc_nm_read(isc_nmhandle_t *handle, isc_nm_recv_cb_t cb, void *cbarg) {
REQUIRE(VALID_NMHANDLE(handle));
switch (handle->sock->type) {
case isc_nm_tcpsocket:
- return (isc__nm_tcp_read(handle, cb, cbarg));
+ isc__nm_tcp_read(handle, cb, cbarg);
+ break;
default:
INSIST(0);
ISC_UNREACHABLE();
}
}
-isc_result_t
+void
isc_nm_resumeread(isc_nmhandle_t *handle) {
REQUIRE(VALID_NMHANDLE(handle));
switch (sock->type) {
case isc_nm_tcpsocket:
- return (isc__nm_tcp_resumeread(sock));
+ isc__nm_tcp_resumeread(sock);
+ break;
default:
INSIST(0);
ISC_UNREACHABLE();
static void
nmsocket_dump(isc_nmsocket_t *sock) {
- isc_nmhandle_t *handle;
+ isc_nmhandle_t *handle = NULL;
+
LOCK(&sock->lock);
fprintf(stderr, "\n=================\n");
fprintf(stderr, "Active socket %p, type %s, refs %lu\n", sock,
backtrace_symbols_fd(sock->backtrace, sock->backtrace_size,
STDERR_FILENO);
fprintf(stderr, "\n");
- fprintf(stderr, "Active handles:\n");
+
for (handle = ISC_LIST_HEAD(sock->active_handles); handle != NULL;
handle = ISC_LIST_NEXT(handle, active_link))
{
+ static bool first = true;
+ if (first) {
+ fprintf(stderr, "Active handles:\n");
+ first = false;
+ }
nmhandle_dump(handle);
}
+
fprintf(stderr, "\n");
UNLOCK(&sock->lock);
}
void
isc__nm_dump_active(isc_nm_t *nm) {
- isc_nmsocket_t *sock;
+ isc_nmsocket_t *sock = NULL;
+
REQUIRE(VALID_NM(nm));
+
LOCK(&nm->lock);
- fprintf(stderr, "Outstanding sockets\n");
for (sock = ISC_LIST_HEAD(nm->active_sockets); sock != NULL;
sock = ISC_LIST_NEXT(sock, active_link))
{
+ static bool first = true;
+ if (first) {
+ fprintf(stderr, "Outstanding sockets\n");
+ first = false;
+ }
nmsocket_dump(sock);
}
UNLOCK(&nm->lock);
isc__nmsocket_detach(&sock);
}
+static void
+failed_read_cb(isc_nmsocket_t *sock, isc_result_t result) {
+ isc_nm_recv_cb_t cb;
+ void *cbarg = NULL;
+
+ uv_read_stop(&sock->uv_handle.stream);
+
+ if (sock->timer_initialized) {
+ uv_timer_stop(&sock->timer);
+ }
+
+ if (sock->quota) {
+ isc_quota_detach(&sock->quota);
+ }
+
+ cb = sock->recv_cb;
+ cbarg = sock->recv_cbarg;
+ isc__nmsocket_clearcb(sock);
+
+ if (cb != NULL) {
+ cb(sock->statichandle, result, NULL, cbarg);
+ }
+}
+
static void
readtimeout_cb(uv_timer_t *handle) {
isc_nmsocket_t *sock = uv_handle_get_data((uv_handle_t *)handle);
- isc_nm_recv_cb_t cb;
- void *cbarg;
REQUIRE(VALID_NMSOCK(sock));
REQUIRE(sock->tid == isc_nm_tid());
/*
* Timeout; stop reading and process whatever we have.
*/
- uv_read_stop(&sock->uv_handle.stream);
- if (sock->quota) {
- isc_quota_detach(&sock->quota);
- }
-
- cb = sock->recv_cb;
- cbarg = sock->recv_cbarg;
- isc__nmsocket_clearcb(sock);
-
- if (cb != NULL) {
- cb(sock->statichandle, ISC_R_TIMEDOUT, NULL, cbarg);
- }
+ failed_read_cb(sock, ISC_R_TIMEDOUT);
}
-isc_result_t
+void
isc__nm_tcp_read(isc_nmhandle_t *handle, isc_nm_recv_cb_t cb, void *cbarg) {
- isc_nmsocket_t *sock = NULL;
+ isc_nmsocket_t *sock = handle->sock;
isc__netievent_startread_t *ievent = NULL;
REQUIRE(VALID_NMHANDLE(handle));
REQUIRE(VALID_NMSOCK(handle->sock));
- sock = handle->sock;
+ if (!isc__nmsocket_active(sock)) {
+ isc__nm_incstats(sock->mgr, sock->statsindex[STATID_RECVFAIL]);
+ cb(handle, ISC_R_CANCELED, NULL, cbarg);
+ return;
+ }
REQUIRE(sock->tid == isc_nm_tid());
sock->recv_cb = cb;
(isc__netievent_t *)ievent);
}
- return (ISC_R_SUCCESS);
+ return;
}
/*%<
int r;
REQUIRE(worker->id == isc_nm_tid());
+
+ r = uv_read_start(&sock->uv_handle.stream, tcp_alloc_cb, read_cb);
+ if (r != 0) {
+ isc__nm_incstats(sock->mgr, sock->statsindex[STATID_RECVFAIL]);
+
+ failed_read_cb(sock, ISC_R_CANCELED);
+
+ return;
+ }
+
if (sock->read_timeout != 0) {
if (!sock->timer_initialized) {
uv_timer_init(&worker->loop, &sock->timer);
uv_timer_start(&sock->timer, readtimeout_cb, sock->read_timeout,
0);
}
-
- r = uv_read_start(&sock->uv_handle.stream, tcp_alloc_cb, read_cb);
- if (r != 0) {
- isc__nm_incstats(sock->mgr, sock->statsindex[STATID_RECVFAIL]);
- }
}
isc_result_t
uv_read_stop(&sock->uv_handle.stream);
}
-isc_result_t
+void
isc__nm_tcp_resumeread(isc_nmsocket_t *sock) {
isc__netievent_startread_t *ievent = NULL;
REQUIRE(sock->tid == isc_nm_tid());
if (sock->recv_cb == NULL) {
- return (ISC_R_CANCELED);
+ return;
+ }
+
+ if (!isc__nmsocket_active(sock)) {
+ failed_read_cb(sock, ISC_R_CANCELED);
+ return;
}
if (!atomic_load(&sock->readpaused)) {
- return (ISC_R_SUCCESS);
+ return;
}
atomic_store(&sock->readpaused, false);
isc__nm_enqueue_ievent(&sock->mgr->workers[sock->tid],
(isc__netievent_t *)ievent);
}
-
- return (ISC_R_SUCCESS);
}
static void
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_recv_cb_t cb;
- void *cbarg;
REQUIRE(VALID_NMSOCK(sock));
REQUIRE(sock->tid == isc_nm_tid());
REQUIRE(buf != NULL);
- cb = sock->recv_cb;
- cbarg = sock->recv_cbarg;
-
if (nread >= 0) {
isc_region_t region = { .base = (unsigned char *)buf->base,
.length = nread };
+ isc_nm_recv_cb_t cb = sock->recv_cb;
+ void *cbarg = sock->recv_cbarg;
if (cb != NULL) {
cb(sock->statichandle, ISC_R_SUCCESS, ®ion, cbarg);
uv_timer_start(&sock->timer, readtimeout_cb,
sock->read_timeout, 0);
}
+ } else {
+ /*
+ * This might happen if the inner socket is closing. It means
+ * that it's detached, so the socket will be closed.
+ */
+ if (nread != UV_EOF) {
+ isc__nm_incstats(sock->mgr,
+ sock->statsindex[STATID_RECVFAIL]);
+ }
- isc__nm_free_uvbuf(sock, buf);
- return;
+ failed_read_cb(sock, ISC_R_EOF);
}
-
isc__nm_free_uvbuf(sock, buf);
-
- /*
- * This might happen if the inner socket is closing. It means that
- * it's detached, so the socket will be closed.
- */
- if (nread != UV_EOF) {
- isc__nm_incstats(sock->mgr, sock->statsindex[STATID_RECVFAIL]);
- }
- if (cb != NULL) {
- isc__nmsocket_clearcb(sock);
- cb(sock->statichandle, ISC_R_EOF, NULL, cbarg);
- }
-
- /*
- * We don't need to clean up now; the socket will be closed and
- * resources and quota reclaimed when handle is freed in
- * isc__nm_tcp_close().
- */
}
static void
return (ISC_R_SUCCESS);
}
-isc_result_t
+void
isc__nm_tcp_send(isc_nmhandle_t *handle, isc_region_t *region, isc_nm_cb_t cb,
void *cbarg) {
isc_nmsocket_t *sock = handle->sock;
REQUIRE(sock->type == isc_nm_tcpsocket);
+ if (!isc__nmsocket_active(sock)) {
+ isc__nm_incstats(sock->mgr, sock->statsindex[STATID_SENDFAIL]);
+ cb(handle, ISC_R_CANCELED, cbarg);
+ return;
+ }
+
uvreq = isc__nm_uvreq_get(sock->mgr, sock);
uvreq->uvbuf.base = (char *)region->base;
uvreq->uvbuf.len = region->length;
+
isc_nmhandle_attach(handle, &uvreq->handle);
+
uvreq->cb.send = cb;
uvreq->cbarg = cbarg;
isc__nm_enqueue_ievent(&sock->mgr->workers[sock->tid],
(isc__netievent_t *)ievent);
}
- return (ISC_R_SUCCESS);
+ return;
}
static void
r = uv_write(&req->uv_req.write, &sock->uv_handle.stream, &req->uvbuf,
1, tcp_send_cb);
if (r < 0) {
- req->cb.send(NULL, isc__nm_uverr2result(r), req->cbarg);
- isc__nm_uvreq_put(&req, sock);
return (isc__nm_uverr2result(r));
}
REQUIRE(VALID_NMSOCK(sock));
REQUIRE(sock->tid == isc_nm_tid());
REQUIRE(sock->type == isc_nm_tcpsocket);
+
if (sock->quota != NULL) {
isc_quota_detach(&sock->quota);
}
uv_read_stop((uv_stream_t *)&sock->uv_handle.handle);
if (sock->timer_initialized) {
- sock->timer_initialized = false;
uv_timer_stop(&sock->timer);
+ }
+
+ if (sock->timer_initialized) {
+ sock->timer_initialized = false;
uv_close((uv_handle_t *)&sock->timer, timer_close_cb);
} else {
uv_close(&sock->uv_handle.handle, tcp_close_cb);
REQUIRE(VALID_NMSOCK(sock));
REQUIRE(sock->tid == isc_nm_tid());
- if (sock->type == isc_nm_tcpsocket && sock->statichandle != NULL) {
- isc_nm_recv_cb_t cb;
- void *cbarg;
+ if (!isc__nmsocket_active(sock)) {
+ return;
+ }
- cb = sock->recv_cb;
- cbarg = sock->recv_cbarg;
- isc__nmsocket_clearcb(sock);
+ atomic_store(&sock->active, false);
- if (cb != NULL) {
- cb(sock->statichandle, ISC_R_CANCELED, NULL, cbarg);
- }
+ if (sock->type == isc_nm_tcpsocket && sock->statichandle != NULL) {
+ failed_read_cb(sock, ISC_R_CANCELED);
}
}
REQUIRE(sock->tid == isc_nm_tid());
if (atomic_load(&sock->client)) {
- isc_nm_recv_cb_t cb;
- void *cbarg;
-
- cb = sock->recv_cb;
- cbarg = sock->recv_cbarg;
- isc__nmsocket_clearcb(sock);
-
- cb(handle, ISC_R_EOF, NULL, cbarg);
+ failed_read_cb(sock, ISC_R_EOF);
}
}
* the connection is closed or there is no more data to be read.
*/
isc_nmhandle_attach(handle, &readhandle);
- result = isc_nm_read(readhandle, dnslisten_readcb, dnssock);
- if (result != ISC_R_SUCCESS) {
- isc_nmhandle_detach(&readhandle);
- }
+ isc_nm_read(readhandle, dnslisten_readcb, dnssock);
isc__nmsocket_detach(&dnssock);
return (ISC_R_SUCCESS);
}
isc_nmhandle_detach(&handle);
} else if (sock->outerhandle != NULL) {
- result = isc_nm_resumeread(sock->outerhandle);
- if (result != ISC_R_SUCCESS) {
- isc_nmhandle_detach(&sock->outerhandle);
- }
+ isc_nm_resumeread(sock->outerhandle);
}
return;
void
isc__nm_async_tcpdnssend(isc__networker_t *worker, isc__netievent_t *ev0) {
- isc_result_t result;
isc__netievent_tcpdnssend_t *ievent =
(isc__netievent_tcpdnssend_t *)ev0;
isc__nm_uvreq_t *req = ievent->req;
REQUIRE(worker->id == sock->tid);
REQUIRE(sock->tid == isc_nm_tid());
- result = ISC_R_NOTCONNECTED;
if (atomic_load(&sock->active) && sock->outerhandle != NULL) {
isc_nmhandle_t *sendhandle = NULL;
isc_region_t r;
r.base = (unsigned char *)req->uvbuf.base;
r.length = req->uvbuf.len;
isc_nmhandle_attach(sock->outerhandle, &sendhandle);
- result = isc_nm_send(sendhandle, &r, tcpdnssend_cb, req);
- if (result != ISC_R_SUCCESS) {
- isc_nmhandle_detach(&sendhandle);
- }
- }
-
- if (result != ISC_R_SUCCESS) {
- req->cb.send(req->handle, result, req->cbarg);
- isc_mem_put(sock->mgr->mctx, req->uvbuf.base, req->uvbuf.len);
- isc__nm_uvreq_put(&req, sock);
+ isc_nm_send(sendhandle, &r, tcpdnssend_cb, req);
+ } else {
+ req->cb.send(req->handle, ISC_R_CANCELED, req->cbarg);
+ isc_mem_put(req->sock->mgr->mctx, req->uvbuf.base,
+ req->uvbuf.len);
+ isc__nm_uvreq_put(&req, req->handle->sock);
}
}
/*
* isc__nm_tcp_send sends buf to a peer on a socket.
*/
-isc_result_t
+void
isc__nm_tcpdns_send(isc_nmhandle_t *handle, isc_region_t *region,
isc_nm_cb_t cb, void *cbarg) {
isc__nm_uvreq_t *uvreq = NULL;
REQUIRE(VALID_NMSOCK(sock));
REQUIRE(sock->type == isc_nm_tcpdnssocket);
+ if (!isc__nmsocket_active(sock)) {
+ cb(handle, ISC_R_CANCELED, cbarg);
+ return;
+ }
+
uvreq = isc__nm_uvreq_get(sock->mgr, sock);
isc_nmhandle_attach(handle, &uvreq->handle);
uvreq->cb.send = cb;
memmove(uvreq->uvbuf.base + 2, region->base, region->length);
if (sock->tid == isc_nm_tid()) {
- isc_result_t result;
isc_nmhandle_t *sendhandle = NULL;
isc_region_t r;
r.length = uvreq->uvbuf.len;
isc_nmhandle_attach(sock->outerhandle, &sendhandle);
- result = isc_nm_send(sock->outerhandle, &r, tcpdnssend_cb,
- uvreq);
- if (result != ISC_R_SUCCESS) {
- isc_nmhandle_detach(&sendhandle);
- }
- return (result);
+ isc_nm_send(sock->outerhandle, &r, tcpdnssend_cb, uvreq);
} else {
isc__netievent_tcpdnssend_t *ievent = NULL;
isc__nm_enqueue_ievent(&sock->mgr->workers[sock->tid],
(isc__netievent_t *)ievent);
-
- return (ISC_R_SUCCESS);
}
-
- return (ISC_R_UNEXPECTED);
}
static void
* a proper sibling/child socket so that we won't have to jump to another
* thread.
*/
-isc_result_t
+void
isc__nm_udp_send(isc_nmhandle_t *handle, isc_region_t *region, isc_nm_cb_t cb,
void *cbarg) {
isc_nmsocket_t *sock = handle->sock;
uint32_t maxudp = atomic_load(&sock->mgr->maxudp);
int ntid;
+ if (!isc__nmsocket_active(sock)) {
+ isc__nm_incstats(sock->mgr, sock->statsindex[STATID_SENDFAIL]);
+ cb(handle, ISC_R_CANCELED, cbarg);
+ return;
+ }
+
/*
* We're simulating a firewall blocking UDP packets bigger than
* 'maxudp' bytes, for testing purposes.
*/
if (maxudp != 0 && region->length > maxudp) {
isc_nmhandle_detach(&handle);
- return (ISC_R_SUCCESS);
+ return;
}
if (sock->type == isc_nm_udpsocket && !atomic_load(&sock->client)) {
ISC_UNREACHABLE();
}
- if (!isc__nmsocket_active(sock)) {
- return (ISC_R_CANCELED);
- }
-
/*
* If we're in the network thread, we can send directly. If the
* handle is associated with a UDP socket, we can reuse its thread
if (isc_nm_tid() == rsock->tid) {
/*
- * If we're in the same thread as the socket we can send the
- * data directly, but we need to emulate returning the error via
- * the callback, not directly to keep the API.
+ * If we're in the same thread as the socket we can send
+ * the data directly, but we still need to return errors
+ * via the callback for API consistency.
*/
isc_result_t result = udp_send_direct(rsock, uvreq, peer);
if (result != ISC_R_SUCCESS) {
+ isc__nm_incstats(rsock->mgr,
+ rsock->statsindex[STATID_SENDFAIL]);
uvreq->cb.send(uvreq->handle, result, uvreq->cbarg);
isc__nm_uvreq_put(&uvreq, sock);
}
isc__nm_enqueue_ievent(&sock->mgr->workers[rsock->tid],
(isc__netievent_t *)ievent);
}
-
- return (ISC_R_SUCCESS);
}
/*
ccmsg->maxsize = maxsize;
}
-isc_result_t
+void
isccc_ccmsg_readmessage(isccc_ccmsg_t *ccmsg, isc_nm_cb_t cb, void *cbarg) {
- isc_result_t result;
-
REQUIRE(VALID_CCMSG(ccmsg));
if (ccmsg->buffer != NULL) {
ccmsg->length_received = false;
if (ccmsg->reading) {
- result = isc_nm_resumeread(ccmsg->handle);
+ isc_nm_resumeread(ccmsg->handle);
} else {
- result = isc_nm_read(ccmsg->handle, recv_data, ccmsg);
+ isc_nm_read(ccmsg->handle, recv_data, ccmsg);
ccmsg->reading = true;
}
- if (result != ISC_R_SUCCESS) {
- ccmsg->reading = false;
- }
-
- return (result);
}
void
*\li 512 <= "maxsize" <= 4294967296
*/
-isc_result_t
+void
isccc_ccmsg_readmessage(isccc_ccmsg_t *ccmsg, isc_nm_cb_t cb, void *cbarg);
/*%
* Schedule an event to be delivered when a command channel message is
*
*\li "ccmsg" be valid.
*
- * Returns:
- *
- *\li #ISC_R_SUCCESS -- no error
- *\li Anything that the isc_nm_read() call can return.
- *
* Notes:
*
*\li The event delivered is a fully generic event. It will contain no
*datap = data;
}
-static isc_result_t
+static void
client_sendpkg(ns_client_t *client, isc_buffer_t *buffer) {
- isc_result_t result;
isc_region_t r;
REQUIRE(client->sendhandle == NULL);
isc_buffer_usedregion(buffer, &r);
isc_nmhandle_attach(client->handle, &client->sendhandle);
- result = isc_nm_send(client->handle, &r, client_senddone, client);
- if (result != ISC_R_SUCCESS) {
- isc_nmhandle_detach(&client->sendhandle);
- }
- return (result);
+ isc_nm_send(client->handle, &r, client_senddone, client);
}
void
r.base[0] = (client->message->id >> 8) & 0xff;
r.base[1] = client->message->id & 0xff;
- result = client_sendpkg(client, &buffer);
- if (result == ISC_R_SUCCESS) {
- return;
- }
+ client_sendpkg(client, &buffer);
+ return;
done:
if (client->tcpbuf != NULL) {
isc_mem_put(client->mctx, client->tcpbuf,
result = ns_client_addopt(client, client->message,
&client->opt);
if (result != ISC_R_SUCCESS) {
- goto done;
+ goto cleanup;
}
}
result = dns_compress_init(&cctx, -1, client->mctx);
if (result != ISC_R_SUCCESS) {
- goto done;
+ goto cleanup;
}
if (client->peeraddr_valid && client->view != NULL) {
isc_netaddr_t netaddr;
result = dns_message_renderbegin(client->message, &cctx, &buffer);
if (result != ISC_R_SUCCESS) {
- goto done;
+ goto cleanup;
}
if (client->opt != NULL) {
opt_included = true;
client->opt = NULL;
if (result != ISC_R_SUCCESS) {
- goto done;
+ goto cleanup;
}
}
result = dns_message_rendersection(client->message,
goto renderend;
}
if (result != ISC_R_SUCCESS) {
- goto done;
+ goto cleanup;
}
/*
* Stop after the question if TC was set for rate limiting.
goto renderend;
}
if (result != ISC_R_SUCCESS) {
- goto done;
+ goto cleanup;
}
result = dns_message_rendersection(
client->message, DNS_SECTION_AUTHORITY,
goto renderend;
}
if (result != ISC_R_SUCCESS) {
- goto done;
+ goto cleanup;
}
result = dns_message_rendersection(client->message,
DNS_SECTION_ADDITIONAL,
preferred_glue | render_opts);
if (result != ISC_R_SUCCESS && result != ISC_R_NOSPACE) {
- goto done;
+ goto cleanup;
}
renderend:
result = dns_message_renderend(client->message);
if (result != ISC_R_SUCCESS) {
- goto done;
+ goto cleanup;
}
#ifdef HAVE_DNSTAP
if (((client->message->flags & DNS_MESSAGEFLAG_AA) != 0) &&
(client->query.authzone != NULL))
{
+ isc_result_t eresult;
isc_buffer_t b;
dns_name_t *zo = dns_zone_getorigin(client->query.authzone);
isc_buffer_init(&b, zone, sizeof(zone));
dns_compress_setmethods(&cctx, DNS_COMPRESS_NONE);
- result = dns_name_towire(zo, &cctx, &b);
- if (result == ISC_R_SUCCESS) {
+ eresult = dns_name_towire(zo, &cctx, &b);
+ if (eresult == ISC_R_SUCCESS) {
isc_buffer_usedregion(&b, &zr);
}
}
if (cleanup_cctx) {
dns_compress_invalidate(&cctx);
- cleanup_cctx = false;
}
if (client->sendcb != NULL) {
respsize = isc_buffer_usedlength(&buffer);
- result = client_sendpkg(client, &buffer);
+ client_sendpkg(client, &buffer);
switch (isc_sockaddr_pf(&client->peeraddr)) {
case AF_INET:
respsize = isc_buffer_usedlength(&buffer);
- result = client_sendpkg(client, &buffer);
+ client_sendpkg(client, &buffer);
switch (isc_sockaddr_pf(&client->peeraddr)) {
case AF_INET:
ns_statscounter_truncatedresp);
}
- if (result == ISC_R_SUCCESS) {
- return;
- }
+ return;
-done:
+cleanup:
if (client->tcpbuf != NULL) {
isc_mem_put(client->mctx, client->tcpbuf,
NS_CLIENT_TCP_BUFFER_SIZE);
isc_nmhandle_attach(xfr->client->handle,
&xfr->client->sendhandle);
- CHECK(isc_nm_send(xfr->client->sendhandle, &used,
- xfrout_senddone, xfr));
+ isc_nm_send(xfr->client->sendhandle, &used, xfrout_senddone,
+ xfr);
xfr->sends++;
xfr->cbytes = used.length;
} else {
projects / thirdparty / bind9.git / commitdiff
