static SOCKET
mono_w32socket_socket (int domain, int type, int protocol)
{
- SOCKET ret;
- MONO_ENTER_GC_SAFE;
- ret = WSASocket (domain, type, protocol, NULL, 0, WSA_FLAG_OVERLAPPED);
- MONO_EXIT_GC_SAFE;
- return ret;
+ return WSASocket (domain, type, protocol, NULL, 0, WSA_FLAG_OVERLAPPED);
}
static gint
mono_w32socket_bind (SOCKET sock, struct sockaddr *addr, socklen_t addrlen)
{
- gint ret;
- MONO_ENTER_GC_SAFE;
- ret = bind (sock, addr, addrlen);
- MONO_EXIT_GC_SAFE;
- return ret;
+ return bind (sock, addr, addrlen);
}
static gint
mono_w32socket_getpeername (SOCKET sock, struct sockaddr *name, socklen_t *namelen)
{
- gint ret;
- MONO_ENTER_GC_SAFE;
- ret = getpeername (sock, name, namelen);
- MONO_EXIT_GC_SAFE;
- return ret;
+ return getpeername (sock, name, namelen);
}
static gint
mono_w32socket_getsockname (SOCKET sock, struct sockaddr *name, socklen_t *namelen)
{
- gint ret;
- MONO_ENTER_GC_SAFE;
- ret = getsockname (sock, name, namelen);
- MONO_EXIT_GC_SAFE;
- return ret;
+ return getsockname (sock, name, namelen);
}
static gint
mono_w32socket_getsockopt (SOCKET sock, gint level, gint optname, gpointer optval, socklen_t *optlen)
{
- gint ret;
- MONO_ENTER_GC_SAFE;
- ret = getsockopt (sock, level, optname, optval, optlen);
- MONO_EXIT_GC_SAFE;
- return ret;
+ return getsockopt (sock, level, optname, optval, optlen);
}
static gint
mono_w32socket_setsockopt (SOCKET sock, gint level, gint optname, const gpointer optval, socklen_t optlen)
{
- gint ret;
- MONO_ENTER_GC_SAFE;
- ret = setsockopt (sock, level, optname, optval, optlen);
- MONO_EXIT_GC_SAFE;
- return ret;
+ return setsockopt (sock, level, optname, optval, optlen);
}
static gint
mono_w32socket_listen (SOCKET sock, gint backlog)
{
- gint ret;
- MONO_ENTER_GC_SAFE;
- ret = listen (sock, backlog);
- MONO_EXIT_GC_SAFE;
- return ret;
+ return listen (sock, backlog);
}
static gint
mono_w32socket_shutdown (SOCKET sock, gint how)
{
- gint ret;
- MONO_ENTER_GC_SAFE;
- ret = shutdown (sock, how);
- MONO_EXIT_GC_SAFE;
- return ret;
+ return shutdown (sock, how);
}
static gint
mono_w32socket_ioctl (SOCKET sock, gint32 command, gchar *input, gint inputlen, gchar *output, gint outputlen, glong *written)
{
- gint ret;
- MONO_ENTER_GC_SAFE;
- ret = WSAIoctl (sock, command, input, inputlen, output, outputlen, written, NULL, NULL);
- MONO_EXIT_GC_SAFE;
- return ret;
+ return WSAIoctl (sock, command, input, inputlen, output, outputlen, written, NULL, NULL);
}
static gboolean
mono_w32socket_close (SOCKET sock)
{
- gboolean ret;
- MONO_ENTER_GC_SAFE;
- ret = CloseHandle (sock);
- MONO_EXIT_GC_SAFE;
- return ret;
+ return CloseHandle (sock);
}
#endif /* HOST_WIN32 */
* polling system does not notify when the socket is closed */
mono_threadpool_io_remove_socket (GPOINTER_TO_INT (sock));
+ MONO_ENTER_GC_SAFE;
mono_w32socket_close ((SOCKET) sock);
+ MONO_EXIT_GC_SAFE;
}
gint32
return NULL;
}
+ MONO_ENTER_GC_SAFE;
newsock = mono_w32socket_accept (sock, NULL, 0, blocking);
+ MONO_EXIT_GC_SAFE;
+
if (newsock == INVALID_SOCKET)
*werror = mono_w32socket_get_last_error ();
error_init (error);
*werror = 0;
+ MONO_ENTER_GC_SAFE;
+
ret = mono_w32socket_listen (sock, backlog);
+
+ MONO_EXIT_GC_SAFE;
+
if (ret == SOCKET_ERROR)
*werror = mono_w32socket_get_last_error ();
}
}
sa = (salen <= 128) ? (gchar *)alloca (salen) : (gchar *)g_malloc0 (salen);
+ MONO_ENTER_GC_SAFE;
+
ret = mono_w32socket_getsockname (sock, (struct sockaddr *)sa, &salen);
+
+ MONO_EXIT_GC_SAFE;
+
if (ret == SOCKET_ERROR) {
*werror = mono_w32socket_get_last_error ();
if (salen > 128)
sa = (salen <= 128) ? (gchar *)alloca (salen) : (gchar *)g_malloc0 (salen);
/* Note: linux returns just 2 for AF_UNIX. Always. */
+ MONO_ENTER_GC_SAFE;
+
ret = mono_w32socket_getpeername (sock, (struct sockaddr *)sa, &salen);
+
+ MONO_EXIT_GC_SAFE;
+
if (ret == SOCKET_ERROR) {
*werror = mono_w32socket_get_last_error ();
if (salen > 128)
return;
}
+ MONO_ENTER_GC_SAFE;
ret = mono_w32socket_connect (sock, sa, sa_size, blocking);
+ MONO_EXIT_GC_SAFE;
+
if (ret == SOCKET_ERROR)
*werror = mono_w32socket_get_last_error ();
return;
}
+ MONO_ENTER_GC_SAFE;
*werror = mono_w32socket_disconnect (sock, reuse);
+ MONO_EXIT_GC_SAFE;
mono_thread_info_uninstall_interrupt (&interrupted);
if (interrupted)
}
#endif /* G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT | HAVE_UWP_WINAPI_SUPPORT) */
-MonoBoolean
-ves_icall_System_Net_Sockets_Socket_Duplicate_internal (gpointer handle, gint32 targetProcessId, gpointer *duplicate_handle, gint32 *werror, MonoError *error)
-{
- error_init (error);
-
- *werror = 0;
- if (!mono_w32socket_duplicate (handle, targetProcessId, duplicate_handle)) {
- *werror = mono_w32error_get_last ();
- return FALSE;
- }
-
- return TRUE;
-}
-
gint32
ves_icall_System_Net_Sockets_Socket_Receive_internal (gsize sock, MonoArrayHandle buffer, gint32 offset, gint32 count, gint32 flags, gint32 *werror, gboolean blocking, MonoError *error)
{
uint32_t gchandle;
gchar *buf = MONO_ARRAY_HANDLE_PIN (buffer, gchar, offset, &gchandle);
+ MONO_ENTER_GC_SAFE;
ret = mono_w32socket_recv (sock, buf, count, recvflags, blocking);
+ MONO_EXIT_GC_SAFE;
mono_gchandle_free (gchandle);
uint32_t gchandle;
WSABUF *wsabufs = MONO_ARRAY_HANDLE_PIN (buffers, WSABUF, 0, &gchandle);
+ MONO_ENTER_GC_SAFE;
ret = mono_w32socket_recvbuffers (sock, wsabufs, count, &recv, &recvflags, NULL, NULL, blocking);
+ MONO_EXIT_GC_SAFE;
mono_gchandle_free (gchandle);
uint32_t gchandle;
buf = MONO_ARRAY_HANDLE_PIN (buffer, gchar, offset, &gchandle);
+ MONO_ENTER_GC_SAFE;
ret = mono_w32socket_recvfrom (sock, buf, count, recvflags, sa, &sa_size, blocking);
+ MONO_EXIT_GC_SAFE;
mono_gchandle_free (gchandle);
uint32_t gchandle;
gchar *buf = MONO_ARRAY_HANDLE_PIN (buffer, gchar, offset, &gchandle);
+ MONO_ENTER_GC_SAFE;
ret = mono_w32socket_send (sock, buf, count, sendflags, blocking);
+ MONO_EXIT_GC_SAFE;
mono_gchandle_free (gchandle);
uint32_t gchandle;
WSABUF *wsabufs = MONO_ARRAY_HANDLE_PIN (buffers, WSABUF, 0, &gchandle);
+ MONO_ENTER_GC_SAFE;
ret = mono_w32socket_sendbuffers (sock, wsabufs, count, &sent, sendflags, NULL, NULL, blocking);
+ MONO_EXIT_GC_SAFE;
mono_gchandle_free (gchandle);
uint32_t gchandle;
gchar *buf = MONO_ARRAY_HANDLE_PIN (buffer, gchar, offset, &gchandle);
+ MONO_ENTER_GC_SAFE;
ret = mono_w32socket_sendto (sock, buf, count, sendflags, sa, sa_size, blocking);
+ MONO_EXIT_GC_SAFE;
mono_gchandle_free (gchandle);
return;
}
+ MONO_ENTER_GC_SAFE;
+
/* No need to deal with MulticastOption names here, because
* you cant getsockopt AddMembership or DropMembership (the
* int getsockopt will error, causing an exception)
ret = mono_w32socket_getsockopt (sock, system_level, system_name, &val, &valsize);
}
+ MONO_EXIT_GC_SAFE;
+
if (ret == SOCKET_ERROR) {
*werror = mono_w32socket_get_last_error ();
return;
uint32_t gchandle;
guchar *buf = MONO_ARRAY_HANDLE_PIN (byte_val, guchar, 0, &gchandle);
+ MONO_ENTER_GC_SAFE;
+
ret = mono_w32socket_getsockopt (sock, system_level, system_name, buf, &valsize);
+ MONO_EXIT_GC_SAFE;
+
mono_gchandle_free (gchandle);
if (ret == SOCKET_ERROR)
return;
}
+ MONO_ENTER_GC_SAFE;
+
/* Currently, the values for how (recv=0, send=1, both=2) match the BSD API */
ret = mono_w32socket_shutdown (sock, how);
+
+ MONO_EXIT_GC_SAFE;
+
if (ret == SOCKET_ERROR)
*werror = mono_w32socket_get_last_error ();
o_buffer = MONO_ARRAY_HANDLE_PIN (output, gchar, 0, &o_gchandle);
}
+ MONO_ENTER_GC_SAFE;
+
ret = mono_w32socket_ioctl (sock, code, i_buffer, i_len, o_buffer, o_len, &output_bytes);
+ MONO_EXIT_GC_SAFE;
+
if (i_gchandle)
mono_gchandle_free (i_gchandle);
if (o_gchandle)
g_free (address);
+ MONO_ENTER_GC_SAFE;
+
switch (family) {
case AF_INET: {
#if HAVE_SOCKADDR_IN_SIN_LEN
saddr.sin_len = sizeof (saddr);
#endif
- MONO_ENTER_GC_SAFE;
ret = getnameinfo ((struct sockaddr*)&saddr, sizeof (saddr), hostname, sizeof (hostname), NULL, 0, 0) == 0;
- MONO_EXIT_GC_SAFE;
break;
}
#ifdef HAVE_STRUCT_SOCKADDR_IN6
#if HAVE_SOCKADDR_IN6_SIN_LEN
saddr6.sin6_len = sizeof (saddr6);
#endif
- MONO_ENTER_GC_SAFE;
ret = getnameinfo ((struct sockaddr*)&saddr6, sizeof (saddr6), hostname, sizeof (hostname), NULL, 0, 0) == 0;
- MONO_EXIT_GC_SAFE;
break;
}
#endif
g_assert_not_reached ();
}
+ MONO_EXIT_GC_SAFE;
+
if (!ret)
return FALSE;
buffers.TailLength = mono_array_handle_length (post_buffer);
}
+ MONO_ENTER_GC_SAFE;
ret = mono_w32socket_transmit_file (sock, file, &buffers, flags, blocking);
+ MONO_EXIT_GC_SAFE;
if (pre_buffer_gchandle)
mono_gchandle_free (pre_buffer_gchandle);