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); }