* BSD 3-Clause License
*
* Copyright (c) 2005-2008, Jelmer Vernooij <jelmer@samba.org>
- * Copyright (c) 2006-2018, Stefan Metzmacher <metze@samba.org>
- * Copyright (c) 2013-20
18, Andreas Schneider <asn@samba.org>
+ * Copyright (c) 2006-2021, Stefan Metzmacher <metze@samba.org>
+ * Copyright (c) 2013-20
21, Andreas Schneider <asn@samba.org>
* Copyright (c) 2014-2017, Michael Adam <obnox@samba.org>
* Copyright (c) 2016-2018, Anoop C S <anoopcs@redhat.com>
* All rights reserved.
#endif
#include <pthread.h>
+#include "socket_wrapper.h"
+
enum swrap_dbglvl_e {
SWRAP_LOG_ERROR = 0,
SWRAP_LOG_WARN,
/* Mutex to guard the initialization of array of socket_info structures */
static pthread_mutex_t sockets_mutex = PTHREAD_MUTEX_INITIALIZER;
-/* Mutex to guard the socket reset in swrap_close() and swrap_remove_stale() */
+/* Mutex to guard the socket reset in swrap_remove_wrapper() */
static pthread_mutex_t socket_reset_mutex = PTHREAD_MUTEX_INITIALIZER;
/* Mutex to synchronize access to first free index in socket_info array */
/* Function prototypes */
-bool socket_wrapper_enabled(void);
-
#if ! defined(HAVE_CONSTRUCTOR_ATTRIBUTE) && defined(HAVE_PRAGMA_INIT)
/* xlC and other oldschool compilers support (only) this */
#pragma init (swrap_constructor)
const struct sockaddr *addr,
socklen_t addrlen);
typedef int (*__libc_close)(int fd);
+#ifdef HAVE___CLOSE_NOCANCEL
+typedef int (*__libc___close_nocancel)(int fd);
+#endif
typedef int (*__libc_connect)(int sockfd,
const struct sockaddr *addr,
socklen_t addrlen);
struct sockaddr *src_addr,
socklen_t *addrlen);
typedef int (*__libc_recvmsg)(int sockfd, const struct msghdr *msg, int flags);
+#ifdef HAVE_RECVMMSG
+#if defined(HAVE_RECVMMSG_SSIZE_T_CONST_TIMEOUT)
+/* FreeBSD */
+typedef ssize_t (*__libc_recvmmsg)(int sockfd, struct mmsghdr *msgvec, size_t vlen, int flags, const struct timespec *timeout);
+#elif defined(HAVE_RECVMMSG_CONST_TIMEOUT)
+/* Linux legacy glibc < 2.21 */
+typedef int (*__libc_recvmmsg)(int sockfd, struct mmsghdr *msgvec, unsigned int vlen, int flags, const struct timespec *timeout);
+#else
+/* Linux glibc >= 2.21 */
+typedef int (*__libc_recvmmsg)(int sockfd, struct mmsghdr *msgvec, unsigned int vlen, int flags, struct timespec *timeout);
+#endif
+#endif /* HAVE_RECVMMSG */
typedef int (*__libc_send)(int sockfd, const void *buf, size_t len, int flags);
typedef int (*__libc_sendmsg)(int sockfd, const struct msghdr *msg, int flags);
+#ifdef HAVE_SENDMMSG
+#if defined(HAVE_SENDMMSG_SSIZE_T)
+/* FreeBSD */
+typedef ssize_t (*__libc_sendmmsg)(int sockfd, struct mmsghdr *msgvec, size_t vlen, int flags);
+#else
+/* Linux */
+typedef int (*__libc_sendmmsg)(int sockfd, struct mmsghdr *msgvec, unsigned int vlen, int flags);
+#endif
+#endif /* HAVE_SENDMMSG */
typedef int (*__libc_sendto)(int sockfd,
const void *buf,
size_t len,
#endif
SWRAP_SYMBOL_ENTRY(bind);
SWRAP_SYMBOL_ENTRY(close);
+#ifdef HAVE___CLOSE_NOCANCEL
+ SWRAP_SYMBOL_ENTRY(__close_nocancel);
+#endif
SWRAP_SYMBOL_ENTRY(connect);
SWRAP_SYMBOL_ENTRY(dup);
SWRAP_SYMBOL_ENTRY(dup2);
SWRAP_SYMBOL_ENTRY(recv);
SWRAP_SYMBOL_ENTRY(recvfrom);
SWRAP_SYMBOL_ENTRY(recvmsg);
+#ifdef HAVE_RECVMMSG
+ SWRAP_SYMBOL_ENTRY(recvmmsg);
+#endif
SWRAP_SYMBOL_ENTRY(send);
SWRAP_SYMBOL_ENTRY(sendmsg);
+#ifdef HAVE_SENDMMSG
+ SWRAP_SYMBOL_ENTRY(sendmmsg);
+#endif
SWRAP_SYMBOL_ENTRY(sendto);
SWRAP_SYMBOL_ENTRY(setsockopt);
#ifdef HAVE_SIGNALFD
return swrap.libc.symbols._libc_close.f(fd);
}
+#ifdef HAVE___CLOSE_NOCANCEL
+static int libc___close_nocancel(int fd)
+{
+ swrap_bind_symbol_all();
+
+ return swrap.libc.symbols._libc___close_nocancel.f(fd);
+}
+#endif /* HAVE___CLOSE_NOCANCEL */
+
static int libc_connect(int sockfd,
const struct sockaddr *addr,
socklen_t addrlen)
}
#endif /* HAVE_FOPEN64 */
+static void swrap_inject_o_largefile(int *flags)
+{
+ (void)*flags; /* maybe unused */
+#if SIZE_MAX == 0xffffffffUL && defined(O_LARGEFILE)
+#ifdef O_PATH
+ if (((*flags) & O_PATH) == 0)
+#endif
+ {
+ *flags |= O_LARGEFILE;
+ }
+#endif
+}
+
static int libc_vopen(const char *pathname, int flags, va_list ap)
{
int mode = 0;
swrap_bind_symbol_all();
+ swrap_inject_o_largefile(&flags);
+
if (flags & O_CREAT) {
mode = va_arg(ap, int);
}
swrap_bind_symbol_all();
+ swrap_inject_o_largefile(&flags);
+
if (flags & O_CREAT) {
mode = va_arg(ap, int);
}
swrap_bind_symbol_all();
+ swrap_inject_o_largefile(&flags);
+
if (flags & O_CREAT) {
mode = va_arg(ap, int);
}
return swrap.libc.symbols._libc_recvmsg.f(sockfd, msg, flags);
}
+#ifdef HAVE_RECVMMSG
+#if defined(HAVE_RECVMMSG_SSIZE_T_CONST_TIMEOUT)
+/* FreeBSD */
+static ssize_t libc_recvmmsg(int sockfd, struct mmsghdr *msgvec, size_t vlen, int flags, const struct timespec *timeout)
+#elif defined(HAVE_RECVMMSG_CONST_TIMEOUT)
+/* Linux legacy glibc < 2.21 */
+static int libc_recvmmsg(int sockfd, struct mmsghdr *msgvec, unsigned int vlen, int flags, const struct timespec *timeout)
+#else
+/* Linux glibc >= 2.21 */
+static int libc_recvmmsg(int sockfd, struct mmsghdr *msgvec, unsigned int vlen, int flags, struct timespec *timeout)
+#endif
+{
+ swrap_bind_symbol_all();
+
+ return swrap.libc.symbols._libc_recvmmsg.f(sockfd, msgvec, vlen, flags, timeout);
+}
+#endif
+
static int libc_send(int sockfd, const void *buf, size_t len, int flags)
{
swrap_bind_symbol_all();
return swrap.libc.symbols._libc_sendmsg.f(sockfd, msg, flags);
}
+#ifdef HAVE_SENDMMSG
+#if defined(HAVE_SENDMMSG_SSIZE_T)
+/* FreeBSD */
+static ssize_t libc_sendmmsg(int sockfd, struct mmsghdr *msgvec, size_t vlen, int flags)
+#else
+/* Linux */
+static int libc_sendmmsg(int sockfd, struct mmsghdr *msgvec, unsigned int vlen, int flags)
+#endif
+{
+ swrap_bind_symbol_all();
+
+ return swrap.libc.symbols._libc_sendmmsg.f(sockfd, msgvec, vlen, flags);
+}
+#endif
+
static int libc_sendto(int sockfd,
const void *buf,
size_t len,
#endif
swrap_bind_symbol_libsocket(bind);
swrap_bind_symbol_libc(close);
+#ifdef HAVE___CLOSE_NOCANCEL
+ swrap_bind_symbol_libc(__close_nocancel);
+#endif
swrap_bind_symbol_libsocket(connect);
swrap_bind_symbol_libc(dup);
swrap_bind_symbol_libc(dup2);
swrap_bind_symbol_libsocket(recv);
swrap_bind_symbol_libsocket(recvfrom);
swrap_bind_symbol_libsocket(recvmsg);
+#ifdef HAVE_RECVMMSG
+ swrap_bind_symbol_libsocket(recvmmsg);
+#endif
swrap_bind_symbol_libsocket(send);
swrap_bind_symbol_libsocket(sendmsg);
+#ifdef HAVE_SENDMMSG
+ swrap_bind_symbol_libsocket(sendmmsg);
+#endif
swrap_bind_symbol_libsocket(sendto);
swrap_bind_symbol_libsocket(setsockopt);
#ifdef HAVE_SIGNALFD
return 0;
}
+struct swrap_sockaddr_buf {
+ char str[128];
+};
+
+static const char *swrap_sockaddr_string(struct swrap_sockaddr_buf *buf,
+ const struct sockaddr *saddr)
+{
+ unsigned int port = 0;
+ char addr[64] = {0,};
+
+ switch (saddr->sa_family) {
+ case AF_INET: {
+ const struct sockaddr_in *in =
+ (const struct sockaddr_in *)(const void *)saddr;
+
+ port = ntohs(in->sin_port);
+
+ inet_ntop(saddr->sa_family,
+ &in->sin_addr,
+ addr, sizeof(addr));
+ break;
+ }
+#ifdef HAVE_IPV6
+ case AF_INET6: {
+ const struct sockaddr_in6 *in6 =
+ (const struct sockaddr_in6 *)(const void *)saddr;
+
+ port = ntohs(in6->sin6_port);
+
+ inet_ntop(saddr->sa_family,
+ &in6->sin6_addr,
+ addr, sizeof(addr));
+ break;
+ }
+#endif
+ default:
+ snprintf(addr, sizeof(addr),
+ "<Unknown address family %u>",
+ saddr->sa_family);
+ break;
+ }
+
+ snprintf(buf->str, sizeof(buf->str),
+ "addr[%s]/port[%u]",
+ addr, port);
+
+ return buf->str;
+}
+
static struct socket_info *swrap_get_socket_info(int si_index)
{
return (struct socket_info *)(&(sockets[si_index].info));
type = u_type;
iface = (addr & 0x000000FF);
} else {
- char str[256] = {0,};
- inet_ntop(inaddr->sa_family,
- &in->sin_addr,
- str, sizeof(str));
+ struct swrap_sockaddr_buf buf = {};
SWRAP_LOG(SWRAP_LOG_WARN,
- "str[%s] prt[%u]",
- str, (unsigned)prt);
+ "%s",
+ swrap_sockaddr_string(&buf, inaddr));
errno = ENETUNREACH;
return -1;
}
if (IN6_ARE_ADDR_EQUAL(&cmp1, &cmp2)) {
iface = in->sin6_addr.s6_addr[15];
} else {
- char str[256] = {0,};
- inet_ntop(inaddr->sa_family,
- &in->sin6_addr,
- str, sizeof(str));
+ struct swrap_sockaddr_buf buf = {};
SWRAP_LOG(SWRAP_LOG_WARN,
- "str[%s] prt[%u]",
- str, (unsigned)prt);
+ "%s",
+ swrap_sockaddr_string(&buf, inaddr));
errno = ENETUNREACH;
return -1;
}
}
#endif
-static void swrap_remove_stale(int fd)
-{
- struct socket_info *si;
- int si_index;
-
- SWRAP_LOG(SWRAP_LOG_TRACE, "remove stale wrapper for %d", fd);
-
- swrap_mutex_lock(&socket_reset_mutex);
-
- si_index = find_socket_info_index(fd);
- if (si_index == -1) {
- swrap_mutex_unlock(&socket_reset_mutex);
- return;
- }
-
- reset_socket_info_index(fd);
-
- si = swrap_get_socket_info(si_index);
-
- swrap_mutex_lock(&first_free_mutex);
- SWRAP_LOCK_SI(si);
-
- swrap_dec_refcount(si);
-
- if (swrap_get_refcount(si) > 0) {
- goto out;
- }
-
- if (si->un_addr.sun_path[0] != '\0') {
- unlink(si->un_addr.sun_path);
- }
-
- swrap_set_next_free(si, first_free);
- first_free = si_index;
-
-out:
- SWRAP_UNLOCK_SI(si);
- swrap_mutex_unlock(&first_free_mutex);
- swrap_mutex_unlock(&socket_reset_mutex);
-}
+static void swrap_remove_stale(int fd);
static int sockaddr_convert_to_un(struct socket_info *si,
const struct sockaddr *in_addr,
char type;
int ret;
int port;
- struct stat st;
char *swrap_dir = NULL;
swrap_mutex_lock(&autobind_start_mutex);
type,
socket_wrapper_default_iface(),
port);
- if (stat(un_addr.sa.un.sun_path, &st) == 0) continue;
ret = libc_bind(fd, &un_addr.sa.s, un_addr.sa_socklen);
if (ret == -1) {
+ if (errno == EALREADY || errno == EADDRINUSE) {
+ continue;
+ }
goto done;
}
.sa_socklen = sizeof(struct sockaddr_un),
};
struct socket_info *si = find_socket_info(s);
+ struct swrap_sockaddr_buf buf = {};
int bcast = 0;
if (!si) {
}
SWRAP_LOG(SWRAP_LOG_TRACE,
- "connect() path=%s, fd=%d",
+ "connect(%s) path=%s, fd=%d",
+ swrap_sockaddr_string(&buf, serv_addr),
un_addr.sa.un.sun_path, s);
.sa_socklen = sizeof(struct sockaddr_un),
};
struct socket_info *si = find_socket_info(s);
+ struct swrap_sockaddr_buf buf = {};
+ int ret_errno = errno;
int bind_error = 0;
#if 0 /* FIXME */
bool in_use;
}
if (bind_error != 0) {
- errno = bind_error;
+ ret_errno = bind_error;
ret = -1;
goto out;
}
1,
&si->bcast);
if (ret == -1) {
+ ret_errno = errno;
goto out;
}
unlink(un_addr.sa.un.sun_path);
ret = libc_bind(s, &un_addr.sa.s, un_addr.sa_socklen);
+ if (ret == -1) {
+ ret_errno = errno;
+ }
SWRAP_LOG(SWRAP_LOG_TRACE,
- "bind() path=%s, fd=%d",
- un_addr.sa.un.sun_path, s);
+ "bind(%s) path=%s, fd=%d ret=%d ret_errno=%d",
+ swrap_sockaddr_string(&buf, myaddr),
+ un_addr.sa.un.sun_path, s, ret, ret_errno);
if (ret == 0) {
si->bound = 1;
out:
SWRAP_UNLOCK_SI(si);
-
+ errno = ret_errno;
return ret;
}
struct cmsghdr *cmsg;
};
-static int swrap_sendmsg_unix_scm_rights(const struct cmsghdr *cmsg,
+static int swrap_sendmsg_unix_scm_rights(struct cmsghdr *cmsg,
uint8_t **cm_data,
size_t *cm_data_space,
int *scm_rights_pipe_fd)
return 0;
}
-static int swrap_sendmsg_unix_sol_socket(const struct cmsghdr *cmsg,
+static int swrap_sendmsg_unix_sol_socket(struct cmsghdr *cmsg,
uint8_t **cm_data,
size_t *cm_data_space,
int *scm_rights_pipe_fd)
return rc;
}
-static int swrap_recvmsg_unix_scm_rights(const struct cmsghdr *cmsg,
+static int swrap_recvmsg_unix_scm_rights(struct cmsghdr *cmsg,
uint8_t **cm_data,
size_t *cm_data_space)
{
return 0;
}
-static int swrap_recvmsg_unix_sol_socket(const struct cmsghdr *cmsg,
+static int swrap_recvmsg_unix_sol_socket(struct cmsghdr *cmsg,
uint8_t **cm_data,
size_t *cm_data_space)
{
{
size_t i, len = 0;
ssize_t ret = -1;
+ struct swrap_sockaddr_buf buf = {};
if (to_un) {
*to_un = NULL;
msg->msg_name = NULL;
msg->msg_namelen = 0;
}
+ SWRAP_LOG(SWRAP_LOG_TRACE,
+ "connected(%s) fd=%d",
+ swrap_sockaddr_string(&buf, &si->peername.sa.s),
+ fd);
} else {
const struct sockaddr *msg_name;
msg_name = (const struct sockaddr *)msg->msg_name;
goto out;
}
+ SWRAP_LOG(SWRAP_LOG_TRACE,
+ "deferred connect(%s) path=%s, fd=%d",
+ swrap_sockaddr_string(&buf, &si->peername.sa.s),
+ tmp_un->sun_path, fd);
+
ret = libc_connect(fd,
(struct sockaddr *)(void *)tmp_un,
sizeof(*tmp_un));
for (i = 0; i < (size_t)msg->msg_iovlen; i++) {
size_t this_time = MIN(remain, (size_t)msg->msg_iov[i].iov_len);
- memcpy(buf + ofs,
- msg->msg_iov[i].iov_base,
- this_time);
+ if (this_time > 0) {
+ memcpy(buf + ofs,
+ msg->msg_iov[i].iov_base,
+ this_time);
+ }
ofs += this_time;
remain -= this_time;
}
return swrap_recvmsg(sockfd, msg, flags);
}
+/****************************************************************************
+ * RECVMMSG
+ ***************************************************************************/
+
+#ifdef HAVE_RECVMMSG
+#if defined(HAVE_RECVMMSG_SSIZE_T_CONST_TIMEOUT)
+/* FreeBSD */
+static ssize_t swrap_recvmmsg(int s, struct mmsghdr *omsgvec, size_t _vlen, int flags, const struct timespec *timeout)
+#elif defined(HAVE_RECVMMSG_CONST_TIMEOUT)
+/* Linux legacy glibc < 2.21 */
+static int swrap_recvmmsg(int s, struct mmsghdr *omsgvec, unsigned int _vlen, int flags, const struct timespec *timeout)
+#else
+/* Linux glibc >= 2.21 */
+static int swrap_recvmmsg(int s, struct mmsghdr *omsgvec, unsigned int _vlen, int flags, struct timespec *timeout)
+#endif
+{
+ struct socket_info *si = find_socket_info(s);
+#define __SWRAP_RECVMMSG_MAX_VLEN 16
+ struct mmsghdr msgvec[__SWRAP_RECVMMSG_MAX_VLEN] = {};
+ struct {
+ struct iovec iov;
+ struct swrap_address from_addr;
+ struct swrap_address convert_addr;
+#ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
+ size_t msg_ctrllen_filled;
+ size_t msg_ctrllen_left;
+#endif
+ } tmp[__SWRAP_RECVMMSG_MAX_VLEN] = {};
+ int vlen;
+ int i;
+ int ret;
+ int rc;
+ int saved_errno;
+
+ if (_vlen > __SWRAP_RECVMMSG_MAX_VLEN) {
+ vlen = __SWRAP_RECVMMSG_MAX_VLEN;
+ } else {
+ vlen = _vlen;
+ }
+
+ if (si == NULL) {
+ uint8_t *tmp_control[__SWRAP_RECVMMSG_MAX_VLEN] = { NULL, };
+
+ for (i = 0; i < vlen; i++) {
+ struct msghdr *omsg = &omsgvec[i].msg_hdr;
+ struct msghdr *msg = &msgvec[i].msg_hdr;
+
+ rc = swrap_recvmsg_before_unix(omsg, msg,
+ &tmp_control[i]);
+ if (rc < 0) {
+ ret = rc;
+ goto fail_libc;
+ }
+ }
+
+ ret = libc_recvmmsg(s, msgvec, vlen, flags, timeout);
+ if (ret < 0) {
+ goto fail_libc;
+ }
+
+ for (i = 0; i < ret; i++) {
+ omsgvec[i].msg_len = msgvec[i].msg_len;
+ }
+
+fail_libc:
+ saved_errno = errno;
+ for (i = 0; i < vlen; i++) {
+ struct msghdr *omsg = &omsgvec[i].msg_hdr;
+ struct msghdr *msg = &msgvec[i].msg_hdr;
+
+ if (i == 0 || i < ret) {
+ swrap_recvmsg_after_unix(msg, &tmp_control[i], omsg, ret);
+ }
+ SAFE_FREE(tmp_control[i]);
+ }
+ errno = saved_errno;
+
+ return ret;
+ }
+
+ for (i = 0; i < vlen; i++) {
+ struct msghdr *omsg = &omsgvec[i].msg_hdr;
+ struct msghdr *msg = &msgvec[i].msg_hdr;
+
+ tmp[i].from_addr.sa_socklen = sizeof(struct sockaddr_un);
+ tmp[i].convert_addr.sa_socklen = sizeof(struct sockaddr_storage);
+
+ msg->msg_name = &tmp[i].from_addr.sa; /* optional address */
+ msg->msg_namelen = tmp[i].from_addr.sa_socklen; /* size of address */
+ msg->msg_iov = omsg->msg_iov; /* scatter/gather array */
+ msg->msg_iovlen = omsg->msg_iovlen; /* # elements in msg_iov */
+#ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
+ tmp[i].msg_ctrllen_filled = 0;
+ tmp[i].msg_ctrllen_left = omsg->msg_controllen;
+
+ msg->msg_control = omsg->msg_control; /* ancillary data, see below */
+ msg->msg_controllen = omsg->msg_controllen; /* ancillary data buffer len */
+ msg->msg_flags = omsg->msg_flags; /* flags on received message */
+#endif
+
+ rc = swrap_recvmsg_before(s, si, msg, &tmp[i].iov);
+ if (rc < 0) {
+ ret = rc;
+ goto fail_swrap;
+ }
+ }
+
+ ret = libc_recvmmsg(s, msgvec, vlen, flags, timeout);
+ if (ret < 0) {
+ goto fail_swrap;
+ }
+
+ for (i = 0; i < ret; i++) {
+ omsgvec[i].msg_len = msgvec[i].msg_len;
+ }
+
+fail_swrap:
+
+ saved_errno = errno;
+ for (i = 0; i < vlen; i++) {
+ struct msghdr *omsg = &omsgvec[i].msg_hdr;
+ struct msghdr *msg = &msgvec[i].msg_hdr;
+
+ if (!(i == 0 || i < ret)) {
+ break;
+ }
+
+#ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
+ tmp[i].msg_ctrllen_filled += msg->msg_controllen;
+ tmp[i].msg_ctrllen_left -= msg->msg_controllen;
+
+ if (omsg->msg_control != NULL) {
+ uint8_t *p;
+
+ p = omsg->msg_control;
+ p += tmp[i].msg_ctrllen_filled;
+
+ msg->msg_control = p;
+ msg->msg_controllen = tmp[i].msg_ctrllen_left;
+ } else {
+ msg->msg_control = NULL;
+ msg->msg_controllen = 0;
+ }
+#endif
+
+ /*
+ * We convert the unix address to a IP address so we need a buffer
+ * which can store the address in case of SOCK_DGRAM, see below.
+ */
+ msg->msg_name = &tmp[i].convert_addr.sa;
+ msg->msg_namelen = tmp[i].convert_addr.sa_socklen;
+
+ swrap_recvmsg_after(s, si, msg,
+ &tmp[i].from_addr.sa.un,
+ tmp[i].from_addr.sa_socklen,
+ ret);
+
+#ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
+ if (omsg->msg_control != NULL) {
+ /* msg->msg_controllen = space left */
+ tmp[i].msg_ctrllen_left = msg->msg_controllen;
+ tmp[i].msg_ctrllen_filled = omsg->msg_controllen - tmp[i].msg_ctrllen_left;
+ }
+
+ /* Update the original message length */
+ omsg->msg_controllen = tmp[i].msg_ctrllen_filled;
+ omsg->msg_flags = msg->msg_flags;
+#endif
+ omsg->msg_iovlen = msg->msg_iovlen;
+
+ SWRAP_LOCK_SI(si);
+
+ /*
+ * From the manpage:
+ *
+ * The msg_name field points to a caller-allocated buffer that is
+ * used to return the source address if the socket is unconnected. The
+ * caller should set msg_namelen to the size of this buffer before this
+ * call; upon return from a successful call, msg_name will contain the
+ * length of the returned address. If the application does not need
+ * to know the source address, msg_name can be specified as NULL.
+ */
+ if (si->type == SOCK_STREAM) {
+ omsg->msg_namelen = 0;
+ } else if (omsg->msg_name != NULL &&
+ omsg->msg_namelen != 0 &&
+ omsg->msg_namelen >= msg->msg_namelen) {
+ memcpy(omsg->msg_name, msg->msg_name, msg->msg_namelen);
+ omsg->msg_namelen = msg->msg_namelen;
+ }
+
+ SWRAP_UNLOCK_SI(si);
+ }
+ errno = saved_errno;
+
+ return ret;
+}
+
+#if defined(HAVE_RECVMMSG_SSIZE_T_CONST_TIMEOUT)
+/* FreeBSD */
+ssize_t recvmmsg(int sockfd, struct mmsghdr *msgvec, size_t vlen, int flags, const struct timespec *timeout)
+#elif defined(HAVE_RECVMMSG_CONST_TIMEOUT)
+/* Linux legacy glibc < 2.21 */
+int recvmmsg(int sockfd, struct mmsghdr *msgvec, unsigned int vlen, int flags, const struct timespec *timeout)
+#else
+/* Linux glibc >= 2.21 */
+int recvmmsg(int sockfd, struct mmsghdr *msgvec, unsigned int vlen, int flags, struct timespec *timeout)
+#endif
+{
+ return swrap_recvmmsg(sockfd, msgvec, vlen, flags, timeout);
+}
+#endif /* HAVE_RECVMMSG */
+
/****************************************************************************
* SENDMSG
***************************************************************************/
return swrap_sendmsg(s, omsg, flags);
}
+/****************************************************************************
+ * SENDMMSG
+ ***************************************************************************/
+
+#ifdef HAVE_SENDMMSG
+#if defined(HAVE_SENDMMSG_SSIZE_T)
+/* FreeBSD */
+static ssize_t swrap_sendmmsg(int s, struct mmsghdr *omsgvec, size_t _vlen, int flags)
+#else
+/* Linux */
+static int swrap_sendmmsg(int s, struct mmsghdr *omsgvec, unsigned int _vlen, int flags)
+#endif
+{
+ struct socket_info *si = find_socket_info(s);
+#define __SWRAP_SENDMMSG_MAX_VLEN 16
+ struct mmsghdr msgvec[__SWRAP_SENDMMSG_MAX_VLEN] = {};
+ struct {
+ struct iovec iov;
+ struct sockaddr_un un_addr;
+ const struct sockaddr_un *to_un;
+ const struct sockaddr *to;
+ int bcast;
+ } tmp[__SWRAP_SENDMMSG_MAX_VLEN] = {};
+ int vlen;
+ int i;
+ char *swrap_dir = NULL;
+ int connected = 0;
+ int found_bcast = 0;
+ int ret;
+ int rc;
+ int saved_errno;
+
+ if (_vlen > __SWRAP_SENDMMSG_MAX_VLEN) {
+ vlen = __SWRAP_SENDMMSG_MAX_VLEN;
+ } else {
+ vlen = _vlen;
+ }
+
+ if (!si) {
+ int scm_rights_pipe_fd[__SWRAP_SENDMMSG_MAX_VLEN];
+
+ for (i = 0; i < __SWRAP_SENDMMSG_MAX_VLEN; i++) {
+ scm_rights_pipe_fd[i] = -1;
+ }
+
+ for (i = 0; i < vlen; i++) {
+ struct msghdr *omsg = &omsgvec[i].msg_hdr;
+ struct msghdr *msg = &msgvec[i].msg_hdr;
+
+ rc = swrap_sendmsg_before_unix(omsg, msg,
+ &scm_rights_pipe_fd[i]);
+ if (rc < 0) {
+ ret = rc;
+ goto fail_libc;
+ }
+ }
+
+ ret = libc_sendmmsg(s, msgvec, vlen, flags);
+ if (ret < 0) {
+ goto fail_libc;
+ }
+
+ for (i = 0; i < ret; i++) {
+ omsgvec[i].msg_len = msgvec[i].msg_len;
+ }
+
+fail_libc:
+ saved_errno = errno;
+ for (i = 0; i < vlen; i++) {
+ struct msghdr *msg = &msgvec[i].msg_hdr;
+
+ swrap_sendmsg_after_unix(msg, ret,
+ scm_rights_pipe_fd[i]);
+ }
+ errno = saved_errno;
+
+ return ret;
+ }
+
+ SWRAP_LOCK_SI(si);
+ connected = si->connected;
+ SWRAP_UNLOCK_SI(si);
+
+ for (i = 0; i < vlen; i++) {
+ struct msghdr *omsg = &omsgvec[i].msg_hdr;
+ struct msghdr *msg = &msgvec[i].msg_hdr;
+
+ if (connected == 0) {
+ msg->msg_name = omsg->msg_name; /* optional address */
+ msg->msg_namelen = omsg->msg_namelen; /* size of address */
+ }
+ msg->msg_iov = omsg->msg_iov; /* scatter/gather array */
+ msg->msg_iovlen = omsg->msg_iovlen; /* # elements in msg_iov */
+
+#ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
+ if (omsg->msg_controllen > 0 && omsg->msg_control != NULL) {
+ uint8_t *cmbuf = NULL;
+ size_t cmlen = 0;
+
+ rc = swrap_sendmsg_filter_cmsghdr(omsg, &cmbuf, &cmlen);
+ if (rc < 0) {
+ ret = rc;
+ goto fail_swrap;
+ }
+
+ if (cmlen != 0) {
+ msg->msg_control = cmbuf;
+ msg->msg_controllen = cmlen;
+ }
+ }
+ msg->msg_flags = omsg->msg_flags; /* flags on received message */
+#endif
+
+ rc = swrap_sendmsg_before(s, si, msg,
+ &tmp[i].iov,
+ &tmp[i].un_addr,
+ &tmp[i].to_un,
+ &tmp[i].to,
+ &tmp[i].bcast);
+ if (rc < 0) {
+ ret = rc;
+ goto fail_swrap;
+ }
+
+ if (tmp[i].bcast) {
+ found_bcast = 1;
+ }
+ }
+
+ if (found_bcast) {
+
+ swrap_dir = socket_wrapper_dir();
+ if (swrap_dir == NULL) {
+ ret = -1;
+ goto fail_swrap;
+ }
+
+ for (i = 0; i < vlen; i++) {
+ struct msghdr *msg = &msgvec[i].msg_hdr;
+ struct sockaddr_un *un_addr = &tmp[i].un_addr;
+ const struct sockaddr *to = tmp[i].to;
+ struct stat st;
+ unsigned int iface;
+ unsigned int prt = ntohs(((const struct sockaddr_in *)(const void *)to)->sin_port);
+ char type;
+ size_t l, len = 0;
+ uint8_t *buf;
+ off_t ofs = 0;
+ size_t avail = 0;
+ size_t remain;
+
+ for (l = 0; l < (size_t)msg->msg_iovlen; l++) {
+ avail += msg->msg_iov[l].iov_len;
+ }
+
+ len = avail;
+ remain = avail;
+
+ /* we capture it as one single packet */
+ buf = (uint8_t *)malloc(remain);
+ if (!buf) {
+ ret = -1;
+ goto fail_swrap;
+ }
+
+ for (l = 0; l < (size_t)msg->msg_iovlen; l++) {
+ size_t this_time = MIN(remain, (size_t)msg->msg_iov[l].iov_len);
+ memcpy(buf + ofs,
+ msg->msg_iov[l].iov_base,
+ this_time);
+ ofs += this_time;
+ remain -= this_time;
+ }
+
+ type = SOCKET_TYPE_CHAR_UDP;
+
+ for(iface=0; iface <= MAX_WRAPPED_INTERFACES; iface++) {
+ swrap_un_path(un_addr, swrap_dir, type, iface, prt);
+ if (stat(un_addr->sun_path, &st) != 0) continue;
+
+ msg->msg_name = un_addr; /* optional address */
+ msg->msg_namelen = sizeof(*un_addr); /* size of address */
+
+ /*
+ * ignore the any errors in broadcast sends and
+ * do a single sendmsg instead of sendmmsg
+ */
+ libc_sendmsg(s, msg, flags);
+ }
+
+ SWRAP_LOCK_SI(si);
+ swrap_pcap_dump_packet(si, to, SWRAP_SENDTO, buf, len);
+ SWRAP_UNLOCK_SI(si);
+
+ SAFE_FREE(buf);
+
+ msgvec[i].msg_len = len;
+ }
+
+ ret = vlen;
+ goto bcast_done;
+ }
+
+ ret = libc_sendmmsg(s, msgvec, vlen, flags);
+ if (ret < 0) {
+ goto fail_swrap;
+ }
+
+bcast_done:
+ for (i = 0; i < ret; i++) {
+ omsgvec[i].msg_len = msgvec[i].msg_len;
+ }
+
+fail_swrap:
+ saved_errno = errno;
+ for (i = 0; i < vlen; i++) {
+ struct msghdr *msg = &msgvec[i].msg_hdr;
+
+ if (i == 0 || i < ret) {
+ swrap_sendmsg_after(s, si, msg, tmp[i].to, ret);
+ }
+#ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
+ SAFE_FREE(msg->msg_control);
+#endif
+ }
+ SAFE_FREE(swrap_dir);
+ errno = saved_errno;
+
+ return ret;
+}
+
+#if defined(HAVE_SENDMMSG_SSIZE_T)
+/* FreeBSD */
+ssize_t sendmmsg(int s, struct mmsghdr *msgvec, size_t vlen, int flags)
+#else
+/* Linux */
+int sendmmsg(int s, struct mmsghdr *msgvec, unsigned int vlen, int flags)
+#endif
+{
+ return swrap_sendmmsg(s, msgvec, vlen, flags);
+}
+#endif /* HAVE_SENDMMSG */
+
/****************************************************************************
* READV
***************************************************************************/
* CLOSE
***************************/
-static int swrap_close(int fd)
+static int swrap_remove_wrapper(const char *__func_name,
+ int (*__close_fd_fn)(int fd),
+ int fd)
{
struct socket_info *si = NULL;
int si_index;
si_index = find_socket_info_index(fd);
if (si_index == -1) {
swrap_mutex_unlock(&socket_reset_mutex);
- return libc_close(fd);
+ return __close_fd_fn(fd);
}
- SWRAP_LOG(SWRAP_LOG_TRACE, "Close wrapper for fd=%d", fd);
+ swrap_log(SWRAP_LOG_TRACE, __func_name, "Remove wrapper for fd=%d", fd);
reset_socket_info_index(fd);
si = swrap_get_socket_info(si_index);
swrap_mutex_lock(&first_free_mutex);
SWRAP_LOCK_SI(si);
- ret = libc_close(fd);
+ ret = __close_fd_fn(fd);
if (ret == -1) {
ret_errno = errno;
}
return ret;
}
+static int swrap_noop_close(int fd)
+{
+ (void)fd; /* unused */
+ return 0;
+}
+
+static void swrap_remove_stale(int fd)
+{
+ swrap_remove_wrapper(__func__, swrap_noop_close, fd);
+}
+
+/*
+ * This allows socket_wrapper aware applications to
+ * indicate that the given fd does not belong to
+ * an inet socket.
+ *
+ * We already overload a lot of unrelated functions
+ * like eventfd(), timerfd_create(), ... in order to
+ * call swrap_remove_stale() on the returned fd, but
+ * we'll never be able to handle all possible syscalls.
+ *
+ * socket_wrapper_indicate_no_inet_fd() gives them a way
+ * to do the same.
+ *
+ * We don't export swrap_remove_stale() in order to
+ * make it easier to analyze SOCKET_WRAPPER_DEBUGLEVEL=3
+ * log files.
+ */
+void socket_wrapper_indicate_no_inet_fd(int fd)
+{
+ swrap_remove_wrapper(__func__, swrap_noop_close, fd);
+}
+
+static int swrap_close(int fd)
+{
+ return swrap_remove_wrapper(__func__, libc_close, fd);
+}
+
int close(int fd)
{
return swrap_close(fd);
}
+#ifdef HAVE___CLOSE_NOCANCEL
+
+static int swrap___close_nocancel(int fd)
+{
+ return swrap_remove_wrapper(__func__, libc___close_nocancel, fd);
+}
+
+int __close_nocancel(int fd);
+int __close_nocancel(int fd)
+{
+ return swrap___close_nocancel(fd);
+}
+
+#endif /* HAVE___CLOSE_NOCANCEL */
+
/****************************
* DUP
***************************/
SAFE_FREE(sockets);
- if (swrap.libc.handle != NULL) {
+ if (swrap.libc.handle != NULL
+#ifdef RTLD_NEXT
+ && swrap.libc.handle != RTLD_NEXT
+#endif
+ ) {
dlclose(swrap.libc.handle);
}
- if (swrap.libc.socket_handle) {
+ if (swrap.libc.socket_handle
+#ifdef RTLD_NEXT
+ && swrap.libc.socket_handle != RTLD_NEXT
+#endif
+ ) {
dlclose(swrap.libc.socket_handle);
}
}
* related syscalls also with the '_' prefix.
*
* This is tested in Samba's 'make test',
- * there we noticed that providing '_read'
- * and '_open' would cause errors, which
+ * there we noticed that providing '_read',
+ * '_open' and '_close' would cause errors, which
* means we skip '_read', '_write' and
* all non socket related calls without
* further analyzing the problem.
#endif
SWRAP_SYMBOL_ALIAS(accept, _accept);
SWRAP_SYMBOL_ALIAS(bind, _bind);
-SWRAP_SYMBOL_ALIAS(close, _close);
SWRAP_SYMBOL_ALIAS(connect, _connect);
SWRAP_SYMBOL_ALIAS(dup, _dup);
SWRAP_SYMBOL_ALIAS(dup2, _dup2);
git.samba.org / socket_wrapper.git / blobdiff