#include <stdio.h>
#include <stdlib.h>
#include <string.h>
-#include <uv.h>
#include <isc/mem.h>
#include <isc/print.h>
#include <isc/result.h>
#include <isc/util.h>
+#include <isc/uv.h>
#include <dns/dlz_dlopen.h>
#include <dns/log.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
-#include <uv.h>
#ifdef HAVE_DNSTAP
#include <protobuf-c/protobuf-c.h>
#include <isc/task.h>
#include <isc/timer.h>
#include <isc/util.h>
+#include <isc/uv.h>
#include <dns/dispatch.h>
#include <dns/dyndb.h>
*/
#include <string.h>
-#include <uv.h>
#include <isc/buffer.h>
#include <isc/mem.h>
#include <isc/task.h>
#include <isc/types.h>
#include <isc/util.h>
+#include <isc/uv.h>
#include <dns/dyndb.h>
#include <dns/log.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
-#include <uv.h>
#define UNIT_TESTING
#include <cmocka.h>
#include <isc/refcount.h>
#include <isc/task.h>
#include <isc/util.h>
+#include <isc/uv.h>
#include <dns/dispatch.h>
#include <dns/name.h>
static int
setup_ephemeral_port(isc_sockaddr_t *addr, sa_family_t family) {
socklen_t addrlen = sizeof(*addr);
- uv_os_sock_t fd;
+ uv_os_sock_t fd = -1;
int r;
isc_sockaddr_fromin6(addr, &in6addr_loopback, 0);
include/isc/types.h \
include/isc/url.h \
include/isc/utf8.h \
- include/isc/util.h
+ include/isc/util.h \
+ include/isc/uv.h
libisc_la_SOURCES = \
$(libisc_la_HEADERS) \
netmgr/timer.c \
netmgr/tlsdns.c \
netmgr/udp.c \
- netmgr/uv-compat.c \
- netmgr/uv-compat.h \
- netmgr/uverr2result.c \
aes.c \
app.c \
assertions.c \
trampoline.c \
trampoline_p.h \
url.c \
- utf8.c
+ utf8.c \
+ uv.c
libisc_la_CPPFLAGS = \
$(AM_CPPFLAGS) \
#else
-#include <uv.h>
+#include <isc/uv.h>
#define isc_barrier_t uv_barrier_t
*/
#pragma once
+
+#include <stdbool.h>
#include <uv.h>
+#include <isc/result.h>
+
/*
* These functions were introduced in newer libuv, but we still
* want BIND9 compile on older ones so we emulate them.
- * They're inline to avoid conflicts when running with a newer
- * library version.
*/
#define UV_VERSION(major, minor, patch) ((major << 16) | (minor << 8) | (patch))
#define UV__ERR(x) (-(x))
#endif
+#if UV_VERSION_HEX < UV_VERSION(1, 12, 0)
+int
+uv_os_getenv(const char *name, char *buffer, size_t *size);
+
+#define uv_os_setenv(name, value) setenv(name, value, 0)
+#endif /* UV_VERSION_HEX < UV_VERSION(1, 12, 0) */
+
#if UV_VERSION_HEX < UV_VERSION(1, 19, 0)
static inline void *
uv_handle_get_data(const uv_handle_t *handle) {
#define isc_uv_udp_connect uv_udp_connect
#endif /* UV_VERSION_HEX < UV_VERSION(1, 27, 0) */
-#if UV_VERSION_HEX < UV_VERSION(1, 12, 0)
-#include <stdlib.h>
-#include <string.h>
-
-static inline int
-uv_os_getenv(const char *name, char *buffer, size_t *size) {
- size_t len;
- char *buf = getenv(name);
-
- if (buf == NULL) {
- return (UV_ENOENT);
- }
+/*
+ * These are used with all versions of libuv:
+ */
- len = strlen(buf) + 1;
- if (len > *size) {
- *size = len;
- return (UV_ENOBUFS);
+#define UV_RUNTIME_CHECK(func, ret) \
+ if (ret != 0) { \
+ isc_error_fatal(__FILE__, __LINE__, "%s failed: %s\n", #func, \
+ uv_strerror(ret)); \
}
- *size = len;
- memmove(buffer, buf, len);
+#define isc_uverr2result(x) \
+ isc__uverr2result(x, true, __FILE__, __LINE__, __func__)
+isc_result_t
+isc__uverr2result(int uverr, bool dolog, const char *file, unsigned int line,
+ const char *func);
+/*%<
+ * Convert a libuv error value into an isc_result_t. The
+ * list of supported error values is not complete; new users
+ * of this function should add any expected errors that are
+ * not already there.
+ */
- return (0);
-}
+/**
+ * Type-casting helpers
+ */
-#define uv_os_setenv(name, value) setenv(name, value, 0)
-#endif /* UV_VERSION_HEX < UV_VERSION(1, 12, 0) */
+#define uv_handle_set_data(handle, data) \
+ uv_handle_set_data((uv_handle_t *)(handle), (data))
+#define uv_handle_get_data(handle) uv_handle_get_data((uv_handle_t *)(handle))
+#define uv_close(handle, close_cb) uv_close((uv_handle_t *)handle, close_cb)
#pragma once
#include <unistd.h>
-#include <uv.h>
#include <openssl/err.h>
#include <openssl/ssl.h>
#include <isc/thread.h>
#include <isc/tls.h>
#include <isc/util.h>
-
-#include "uv-compat.h"
+#include <isc/uv.h>
#define ISC_NETMGR_TID_UNKNOWN -1
void
isc__nm_async_settlsctx(isc__networker_t *worker, isc__netievent_t *ev0);
-#define isc__nm_uverr2result(x) \
- isc___nm_uverr2result(x, true, __FILE__, __LINE__, __func__)
-isc_result_t
-isc___nm_uverr2result(int uverr, bool dolog, const char *file,
- unsigned int line, const char *func);
-/*%<
- * Convert a libuv error value into an isc_result_t. The
- * list of supported error values is not complete; new users
- * of this function should add any expected errors that are
- * not already there.
- */
-
bool
isc__nm_acquire_interlocked(isc_nm_t *mgr);
/*%<
void
isc__nmsocket_writetimeout_cb(void *data, isc_result_t eresult);
-#define UV_RUNTIME_CHECK(func, ret) \
- if (ret != 0) { \
- isc_error_fatal(__FILE__, __LINE__, "%s failed: %s", #func, \
- uv_strerror(ret)); \
- }
-
/*
* Bind to the socket, but allow binding to IPv6 tentative addresses reported by
* the route socket by setting IP_FREEBIND (or equivalent).
#include <inttypes.h>
#include <unistd.h>
-#include <uv.h>
#include <isc/atomic.h>
#include <isc/backtrace.h>
#include <isc/thread.h>
#include <isc/tls.h>
#include <isc/util.h>
+#include <isc/uv.h>
#include "netmgr-int.h"
#include "netmgr_p.h"
#include "openssl_shim.h"
#include "trampoline_p.h"
-#include "uv-compat.h"
/*%
* How many isc_nmhandles and isc_nm_uvreqs will we be
isc_nm_t *netmgr = work->netmgr;
if (status != 0) {
- result = isc__nm_uverr2result(status);
+ result = isc_uverr2result(status);
}
work->after_cb(work->data, result);
*/
#include <isc/errno.h>
+#include <isc/uv.h>
#include "netmgr-int.h"
-#include "uv-compat.h"
#define setsockopt_on(socket, level, name) \
setsockopt(socket, level, name, &(int){ 1 }, sizeof(int))
isc__nm_udp_freebind(uv_udp_t *handle, const struct sockaddr *addr,
unsigned int flags) {
int r;
- uv_os_sock_t fd;
+ uv_os_sock_t fd = -1;
r = uv_fileno((const uv_handle_t *)handle, (uv_os_fd_t *)&fd);
if (r < 0) {
isc__nm_tcp_freebind(uv_tcp_t *handle, const struct sockaddr *addr,
unsigned int flags) {
int r;
- uv_os_sock_t fd;
+ uv_os_sock_t fd = -1;
r = uv_fileno((const uv_handle_t *)handle, (uv_os_fd_t *)&fd);
if (r < 0) {
#include <libgen.h>
#include <unistd.h>
-#include <uv.h>
#include <isc/atomic.h>
#include <isc/barrier.h>
#include <isc/stdtime.h>
#include <isc/thread.h>
#include <isc/util.h>
+#include <isc/uv.h>
#include "netmgr-int.h"
-#include "uv-compat.h"
static atomic_uint_fast32_t last_tcpquota_log = 0;
atomic_store(&sock->connected, true);
done:
- result = isc__nm_uverr2result(r);
+ result = isc_uverr2result(r);
LOCK(&sock->lock);
sock->result = result;
SIGNAL(&sock->cond);
result = ISC_R_TIMEDOUT;
goto error;
} else if (status != 0) {
- result = isc__nm_uverr2result(status);
+ result = isc_uverr2result(status);
goto error;
}
r = uv_tcp_getpeername(&sock->uv_handle.tcp, (struct sockaddr *)&ss,
&(int){ sizeof(ss) });
if (r != 0) {
- result = isc__nm_uverr2result(r);
+ result = isc_uverr2result(r);
goto error;
}
isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
ISC_LOGMODULE_NETMGR, ISC_LOG_ERROR,
"uv_listen failed: %s",
- isc_result_totext(isc__nm_uverr2result(r)));
+ isc_result_totext(isc_uverr2result(r)));
isc__nm_incstats(sock, STATID_BINDFAIL);
goto done;
}
atomic_store(&sock->listening, true);
done:
- result = isc__nm_uverr2result(r);
+ result = isc_uverr2result(r);
if (result != ISC_R_SUCCESS) {
sock->pquota = NULL;
}
isc_quota_t *quota = NULL;
if (status != 0) {
- result = isc__nm_uverr2result(status);
+ result = isc_uverr2result(status);
goto done;
}
isc__nm_incstats(sock, STATID_RECVFAIL);
}
- isc__nm_tcp_failed_read_cb(sock, isc__nm_uverr2result(nread));
+ isc__nm_tcp_failed_read_cb(sock, isc_uverr2result(nread));
goto free;
}
r = uv_accept(&ssock->uv_handle.stream, &csock->uv_handle.stream);
if (r != 0) {
- result = isc__nm_uverr2result(r);
+ result = isc_uverr2result(r);
goto failure;
}
r = uv_tcp_getpeername(&csock->uv_handle.tcp, (struct sockaddr *)&ss,
&(int){ sizeof(ss) });
if (r != 0) {
- result = isc__nm_uverr2result(r);
+ result = isc_uverr2result(r);
goto failure;
}
r = uv_tcp_getsockname(&csock->uv_handle.tcp, (struct sockaddr *)&ss,
&(int){ sizeof(ss) });
if (r != 0) {
- result = isc__nm_uverr2result(r);
+ result = isc_uverr2result(r);
goto failure;
}
if (status < 0) {
isc__nm_incstats(sock, STATID_SENDFAIL);
- isc__nm_failed_send_cb(sock, uvreq,
- isc__nm_uverr2result(status));
+ isc__nm_failed_send_cb(sock, uvreq, isc_uverr2result(status));
return;
}
r = uv_write(&req->uv_req.write, &sock->uv_handle.stream, &req->uvbuf,
1, tcp_send_cb);
if (r < 0) {
- return (isc__nm_uverr2result(r));
+ return (isc_uverr2result(r));
}
isc_nm_timer_create(req->handle, isc__nmsocket_writetimeout_cb, req,
#include <libgen.h>
#include <unistd.h>
-#include <uv.h>
#include <isc/atomic.h>
#include <isc/barrier.h>
#include <isc/stdtime.h>
#include <isc/thread.h>
#include <isc/util.h>
+#include <isc/uv.h>
#include "netmgr-int.h"
-#include "uv-compat.h"
static atomic_uint_fast32_t last_tcpdnsquota_log = 0;
atomic_store(&sock->connected, true);
done:
- result = isc__nm_uverr2result(r);
+ result = isc_uverr2result(r);
error:
LOCK(&sock->lock);
sock->result = result;
result = ISC_R_TIMEDOUT;
goto error;
} else if (status != 0) {
- result = isc__nm_uverr2result(status);
+ result = isc_uverr2result(status);
goto error;
}
r = uv_tcp_getpeername(&sock->uv_handle.tcp, (struct sockaddr *)&ss,
&(int){ sizeof(ss) });
if (r != 0) {
- result = isc__nm_uverr2result(r);
+ result = isc_uverr2result(r);
goto error;
}
static uv_os_sock_t
isc__nm_tcpdns_lb_socket(isc_nm_t *mgr, sa_family_t sa_family) {
isc_result_t result;
- uv_os_sock_t sock;
+ uv_os_sock_t sock = -1;
result = isc__nm_socket(sa_family, SOCK_STREAM, 0, &sock);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
ISC_LOGMODULE_NETMGR, ISC_LOG_ERROR,
"uv_listen failed: %s",
- isc_result_totext(isc__nm_uverr2result(r)));
+ isc_result_totext(isc_uverr2result(r)));
isc__nm_incstats(sock, STATID_BINDFAIL);
goto done;
}
atomic_store(&sock->listening, true);
done:
- result = isc__nm_uverr2result(r);
+ result = isc_uverr2result(r);
if (result != ISC_R_SUCCESS) {
sock->pquota = NULL;
}
isc_quota_t *quota = NULL;
if (status != 0) {
- result = isc__nm_uverr2result(status);
+ result = isc_uverr2result(status);
goto done;
}
isc__nm_incstats(sock, STATID_RECVFAIL);
}
- isc__nm_failed_read_cb(sock, isc__nm_uverr2result(nread), true);
+ isc__nm_failed_read_cb(sock, isc_uverr2result(nread), true);
goto free;
}
r = uv_accept(&ssock->uv_handle.stream, &csock->uv_handle.stream);
if (r != 0) {
- result = isc__nm_uverr2result(r);
+ result = isc_uverr2result(r);
goto failure;
}
(struct sockaddr *)&peer_ss,
&(int){ sizeof(peer_ss) });
if (r != 0) {
- result = isc__nm_uverr2result(r);
+ result = isc_uverr2result(r);
goto failure;
}
(struct sockaddr *)&local_ss,
&(int){ sizeof(local_ss) });
if (r != 0) {
- result = isc__nm_uverr2result(r);
+ result = isc_uverr2result(r);
goto failure;
}
if (status < 0) {
isc__nm_incstats(sock, STATID_SENDFAIL);
- isc__nm_failed_send_cb(sock, uvreq,
- isc__nm_uverr2result(status));
+ isc__nm_failed_send_cb(sock, uvreq, isc_uverr2result(status));
return;
}
/* uv_try_write not supported, send asynchronously */
} else {
/* error sending data */
- result = isc__nm_uverr2result(r);
+ result = isc_uverr2result(r);
goto fail;
}
r = uv_write(&uvreq->uv_req.write, &sock->uv_handle.stream, bufs, nbufs,
tcpdns_send_cb);
if (r < 0) {
- result = isc__nm_uverr2result(r);
+ result = isc_uverr2result(r);
goto fail;
}
* information regarding copyright ownership.
*/
-#include <uv.h>
-
#include <isc/netmgr.h>
#include <isc/util.h>
+#include <isc/uv.h>
#include "netmgr-int.h"
#include <libgen.h>
#include <unistd.h>
-#include <uv.h>
#include <isc/atomic.h>
#include <isc/barrier.h>
#include <isc/stdtime.h>
#include <isc/thread.h>
#include <isc/util.h>
+#include <isc/uv.h>
#include "netmgr-int.h"
#include "openssl_shim.h"
-#include "uv-compat.h"
static atomic_uint_fast32_t last_tlsdnsquota_log = 0;
atomic_store(&sock->connected, true);
done:
- result = isc__nm_uverr2result(r);
+ result = isc_uverr2result(r);
error:
LOCK(&sock->lock);
sock->result = result;
result = ISC_R_TIMEDOUT;
goto error;
} else if (status != 0) {
- result = isc__nm_uverr2result(status);
+ result = isc_uverr2result(status);
goto error;
}
r = uv_tcp_getpeername(&sock->uv_handle.tcp, (struct sockaddr *)&ss,
&(int){ sizeof(ss) });
if (r != 0) {
- result = isc__nm_uverr2result(r);
+ result = isc_uverr2result(r);
goto error;
}
isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
ISC_LOGMODULE_NETMGR, ISC_LOG_ERROR,
"uv_listen failed: %s",
- isc_result_totext(isc__nm_uverr2result(r)));
+ isc_result_totext(isc_uverr2result(r)));
isc__nm_incstats(sock, STATID_BINDFAIL);
goto done;
}
atomic_store(&sock->listening, true);
done:
- result = isc__nm_uverr2result(r);
+ result = isc_uverr2result(r);
if (result != ISC_R_SUCCESS) {
sock->pquota = NULL;
}
isc_quota_t *quota = NULL;
if (status != 0) {
- result = isc__nm_uverr2result(status);
+ result = isc_uverr2result(status);
goto done;
}
static void
tls_write_cb(uv_write_t *req, int status) {
- isc_result_t result = status != 0 ? isc__nm_uverr2result(status)
+ isc_result_t result = status != 0 ? isc_uverr2result(status)
: ISC_R_SUCCESS;
isc__nm_uvreq_t *uvreq = (isc__nm_uvreq_t *)req->data;
isc_nmsocket_t *sock = uvreq->sock;
/* uv_try_write is not supported, send
* asynchronously */
} else {
- result = isc__nm_uverr2result(r);
+ result = isc_uverr2result(r);
isc__nm_uvreq_put(&req, sock);
free_senddata(sock, result);
break;
r = uv_write(&req->uv_req.write, &sock->uv_handle.stream,
&req->uvbuf, 1, tls_write_cb);
if (r < 0) {
- result = isc__nm_uverr2result(r);
+ result = isc_uverr2result(r);
isc__nm_uvreq_put(&req, sock);
free_senddata(sock, result);
break;
isc__nm_incstats(sock, STATID_RECVFAIL);
}
- isc__nm_failed_read_cb(sock, isc__nm_uverr2result(nread), true);
+ isc__nm_failed_read_cb(sock, isc_uverr2result(nread), true);
goto free;
}
r = uv_accept(&ssock->uv_handle.stream, &csock->uv_handle.stream);
if (r != 0) {
- result = isc__nm_uverr2result(r);
+ result = isc_uverr2result(r);
goto failure;
}
(struct sockaddr *)&peer_ss,
&(int){ sizeof(peer_ss) });
if (r != 0) {
- result = isc__nm_uverr2result(r);
+ result = isc_uverr2result(r);
goto failure;
}
(struct sockaddr *)&local_ss,
&(int){ sizeof(local_ss) });
if (r != 0) {
- result = isc__nm_uverr2result(r);
+ result = isc_uverr2result(r);
goto failure;
}
#include <errno.h>
#include <libgen.h>
#include <unistd.h>
-#include <uv.h>
#include <openssl/err.h>
#include <openssl/ssl.h>
#include <isc/stdtime.h>
#include <isc/thread.h>
#include <isc/util.h>
+#include <isc/uv.h>
#include "../openssl_shim.h"
#include "netmgr-int.h"
-#include "uv-compat.h"
#define TLS_BUF_SIZE (UINT16_MAX)
*/
#include <unistd.h>
-#include <uv.h>
#include <isc/atomic.h>
#include <isc/barrier.h>
#include <isc/sockaddr.h>
#include <isc/thread.h>
#include <isc/util.h>
+#include <isc/uv.h>
#include "netmgr-int.h"
-#include "uv-compat.h"
#ifdef HAVE_NET_ROUTE_H
#include <net/route.h>
static uv_os_sock_t
isc__nm_udp_lb_socket(isc_nm_t *mgr, sa_family_t sa_family) {
isc_result_t result;
- uv_os_sock_t sock;
+ uv_os_sock_t sock = -1;
result = isc__nm_socket(sa_family, SOCK_DGRAM, 0, &sock);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
static isc_result_t
route_socket(uv_os_sock_t *fdp) {
isc_result_t result;
- uv_os_sock_t fd;
+ uv_os_sock_t fd = -1;
#ifdef USE_NETLINK
struct sockaddr_nl sa;
int r;
atomic_store(&sock->connected, true);
done:
- result = isc__nm_uverr2result(r);
+ result = isc_uverr2result(r);
error:
LOCK(&sock->lock);
atomic_store(&sock->listening, true);
done:
- result = isc__nm_uverr2result(r);
+ result = isc_uverr2result(r);
atomic_fetch_add(&sock->parent->rchildren, 1);
if (sock->parent->result == ISC_R_UNSET) {
sock->parent->result = result;
* - If there was a networking error.
*/
if (nrecv < 0) {
- isc__nm_failed_read_cb(sock, isc__nm_uverr2result(nrecv),
- false);
+ isc__nm_failed_read_cb(sock, isc_uverr2result(nrecv), false);
goto free;
}
REQUIRE(sock->tid == isc_nm_tid());
if (status < 0) {
- result = isc__nm_uverr2result(status);
+ result = isc_uverr2result(status);
isc__nm_incstats(sock, STATID_SENDFAIL);
}
r = uv_udp_send(&req->uv_req.udp_send, &sock->uv_handle.udp,
&req->uvbuf, 1, sa, udp_send_cb);
if (r < 0) {
- return (isc__nm_uverr2result(r));
+ return (isc_uverr2result(r));
}
return (ISC_R_SUCCESS);
atomic_store(&sock->connected, true);
done:
- result = isc__nm_uverr2result(r);
+ result = isc_uverr2result(r);
error:
LOCK(&sock->lock);
+++ /dev/null
-/*
- * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
- *
- * SPDX-License-Identifier: MPL-2.0
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, you can obtain one at https://mozilla.org/MPL/2.0/.
- *
- * See the COPYRIGHT file distributed with this work for additional
- * information regarding copyright ownership.
- */
-
-#include "uv-compat.h"
-#include <unistd.h>
-
-#include <isc/util.h>
-
-#include "netmgr-int.h"
-
-#if UV_VERSION_HEX < UV_VERSION(1, 27, 0)
-int
-isc_uv_udp_connect(uv_udp_t *handle, const struct sockaddr *addr) {
- int err = 0;
-
- do {
- int addrlen = (addr->sa_family == AF_INET)
- ? sizeof(struct sockaddr_in)
- : sizeof(struct sockaddr_in6);
- err = connect(handle->io_watcher.fd, addr, addrlen);
- } while (err == -1 && errno == EINTR);
-
- if (err) {
-#if UV_VERSION_HEX >= UV_VERSION(1, 10, 0)
- return (uv_translate_sys_error(errno));
-#else
- return (-errno);
-#endif /* UV_VERSION_HEX >= UV_VERSION(1, 10, 0) */
- }
-
- return (0);
-}
-#endif /* UV_VERSION_HEX < UV_VERSION(1, 27, 0) */
-
-#if UV_VERSION_HEX < UV_VERSION(1, 32, 0)
-int
-uv_tcp_close_reset(uv_tcp_t *handle, uv_close_cb close_cb) {
- if (setsockopt(handle->io_watcher.fd, SOL_SOCKET, SO_LINGER,
- &(struct linger){ 1, 0 }, sizeof(struct linger)) == -1)
- {
-#if UV_VERSION_HEX >= UV_VERSION(1, 10, 0)
- return (uv_translate_sys_error(errno));
-#else
- return (-errno);
-#endif /* UV_VERSION_HEX >= UV_VERSION(1, 10, 0) */
- }
-
- uv_close((uv_handle_t *)handle, close_cb);
- return (0);
-}
-#endif /* UV_VERSION_HEX < UV_VERSION(1, 32, 0) */
#include <stdbool.h>
#include <unistd.h>
-#include <uv.h>
#include <isc/app.h>
#include <isc/atomic.h>
#include <isc/thread.h>
#include <isc/time.h>
#include <isc/util.h>
+#include <isc/uv.h>
#ifdef HAVE_LIBXML2
#include <libxml/xmlwriter.h>
#include <json_object.h>
#endif /* HAVE_JSON_C */
-#include "netmgr/uv-compat.h"
#include "task_p.h"
/*
include $(top_srcdir)/Makefile.top
AM_CPPFLAGS += \
- $(LIBISC_CFLAGS)
+ $(LIBISC_CFLAGS) \
+ -I..
LDADD += \
libisctest.la \
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
-#include <uv.h>
#define UNIT_TESTING
#include <cmocka.h>
#include <isc/refcount.h>
#include <isc/sockaddr.h>
#include <isc/thread.h>
+#include <isc/uv.h>
#include "uv_wrap.h"
#define KEEP_BEFORE
#include "../netmgr/http.c"
#include "../netmgr/netmgr-int.h"
#include "../netmgr/socket.c"
-#include "../netmgr/uv-compat.c"
-#include "../netmgr/uv-compat.h"
#include "../netmgr_p.h"
#include "isctest.h"
#include <stdarg.h>
#include <stdlib.h>
#include <unistd.h>
-#include <uv.h>
#define UNIT_TESTING
#include <cmocka.h>
#include <isc/sockaddr.h>
#include <isc/thread.h>
#include <isc/util.h>
+#include <isc/uv.h>
#include "uv_wrap.h"
#define KEEP_BEFORE
#include "../netmgr/netmgr-int.h"
#include "../netmgr/socket.c"
#include "../netmgr/udp.c"
-#include "../netmgr/uv-compat.c"
-#include "../netmgr/uv-compat.h"
#include "../netmgr_p.h"
#include "isctest.h"
static int
setup_ephemeral_port(isc_sockaddr_t *addr, sa_family_t family) {
socklen_t addrlen = sizeof(*addr);
- uv_os_sock_t fd;
+ uv_os_sock_t fd = -1;
int r;
isc_sockaddr_fromin6(addr, &in6addr_loopback, 0);
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
-#include <uv.h>
#include <isc/atomic.h>
#define UNIT_TESTING
#include <cmocka.h>
-#include "../netmgr/uv-compat.h"
+#include <isc/uv.h>
/* uv_udp_t */
* information regarding copyright ownership.
*/
-#include <stdbool.h>
-#include <uv.h>
+#include <unistd.h>
-#include <isc/result.h>
-#include <isc/strerr.h>
-#include <isc/string.h>
#include <isc/util.h>
+#include <isc/uv.h>
-#include "netmgr-int.h"
+#if UV_VERSION_HEX < UV_VERSION(1, 12, 0)
+#include <stdlib.h>
+#include <string.h>
+
+#endif
+
+#if UV_VERSION_HEX < UV_VERSION(1, 27, 0)
+int
+isc_uv_udp_connect(uv_udp_t *handle, const struct sockaddr *addr) {
+ int err = 0;
+
+ do {
+ int addrlen = (addr->sa_family == AF_INET)
+ ? sizeof(struct sockaddr_in)
+ : sizeof(struct sockaddr_in6);
+ err = connect(handle->io_watcher.fd, addr, addrlen);
+ } while (err == -1 && errno == EINTR);
+
+ if (err) {
+#if UV_VERSION_HEX >= UV_VERSION(1, 10, 0)
+ return (uv_translate_sys_error(errno));
+#else
+ return (-errno);
+#endif /* UV_VERSION_HEX >= UV_VERSION(1, 10, 0) */
+ }
+
+ return (0);
+}
+#endif /* UV_VERSION_HEX < UV_VERSION(1, 27, 0) */
+
+#if UV_VERSION_HEX < UV_VERSION(1, 32, 0)
+int
+uv_tcp_close_reset(uv_tcp_t *handle, uv_close_cb close_cb) {
+ if (setsockopt(handle->io_watcher.fd, SOL_SOCKET, SO_LINGER,
+ &(struct linger){ 1, 0 }, sizeof(struct linger)) == -1)
+ {
+#if UV_VERSION_HEX >= UV_VERSION(1, 10, 0)
+ return (uv_translate_sys_error(errno));
+#else
+ return (-errno);
+#endif /* UV_VERSION_HEX >= UV_VERSION(1, 10, 0) */
+ }
+
+ INSIST(!uv_is_closing((uv_handle_t *)handle));
+ uv_close((uv_handle_t *)handle, close_cb);
+ return (0);
+}
+#endif /* UV_VERSION_HEX < UV_VERSION(1, 32, 0) */
+
+#define setsockopt_on(socket, level, name) \
+ setsockopt(socket, level, name, &(int){ 1 }, sizeof(int))
/*%
* Convert a libuv error value into an isc_result_t. The
* not already there.
*/
isc_result_t
-isc___nm_uverr2result(int uverr, bool dolog, const char *file,
- unsigned int line, const char *func) {
+isc__uverr2result(int uverr, bool dolog, const char *file, unsigned int line,
+ const char *func) {
switch (uverr) {
case 0:
return (ISC_R_SUCCESS);
#include <errno.h>
#include <stdio.h>
#include <string.h>
-#include <uv.h>
#include <isc/errno.h>
#include <isc/list.h>
#include <isc/result.h>
#include <isc/types.h>
#include <isc/util.h>
+#include <isc/uv.h>
#include <dns/view.h>
projects / thirdparty / bind9.git / commitdiff
