static gint
wapi_sendfile (guint32 socket, gpointer fd, guint32 bytes_to_write, guint32 bytes_per_send, guint32 flags)
{
MonoThreadInfo *info = mono_thread_info_current ();
#if defined(HAVE_SENDFILE) && (defined(__linux__) || defined(DARWIN))
gint file = GPOINTER_TO_INT (fd);
gint n;
gint errnum;
gssize res;
struct stat statbuf;
n = fstat (file, &statbuf);
if (n == -1) {
errnum = errno;
errnum = errno_to_WSA (errnum, __func__);
WSASetLastError (errnum);
return SOCKET_ERROR;
}
do {
#ifdef __linux__
res = sendfile (socket, file, NULL, statbuf.st_size);
#elif defined(DARWIN)
/* TODO: header/tail could be sent in the 5th argument */
/* TODO: Might not send the entire file for non-blocking sockets */
res = sendfile (file, socket, 0, &statbuf.st_size, NULL, 0);
#endif
} while (res != -1 && errno == EINTR && !mono_thread_info_is_interrupt_state (info));
if (res == -1) {
errnum = errno;
errnum = errno_to_WSA (errnum, __func__);
WSASetLastError (errnum);
return SOCKET_ERROR;
}
#else
/* Default implementation */
gint file = GPOINTER_TO_INT (fd);
gchar *buffer;
gint n;
buffer = g_malloc (SF_BUFFER_SIZE);
do {
do {
n = read (file, buffer, SF_BUFFER_SIZE);
} while (n == -1 && errno == EINTR && !mono_thread_info_is_interrupt_state (info));
if (n == -1)
break;
if (n == 0) {
g_free (buffer);
return 0; /* We're done reading */
}
do {
n = send (socket, buffer, n, 0); /* short sends? enclose this in a loop? */
} while (n == -1 && errno == EINTR && !mono_thread_info_is_interrupt_state (info));
} while (n != -1 && errno == EINTR && !mono_thread_info_is_interrupt_state (info));
if (n == -1) {
gint errnum = errno;
errnum = errno_to_WSA (errnum, __func__);
WSASetLastError (errnum);
g_free (buffer);
return SOCKET_ERROR;
}
g_free (buffer);
#endif
return 0;
}
int
WSAIoctl (guint32 fd, gint32 command,
gchar *input, gint i_len,
gchar *output, gint o_len, glong *written,
void *unused1, void *unused2)
{
gpointer handle = GUINT_TO_POINTER (fd);
int ret;
gchar *buffer = NULL;
if (_wapi_handle_type (handle) != WAPI_HANDLE_SOCKET) {
WSASetLastError (WSAENOTSOCK);
return SOCKET_ERROR;
}
if (command == SIO_GET_EXTENSION_FUNCTION_POINTER) {
int i = 0;
WapiGuid *guid = (WapiGuid *)input;
if (i_len < sizeof(WapiGuid)) {
/* As far as I can tell, windows doesn't
* actually set an error here...
*/
WSASetLastError (WSAEINVAL);
return(SOCKET_ERROR);
}
if (o_len < sizeof(gpointer)) {
/* Or here... */
WSASetLastError (WSAEINVAL);
return(SOCKET_ERROR);
}
if (output == NULL) {
/* Or here */
WSASetLastError (WSAEINVAL);
return(SOCKET_ERROR);
}
while(extension_functions[i].func != NULL) {
if (!memcmp (guid, &extension_functions[i].guid,
sizeof(WapiGuid))) {
memcpy (output, &extension_functions[i].func,
sizeof(gpointer));
*written = sizeof(gpointer);
return(0);
}
i++;
}
WSASetLastError (WSAEINVAL);
return(SOCKET_ERROR);
}
if (command == SIO_KEEPALIVE_VALS) {
uint32_t onoff;
uint32_t keepalivetime;
uint32_t keepaliveinterval;
if (i_len < (3 * sizeof (uint32_t))) {
WSASetLastError (WSAEINVAL);
return SOCKET_ERROR;
}
memcpy (&onoff, input, sizeof (uint32_t));
memcpy (&keepalivetime, input + sizeof (uint32_t), sizeof (uint32_t));
memcpy (&keepaliveinterval, input + 2 * sizeof (uint32_t), sizeof (uint32_t));
ret = setsockopt (fd, SOL_SOCKET, SO_KEEPALIVE, &onoff, sizeof (uint32_t));
if (ret < 0) {
gint errnum = errno;
errnum = errno_to_WSA (errnum, __func__);
WSASetLastError (errnum);
return SOCKET_ERROR;
}
if (onoff != 0) {
#if defined(TCP_KEEPIDLE) && defined(TCP_KEEPINTVL)
/* Values are in ms, but we need s */
uint32_t rem;
/* keepalivetime and keepaliveinterval are > 0 (checked in managed code) */
rem = keepalivetime % 1000;
keepalivetime /= 1000;
if (keepalivetime == 0 || rem >= 500)
keepalivetime++;
ret = setsockopt (fd, IPPROTO_TCP, TCP_KEEPIDLE, &keepalivetime, sizeof (uint32_t));
if (ret == 0) {
rem = keepaliveinterval % 1000;
keepaliveinterval /= 1000;
if (keepaliveinterval == 0 || rem >= 500)
keepaliveinterval++;
ret = setsockopt (fd, IPPROTO_TCP, TCP_KEEPINTVL, &keepaliveinterval, sizeof (uint32_t));
}
if (ret != 0) {
gint errnum = errno;
errnum = errno_to_WSA (errnum, __func__);
WSASetLastError (errnum);
return SOCKET_ERROR;
}
return 0;
#endif
}
return 0;
}
if (i_len > 0) {
buffer = g_memdup (input, i_len);
}
ret = ioctl (fd, command, buffer);
if (ret == -1) {
gint errnum = errno;
DEBUG("%s: WSAIoctl error: %s", __func__,
strerror (errno));
errnum = errno_to_WSA (errnum, __func__);
WSASetLastError (errnum);
g_free (buffer);
return(SOCKET_ERROR);
}
if (buffer == NULL) {
*written = 0;
} else {
/* We just copy the buffer to the output. Some ioctls
* don't even output any data, but, well...
*
* NB windows returns WSAEFAULT if o_len is too small
*/
i_len = (i_len > o_len) ? o_len : i_len;
if (i_len > 0 && output != NULL) {
memcpy (output, buffer, i_len);
}
g_free (buffer);
*written = i_len;
}
return(0);
}
int _wapi_setsockopt(guint32 fd, int level, int optname,
const void *optval, socklen_t optlen)
{
gpointer handle = GUINT_TO_POINTER (fd);
int ret;
const void *tmp_val;
#if defined (__linux__)
/* This has its address taken so it cannot be moved to the if block which uses it */
int bufsize = 0;
#endif
struct timeval tv;
if (mono_w32handle_get_type (handle) != MONO_W32HANDLE_SOCKET) {
WSASetLastError (WSAENOTSOCK);
return(SOCKET_ERROR);
}
tmp_val = optval;
if (level == SOL_SOCKET &&
(optname == SO_RCVTIMEO || optname == SO_SNDTIMEO)) {
int ms = *((int *) optval);
tv.tv_sec = ms / 1000;
tv.tv_usec = (ms % 1000) * 1000; // micro from milli
tmp_val = &tv;
optlen = sizeof (tv);
}
#if defined (__linux__)
else if (level == SOL_SOCKET &&
(optname == SO_SNDBUF || optname == SO_RCVBUF)) {
/* According to socket(7) the Linux kernel doubles the
* buffer sizes "to allow space for bookkeeping
* overhead."
*/
bufsize = *((int *) optval);
bufsize /= 2;
tmp_val = &bufsize;
}
#endif
ret = setsockopt (fd, level, optname, tmp_val, optlen);
if (ret == -1) {
gint errnum = errno;
MONO_TRACE (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: setsockopt error: %s", __func__,
strerror (errno));
errnum = errno_to_WSA (errnum, __func__);
WSASetLastError (errnum);
return(SOCKET_ERROR);
}
#if defined (SO_REUSEPORT)
/* BSD's and MacOS X multicast sockets also need SO_REUSEPORT when SO_REUSEADDR is requested. */
if (level == SOL_SOCKET && optname == SO_REUSEADDR) {
int type;
socklen_t type_len = sizeof (type);
if (!getsockopt (fd, level, SO_TYPE, &type, &type_len)) {
if (type == SOCK_DGRAM || type == SOCK_STREAM)
setsockopt (fd, level, SO_REUSEPORT, tmp_val, optlen);
}
}
#endif
return(ret);
}
guint32 _wapi_socket(int domain, int type, int protocol, void *unused,
guint32 unused2, guint32 unused3)
{
struct _WapiHandle_socket socket_handle = {0};
gpointer handle;
int fd;
socket_handle.domain = domain;
socket_handle.type = type;
socket_handle.protocol = protocol;
socket_handle.still_readable = 1;
fd = socket (domain, type, protocol);
if (fd == -1 && domain == AF_INET && type == SOCK_RAW &&
protocol == 0) {
/* Retry with protocol == 4 (see bug #54565) */
// https://bugzilla.novell.com/show_bug.cgi?id=MONO54565
socket_handle.protocol = 4;
fd = socket (AF_INET, SOCK_RAW, 4);
}
if (fd == -1) {
gint errnum = errno;
MONO_TRACE (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: socket error: %s", __func__, strerror (errno));
errnum = errno_to_WSA (errnum, __func__);
WSASetLastError (errnum);
return(INVALID_SOCKET);
}
if (fd >= mono_w32handle_fd_reserve) {
MONO_TRACE (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: File descriptor is too big (%d >= %d)",
__func__, fd, mono_w32handle_fd_reserve);
WSASetLastError (WSASYSCALLFAILURE);
close (fd);
return(INVALID_SOCKET);
}
/* .net seems to set this by default for SOCK_STREAM, not for
* SOCK_DGRAM (see bug #36322)
* https://bugzilla.novell.com/show_bug.cgi?id=MONO36322
*
* It seems winsock has a rather different idea of what
* SO_REUSEADDR means. If it's set, then a new socket can be
* bound over an existing listening socket. There's a new
* windows-specific option called SO_EXCLUSIVEADDRUSE but
* using that means the socket MUST be closed properly, or a
* denial of service can occur. Luckily for us, winsock
* behaves as though any other system would when SO_REUSEADDR
* is true, so we don't need to do anything else here. See
* bug 53992.
* https://bugzilla.novell.com/show_bug.cgi?id=MONO53992
*/
{
int ret, true_ = 1;
ret = setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &true_,
sizeof (true_));
if (ret == -1) {
int errnum = errno;
MONO_TRACE (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Error setting SO_REUSEADDR", __func__);
errnum = errno_to_WSA (errnum, __func__);
WSASetLastError (errnum);
close (fd);
return(INVALID_SOCKET);
}
}
handle = mono_w32handle_new_fd (MONO_W32HANDLE_SOCKET, fd, &socket_handle);
if (handle == INVALID_HANDLE_VALUE) {
g_warning ("%s: error creating socket handle", __func__);
WSASetLastError (WSASYSCALLFAILURE);
close (fd);
return(INVALID_SOCKET);
}
MONO_TRACE (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: returning socket handle %p", __func__, handle);
return(fd);
}
int _wapi_getsockopt(guint32 fd, int level, int optname, void *optval,
socklen_t *optlen)
{
gpointer handle = GUINT_TO_POINTER (fd);
int ret;
struct timeval tv;
void *tmp_val;
struct _WapiHandle_socket *socket_handle;
gboolean ok;
if (mono_w32handle_get_type (handle) != MONO_W32HANDLE_SOCKET) {
WSASetLastError (WSAENOTSOCK);
return(SOCKET_ERROR);
}
tmp_val = optval;
if (level == SOL_SOCKET &&
(optname == SO_RCVTIMEO || optname == SO_SNDTIMEO)) {
tmp_val = &tv;
*optlen = sizeof (tv);
}
ret = getsockopt (fd, level, optname, tmp_val, optlen);
if (ret == -1) {
gint errnum = errno;
MONO_TRACE (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: getsockopt error: %s", __func__,
strerror (errno));
errnum = errno_to_WSA (errnum, __func__);
WSASetLastError (errnum);
return(SOCKET_ERROR);
}
if (level == SOL_SOCKET &&
(optname == SO_RCVTIMEO || optname == SO_SNDTIMEO)) {
*((int *) optval) = tv.tv_sec * 1000 + (tv.tv_usec / 1000); // milli from micro
*optlen = sizeof (int);
}
if (optname == SO_ERROR) {
ok = mono_w32handle_lookup (handle, MONO_W32HANDLE_SOCKET,
(gpointer *)&socket_handle);
if (ok == FALSE) {
g_warning ("%s: error looking up socket handle %p",
__func__, handle);
/* can't extract the last error */
*((int *) optval) = errno_to_WSA (*((int *)optval),
__func__);
} else {
if (*((int *)optval) != 0) {
*((int *) optval) = errno_to_WSA (*((int *)optval),
__func__);
socket_handle->saved_error = *((int *)optval);
} else {
*((int *)optval) = socket_handle->saved_error;
}
}
}
return(ret);
}
int _wapi_connect(guint32 fd, const struct sockaddr *serv_addr,
socklen_t addrlen)
{
gpointer handle = GUINT_TO_POINTER (fd);
struct _WapiHandle_socket *socket_handle;
gboolean ok;
gint errnum;
MonoThreadInfo *info = mono_thread_info_current ();
if (mono_w32handle_get_type (handle) != MONO_W32HANDLE_SOCKET) {
WSASetLastError (WSAENOTSOCK);
return(SOCKET_ERROR);
}
if (connect (fd, serv_addr, addrlen) == -1) {
mono_pollfd fds;
int so_error;
socklen_t len;
errnum = errno;
if (errno != EINTR) {
MONO_TRACE (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: connect error: %s", __func__,
strerror (errnum));
errnum = errno_to_WSA (errnum, __func__);
if (errnum == WSAEINPROGRESS)
errnum = WSAEWOULDBLOCK; /* see bug #73053 */
WSASetLastError (errnum);
/*
* On solaris x86 getsockopt (SO_ERROR) is not set after
* connect () fails so we need to save this error.
*
* But don't do this for EWOULDBLOCK (bug 317315)
*/
if (errnum != WSAEWOULDBLOCK) {
ok = mono_w32handle_lookup (handle,
MONO_W32HANDLE_SOCKET,
(gpointer *)&socket_handle);
if (ok == FALSE) {
/* ECONNRESET means the socket was closed by another thread */
/* Async close on mac raises ECONNABORTED. */
if (errnum != WSAECONNRESET && errnum != WSAENETDOWN)
g_warning ("%s: error looking up socket handle %p (error %d)", __func__, handle, errnum);
} else {
socket_handle->saved_error = errnum;
}
}
return(SOCKET_ERROR);
}
fds.fd = fd;
fds.events = MONO_POLLOUT;
while (mono_poll (&fds, 1, -1) == -1 &&
!mono_thread_info_is_interrupt_state (info)) {
if (errno != EINTR) {
errnum = errno_to_WSA (errno, __func__);
MONO_TRACE (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: connect poll error: %s",
__func__, strerror (errno));
WSASetLastError (errnum);
return(SOCKET_ERROR);
}
}
len = sizeof(so_error);
if (getsockopt (fd, SOL_SOCKET, SO_ERROR, &so_error,
&len) == -1) {
errnum = errno_to_WSA (errno, __func__);
MONO_TRACE (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: connect getsockopt error: %s",
__func__, strerror (errno));
WSASetLastError (errnum);
return(SOCKET_ERROR);
}
if (so_error != 0) {
errnum = errno_to_WSA (so_error, __func__);
/* Need to save this socket error */
ok = mono_w32handle_lookup (handle, MONO_W32HANDLE_SOCKET,
(gpointer *)&socket_handle);
if (ok == FALSE) {
g_warning ("%s: error looking up socket handle %p", __func__, handle);
} else {
socket_handle->saved_error = errnum;
}
MONO_TRACE (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: connect getsockopt returned error: %s",
__func__, strerror (so_error));
WSASetLastError (errnum);
return(SOCKET_ERROR);
}
}
return(0);
}
guint32 _wapi_accept(guint32 fd, struct sockaddr *addr, socklen_t *addrlen)
{
gpointer handle = GUINT_TO_POINTER (fd);
gpointer new_handle;
struct _WapiHandle_socket *socket_handle;
struct _WapiHandle_socket new_socket_handle = {0};
gboolean ok;
int new_fd;
MonoThreadInfo *info = mono_thread_info_current ();
if (addr != NULL && *addrlen < sizeof(struct sockaddr)) {
WSASetLastError (WSAEFAULT);
return(INVALID_SOCKET);
}
if (mono_w32handle_get_type (handle) != MONO_W32HANDLE_SOCKET) {
WSASetLastError (WSAENOTSOCK);
return(INVALID_SOCKET);
}
ok = mono_w32handle_lookup (handle, MONO_W32HANDLE_SOCKET,
(gpointer *)&socket_handle);
if (ok == FALSE) {
g_warning ("%s: error looking up socket handle %p",
__func__, handle);
WSASetLastError (WSAENOTSOCK);
return(INVALID_SOCKET);
}
do {
new_fd = accept (fd, addr, addrlen);
} while (new_fd == -1 && errno == EINTR &&
!mono_thread_info_is_interrupt_state (info));
if (new_fd == -1) {
gint errnum = errno;
MONO_TRACE (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: accept error: %s", __func__, strerror(errno));
errnum = errno_to_WSA (errnum, __func__);
WSASetLastError (errnum);
return(INVALID_SOCKET);
}
if (new_fd >= mono_w32handle_fd_reserve) {
MONO_TRACE (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: File descriptor is too big", __func__);
WSASetLastError (WSASYSCALLFAILURE);
close (new_fd);
return(INVALID_SOCKET);
}
new_socket_handle.domain = socket_handle->domain;
new_socket_handle.type = socket_handle->type;
new_socket_handle.protocol = socket_handle->protocol;
new_socket_handle.still_readable = 1;
new_handle = mono_w32handle_new_fd (MONO_W32HANDLE_SOCKET, new_fd,
&new_socket_handle);
if(new_handle == INVALID_HANDLE_VALUE) {
g_warning ("%s: error creating socket handle", __func__);
WSASetLastError (ERROR_GEN_FAILURE);
return(INVALID_SOCKET);
}
MONO_TRACE (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: returning newly accepted socket handle %p with",
__func__, new_handle);
return(new_fd);
}
int ioctlsocket(guint32 fd, unsigned long command, gpointer arg)
{
gpointer handle = GUINT_TO_POINTER (fd);
int ret;
if (mono_w32handle_get_type (handle) != MONO_W32HANDLE_SOCKET) {
WSASetLastError (WSAENOTSOCK);
return(SOCKET_ERROR);
}
switch(command){
case FIONBIO:
#ifdef O_NONBLOCK
/* This works better than ioctl(...FIONBIO...)
* on Linux (it causes connect to return
* EINPROGRESS, but the ioctl doesn't seem to)
*/
ret = fcntl(fd, F_GETFL, 0);
if (ret != -1) {
if (*(gboolean *)arg) {
ret |= O_NONBLOCK;
} else {
ret &= ~O_NONBLOCK;
}
ret = fcntl(fd, F_SETFL, ret);
}
break;
#endif /* O_NONBLOCK */
/* Unused in Mono */
case SIOCATMARK:
ret = ioctl (fd, command, arg);
break;
case FIONREAD:
{
#if defined (PLATFORM_MACOSX)
// ioctl (fd, FIONREAD, XXX) returns the size of
// the UDP header as well on
// Darwin.
//
// Use getsockopt SO_NREAD instead to get the
// right values for TCP and UDP.
//
// ai_canonname can be null in some cases on darwin, where the runtime assumes it will
// be the value of the ip buffer.
socklen_t optlen = sizeof (int);
ret = getsockopt (fd, SOL_SOCKET, SO_NREAD, arg, &optlen);
#else
ret = ioctl (fd, command, arg);
#endif
break;
}
default:
WSASetLastError (WSAEINVAL);
return(SOCKET_ERROR);
}
if (ret == -1) {
gint errnum = errno;
MONO_TRACE (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: ioctl error: %s", __func__, strerror (errno));
errnum = errno_to_WSA (errnum, __func__);
WSASetLastError (errnum);
return(SOCKET_ERROR);
}
return(0);
}
guint32 _wapi_accept(guint32 fd, struct sockaddr *addr, socklen_t *addrlen)
{
gpointer handle = GUINT_TO_POINTER (fd);
gpointer new_handle;
struct _WapiHandle_socket *socket_handle;
struct _WapiHandle_socket new_socket_handle = {0};
gboolean ok;
int new_fd;
if (addr != NULL && *addrlen < sizeof(struct sockaddr)) {
WSASetLastError (WSAEFAULT);
return(INVALID_SOCKET);
}
if (_wapi_handle_type (handle) != WAPI_HANDLE_SOCKET) {
WSASetLastError (WSAENOTSOCK);
return(INVALID_SOCKET);
}
ok = _wapi_lookup_handle (handle, WAPI_HANDLE_SOCKET,
(gpointer *)&socket_handle);
if (ok == FALSE) {
g_warning ("%s: error looking up socket handle %p",
__func__, handle);
WSASetLastError (WSAENOTSOCK);
return(INVALID_SOCKET);
}
do {
new_fd = accept (fd, addr, addrlen);
} while (new_fd == -1 && errno == EINTR &&
!_wapi_thread_cur_apc_pending());
if (new_fd == -1) {
gint errnum = errno;
DEBUG ("%s: accept error: %s", __func__, strerror(errno));
errnum = errno_to_WSA (errnum, __func__);
WSASetLastError (errnum);
return(INVALID_SOCKET);
}
if (new_fd >= _wapi_fd_reserve) {
DEBUG ("%s: File descriptor is too big", __func__);
WSASetLastError (WSASYSCALLFAILURE);
close (new_fd);
return(INVALID_SOCKET);
}
new_socket_handle.domain = socket_handle->domain;
new_socket_handle.type = socket_handle->type;
new_socket_handle.protocol = socket_handle->protocol;
new_socket_handle.still_readable = 1;
new_handle = _wapi_handle_new_fd (WAPI_HANDLE_SOCKET, new_fd,
&new_socket_handle);
if(new_handle == _WAPI_HANDLE_INVALID) {
g_warning ("%s: error creating socket handle", __func__);
WSASetLastError (ERROR_GEN_FAILURE);
return(INVALID_SOCKET);
}
DEBUG ("%s: returning newly accepted socket handle %p with",
__func__, new_handle);
return(new_fd);
}
