mono/metadata/w32socket.c

   1 /*
   2  * socket-io.c: Socket IO internal calls
   3  *
   4  * Authors:
   5  *      Dick Porter (dick@ximian.com)
   6  *      Gonzalo Paniagua Javier (gonzalo@ximian.com)
   7  *
   8  * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
   9  * Copyright 2004-2009 Novell, Inc (http://www.novell.com)
  10  *
  11  * This file has been re-licensed under the MIT License:
  12  * http://opensource.org/licenses/MIT
  13  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
  14  */
  15
  16 #include <config.h>
  17
  18 #ifndef DISABLE_SOCKETS
  19
  20 #if defined(__APPLE__) || defined(__FreeBSD__)
  21 #define __APPLE_USE_RFC_3542
  22 #endif
  23
  24 #include <glib.h>
  25 #include <string.h>
  26 #include <stdlib.h>
  27 #ifdef HOST_WIN32
  28 #include <ws2tcpip.h>
  29 #else
  30 #include <sys/socket.h>
  31 #ifdef HAVE_SYS_IOCTL_H
  32 #include <sys/ioctl.h>
  33 #endif
  34 #include <netinet/in.h>
  35 #include <netinet/tcp.h>
  36 #ifdef HAVE_NETDB_H
  37 #include <netdb.h>
  38 #endif
  39 #include <arpa/inet.h>
  40 #endif
  41 #ifdef HAVE_UNISTD_H
  42 #include <unistd.h>
  43 #endif
  44 #include <errno.h>
  45
  46 #include <sys/types.h>
  47
  48 #include <mono/metadata/object.h>
  49 #include <mono/io-layer/io-layer.h>
  50 #include <mono/metadata/exception.h>
  51 #include <mono/metadata/assembly.h>
  52 #include <mono/metadata/appdomain.h>
  53 #include <mono/metadata/w32file.h>
  54 #include <mono/metadata/threads.h>
  55 #include <mono/metadata/threads-types.h>
  56 #include <mono/metadata/threadpool-io.h>
  57 #include <mono/utils/mono-poll.h>
  58 /* FIXME change this code to not mess so much with the internals */
  59 #include <mono/metadata/class-internals.h>
  60 #include <mono/metadata/domain-internals.h>
  61 #include <mono/utils/mono-threads.h>
  62 #include <mono/utils/mono-memory-model.h>
  63 #include <mono/utils/networking.h>
  64 #include <mono/metadata/w32handle.h>
  65 #include <mono/metadata/w32socket.h>
  66 #include <mono/metadata/w32socket-internals.h>
  67
  68 #include <time.h>
  69 #ifdef HAVE_SYS_TIME_H
  70 #include <sys/time.h>
  71 #endif
  72 #ifdef HAVE_SYS_IOCTL_H
  73 #include <sys/ioctl.h>
  74 #endif
  75 #ifdef HAVE_NET_IF_H
  76 #include <net/if.h>
  77 #endif
  78
  79 #ifdef HAVE_NETDB_H
  80 #include <netdb.h>
  81 #endif
  82 #ifdef HAVE_SYS_FILIO_H
  83 #include <sys/filio.h>     /* defines FIONBIO and FIONREAD */
  84 #endif
  85 #ifdef HAVE_SYS_SOCKIO_H
  86 #include <sys/sockio.h>    /* defines SIOCATMARK */
  87 #endif
  88 #ifdef HAVE_SYS_UN_H
  89 #include <sys/un.h>
  90 #endif
  91
  92 #ifdef HAVE_GETIFADDRS
  93 // <net/if.h> must be included before <ifaddrs.h>
  94 #include <ifaddrs.h>
  95 #endif
  96
  97 #if defined(_MSC_VER) && G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT | HAVE_UWP_WINAPI_SUPPORT)
  98 #include <MSWSock.h>
  99 #endif
 100
 101 #define LOGDEBUG(...)
 102 /* define LOGDEBUG(...) g_message(__VA_ARGS__)  */
 103
 104 #ifdef HOST_WIN32
 105
 106 static SOCKET
 107 mono_w32socket_socket (int domain, int type, int protocol)
 108 {
 109         return WSASocket (domain, type, protocol, NULL, 0, WSA_FLAG_OVERLAPPED);
 110 }
 111
 112 static gint
 113 mono_w32socket_bind (SOCKET sock, struct sockaddr *addr, socklen_t addrlen)
 114 {
 115         return bind (sock, addr, addrlen);
 116 }
 117
 118 static gint
 119 mono_w32socket_getpeername (SOCKET sock, struct sockaddr *name, socklen_t *namelen)
 120 {
 121         return getpeername (sock, name, namelen);
 122 }
 123
 124 static gint
 125 mono_w32socket_getsockname (SOCKET sock, struct sockaddr *name, socklen_t *namelen)
 126 {
 127         return getsockname (sock, name, namelen);
 128 }
 129
 130 static gint
 131 mono_w32socket_getsockopt (SOCKET sock, gint level, gint optname, gpointer optval, socklen_t *optlen)
 132 {
 133         return getsockopt (sock, level, optname, optval, optlen);
 134 }
 135
 136 static gint
 137 mono_w32socket_setsockopt (SOCKET sock, gint level, gint optname, const gpointer optval, socklen_t optlen)
 138 {
 139         return setsockopt (sock, level, optname, optval, optlen);
 140 }
 141
 142 static gint
 143 mono_w32socket_listen (SOCKET sock, gint backlog)
 144 {
 145         return listen (sock, backlog);
 146 }
 147
 148 static gint
 149 mono_w32socket_shutdown (SOCKET sock, gint how)
 150 {
 151         return shutdown (sock, how);
 152 }
 153
 154 static gint
 155 mono_w32socket_ioctl (SOCKET sock, gint32 command, gchar *input, gint inputlen, gchar *output, gint outputlen, glong *written)
 156 {
 157         return WSAIoctl (sock, command, input, inputlen, output, outputlen, written, NULL, NULL);
 158 }
 159
 160 #endif /* HOST_WIN32 */
 161
 162 static void
 163 abort_syscall (gpointer data)
 164 {
 165         mono_thread_info_abort_socket_syscall_for_close ((MonoNativeThreadId) (gsize) data);
 166 }
 167
 168 static gint32
 169 convert_family (MonoAddressFamily mono_family)
 170 {
 171         switch (mono_family) {
 172         case AddressFamily_Unknown:
 173         case AddressFamily_ImpLink:
 174         case AddressFamily_Pup:
 175         case AddressFamily_Chaos:
 176         case AddressFamily_Iso:
 177         case AddressFamily_Ecma:
 178         case AddressFamily_DataKit:
 179         case AddressFamily_Ccitt:
 180         case AddressFamily_DataLink:
 181         case AddressFamily_Lat:
 182         case AddressFamily_HyperChannel:
 183         case AddressFamily_NetBios:
 184         case AddressFamily_VoiceView:
 185         case AddressFamily_FireFox:
 186         case AddressFamily_Banyan:
 187         case AddressFamily_Atm:
 188         case AddressFamily_Cluster:
 189         case AddressFamily_Ieee12844:
 190         case AddressFamily_NetworkDesigners:
 191                 g_warning ("System.Net.Sockets.AddressFamily has unsupported value 0x%x", mono_family);
 192                 return -1;
 193         case AddressFamily_Unspecified:
 194                 return AF_UNSPEC;
 195         case AddressFamily_Unix:
 196                 return AF_UNIX;
 197         case AddressFamily_InterNetwork:
 198                 return AF_INET;
 199         case AddressFamily_AppleTalk:
 200                 return AF_APPLETALK;
 201         case AddressFamily_InterNetworkV6:
 202                 return AF_INET6;
 203         case AddressFamily_DecNet:
 204 #ifdef AF_DECnet
 205                 return AF_DECnet;
 206 #else
 207                 return -1;
 208 #endif
 209         case AddressFamily_Ipx:
 210 #ifdef AF_IPX
 211                 return AF_IPX;
 212 #else
 213                 return -1;
 214 #endif
 215         case AddressFamily_Sna:
 216 #ifdef AF_SNA
 217                 return AF_SNA;
 218 #else
 219                 return -1;
 220 #endif
 221         case AddressFamily_Irda:
 222 #ifdef AF_IRDA
 223                 return AF_IRDA;
 224 #else
 225                 return -1;
 226 #endif
 227         default:
 228                 g_warning ("System.Net.Sockets.AddressFamily has unknown value 0x%x", mono_family);
 229                 return -1;
 230         }
 231 }
 232
 233 static MonoAddressFamily
 234 convert_to_mono_family (guint16 af_family)
 235 {
 236         switch (af_family) {
 237         case AF_UNSPEC:
 238                 return AddressFamily_Unspecified;
 239         case AF_UNIX:
 240                 return AddressFamily_Unix;
 241         case AF_INET:
 242                 return AddressFamily_InterNetwork;
 243 #ifdef AF_IPX
 244         case AF_IPX:
 245                 return AddressFamily_Ipx;
 246 #endif
 247 #ifdef AF_SNA
 248         case AF_SNA:
 249                 return AddressFamily_Sna;
 250 #endif
 251 #ifdef AF_DECnet
 252         case AF_DECnet:
 253                 return AddressFamily_DecNet;
 254 #endif
 255         case AF_APPLETALK:
 256                 return AddressFamily_AppleTalk;
 257         case AF_INET6:
 258                 return AddressFamily_InterNetworkV6;
 259 #ifdef AF_IRDA
 260         case AF_IRDA:
 261                 return AddressFamily_Irda;
 262 #endif
 263         default:
 264                 g_warning ("unknown address family 0x%x", af_family);
 265                 return AddressFamily_Unknown;
 266         }
 267 }
 268
 269 static gint32
 270 convert_type (MonoSocketType mono_type)
 271 {
 272         switch (mono_type) {
 273         case SocketType_Stream:
 274                 return SOCK_STREAM;
 275         case SocketType_Dgram:
 276                 return SOCK_DGRAM;
 277         case SocketType_Raw:
 278                 return SOCK_RAW;
 279         case SocketType_Rdm:
 280 #ifdef SOCK_RDM
 281                 return SOCK_RDM;
 282 #else
 283                 return -1;
 284 #endif
 285         case SocketType_Seqpacket:
 286                 return SOCK_SEQPACKET;
 287         case SocketType_Unknown:
 288                 g_warning ("System.Net.Sockets.SocketType has unsupported value 0x%x", mono_type);
 289                 return -1;
 290         default:
 291                 g_warning ("System.Net.Sockets.SocketType has unknown value 0x%x", mono_type);
 292                 return -1;
 293         }
 294 }
 295
 296 static gint32
 297 convert_proto (MonoProtocolType mono_proto)
 298 {
 299         switch (mono_proto) {
 300         case ProtocolType_IP:
 301         case ProtocolType_IPv6:
 302         case ProtocolType_Icmp:
 303         case ProtocolType_Igmp:
 304         case ProtocolType_Ggp:
 305         case ProtocolType_Tcp:
 306         case ProtocolType_Pup:
 307         case ProtocolType_Udp:
 308         case ProtocolType_Idp:
 309                 /* These protocols are known (on my system at least) */
 310                 return mono_proto;
 311         case ProtocolType_ND:
 312         case ProtocolType_Raw:
 313         case ProtocolType_Ipx:
 314         case ProtocolType_Spx:
 315         case ProtocolType_SpxII:
 316         case ProtocolType_Unknown:
 317                 /* These protocols arent */
 318                 g_warning ("System.Net.Sockets.ProtocolType has unsupported value 0x%x", mono_proto);
 319                 return -1;
 320         default:
 321                 return -1;
 322         }
 323 }
 324
 325 /* Convert MonoSocketFlags */
 326 static gint32
 327 convert_socketflags (gint32 sflags)
 328 {
 329         gint32 flags = 0;
 330
 331         if (!sflags)
 332                 /* SocketFlags.None */
 333                 return 0;
 334
 335         if (sflags & ~(SocketFlags_OutOfBand | SocketFlags_MaxIOVectorLength | SocketFlags_Peek |
 336                         SocketFlags_DontRoute | SocketFlags_Partial))
 337                 /* Contains invalid flag values */
 338                 return -1;
 339
 340         if (sflags & SocketFlags_OutOfBand)
 341                 flags |= MSG_OOB;
 342         if (sflags & SocketFlags_Peek)
 343                 flags |= MSG_PEEK;
 344         if (sflags & SocketFlags_DontRoute)
 345                 flags |= MSG_DONTROUTE;
 346
 347         /* Ignore Partial - see bug 349688.  Don't return -1, because
 348          * according to the comment in that bug ms runtime doesn't for
 349          * UDP sockets (this means we will silently ignore it for TCP
 350          * too)
 351          */
 352 #ifdef MSG_MORE
 353         if (sflags & SocketFlags_Partial)
 354                 flags |= MSG_MORE;
 355 #endif
 356 #if 0
 357         /* Don't do anything for MaxIOVectorLength */
 358         if (sflags & SocketFlags_MaxIOVectorLength)
 359                 return -1;
 360 #endif
 361         return flags;
 362 }
 363
 364 /*
 365  * Returns:
 366  *    0 on success (mapped mono_level and mono_name to system_level and system_name
 367  *   -1 on error
 368  *   -2 on non-fatal error (ie, must ignore)
 369  */
 370 static gint32
 371 convert_sockopt_level_and_name (MonoSocketOptionLevel mono_level, MonoSocketOptionName mono_name, int *system_level, int *system_name)
 372 {
 373         switch (mono_level) {
 374         case SocketOptionLevel_Socket:
 375                 *system_level = SOL_SOCKET;
 376
 377                 switch (mono_name) {
 378                 case SocketOptionName_DontLinger:
 379                         /* This is SO_LINGER, because the setsockopt
 380                          * internal call maps DontLinger to SO_LINGER
 381                          * with l_onoff=0
 382                          */
 383                         *system_name = SO_LINGER;
 384                         break;
 385                 case SocketOptionName_Debug:
 386                         *system_name = SO_DEBUG;
 387                         break;
 388 #ifdef SO_ACCEPTCONN
 389                 case SocketOptionName_AcceptConnection:
 390                         *system_name = SO_ACCEPTCONN;
 391                         break;
 392 #endif
 393                 case SocketOptionName_ReuseAddress:
 394                         *system_name = SO_REUSEADDR;
 395                         break;
 396                 case SocketOptionName_KeepAlive:
 397                         *system_name = SO_KEEPALIVE;
 398                         break;
 399                 case SocketOptionName_DontRoute:
 400                         *system_name = SO_DONTROUTE;
 401                         break;
 402                 case SocketOptionName_Broadcast:
 403                         *system_name = SO_BROADCAST;
 404                         break;
 405                 case SocketOptionName_Linger:
 406                         *system_name = SO_LINGER;
 407                         break;
 408                 case SocketOptionName_OutOfBandInline:
 409                         *system_name = SO_OOBINLINE;
 410                         break;
 411                 case SocketOptionName_SendBuffer:
 412                         *system_name = SO_SNDBUF;
 413                         break;
 414                 case SocketOptionName_ReceiveBuffer:
 415                         *system_name = SO_RCVBUF;
 416                         break;
 417                 case SocketOptionName_SendLowWater:
 418                         *system_name = SO_SNDLOWAT;
 419                         break;
 420                 case SocketOptionName_ReceiveLowWater:
 421                         *system_name = SO_RCVLOWAT;
 422                         break;
 423                 case SocketOptionName_SendTimeout:
 424                         *system_name = SO_SNDTIMEO;
 425                         break;
 426                 case SocketOptionName_ReceiveTimeout:
 427                         *system_name = SO_RCVTIMEO;
 428                         break;
 429                 case SocketOptionName_Error:
 430                         *system_name = SO_ERROR;
 431                         break;
 432                 case SocketOptionName_Type:
 433                         *system_name = SO_TYPE;
 434                         break;
 435 #ifdef SO_PEERCRED
 436                 case SocketOptionName_PeerCred:
 437                         *system_name = SO_PEERCRED;
 438                         break;
 439 #endif
 440                 case SocketOptionName_ExclusiveAddressUse:
 441 #ifdef SO_EXCLUSIVEADDRUSE
 442                         *system_name = SO_EXCLUSIVEADDRUSE;
 443                         break;
 444 #endif
 445                 case SocketOptionName_UseLoopback:
 446 #ifdef SO_USELOOPBACK
 447                         *system_name = SO_USELOOPBACK;
 448                         break;
 449 #endif
 450                 case SocketOptionName_MaxConnections:
 451 #ifdef SO_MAXCONN
 452                         *system_name = SO_MAXCONN;
 453                         break;
 454 #elif defined(SOMAXCONN)
 455                         *system_name = SOMAXCONN;
 456                         break;
 457 #endif
 458                 default:
 459                         g_warning ("System.Net.Sockets.SocketOptionName 0x%x is not supported at Socket level", mono_name);
 460                         return -1;
 461                 }
 462                 break;
 463
 464         case SocketOptionLevel_IP:
 465                 *system_level = mono_networking_get_ip_protocol ();
 466
 467                 switch (mono_name) {
 468                 case SocketOptionName_IPOptions:
 469                         *system_name = IP_OPTIONS;
 470                         break;
 471 #ifdef IP_HDRINCL
 472                 case SocketOptionName_HeaderIncluded:
 473                         *system_name = IP_HDRINCL;
 474                         break;
 475 #endif
 476 #ifdef IP_TOS
 477                 case SocketOptionName_TypeOfService:
 478                         *system_name = IP_TOS;
 479                         break;
 480 #endif
 481 #ifdef IP_TTL
 482                 case SocketOptionName_IpTimeToLive:
 483                         *system_name = IP_TTL;
 484                         break;
 485 #endif
 486                 case SocketOptionName_MulticastInterface:
 487                         *system_name = IP_MULTICAST_IF;
 488                         break;
 489                 case SocketOptionName_MulticastTimeToLive:
 490                         *system_name = IP_MULTICAST_TTL;
 491                         break;
 492                 case SocketOptionName_MulticastLoopback:
 493                         *system_name = IP_MULTICAST_LOOP;
 494                         break;
 495                 case SocketOptionName_AddMembership:
 496                         *system_name = IP_ADD_MEMBERSHIP;
 497                         break;
 498                 case SocketOptionName_DropMembership:
 499                         *system_name = IP_DROP_MEMBERSHIP;
 500                         break;
 501 #ifdef HAVE_IP_PKTINFO
 502                 case SocketOptionName_PacketInformation:
 503                         *system_name = IP_PKTINFO;
 504                         break;
 505 #endif /* HAVE_IP_PKTINFO */
 506
 507                 case SocketOptionName_DontFragment:
 508 #ifdef HAVE_IP_DONTFRAGMENT
 509                         *system_name = IP_DONTFRAGMENT;
 510                         break;
 511 #elif defined HAVE_IP_MTU_DISCOVER
 512                         /* Not quite the same */
 513                         *system_name = IP_MTU_DISCOVER;
 514                         break;
 515 #else
 516                         /* If the flag is not available on this system, we can ignore this error */
 517                         return -2;
 518 #endif /* HAVE_IP_DONTFRAGMENT */
 519                 case SocketOptionName_AddSourceMembership:
 520                 case SocketOptionName_DropSourceMembership:
 521                 case SocketOptionName_BlockSource:
 522                 case SocketOptionName_UnblockSource:
 523                         /* Can't figure out how to map these, so fall
 524                          * through
 525                          */
 526                 default:
 527                         g_warning ("System.Net.Sockets.SocketOptionName 0x%x is not supported at IP level", mono_name);
 528                         return -1;
 529                 }
 530                 break;
 531
 532         case SocketOptionLevel_IPv6:
 533                 *system_level = mono_networking_get_ipv6_protocol ();
 534
 535                 switch (mono_name) {
 536                 case SocketOptionName_IpTimeToLive:
 537                 case SocketOptionName_HopLimit:
 538                         *system_name = IPV6_UNICAST_HOPS;
 539                         break;
 540                 case SocketOptionName_MulticastInterface:
 541                         *system_name = IPV6_MULTICAST_IF;
 542                         break;
 543                 case SocketOptionName_MulticastTimeToLive:
 544                         *system_name = IPV6_MULTICAST_HOPS;
 545                         break;
 546                 case SocketOptionName_MulticastLoopback:
 547                         *system_name = IPV6_MULTICAST_LOOP;
 548                         break;
 549                 case SocketOptionName_AddMembership:
 550                         *system_name = IPV6_JOIN_GROUP;
 551                         break;
 552                 case SocketOptionName_DropMembership:
 553                         *system_name = IPV6_LEAVE_GROUP;
 554                         break;
 555                 case SocketOptionName_IPv6Only:
 556 #ifdef IPV6_V6ONLY
 557                         *system_name = IPV6_V6ONLY;
 558 #else
 559                         return -1;
 560 #endif
 561                         break;
 562                 case SocketOptionName_PacketInformation:
 563 #ifdef HAVE_IPV6_PKTINFO
 564                         *system_name = IPV6_PKTINFO;
 565 #endif
 566                         break;
 567                 case SocketOptionName_HeaderIncluded:
 568                 case SocketOptionName_IPOptions:
 569                 case SocketOptionName_TypeOfService:
 570                 case SocketOptionName_DontFragment:
 571                 case SocketOptionName_AddSourceMembership:
 572                 case SocketOptionName_DropSourceMembership:
 573                 case SocketOptionName_BlockSource:
 574                 case SocketOptionName_UnblockSource:
 575                         /* Can't figure out how to map these, so fall
 576                          * through
 577                          */
 578                 default:
 579                         g_warning ("System.Net.Sockets.SocketOptionName 0x%x is not supported at IPv6 level", mono_name);
 580                         return -1;
 581                 }
 582                 break;  /* SocketOptionLevel_IPv6 */
 583
 584         case SocketOptionLevel_Tcp:
 585                 *system_level = mono_networking_get_tcp_protocol ();
 586
 587                 switch (mono_name) {
 588                 case SocketOptionName_NoDelay:
 589                         *system_name = TCP_NODELAY;
 590                         break;
 591 #if 0
 592                         /* The documentation is talking complete
 593                          * bollocks here: rfc-1222 is titled
 594                          * 'Advancing the NSFNET Routing Architecture'
 595                          * and doesn't mention either of the words
 596                          * "expedite" or "urgent".
 597                          */
 598                 case SocketOptionName_BsdUrgent:
 599                 case SocketOptionName_Expedited:
 600 #endif
 601                 default:
 602                         g_warning ("System.Net.Sockets.SocketOptionName 0x%x is not supported at TCP level", mono_name);
 603                         return -1;
 604                 }
 605                 break;
 606
 607         case SocketOptionLevel_Udp:
 608                 g_warning ("System.Net.Sockets.SocketOptionLevel has unsupported value 0x%x", mono_level);
 609
 610                 switch(mono_name) {
 611                 case SocketOptionName_NoChecksum:
 612                 case SocketOptionName_ChecksumCoverage:
 613                 default:
 614                         g_warning ("System.Net.Sockets.SocketOptionName 0x%x is not supported at UDP level", mono_name);
 615                         return -1;
 616                 }
 617                 return -1;
 618                 break;
 619
 620         default:
 621                 g_warning ("System.Net.Sockets.SocketOptionLevel has unknown value 0x%x", mono_level);
 622                 return -1;
 623         }
 624
 625         return 0;
 626 }
 627
 628 static MonoImage*
 629 get_socket_assembly (void)
 630 {
 631         MonoDomain *domain = mono_domain_get ();
 632
 633         if (domain->socket_assembly == NULL) {
 634                 MonoImage *socket_assembly;
 635
 636                 socket_assembly = mono_image_loaded ("System");
 637                 if (!socket_assembly) {
 638                         MonoAssembly *sa = mono_assembly_open ("System.dll", NULL);
 639
 640                         if (!sa) {
 641                                 g_assert_not_reached ();
 642                         } else {
 643                                 socket_assembly = mono_assembly_get_image (sa);
 644                         }
 645                 }
 646                 mono_atomic_store_release (&domain->socket_assembly, socket_assembly);
 647         }
 648
 649         return domain->socket_assembly;
 650 }
 651
 652 gpointer
 653 ves_icall_System_Net_Sockets_Socket_Socket_internal (MonoObject *this_obj, gint32 family, gint32 type, gint32 proto, gint32 *werror)
 654 {
 655         SOCKET sock;
 656         gint32 sock_family;
 657         gint32 sock_proto;
 658         gint32 sock_type;
 659
 660         *werror = 0;
 661
 662         sock_family = convert_family ((MonoAddressFamily)family);
 663         if (sock_family == -1) {
 664                 *werror = WSAEAFNOSUPPORT;
 665                 return NULL;
 666         }
 667
 668         sock_proto = convert_proto ((MonoProtocolType)proto);
 669         if (sock_proto == -1) {
 670                 *werror = WSAEPROTONOSUPPORT;
 671                 return NULL;
 672         }
 673
 674         sock_type = convert_type ((MonoSocketType)type);
 675         if (sock_type == -1) {
 676                 *werror = WSAESOCKTNOSUPPORT;
 677                 return NULL;
 678         }
 679
 680         sock = mono_w32socket_socket (sock_family, sock_type, sock_proto);
 681
 682         if (sock == INVALID_SOCKET) {
 683                 *werror = mono_w32socket_get_last_error ();
 684                 return NULL;
 685         }
 686
 687         return GUINT_TO_POINTER (sock);
 688 }
 689
 690 /* FIXME: the SOCKET parameter (here and in other functions in this
 691  * file) is really an IntPtr which needs to be converted to a guint32.
 692  */
 693 void
 694 ves_icall_System_Net_Sockets_Socket_Close_internal (gsize sock, gint32 *werror)
 695 {
 696         LOGDEBUG (g_message ("%s: closing 0x%x", __func__, sock));
 697
 698         *werror = 0;
 699
 700         /* Clear any pending work item from this socket if the underlying
 701          * polling system does not notify when the socket is closed */
 702         mono_threadpool_io_remove_socket (GPOINTER_TO_INT (sock));
 703
 704         MONO_ENTER_GC_SAFE;
 705         CloseHandle (GINT_TO_POINTER (sock));
 706         MONO_EXIT_GC_SAFE;
 707 }
 708
 709 gint32
 710 ves_icall_System_Net_Sockets_SocketException_WSAGetLastError_internal (void)
 711 {
 712         LOGDEBUG (g_message("%s: returning %d", __func__, mono_w32socket_get_last_error ()));
 713
 714         return mono_w32socket_get_last_error ();
 715 }
 716
 717 gint32
 718 ves_icall_System_Net_Sockets_Socket_Available_internal (gsize sock, gint32 *werror)
 719 {
 720         int ret;
 721         guint64 amount;
 722
 723         *werror = 0;
 724
 725         /* FIXME: this might require amount to be unsigned long. */
 726         ret = mono_w32socket_get_available (sock, &amount);
 727         if (ret == SOCKET_ERROR) {
 728                 *werror = mono_w32socket_get_last_error ();
 729                 return 0;
 730         }
 731
 732         return amount;
 733 }
 734
 735 void
 736 ves_icall_System_Net_Sockets_Socket_Blocking_internal (gsize sock, gboolean block, gint32 *werror)
 737 {
 738         int ret;
 739
 740         *werror = 0;
 741
 742         ret = mono_w32socket_set_blocking (sock, block);
 743         if (ret == SOCKET_ERROR)
 744                 *werror = mono_w32socket_get_last_error ();
 745 }
 746
 747 gpointer
 748 ves_icall_System_Net_Sockets_Socket_Accept_internal (gsize sock, gint32 *werror, gboolean blocking)
 749 {
 750         gboolean interrupted;
 751         SOCKET newsock;
 752
 753         *werror = 0;
 754
 755         mono_thread_info_install_interrupt (abort_syscall, (gpointer) (gsize) mono_native_thread_id_get (), &interrupted);
 756         if (interrupted) {
 757                 *werror = WSAEINTR;
 758                 return NULL;
 759         }
 760
 761         MONO_ENTER_GC_SAFE;
 762         newsock = mono_w32socket_accept (sock, NULL, 0, blocking);
 763         MONO_EXIT_GC_SAFE;
 764
 765         if (newsock == INVALID_SOCKET)
 766                 *werror = mono_w32socket_get_last_error ();
 767
 768         mono_thread_info_uninstall_interrupt (&interrupted);
 769         if (interrupted)
 770                 *werror = WSAEINTR;
 771
 772         if (*werror)
 773                 return NULL;
 774
 775         return GUINT_TO_POINTER (newsock);
 776 }
 777
 778 void
 779 ves_icall_System_Net_Sockets_Socket_Listen_internal(gsize sock, guint32 backlog, gint32 *werror)
 780 {
 781         int ret;
 782
 783         *werror = 0;
 784
 785         MONO_ENTER_GC_SAFE;
 786
 787         ret = mono_w32socket_listen (sock, backlog);
 788
 789         MONO_EXIT_GC_SAFE;
 790
 791         if (ret == SOCKET_ERROR)
 792                 *werror = mono_w32socket_get_last_error ();
 793 }
 794
 795 // Check whether it's ::ffff::0:0.
 796 static gboolean
 797 is_ipv4_mapped_any (const struct in6_addr *addr)
 798 {
 799         int i;
 800
 801         for (i = 0; i < 10; i++) {
 802                 if (addr->s6_addr [i])
 803                         return FALSE;
 804         }
 805         if ((addr->s6_addr [10] != 0xff) || (addr->s6_addr [11] != 0xff))
 806                 return FALSE;
 807         for (i = 12; i < 16; i++) {
 808                 if (addr->s6_addr [i])
 809                         return FALSE;
 810         }
 811         return TRUE;
 812 }
 813
 814 static MonoObject*
 815 create_object_from_sockaddr (struct sockaddr *saddr, int sa_size, gint32 *werror, MonoError *error)
 816 {
 817         MonoDomain *domain = mono_domain_get ();
 818         MonoObject *sockaddr_obj;
 819         MonoArray *data;
 820         MonoAddressFamily family;
 821
 822         mono_error_init (error);
 823
 824         /* Build a System.Net.SocketAddress object instance */
 825         if (!domain->sockaddr_class)
 826                 domain->sockaddr_class = mono_class_load_from_name (get_socket_assembly (), "System.Net", "SocketAddress");
 827         sockaddr_obj = mono_object_new_checked (domain, domain->sockaddr_class, error);
 828         return_val_if_nok (error, NULL);
 829
 830         /* Locate the SocketAddress data buffer in the object */
 831         if (!domain->sockaddr_data_field) {
 832                 domain->sockaddr_data_field = mono_class_get_field_from_name (domain->sockaddr_class, "m_Buffer");
 833                 g_assert (domain->sockaddr_data_field);
 834         }
 835
 836         /* Locate the SocketAddress data buffer length in the object */
 837         if (!domain->sockaddr_data_length_field) {
 838                 domain->sockaddr_data_length_field = mono_class_get_field_from_name (domain->sockaddr_class, "m_Size");
 839                 g_assert (domain->sockaddr_data_length_field);
 840         }
 841
 842         /* May be the +2 here is too conservative, as sa_len returns
 843          * the length of the entire sockaddr_in/in6, including
 844          * sizeof (unsigned short) of the family */
 845         /* We can't really avoid the +2 as all code below depends on this size - INCLUDING unix domain sockets.*/
 846         data = mono_array_new_cached (domain, mono_get_byte_class (), sa_size + 2, error);
 847         return_val_if_nok (error, NULL);
 848
 849         /* The data buffer is laid out as follows:
 850          * bytes 0 and 1 are the address family
 851          * bytes 2 and 3 are the port info
 852          * the rest is the address info
 853          */
 854
 855         family = convert_to_mono_family (saddr->sa_family);
 856         if (family == AddressFamily_Unknown) {
 857                 *werror = WSAEAFNOSUPPORT;
 858                 return NULL;
 859         }
 860
 861         mono_array_set (data, guint8, 0, family & 0x0FF);
 862         mono_array_set (data, guint8, 1, (family >> 8) & 0x0FF);
 863
 864         if (saddr->sa_family == AF_INET) {
 865                 struct sockaddr_in *sa_in = (struct sockaddr_in *)saddr;
 866                 guint16 port = ntohs (sa_in->sin_port);
 867                 guint32 address = ntohl (sa_in->sin_addr.s_addr);
 868                 int buffer_size = 8;
 869
 870                 if (sa_size < buffer_size) {
 871                         mono_error_set_exception_instance (error, mono_exception_from_name (mono_get_corlib (), "System", "SystemException"));
 872                         return NULL;
 873                 }
 874
 875                 mono_array_set (data, guint8, 2, (port>>8) & 0xff);
 876                 mono_array_set (data, guint8, 3, (port) & 0xff);
 877                 mono_array_set (data, guint8, 4, (address>>24) & 0xff);
 878                 mono_array_set (data, guint8, 5, (address>>16) & 0xff);
 879                 mono_array_set (data, guint8, 6, (address>>8) & 0xff);
 880                 mono_array_set (data, guint8, 7, (address) & 0xff);
 881
 882                 mono_field_set_value (sockaddr_obj, domain->sockaddr_data_field, data);
 883                 mono_field_set_value (sockaddr_obj, domain->sockaddr_data_length_field, &buffer_size);
 884
 885                 return sockaddr_obj;
 886         } else if (saddr->sa_family == AF_INET6) {
 887                 struct sockaddr_in6 *sa_in = (struct sockaddr_in6 *)saddr;
 888                 int i;
 889                 int buffer_size = 28;
 890
 891                 guint16 port = ntohs (sa_in->sin6_port);
 892
 893                 if (sa_size < buffer_size) {
 894                         mono_error_set_exception_instance (error, mono_exception_from_name (mono_get_corlib (), "System", "SystemException"));
 895                         return NULL;
 896                 }
 897
 898                 mono_array_set (data, guint8, 2, (port>>8) & 0xff);
 899                 mono_array_set (data, guint8, 3, (port) & 0xff);
 900
 901                 if (is_ipv4_mapped_any (&sa_in->sin6_addr)) {
 902                         // Map ::ffff:0:0 to :: (bug #5502)
 903                         for (i = 0; i < 16; i++)
 904                                 mono_array_set (data, guint8, 8 + i, 0);
 905                 } else {
 906                         for (i = 0; i < 16; i++) {
 907                                 mono_array_set (data, guint8, 8 + i,
 908                                                                 sa_in->sin6_addr.s6_addr [i]);
 909                         }
 910                 }
 911
 912                 mono_array_set (data, guint8, 24, sa_in->sin6_scope_id & 0xff);
 913                 mono_array_set (data, guint8, 25,
 914                                                 (sa_in->sin6_scope_id >> 8) & 0xff);
 915                 mono_array_set (data, guint8, 26,
 916                                                 (sa_in->sin6_scope_id >> 16) & 0xff);
 917                 mono_array_set (data, guint8, 27,
 918                                                 (sa_in->sin6_scope_id >> 24) & 0xff);
 919
 920                 mono_field_set_value (sockaddr_obj, domain->sockaddr_data_field, data);
 921                 mono_field_set_value (sockaddr_obj, domain->sockaddr_data_length_field, &buffer_size);
 922
 923                 return sockaddr_obj;
 924         }
 925 #ifdef HAVE_SYS_UN_H
 926         else if (saddr->sa_family == AF_UNIX) {
 927                 int i;
 928                 int buffer_size = sa_size + 2;
 929
 930                 for (i = 0; i < sa_size; i++)
 931                         mono_array_set (data, guint8, i + 2, saddr->sa_data [i]);
 932
 933                 mono_field_set_value (sockaddr_obj, domain->sockaddr_data_field, data);
 934                 mono_field_set_value (sockaddr_obj, domain->sockaddr_data_length_field, &buffer_size);
 935
 936                 return sockaddr_obj;
 937         }
 938 #endif
 939         else {
 940                 *werror = WSAEAFNOSUPPORT;
 941                 return NULL;
 942         }
 943 }
 944
 945 static int
 946 get_sockaddr_size (int family)
 947 {
 948         int size;
 949
 950         size = 0;
 951         if (family == AF_INET) {
 952                 size = sizeof (struct sockaddr_in);
 953         } else if (family == AF_INET6) {
 954                 size = sizeof (struct sockaddr_in6);
 955         }
 956 #ifdef HAVE_SYS_UN_H
 957         else if (family == AF_UNIX) {
 958                 size = sizeof (struct sockaddr_un);
 959         }
 960 #endif
 961         return size;
 962 }
 963
 964 MonoObject*
 965 ves_icall_System_Net_Sockets_Socket_LocalEndPoint_internal (gsize sock, gint32 af, gint32 *werror)
 966 {
 967         gchar *sa;
 968         socklen_t salen;
 969         int ret;
 970         MonoObject *result;
 971         MonoError error;
 972
 973         *werror = 0;
 974
 975         salen = get_sockaddr_size (convert_family ((MonoAddressFamily)af));
 976         if (salen == 0) {
 977                 *werror = WSAEAFNOSUPPORT;
 978                 return NULL;
 979         }
 980         sa = (salen <= 128) ? (gchar *)alloca (salen) : (gchar *)g_malloc0 (salen);
 981
 982         MONO_ENTER_GC_SAFE;
 983
 984         ret = mono_w32socket_getsockname (sock, (struct sockaddr *)sa, &salen);
 985
 986         MONO_EXIT_GC_SAFE;
 987
 988         if (ret == SOCKET_ERROR) {
 989                 *werror = mono_w32socket_get_last_error ();
 990                 if (salen > 128)
 991                         g_free (sa);
 992                 return NULL;
 993         }
 994
 995         LOGDEBUG (g_message("%s: bound to %s port %d", __func__, inet_ntoa (((struct sockaddr_in *)&sa)->sin_addr), ntohs (((struct sockaddr_in *)&sa)->sin_port)));
 996
 997         result = create_object_from_sockaddr ((struct sockaddr *)sa, salen, werror, &error);
 998         if (salen > 128)
 999                 g_free (sa);
1000         if (!mono_error_ok (&error))
1001                 mono_error_set_pending_exception (&error);
1002         return result;
1003 }
1004
1005 MonoObject*
1006 ves_icall_System_Net_Sockets_Socket_RemoteEndPoint_internal (gsize sock, gint32 af, gint32 *werror)
1007 {
1008         gchar *sa;
1009         socklen_t salen;
1010         int ret;
1011         MonoObject *result;
1012         MonoError error;
1013
1014         *werror = 0;
1015
1016         salen = get_sockaddr_size (convert_family ((MonoAddressFamily)af));
1017         if (salen == 0) {
1018                 *werror = WSAEAFNOSUPPORT;
1019                 return NULL;
1020         }
1021         sa = (salen <= 128) ? (gchar *)alloca (salen) : (gchar *)g_malloc0 (salen);
1022         /* Note: linux returns just 2 for AF_UNIX. Always. */
1023
1024         MONO_ENTER_GC_SAFE;
1025
1026         ret = mono_w32socket_getpeername (sock, (struct sockaddr *)sa, &salen);
1027
1028         MONO_EXIT_GC_SAFE;
1029
1030         if (ret == SOCKET_ERROR) {
1031                 *werror = mono_w32socket_get_last_error ();
1032                 if (salen > 128)
1033                         g_free (sa);
1034                 return NULL;
1035         }
1036
1037         LOGDEBUG (g_message("%s: connected to %s port %d", __func__, inet_ntoa (((struct sockaddr_in *)&sa)->sin_addr), ntohs (((struct sockaddr_in *)&sa)->sin_port)));
1038
1039         result = create_object_from_sockaddr ((struct sockaddr *)sa, salen, werror, &error);
1040         if (salen > 128)
1041                 g_free (sa);
1042         if (!mono_error_ok (&error))
1043                 mono_error_set_pending_exception (&error);
1044         return result;
1045 }
1046
1047 static struct sockaddr*
1048 create_sockaddr_from_object (MonoObject *saddr_obj, socklen_t *sa_size, gint32 *werror, MonoError *error)
1049 {
1050         MonoDomain *domain = mono_domain_get ();
1051         MonoArray *data;
1052         gint32 family;
1053         int len;
1054
1055         mono_error_init (error);
1056
1057         if (!domain->sockaddr_class)
1058                 domain->sockaddr_class = mono_class_load_from_name (get_socket_assembly (), "System.Net", "SocketAddress");
1059
1060         /* Locate the SocketAddress data buffer in the object */
1061         if (!domain->sockaddr_data_field) {
1062                 domain->sockaddr_data_field = mono_class_get_field_from_name (domain->sockaddr_class, "m_Buffer");
1063                 g_assert (domain->sockaddr_data_field);
1064         }
1065
1066         /* Locate the SocketAddress data buffer length in the object */
1067         if (!domain->sockaddr_data_length_field) {
1068                 domain->sockaddr_data_length_field = mono_class_get_field_from_name (domain->sockaddr_class, "m_Size");
1069                 g_assert (domain->sockaddr_data_length_field);
1070         }
1071
1072         data = *(MonoArray **)(((char *)saddr_obj) + domain->sockaddr_data_field->offset);
1073
1074         /* The data buffer is laid out as follows:
1075          * byte 0 is the address family low byte
1076          * byte 1 is the address family high byte
1077          * INET:
1078          *      bytes 2 and 3 are the port info
1079          *      the rest is the address info
1080          * UNIX:
1081          *      the rest is the file name
1082          */
1083         len = *(int *)(((char *)saddr_obj) + domain->sockaddr_data_length_field->offset);
1084         g_assert (len >= 2);
1085
1086         family = convert_family ((MonoAddressFamily)(mono_array_get (data, guint8, 0) + (mono_array_get (data, guint8, 1) << 8)));
1087         if (family == AF_INET) {
1088                 struct sockaddr_in *sa;
1089                 guint16 port;
1090                 guint32 address;
1091
1092                 if (len < 8) {
1093                         mono_error_set_exception_instance (error, mono_exception_from_name (mono_get_corlib (), "System", "SystemException"));
1094                         return NULL;
1095                 }
1096
1097                 sa = g_new0 (struct sockaddr_in, 1);
1098                 port = (mono_array_get (data, guint8, 2) << 8) +
1099                         mono_array_get (data, guint8, 3);
1100                 address = (mono_array_get (data, guint8, 4) << 24) +
1101                         (mono_array_get (data, guint8, 5) << 16 ) +
1102                         (mono_array_get (data, guint8, 6) << 8) +
1103                         mono_array_get (data, guint8, 7);
1104
1105                 sa->sin_family = family;
1106                 sa->sin_addr.s_addr = htonl (address);
1107                 sa->sin_port = htons (port);
1108
1109                 *sa_size = sizeof (struct sockaddr_in);
1110                 return (struct sockaddr *)sa;
1111         } else if (family == AF_INET6) {
1112                 struct sockaddr_in6 *sa;
1113                 int i;
1114                 guint16 port;
1115                 guint32 scopeid;
1116
1117                 if (len < 28) {
1118                         mono_error_set_exception_instance (error, mono_exception_from_name (mono_get_corlib (), "System", "SystemException"));
1119                         return NULL;
1120                 }
1121
1122                 sa = g_new0 (struct sockaddr_in6, 1);
1123                 port = mono_array_get (data, guint8, 3) +
1124                         (mono_array_get (data, guint8, 2) << 8);
1125                 scopeid = mono_array_get (data, guint8, 24) +
1126                         (mono_array_get (data, guint8, 25) << 8) +
1127                         (mono_array_get (data, guint8, 26) << 16) +
1128                         (mono_array_get (data, guint8, 27) << 24);
1129
1130                 sa->sin6_family = family;
1131                 sa->sin6_port = htons (port);
1132                 sa->sin6_scope_id = scopeid;
1133
1134                 for (i = 0; i < 16; i++)
1135                         sa->sin6_addr.s6_addr [i] = mono_array_get (data, guint8, 8 + i);
1136
1137                 *sa_size = sizeof (struct sockaddr_in6);
1138                 return (struct sockaddr *)sa;
1139         }
1140 #ifdef HAVE_SYS_UN_H
1141         else if (family == AF_UNIX) {
1142                 struct sockaddr_un *sock_un;
1143                 int i;
1144
1145                 /* Need a byte for the '\0' terminator/prefix, and the first
1146                  * two bytes hold the SocketAddress family
1147                  */
1148                 if (len - 2 >= sizeof (sock_un->sun_path)) {
1149                         mono_error_set_exception_instance (error, mono_get_exception_index_out_of_range ());
1150                         return NULL;
1151                 }
1152
1153                 sock_un = g_new0 (struct sockaddr_un, 1);
1154
1155                 sock_un->sun_family = family;
1156                 for (i = 0; i < len - 2; i++)
1157                         sock_un->sun_path [i] = mono_array_get (data, guint8, i + 2);
1158
1159                 *sa_size = len;
1160                 return (struct sockaddr *)sock_un;
1161         }
1162 #endif
1163         else {
1164                 *werror = WSAEAFNOSUPPORT;
1165                 return 0;
1166         }
1167 }
1168
1169 void
1170 ves_icall_System_Net_Sockets_Socket_Bind_internal (gsize sock, MonoObject *sockaddr, gint32 *werror)
1171 {
1172         MonoError error;
1173         struct sockaddr *sa;
1174         socklen_t sa_size;
1175         int ret;
1176
1177         *werror = 0;
1178
1179         sa = create_sockaddr_from_object (sockaddr, &sa_size, werror, &error);
1180         if (*werror != 0)
1181                 return;
1182         if (!mono_error_ok (&error)) {
1183                 mono_error_set_pending_exception (&error);
1184                 return;
1185         }
1186
1187         LOGDEBUG (g_message("%s: binding to %s port %d", __func__, inet_ntoa (((struct sockaddr_in *)sa)->sin_addr), ntohs (((struct sockaddr_in *)sa)->sin_port)));
1188
1189         ret = mono_w32socket_bind (sock, sa, sa_size);
1190
1191         if (ret == SOCKET_ERROR)
1192                 *werror = mono_w32socket_get_last_error ();
1193
1194         g_free (sa);
1195 }
1196
1197 enum {
1198         SelectModeRead,
1199         SelectModeWrite,
1200         SelectModeError
1201 };
1202
1203 MonoBoolean
1204 ves_icall_System_Net_Sockets_Socket_Poll_internal (gsize sock, gint mode,
1205                                                                                                    gint timeout, gint32 *werror)
1206 {
1207         MonoInternalThread *thread = mono_thread_internal_current ();
1208         mono_pollfd *pfds;
1209         int ret;
1210         gboolean interrupted;
1211         time_t start;
1212
1213         *werror = 0;
1214
1215         pfds = g_new0 (mono_pollfd, 1);
1216         pfds->fd = GPOINTER_TO_INT (sock);
1217
1218         switch (mode) {
1219         case SelectModeRead:
1220                 pfds->events = MONO_POLLIN;
1221                 break;
1222         case SelectModeWrite:
1223                 pfds->events = MONO_POLLOUT;
1224                 break;
1225         default:
1226                 pfds->events = MONO_POLLERR | MONO_POLLHUP | MONO_POLLNVAL;
1227                 break;
1228         }
1229
1230         timeout = (timeout >= 0) ? (timeout / 1000) : -1;
1231         start = time (NULL);
1232
1233         do {
1234                 mono_thread_info_install_interrupt (abort_syscall, (gpointer) (gsize) mono_native_thread_id_get (), &interrupted);
1235                 if (interrupted) {
1236                         g_free (pfds);
1237                         *werror = WSAEINTR;
1238                         return FALSE;
1239                 }
1240
1241                 MONO_ENTER_GC_SAFE;
1242
1243                 ret = mono_poll (pfds, 1, timeout);
1244
1245                 MONO_EXIT_GC_SAFE;
1246
1247                 mono_thread_info_uninstall_interrupt (&interrupted);
1248                 if (interrupted) {
1249                         g_free (pfds);
1250                         *werror = WSAEINTR;
1251                         return FALSE;
1252                 }
1253
1254                 if (timeout > 0 && ret < 0) {
1255                         int err = errno;
1256                         int sec = time (NULL) - start;
1257
1258                         timeout -= sec * 1000;
1259                         if (timeout < 0) {
1260                                 timeout = 0;
1261                         }
1262
1263                         errno = err;
1264                 }
1265
1266                 if (ret == -1 && errno == EINTR) {
1267                         if (mono_thread_test_state (thread, (MonoThreadState)(ThreadState_AbortRequested | ThreadState_StopRequested))) {
1268                                 g_free (pfds);
1269                                 return FALSE;
1270                         }
1271
1272                         /* Suspend requested? */
1273                         mono_thread_interruption_checkpoint ();
1274
1275                         errno = EINTR;
1276                 }
1277         } while (ret == -1 && errno == EINTR);
1278
1279         if (ret == -1) {
1280                 *werror = mono_w32socket_convert_error (errno);
1281                 g_free (pfds);
1282                 return FALSE;
1283         }
1284
1285         g_free (pfds);
1286         return ret != 0;
1287 }
1288
1289 void
1290 ves_icall_System_Net_Sockets_Socket_Connect_internal (gsize sock, MonoObject *sockaddr, gint32 *werror, gboolean blocking)
1291 {
1292         MonoError error;
1293         struct sockaddr *sa;
1294         socklen_t sa_size;
1295         int ret;
1296         gboolean interrupted;
1297
1298         *werror = 0;
1299
1300         sa = create_sockaddr_from_object (sockaddr, &sa_size, werror, &error);
1301         if (*werror != 0)
1302                 return;
1303         if (!mono_error_ok (&error)) {
1304                 mono_error_set_pending_exception (&error);
1305                 return;
1306         }
1307
1308         LOGDEBUG (g_message("%s: connecting to %s port %d", __func__, inet_ntoa (((struct sockaddr_in *)sa)->sin_addr), ntohs (((struct sockaddr_in *)sa)->sin_port)));
1309
1310         mono_thread_info_install_interrupt (abort_syscall, (gpointer) (gsize) mono_native_thread_id_get (), &interrupted);
1311         if (interrupted) {
1312                 *werror = WSAEINTR;
1313                 return;
1314         }
1315
1316         MONO_ENTER_GC_SAFE;
1317         ret = mono_w32socket_connect (sock, sa, sa_size, blocking);
1318         MONO_EXIT_GC_SAFE;
1319
1320         if (ret == SOCKET_ERROR)
1321                 *werror = mono_w32socket_get_last_error ();
1322
1323         mono_thread_info_uninstall_interrupt (&interrupted);
1324         if (interrupted)
1325                 *werror = WSAEINTR;
1326
1327         g_free (sa);
1328 }
1329
1330 #if G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT | HAVE_UWP_WINAPI_SUPPORT)
1331
1332 void
1333 ves_icall_System_Net_Sockets_Socket_Disconnect_internal (gsize sock, MonoBoolean reuse, gint32 *werror)
1334 {
1335         gboolean interrupted;
1336
1337         LOGDEBUG (g_message("%s: disconnecting from socket %p (reuse %d)", __func__, sock, reuse));
1338
1339         mono_thread_info_install_interrupt (abort_syscall, (gpointer) (gsize) mono_native_thread_id_get (), &interrupted);
1340         if (interrupted) {
1341                 *werror = WSAEINTR;
1342                 return;
1343         }
1344
1345         MONO_ENTER_GC_SAFE;
1346         *werror = mono_w32socket_disconnect (sock, reuse);
1347         MONO_EXIT_GC_SAFE;
1348
1349         mono_thread_info_uninstall_interrupt (&interrupted);
1350         if (interrupted)
1351                 *werror = WSAEINTR;
1352 }
1353 #endif /* G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT | HAVE_UWP_WINAPI_SUPPORT) */
1354
1355 gint32
1356 ves_icall_System_Net_Sockets_Socket_Receive_internal (gsize sock, MonoArray *buffer, gint32 offset, gint32 count, gint32 flags, gint32 *werror, gboolean blocking)
1357 {
1358         int ret;
1359         gchar *buf;
1360         gint32 alen;
1361         int recvflags = 0;
1362         gboolean interrupted;
1363         MonoInternalThread* curthread G_GNUC_UNUSED = mono_thread_internal_current ();
1364
1365         *werror = 0;
1366
1367         alen = mono_array_length (buffer);
1368         if (offset > alen - count)
1369                 return 0;
1370
1371         buf = mono_array_addr (buffer, gchar, offset);
1372
1373         recvflags = convert_socketflags (flags);
1374         if (recvflags == -1) {
1375                 *werror = WSAEOPNOTSUPP;
1376                 return 0;
1377         }
1378
1379         mono_thread_info_install_interrupt (abort_syscall, (gpointer) (gsize) mono_native_thread_id_get (), &interrupted);
1380         if (interrupted)
1381                 return 0;
1382
1383         MONO_ENTER_GC_SAFE;
1384         ret = mono_w32socket_recv (sock, buf, count, recvflags, blocking);
1385         MONO_EXIT_GC_SAFE;
1386
1387         if (ret == SOCKET_ERROR)
1388                 *werror = mono_w32socket_get_last_error ();
1389
1390         mono_thread_info_uninstall_interrupt (&interrupted);
1391         if (interrupted)
1392                 *werror = WSAEINTR;
1393
1394         if (*werror)
1395                 return 0;
1396
1397         return ret;
1398 }
1399
1400 gint32
1401 ves_icall_System_Net_Sockets_Socket_Receive_array_internal (gsize sock, MonoArray *buffers, gint32 flags, gint32 *werror, gboolean blocking)
1402 {
1403         int ret, count;
1404         gboolean interrupted;
1405         guint32 recv;
1406         WSABUF *wsabufs;
1407         guint32 recvflags = 0;
1408
1409         *werror = 0;
1410
1411         wsabufs = mono_array_addr (buffers, WSABUF, 0);
1412         count = mono_array_length (buffers);
1413
1414         recvflags = convert_socketflags (flags);
1415         if (recvflags == -1) {
1416                 *werror = WSAEOPNOTSUPP;
1417                 return 0;
1418         }
1419
1420         mono_thread_info_install_interrupt (abort_syscall, (gpointer) (gsize) mono_native_thread_id_get (), &interrupted);
1421         if (interrupted) {
1422                 *werror = WSAEINTR;
1423                 return 0;
1424         }
1425
1426         MONO_ENTER_GC_SAFE;
1427         ret = mono_w32socket_recvbuffers (sock, wsabufs, count, &recv, &recvflags, NULL, NULL, blocking);
1428         MONO_EXIT_GC_SAFE;
1429
1430         if (ret == SOCKET_ERROR)
1431                 *werror = mono_w32socket_get_last_error ();
1432
1433         mono_thread_info_uninstall_interrupt (&interrupted);
1434         if (interrupted)
1435                 *werror = WSAEINTR;
1436
1437         if (*werror)
1438                 return 0;
1439
1440         return recv;
1441 }
1442
1443 gint32
1444 ves_icall_System_Net_Sockets_Socket_ReceiveFrom_internal (gsize sock, MonoArray *buffer, gint32 offset, gint32 count, gint32 flags, MonoObject **sockaddr, gint32 *werror, gboolean blocking)
1445 {
1446         MonoError error;
1447         int ret;
1448         gchar *buf;
1449         gint32 alen;
1450         int recvflags = 0;
1451         struct sockaddr *sa;
1452         socklen_t sa_size;
1453         gboolean interrupted;
1454
1455         *werror = 0;
1456
1457         alen = mono_array_length (buffer);
1458         if (offset > alen - count)
1459                 return 0;
1460
1461         sa = create_sockaddr_from_object (*sockaddr, &sa_size, werror, &error);
1462         if (*werror != 0)
1463                 return 0;
1464         if (!mono_error_ok (&error)) {
1465                 mono_error_set_pending_exception (&error);
1466                 return 0;
1467         }
1468
1469         buf = mono_array_addr (buffer, gchar, offset);
1470
1471         recvflags = convert_socketflags (flags);
1472         if (recvflags == -1) {
1473                 *werror = WSAEOPNOTSUPP;
1474                 return 0;
1475         }
1476
1477         mono_thread_info_install_interrupt (abort_syscall, (gpointer) (gsize) mono_native_thread_id_get (), &interrupted);
1478         if (interrupted) {
1479                 g_free (sa);
1480                 *werror = WSAEINTR;
1481                 return 0;
1482         }
1483
1484         MONO_ENTER_GC_SAFE;
1485         ret = mono_w32socket_recvfrom (sock, buf, count, recvflags, sa, &sa_size, blocking);
1486         MONO_EXIT_GC_SAFE;
1487
1488         if (ret == SOCKET_ERROR)
1489                 *werror = mono_w32socket_get_last_error ();
1490
1491         mono_thread_info_uninstall_interrupt (&interrupted);
1492
1493         if (interrupted)
1494                 *werror = WSAEINTR;
1495
1496         if (*werror) {
1497                 g_free(sa);
1498                 return 0;
1499         }
1500
1501         /* If we didn't get a socket size, then we're probably a
1502          * connected connection-oriented socket and the stack hasn't
1503          * returned the remote address. All we can do is return null.
1504          */
1505         if (sa_size) {
1506                 *sockaddr = create_object_from_sockaddr (sa, sa_size, werror, &error);
1507                 if (!mono_error_ok (&error)) {
1508                         mono_error_set_pending_exception (&error);
1509                         g_free (sa);
1510                         return 0;
1511                 }
1512         } else {
1513                 *sockaddr = NULL;
1514         }
1515
1516         g_free (sa);
1517
1518         return ret;
1519 }
1520
1521 gint32
1522 ves_icall_System_Net_Sockets_Socket_Send_internal (gsize sock, MonoArray *buffer, gint32 offset, gint32 count, gint32 flags, gint32 *werror, gboolean blocking)
1523 {
1524         int ret;
1525         gchar *buf;
1526         gint32 alen;
1527         int sendflags = 0;
1528         gboolean interrupted;
1529
1530         *werror = 0;
1531
1532         alen = mono_array_length (buffer);
1533         if (offset > alen - count)
1534                 return 0;
1535
1536         LOGDEBUG (g_message("%s: alen: %d", __func__, alen));
1537
1538         buf = mono_array_addr (buffer, gchar, offset);
1539
1540         LOGDEBUG (g_message("%s: Sending %d bytes", __func__, count));
1541
1542         sendflags = convert_socketflags (flags);
1543         if (sendflags == -1) {
1544                 *werror = WSAEOPNOTSUPP;
1545                 return 0;
1546         }
1547
1548         mono_thread_info_install_interrupt (abort_syscall, (gpointer) (gsize) mono_native_thread_id_get (), &interrupted);
1549         if (interrupted) {
1550                 *werror = WSAEINTR;
1551                 return 0;
1552         }
1553
1554         MONO_ENTER_GC_SAFE;
1555         ret = mono_w32socket_send (sock, buf, count, sendflags, blocking);
1556         MONO_EXIT_GC_SAFE;
1557
1558         if (ret == SOCKET_ERROR)
1559                 *werror = mono_w32socket_get_last_error ();
1560
1561         mono_thread_info_uninstall_interrupt (&interrupted);
1562         if (interrupted)
1563                 *werror = WSAEINTR;
1564
1565         if (*werror)
1566                 return 0;
1567
1568         return ret;
1569 }
1570
1571 gint32
1572 ves_icall_System_Net_Sockets_Socket_Send_array_internal (gsize sock, MonoArray *buffers, gint32 flags, gint32 *werror, gboolean blocking)
1573 {
1574         int ret, count;
1575         guint32 sent;
1576         WSABUF *wsabufs;
1577         guint32 sendflags = 0;
1578         gboolean interrupted;
1579
1580         *werror = 0;
1581
1582         wsabufs = mono_array_addr (buffers, WSABUF, 0);
1583         count = mono_array_length (buffers);
1584
1585         sendflags = convert_socketflags (flags);
1586         if (sendflags == -1) {
1587                 *werror = WSAEOPNOTSUPP;
1588                 return 0;
1589         }
1590
1591         mono_thread_info_install_interrupt (abort_syscall, (gpointer) (gsize) mono_native_thread_id_get (), &interrupted);
1592         if (interrupted) {
1593                 *werror = WSAEINTR;
1594                 return 0;
1595         }
1596
1597         MONO_ENTER_GC_SAFE;
1598         ret = mono_w32socket_sendbuffers (sock, wsabufs, count, &sent, sendflags, NULL, NULL, blocking);
1599         MONO_EXIT_GC_SAFE;
1600
1601         if (ret == SOCKET_ERROR)
1602                 *werror = mono_w32socket_get_last_error ();
1603
1604         mono_thread_info_uninstall_interrupt (&interrupted);
1605         if (interrupted)
1606                 *werror = WSAEINTR;
1607
1608         if (*werror)
1609                 return 0;
1610
1611         return sent;
1612 }
1613
1614 gint32
1615 ves_icall_System_Net_Sockets_Socket_SendTo_internal (gsize sock, MonoArray *buffer, gint32 offset, gint32 count, gint32 flags, MonoObject *sockaddr, gint32 *werror, gboolean blocking)
1616 {
1617         MonoError error;
1618         int ret;
1619         gchar *buf;
1620         gint32 alen;
1621         int sendflags = 0;
1622         struct sockaddr *sa;
1623         socklen_t sa_size;
1624         gboolean interrupted;
1625
1626         *werror = 0;
1627
1628         alen = mono_array_length (buffer);
1629         if (offset > alen - count) {
1630                 return 0;
1631         }
1632
1633         sa = create_sockaddr_from_object(sockaddr, &sa_size, werror, &error);
1634         if (*werror != 0)
1635                 return 0;
1636         if (!mono_error_ok (&error)) {
1637                 mono_error_set_pending_exception (&error);
1638                 return 0;
1639         }
1640
1641         LOGDEBUG (g_message ("%s: alen: %d", __func__, alen));
1642
1643         buf = mono_array_addr (buffer, gchar, offset);
1644
1645         LOGDEBUG (g_message("%s: Sending %d bytes", __func__, count));
1646
1647         sendflags = convert_socketflags (flags);
1648         if (sendflags == -1) {
1649                 g_free (sa);
1650                 *werror = WSAEOPNOTSUPP;
1651                 return 0;
1652         }
1653
1654         mono_thread_info_install_interrupt (abort_syscall, (gpointer) (gsize) mono_native_thread_id_get (), &interrupted);
1655         if (interrupted) {
1656                 g_free (sa);
1657                 *werror = WSAEINTR;
1658                 return 0;
1659         }
1660
1661         MONO_ENTER_GC_SAFE;
1662         ret = mono_w32socket_sendto (sock, buf, count, sendflags, sa, sa_size, blocking);
1663         MONO_EXIT_GC_SAFE;
1664
1665         if (ret == SOCKET_ERROR)
1666                 *werror = mono_w32socket_get_last_error ();
1667
1668         mono_thread_info_uninstall_interrupt (&interrupted);
1669         if (interrupted)
1670                 *werror = WSAEINTR;
1671
1672         g_free(sa);
1673
1674         if (*werror)
1675                 return 0;
1676
1677         return ret;
1678 }
1679
1680 static SOCKET
1681 Socket_to_SOCKET (MonoObject *sockobj)
1682 {
1683         MonoSafeHandle *safe_handle;
1684         MonoClassField *field;
1685
1686         field = mono_class_get_field_from_name (sockobj->vtable->klass, "m_Handle");
1687         safe_handle = ((MonoSafeHandle *)(*(gpointer *)(((char *)sockobj) + field->offset)));
1688
1689         if (safe_handle == NULL)
1690                 return -1;
1691
1692         return (SOCKET)safe_handle->handle;
1693 }
1694
1695 #define POLL_ERRORS (MONO_POLLERR | MONO_POLLHUP | MONO_POLLNVAL)
1696
1697 void
1698 ves_icall_System_Net_Sockets_Socket_Select_internal (MonoArray **sockets, gint32 timeout, gint32 *werror)
1699 {
1700         MonoError error;
1701         MonoInternalThread *thread = mono_thread_internal_current ();
1702         MonoObject *obj;
1703         mono_pollfd *pfds;
1704         int nfds, idx;
1705         int ret;
1706         int i, count;
1707         int mode;
1708         MonoClass *sock_arr_class;
1709         MonoArray *socks;
1710         time_t start;
1711         uintptr_t socks_size;
1712         gboolean interrupted;
1713
1714         *werror = 0;
1715
1716         /* *sockets -> READ, null, WRITE, null, ERROR, null */
1717         count = mono_array_length (*sockets);
1718         nfds = count - 3; /* NULL separators */
1719         pfds = g_new0 (mono_pollfd, nfds);
1720         mode = idx = 0;
1721         for (i = 0; i < count; i++) {
1722                 obj = mono_array_get (*sockets, MonoObject *, i);
1723                 if (obj == NULL) {
1724                         mode++;
1725                         continue;
1726                 }
1727
1728                 if (idx >= nfds) {
1729                         /* The socket array was bogus */
1730                         g_free (pfds);
1731                         *werror = WSAEFAULT;
1732                         return;
1733                 }
1734
1735                 pfds [idx].fd = Socket_to_SOCKET (obj);
1736                 pfds [idx].events = (mode == 0) ? MONO_POLLIN : (mode == 1) ? MONO_POLLOUT : POLL_ERRORS;
1737                 idx++;
1738         }
1739
1740         timeout = (timeout >= 0) ? (timeout / 1000) : -1;
1741         start = time (NULL);
1742         do {
1743                 mono_thread_info_install_interrupt (abort_syscall, (gpointer) (gsize) mono_native_thread_id_get (), &interrupted);
1744                 if (interrupted) {
1745                         g_free (pfds);
1746                         *werror = WSAEINTR;
1747                         return;
1748                 }
1749
1750                 MONO_ENTER_GC_SAFE;
1751
1752                 ret = mono_poll (pfds, nfds, timeout);
1753
1754                 MONO_EXIT_GC_SAFE;
1755
1756                 mono_thread_info_uninstall_interrupt (&interrupted);
1757                 if (interrupted) {
1758                         g_free (pfds);
1759                         *werror = WSAEINTR;
1760                         return;
1761                 }
1762
1763                 if (timeout > 0 && ret < 0) {
1764                         int err = errno;
1765                         int sec = time (NULL) - start;
1766
1767                         timeout -= sec * 1000;
1768                         if (timeout < 0)
1769                                 timeout = 0;
1770                         errno = err;
1771                 }
1772
1773                 if (ret == -1 && errno == EINTR) {
1774                         if (mono_thread_test_state (thread, (MonoThreadState)(ThreadState_AbortRequested | ThreadState_StopRequested))) {
1775                                 g_free (pfds);
1776                                 *sockets = NULL;
1777                                 return;
1778                         }
1779
1780                         /* Suspend requested? */
1781                         mono_thread_interruption_checkpoint ();
1782
1783                         errno = EINTR;
1784                 }
1785         } while (ret == -1 && errno == EINTR);
1786
1787         if (ret == -1) {
1788                 *werror = mono_w32socket_convert_error (errno);
1789                 g_free (pfds);
1790                 return;
1791         }
1792
1793         if (ret == 0) {
1794                 g_free (pfds);
1795                 *sockets = NULL;
1796                 return;
1797         }
1798
1799         sock_arr_class = ((MonoObject *)*sockets)->vtable->klass;
1800         socks_size = ((uintptr_t)ret) + 3; /* space for the NULL delimiters */
1801         socks = mono_array_new_full_checked (mono_domain_get (), sock_arr_class, &socks_size, NULL, &error);
1802         if (!mono_error_ok (&error)) {
1803                 mono_error_set_pending_exception (&error);
1804                 g_free (pfds);
1805                 return;
1806         }
1807
1808         mode = idx = 0;
1809         for (i = 0; i < count && ret > 0; i++) {
1810                 mono_pollfd *pfd;
1811
1812                 obj = mono_array_get (*sockets, MonoObject *, i);
1813                 if (obj == NULL) {
1814                         mode++;
1815                         idx++;
1816                         continue;
1817                 }
1818
1819                 pfd = &pfds [i - mode];
1820                 if (pfd->revents == 0)
1821                         continue;
1822
1823                 ret--;
1824                 if (mode == 0 && (pfd->revents & (MONO_POLLIN | POLL_ERRORS)) != 0) {
1825                         mono_array_setref (socks, idx++, obj);
1826                 } else if (mode == 1 && (pfd->revents & (MONO_POLLOUT | POLL_ERRORS)) != 0) {
1827                         mono_array_setref (socks, idx++, obj);
1828                 } else if ((pfd->revents & POLL_ERRORS) != 0) {
1829                         mono_array_setref (socks, idx++, obj);
1830                 }
1831         }
1832
1833         *sockets = socks;
1834         g_free (pfds);
1835 }
1836
1837 static MonoObject*
1838 int_to_object (MonoDomain *domain, int val, MonoError *error)
1839 {
1840         return mono_value_box_checked (domain, mono_get_int32_class (), &val, error);
1841 }
1842
1843 void
1844 ves_icall_System_Net_Sockets_Socket_GetSocketOption_obj_internal (gsize sock, gint32 level, gint32 name, MonoObject **obj_val, gint32 *werror)
1845 {
1846         int system_level = 0;
1847         int system_name = 0;
1848         int ret;
1849         int val = 0;
1850         socklen_t valsize = sizeof (val);
1851         struct linger linger;
1852         socklen_t lingersize = sizeof (linger);
1853         int time_ms = 0;
1854         socklen_t time_ms_size = sizeof (time_ms);
1855 #ifdef SO_PEERCRED
1856 #  if defined(__OpenBSD__)
1857         struct sockpeercred cred;
1858 #  else
1859         struct ucred cred;
1860 #  endif
1861         socklen_t credsize = sizeof (cred);
1862 #endif
1863         MonoError error;
1864         MonoDomain *domain = mono_domain_get ();
1865         MonoObject *obj;
1866         MonoClass *obj_class;
1867         MonoClassField *field;
1868
1869         *werror = 0;
1870
1871 #if !defined(SO_EXCLUSIVEADDRUSE) && defined(SO_REUSEADDR)
1872         if (level == SocketOptionLevel_Socket && name == SocketOptionName_ExclusiveAddressUse) {
1873                 system_level = SOL_SOCKET;
1874                 system_name = SO_REUSEADDR;
1875                 ret = 0;
1876         } else
1877 #endif
1878         {
1879                 ret = convert_sockopt_level_and_name ((MonoSocketOptionLevel)level, (MonoSocketOptionName)name, &system_level, &system_name);
1880         }
1881
1882         if (ret == -1) {
1883                 *werror = WSAENOPROTOOPT;
1884                 return;
1885         }
1886         if (ret == -2) {
1887                 *obj_val = int_to_object (domain, 0, &error);
1888                 mono_error_set_pending_exception (&error);
1889                 return;
1890         }
1891
1892         MONO_ENTER_GC_SAFE;
1893
1894         /* No need to deal with MulticastOption names here, because
1895          * you cant getsockopt AddMembership or DropMembership (the
1896          * int getsockopt will error, causing an exception)
1897          */
1898         switch (name) {
1899         case SocketOptionName_Linger:
1900         case SocketOptionName_DontLinger:
1901                 ret = mono_w32socket_getsockopt (sock, system_level, system_name, &linger, &lingersize);
1902                 break;
1903
1904         case SocketOptionName_SendTimeout:
1905         case SocketOptionName_ReceiveTimeout:
1906                 ret = mono_w32socket_getsockopt (sock, system_level, system_name, (char *)&time_ms, &time_ms_size);
1907                 break;
1908
1909 #ifdef SO_PEERCRED
1910         case SocketOptionName_PeerCred:
1911                 ret = mono_w32socket_getsockopt (sock, system_level, system_name, &cred, &credsize);
1912                 break;
1913 #endif
1914
1915         default:
1916                 ret = mono_w32socket_getsockopt (sock, system_level, system_name, &val, &valsize);
1917         }
1918
1919         MONO_EXIT_GC_SAFE;
1920
1921         if (ret == SOCKET_ERROR) {
1922                 *werror = mono_w32socket_get_last_error ();
1923                 return;
1924         }
1925
1926         switch (name) {
1927         case SocketOptionName_Linger:
1928                 /* build a System.Net.Sockets.LingerOption */
1929                 obj_class = mono_class_load_from_name (get_socket_assembly (),
1930                                                                                            "System.Net.Sockets",
1931                                                                                            "LingerOption");
1932                 obj = mono_object_new_checked (domain, obj_class, &error);
1933                 if (!mono_error_ok (&error)) {
1934                         mono_error_set_pending_exception (&error);
1935                         return;
1936                 }
1937
1938                 /* Locate and set the fields "bool enabled" and "int
1939                  * lingerTime"
1940                  */
1941                 field = mono_class_get_field_from_name(obj_class, "enabled");
1942                 *(guint8 *)(((char *)obj)+field->offset) = linger.l_onoff;
1943
1944                 field = mono_class_get_field_from_name(obj_class, "lingerTime");
1945                 *(guint32 *)(((char *)obj)+field->offset)=linger.l_linger;
1946                 break;
1947         case SocketOptionName_DontLinger:
1948                 /* construct a bool int in val - true if linger is off */
1949                 obj = int_to_object (domain, !linger.l_onoff, &error);
1950                 mono_error_set_pending_exception (&error);
1951                 break;
1952         case SocketOptionName_SendTimeout:
1953         case SocketOptionName_ReceiveTimeout:
1954                 obj = int_to_object (domain, time_ms, &error);
1955                 mono_error_set_pending_exception (&error);
1956                 break;
1957
1958 #ifdef SO_PEERCRED
1959         case SocketOptionName_PeerCred:  {
1960                 /*
1961                  * build a Mono.Posix.PeerCred+PeerCredData if
1962                  * possible
1963                  */
1964                 static MonoImage *mono_posix_image = NULL;
1965                 MonoPeerCredData *cred_data;
1966
1967                 if (mono_posix_image == NULL) {
1968                         mono_posix_image = mono_image_loaded ("Mono.Posix");
1969                         if (!mono_posix_image) {
1970                                 MonoAssembly *sa = mono_assembly_open ("Mono.Posix.dll", NULL);
1971                                 if (!sa) {
1972                                         *werror = WSAENOPROTOOPT;
1973                                         return;
1974                                 } else {
1975                                         mono_posix_image = mono_assembly_get_image (sa);
1976                                 }
1977                         }
1978                 }
1979
1980                 obj_class = mono_class_load_from_name (mono_posix_image,
1981                                                  "Mono.Posix",
1982                                                  "PeerCredData");
1983                 obj = mono_object_new_checked (domain, obj_class, &error);
1984                 if (!mono_error_ok (&error)) {
1985                         mono_error_set_pending_exception (&error);
1986                         return;
1987                 }
1988                 cred_data = (MonoPeerCredData *)obj;
1989                 cred_data->pid = cred.pid;
1990                 cred_data->uid = cred.uid;
1991                 cred_data->gid = cred.gid;
1992                 break;
1993         }
1994 #endif
1995
1996         default:
1997 #if !defined(SO_EXCLUSIVEADDRUSE) && defined(SO_REUSEADDR)
1998                 if (level == SocketOptionLevel_Socket && name == SocketOptionName_ExclusiveAddressUse)
1999                         val = val ? 0 : 1;
2000 #endif
2001                 obj = int_to_object (domain, val, &error);
2002                 mono_error_set_pending_exception (&error);
2003         }
2004
2005         *obj_val = obj;
2006 }
2007
2008 void
2009 ves_icall_System_Net_Sockets_Socket_GetSocketOption_arr_internal (gsize sock, gint32 level, gint32 name, MonoArray **byte_val, gint32 *werror)
2010 {
2011         int system_level = 0;
2012         int system_name = 0;
2013         int ret;
2014         guchar *buf;
2015         socklen_t valsize;
2016
2017         *werror = 0;
2018
2019         ret = convert_sockopt_level_and_name((MonoSocketOptionLevel)level, (MonoSocketOptionName)name, &system_level,
2020                                                                                  &system_name);
2021         if (ret == -1) {
2022                 *werror = WSAENOPROTOOPT;
2023                 return;
2024         }
2025         if (ret == -2)
2026                 return;
2027
2028         valsize = mono_array_length (*byte_val);
2029         buf = mono_array_addr (*byte_val, guchar, 0);
2030
2031         MONO_ENTER_GC_SAFE;
2032
2033         ret = mono_w32socket_getsockopt (sock, system_level, system_name, buf, &valsize);
2034
2035         MONO_EXIT_GC_SAFE;
2036
2037         if (ret == SOCKET_ERROR)
2038                 *werror = mono_w32socket_get_last_error ();
2039 }
2040
2041 #if defined(HAVE_STRUCT_IP_MREQN) || defined(HAVE_STRUCT_IP_MREQ)
2042 static struct in_addr
2043 ipaddress_to_struct_in_addr (MonoObject *ipaddr)
2044 {
2045         struct in_addr inaddr;
2046         MonoClassField *field;
2047
2048         field = mono_class_get_field_from_name (ipaddr->vtable->klass, "m_Address");
2049
2050         /* No idea why .net uses a 64bit type to hold a 32bit value...
2051          *
2052          * Internal value of IPAddess is in little-endian order
2053          */
2054         inaddr.s_addr = GUINT_FROM_LE ((guint32)*(guint64 *)(((char *)ipaddr) + field->offset));
2055
2056         return inaddr;
2057 }
2058
2059 static struct in6_addr
2060 ipaddress_to_struct_in6_addr (MonoObject *ipaddr)
2061 {
2062         struct in6_addr in6addr;
2063         MonoClassField *field;
2064         MonoArray *data;
2065         int i;
2066
2067         field = mono_class_get_field_from_name (ipaddr->vtable->klass, "m_Numbers");
2068         g_assert (field);
2069         data = *(MonoArray **)(((char *)ipaddr) + field->offset);
2070
2071         for (i = 0; i < 8; i++) {
2072                 const guint16 s = GUINT16_TO_BE (mono_array_get (data, guint16, i));
2073
2074 /* Solaris/MacOS have only the 8 bit version. */
2075 #ifndef s6_addr16
2076                 in6addr.s6_addr[2 * i + 1] = (s >> 8) & 0xff;
2077                 in6addr.s6_addr[2 * i] = s & 0xff;
2078 #else
2079                 in6addr.s6_addr16[i] = s;
2080 #endif
2081         }
2082         return in6addr;
2083 }
2084 #endif
2085
2086 #if defined(__APPLE__) || defined(__FreeBSD__)
2087
2088 static int
2089 get_local_interface_id (int family)
2090 {
2091 #if !defined(HAVE_GETIFADDRS) || !defined(HAVE_IF_NAMETOINDEX)
2092         return 0;
2093 #else
2094         struct ifaddrs *ifap = NULL, *ptr;
2095         int idx = 0;
2096
2097         if (getifaddrs (&ifap))
2098                 return 0;
2099
2100         for (ptr = ifap; ptr; ptr = ptr->ifa_next) {
2101                 if (!ptr->ifa_addr || !ptr->ifa_name)
2102                         continue;
2103                 if (ptr->ifa_addr->sa_family != family)
2104                         continue;
2105                 if ((ptr->ifa_flags & IFF_LOOPBACK) != 0)
2106                         continue;
2107                 if ((ptr->ifa_flags & IFF_MULTICAST) == 0)
2108                         continue;
2109
2110                 idx = if_nametoindex (ptr->ifa_name);
2111                 break;
2112         }
2113
2114         freeifaddrs (ifap);
2115         return idx;
2116 #endif
2117 }
2118
2119 #endif /* defined(__APPLE__) || defined(__FreeBSD__) */
2120
2121 void
2122 ves_icall_System_Net_Sockets_Socket_SetSocketOption_internal (gsize sock, gint32 level, gint32 name, MonoObject *obj_val, MonoArray *byte_val, gint32 int_val, gint32 *werror)
2123 {
2124         struct linger linger;
2125         int system_level = 0;
2126         int system_name = 0;
2127         int ret;
2128         int sol_ip;
2129         int sol_ipv6;
2130
2131         *werror = 0;
2132
2133         sol_ipv6 = mono_networking_get_ipv6_protocol ();
2134         sol_ip = mono_networking_get_ip_protocol ();
2135
2136         ret = convert_sockopt_level_and_name ((MonoSocketOptionLevel)level, (MonoSocketOptionName)name, &system_level,
2137                                                                                   &system_name);
2138
2139 #if !defined(SO_EXCLUSIVEADDRUSE) && defined(SO_REUSEADDR)
2140         if (level == SocketOptionLevel_Socket && name == SocketOptionName_ExclusiveAddressUse) {
2141                 system_name = SO_REUSEADDR;
2142                 int_val = int_val ? 0 : 1;
2143                 ret = 0;
2144         }
2145 #endif
2146
2147         if (ret == -1) {
2148                 *werror = WSAENOPROTOOPT;
2149                 return;
2150         }
2151         if (ret == -2)
2152                 return;
2153
2154         /* Only one of obj_val, byte_val or int_val has data */
2155         if (obj_val) {
2156                 MonoClassField *field;
2157                 int valsize;
2158
2159                 switch (name) {
2160                 case SocketOptionName_Linger:
2161                         /* Dig out "bool enabled" and "int lingerTime"
2162                          * fields
2163                          */
2164                         field = mono_class_get_field_from_name (obj_val->vtable->klass, "enabled");
2165                         linger.l_onoff = *(guint8 *)(((char *)obj_val) + field->offset);
2166                         field = mono_class_get_field_from_name (obj_val->vtable->klass, "lingerTime");
2167                         linger.l_linger = *(guint32 *)(((char *)obj_val) + field->offset);
2168
2169                         valsize = sizeof (linger);
2170                         ret = mono_w32socket_setsockopt (sock, system_level, system_name, &linger, valsize);
2171                         break;
2172                 case SocketOptionName_AddMembership:
2173                 case SocketOptionName_DropMembership:
2174 #if defined(HAVE_STRUCT_IP_MREQN) || defined(HAVE_STRUCT_IP_MREQ)
2175                 {
2176                         MonoObject *address = NULL;
2177
2178                         if (system_level == sol_ipv6) {
2179                                 struct ipv6_mreq mreq6;
2180
2181                                 /*
2182                                  *      Get group address
2183                                  */
2184                                 field = mono_class_get_field_from_name (obj_val->vtable->klass, "m_Group");
2185                                 g_assert (field);
2186                                 address = *(MonoObject **)(((char *)obj_val) + field->offset);
2187
2188                                 if (address)
2189                                         mreq6.ipv6mr_multiaddr = ipaddress_to_struct_in6_addr (address);
2190
2191                                 field = mono_class_get_field_from_name (obj_val->vtable->klass, "m_Interface");
2192                                 mreq6.ipv6mr_interface = *(guint64 *)(((char *)obj_val) + field->offset);
2193
2194 #if defined(__APPLE__) || defined(__FreeBSD__)
2195                                 /*
2196                                 * Bug #5504:
2197                                 *
2198                                 * Mac OS Lion doesn't allow ipv6mr_interface = 0.
2199                                 *
2200                                 * Tests on Windows and Linux show that the multicast group is only
2201                                 * joined on one NIC when interface = 0, so we simply use the interface
2202                                 * id from the first non-loopback interface (this is also what
2203                                 * Dns.GetHostName (string.Empty) would return).
2204                                 */
2205                                 if (!mreq6.ipv6mr_interface)
2206                                         mreq6.ipv6mr_interface = get_local_interface_id (AF_INET6);
2207 #endif
2208
2209                                 ret = mono_w32socket_setsockopt (sock, system_level, system_name, &mreq6, sizeof (mreq6));
2210                         } else if (system_level == sol_ip) {
2211 #ifdef HAVE_STRUCT_IP_MREQN
2212                                 struct ip_mreqn mreq = {{0}};
2213 #else
2214                                 struct ip_mreq mreq = {{0}};
2215 #endif /* HAVE_STRUCT_IP_MREQN */
2216
2217                                 /*
2218                                  * pain! MulticastOption holds two IPAddress
2219                                  * members, so I have to dig the value out of
2220                                  * those :-(
2221                                  */
2222                                 field = mono_class_get_field_from_name (obj_val->vtable->klass, "group");
2223                                 address = *(MonoObject **)(((char *)obj_val) + field->offset);
2224
2225                                 /* address might not be defined and if so, set the address to ADDR_ANY.
2226                                  */
2227                                 if (address)
2228                                         mreq.imr_multiaddr = ipaddress_to_struct_in_addr (address);
2229
2230                                 field = mono_class_get_field_from_name (obj_val->vtable->klass, "localAddress");
2231                                 address = *(MonoObject **)(((char *)obj_val) + field->offset);
2232
2233 #ifdef HAVE_STRUCT_IP_MREQN
2234                                 if (address)
2235                                         mreq.imr_address = ipaddress_to_struct_in_addr (address);
2236
2237                                 field = mono_class_get_field_from_name (obj_val->vtable->klass, "ifIndex");
2238                                 mreq.imr_ifindex = *(gint32 *)(((char *)obj_val) + field->offset);
2239 #else
2240                                 if (address)
2241                                         mreq.imr_interface = ipaddress_to_struct_in_addr (address);
2242 #endif /* HAVE_STRUCT_IP_MREQN */
2243
2244                                 ret = mono_w32socket_setsockopt (sock, system_level, system_name, &mreq, sizeof (mreq));
2245                         }
2246                         break;
2247                 }
2248 #endif /* HAVE_STRUCT_IP_MREQN || HAVE_STRUCT_IP_MREQ */
2249                 default:
2250                         /* Cause an exception to be thrown */
2251                         *werror = WSAEINVAL;
2252                         return;
2253                 }
2254         } else if (byte_val!=NULL) {
2255                 int valsize = mono_array_length (byte_val);
2256                 guchar *buf = mono_array_addr (byte_val, guchar, 0);
2257
2258                 switch(name) {
2259                 case SocketOptionName_DontLinger:
2260                         if (valsize == 1) {
2261                                 linger.l_onoff = (*buf) ? 0 : 1;
2262                                 linger.l_linger = 0;
2263                                 ret = mono_w32socket_setsockopt (sock, system_level, system_name, &linger, sizeof (linger));
2264                         } else {
2265                                 *werror = WSAEINVAL;
2266                         }
2267                         break;
2268                 default:
2269                         ret = mono_w32socket_setsockopt (sock, system_level, system_name, buf, valsize);
2270                         break;
2271                 }
2272         } else {
2273                 /* ReceiveTimeout/SendTimeout get here */
2274                 switch (name) {
2275                 case SocketOptionName_DontLinger:
2276                         linger.l_onoff = !int_val;
2277                         linger.l_linger = 0;
2278                         ret = mono_w32socket_setsockopt (sock, system_level, system_name, &linger, sizeof (linger));
2279                         break;
2280                 case SocketOptionName_MulticastInterface:
2281 #ifndef HOST_WIN32
2282 #ifdef HAVE_STRUCT_IP_MREQN
2283                         int_val = GUINT32_FROM_BE (int_val);
2284                         if ((int_val & 0xff000000) == 0) {
2285                                 /* int_val is interface index */
2286                                 struct ip_mreqn mreq = {{0}};
2287                                 mreq.imr_ifindex = int_val;
2288                                 ret = mono_w32socket_setsockopt (sock, system_level, system_name, (char *) &mreq, sizeof (mreq));
2289                                 break;
2290                         }
2291                         int_val = GUINT32_TO_BE (int_val);
2292 #endif /* HAVE_STRUCT_IP_MREQN */
2293 #endif /* HOST_WIN32 */
2294                         /* int_val is in_addr */
2295                         ret = mono_w32socket_setsockopt (sock, system_level, system_name, (char *) &int_val, sizeof (int_val));
2296                         break;
2297                 case SocketOptionName_DontFragment:
2298 #ifdef HAVE_IP_MTU_DISCOVER
2299                         /* Fiddle with the value slightly if we're
2300                          * turning DF on
2301                          */
2302                         if (int_val == 1)
2303                                 int_val = IP_PMTUDISC_DO;
2304                         /* Fall through */
2305 #endif
2306
2307                 default:
2308                         ret = mono_w32socket_setsockopt (sock, system_level, system_name, (char *) &int_val, sizeof (int_val));
2309                 }
2310         }
2311
2312         if (ret == SOCKET_ERROR)
2313                 *werror = mono_w32socket_get_last_error ();
2314 }
2315
2316 void
2317 ves_icall_System_Net_Sockets_Socket_Shutdown_internal (gsize sock, gint32 how, gint32 *werror)
2318 {
2319         int ret;
2320         gboolean interrupted;
2321
2322         *werror = 0;
2323
2324         mono_thread_info_install_interrupt (abort_syscall, (gpointer) (gsize) mono_native_thread_id_get (), &interrupted);
2325         if (interrupted) {
2326                 *werror = WSAEINTR;
2327                 return;
2328         }
2329
2330         MONO_ENTER_GC_SAFE;
2331
2332         /* Currently, the values for how (recv=0, send=1, both=2) match the BSD API */
2333         ret = mono_w32socket_shutdown (sock, how);
2334
2335         MONO_EXIT_GC_SAFE;
2336
2337         if (ret == SOCKET_ERROR)
2338                 *werror = mono_w32socket_get_last_error ();
2339
2340         mono_thread_info_uninstall_interrupt (&interrupted);
2341         if (interrupted) {
2342                 *werror = WSAEINTR;
2343         }
2344
2345 }
2346
2347 gint
2348 ves_icall_System_Net_Sockets_Socket_IOControl_internal (gsize sock, gint32 code, MonoArray *input, MonoArray *output, gint32 *werror)
2349 {
2350         glong output_bytes = 0;
2351         gchar *i_buffer, *o_buffer;
2352         gint i_len, o_len;
2353         gint ret;
2354
2355         *werror = 0;
2356
2357         if ((guint32)code == FIONBIO)
2358                 /* Invalid command. Must use Socket.Blocking */
2359                 return -1;
2360
2361         if (input == NULL) {
2362                 i_buffer = NULL;
2363                 i_len = 0;
2364         } else {
2365                 i_buffer = mono_array_addr (input, gchar, 0);
2366                 i_len = mono_array_length (input);
2367         }
2368
2369         if (output == NULL) {
2370                 o_buffer = NULL;
2371                 o_len = 0;
2372         } else {
2373                 o_buffer = mono_array_addr (output, gchar, 0);
2374                 o_len = mono_array_length (output);
2375         }
2376
2377         MONO_ENTER_GC_SAFE;
2378
2379         ret = mono_w32socket_ioctl (sock, code, i_buffer, i_len, o_buffer, o_len, &output_bytes);
2380
2381         MONO_EXIT_GC_SAFE;
2382
2383         if (ret == SOCKET_ERROR) {
2384                 *werror = mono_w32socket_get_last_error ();
2385                 return -1;
2386         }
2387
2388         return (gint)output_bytes;
2389 }
2390
2391 static gboolean
2392 addrinfo_to_IPHostEntry (MonoAddressInfo *info, MonoString **h_name, MonoArray **h_aliases, MonoArray **h_addr_list, gboolean add_local_ips, MonoError *error)
2393 {
2394         gint32 count, i;
2395         MonoAddressEntry *ai = NULL;
2396         struct in_addr *local_in = NULL;
2397         int nlocal_in = 0;
2398         struct in6_addr *local_in6 = NULL;
2399         int nlocal_in6 = 0;
2400         int addr_index;
2401         MonoDomain *domain = mono_domain_get ();
2402
2403         mono_error_init (error);
2404         addr_index = 0;
2405         *h_aliases = mono_array_new_checked (domain, mono_get_string_class (), 0, error);
2406         return_val_if_nok (error, FALSE);
2407         if (add_local_ips) {
2408                 local_in = (struct in_addr *) mono_get_local_interfaces (AF_INET, &nlocal_in);
2409                 local_in6 = (struct in6_addr *) mono_get_local_interfaces (AF_INET6, &nlocal_in6);
2410                 if (nlocal_in || nlocal_in6) {
2411                         char addr [INET6_ADDRSTRLEN];
2412                         *h_addr_list = mono_array_new_checked (domain, mono_get_string_class (), nlocal_in + nlocal_in6, error);
2413                         if (!is_ok (error))
2414                                 goto leave;
2415
2416                         if (nlocal_in) {
2417                                 MonoString *addr_string;
2418                                 int i;
2419
2420                                 for (i = 0; i < nlocal_in; i++) {
2421                                         MonoAddress maddr;
2422                                         mono_address_init (&maddr, AF_INET, &local_in [i]);
2423                                         if (mono_networking_addr_to_str (&maddr, addr, sizeof (addr))) {
2424                                                 addr_string = mono_string_new (domain, addr);
2425                                                 mono_array_setref (*h_addr_list, addr_index, addr_string);
2426                                                 addr_index++;
2427                                         }
2428                                 }
2429                         }
2430
2431                         if (nlocal_in6) {
2432                                 MonoString *addr_string;
2433                                 int i;
2434
2435                                 for (i = 0; i < nlocal_in6; i++) {
2436                                         MonoAddress maddr;
2437                                         mono_address_init (&maddr, AF_INET6, &local_in6 [i]);
2438                                         if (mono_networking_addr_to_str (&maddr, addr, sizeof (addr))) {
2439                                                 addr_string = mono_string_new (domain, addr);
2440                                                 mono_array_setref (*h_addr_list, addr_index, addr_string);
2441                                                 addr_index++;
2442                                         }
2443                                 }
2444                         }
2445
2446                 leave:
2447                         g_free (local_in);
2448                         g_free (local_in6);
2449                         if (info)
2450                                 mono_free_address_info (info);
2451                         return is_ok (error);;
2452                 }
2453
2454                 g_free (local_in);
2455                 g_free (local_in6);
2456         }
2457
2458         for (count = 0, ai = info->entries; ai != NULL; ai = ai->next) {
2459                 if (ai->family != AF_INET && ai->family != AF_INET6)
2460                         continue;
2461                 count++;
2462         }
2463
2464         *h_addr_list = mono_array_new_checked (domain, mono_get_string_class (), count, error);
2465         if (!is_ok (error))
2466                 goto leave2;
2467
2468         for (ai = info->entries, i = 0; ai != NULL; ai = ai->next) {
2469                 MonoAddress maddr;
2470                 MonoString *addr_string;
2471                 char buffer [INET6_ADDRSTRLEN]; /* Max. size for IPv6 */
2472
2473                 if ((ai->family != PF_INET) && (ai->family != PF_INET6))
2474                         continue;
2475
2476                 mono_address_init (&maddr, ai->family, &ai->address);
2477                 if (mono_networking_addr_to_str (&maddr, buffer, sizeof (buffer)))
2478                         addr_string = mono_string_new (domain, buffer);
2479                 else
2480                         addr_string = mono_string_new (domain, "");
2481
2482                 mono_array_setref (*h_addr_list, addr_index, addr_string);
2483
2484                 if (!i) {
2485                         i++;
2486                         if (ai->canonical_name != NULL) {
2487                                 *h_name = mono_string_new (domain, ai->canonical_name);
2488                         } else {
2489                                 *h_name = mono_string_new (domain, buffer);
2490                         }
2491                 }
2492
2493                 addr_index++;
2494         }
2495
2496 leave2:
2497         if (info)
2498                 mono_free_address_info (info);
2499
2500         return is_ok (error);
2501 }
2502
2503 MonoBoolean
2504 ves_icall_System_Net_Dns_GetHostByName_internal (MonoString *host, MonoString **h_name, MonoArray **h_aliases, MonoArray **h_addr_list, gint32 hint)
2505 {
2506         MonoError error;
2507         gboolean add_local_ips = FALSE, add_info_ok = TRUE;
2508         gchar this_hostname [256];
2509         MonoAddressInfo *info = NULL;
2510
2511         char *hostname = mono_string_to_utf8_checked (host, &error);
2512         if (mono_error_set_pending_exception (&error))
2513                 return FALSE;
2514
2515         if (*hostname == '\0') {
2516                 add_local_ips = TRUE;
2517                 *h_name = host;
2518         }
2519
2520         if (!add_local_ips && gethostname (this_hostname, sizeof (this_hostname)) != -1) {
2521                 if (!strcmp (hostname, this_hostname)) {
2522                         add_local_ips = TRUE;
2523                         *h_name = host;
2524                 }
2525         }
2526
2527 #ifdef HOST_WIN32
2528         // Win32 APIs already returns local interface addresses for empty hostname ("")
2529         // so we never want to add them manually.
2530         add_local_ips = FALSE;
2531         if (mono_get_address_info(hostname, 0, MONO_HINT_CANONICAL_NAME | hint, &info))
2532                 add_info_ok = FALSE;
2533 #else
2534         if (*hostname && mono_get_address_info (hostname, 0, MONO_HINT_CANONICAL_NAME | hint, &info))
2535                 add_info_ok = FALSE;
2536 #endif
2537
2538         g_free(hostname);
2539
2540         if (add_info_ok) {
2541                 MonoBoolean result = addrinfo_to_IPHostEntry (info, h_name, h_aliases, h_addr_list, add_local_ips, &error);
2542                 mono_error_set_pending_exception (&error);
2543                 return result;
2544         }
2545         return FALSE;
2546 }
2547
2548 MonoBoolean
2549 ves_icall_System_Net_Dns_GetHostByAddr_internal (MonoString *addr, MonoString **h_name, MonoArray **h_aliases, MonoArray **h_addr_list, gint32 hint)
2550 {
2551         char *address;
2552         struct sockaddr_in saddr;
2553         struct sockaddr_in6 saddr6;
2554         MonoAddressInfo *info = NULL;
2555         MonoError error;
2556         gint32 family;
2557         gchar hostname [NI_MAXHOST] = { 0 };
2558         gboolean ret;
2559
2560         address = mono_string_to_utf8_checked (addr, &error);
2561         if (mono_error_set_pending_exception (&error))
2562                 return FALSE;
2563
2564         if (inet_pton (AF_INET, address, &saddr.sin_addr ) == 1) {
2565                 family = AF_INET;
2566                 saddr.sin_family = AF_INET;
2567         } else if (inet_pton (AF_INET6, address, &saddr6.sin6_addr) == 1) {
2568                 family = AF_INET6;
2569                 saddr6.sin6_family = AF_INET6;
2570         } else {
2571                 g_free (address);
2572                 return FALSE;
2573         }
2574
2575         g_free (address);
2576
2577         MONO_ENTER_GC_SAFE;
2578
2579         switch (family) {
2580         case AF_INET: {
2581 #if HAVE_SOCKADDR_IN_SIN_LEN
2582                 saddr.sin_len = sizeof (saddr);
2583 #endif
2584                 ret = getnameinfo ((struct sockaddr*)&saddr, sizeof (saddr), hostname, sizeof (hostname), NULL, 0, 0) == 0;
2585                 break;
2586         }
2587         case AF_INET6: {
2588 #if HAVE_SOCKADDR_IN6_SIN_LEN
2589                 saddr6.sin6_len = sizeof (saddr6);
2590 #endif
2591                 ret = getnameinfo ((struct sockaddr*)&saddr6, sizeof (saddr6), hostname, sizeof (hostname), NULL, 0, 0) == 0;
2592                 break;
2593         }
2594         default:
2595                 g_assert_not_reached ();
2596         }
2597
2598         MONO_EXIT_GC_SAFE;
2599
2600         if (!ret)
2601                 return FALSE;
2602
2603         if (mono_get_address_info (hostname, 0, hint | MONO_HINT_CANONICAL_NAME | MONO_HINT_CONFIGURED_ONLY, &info) != 0)
2604                 return FALSE;
2605
2606         MonoBoolean result = addrinfo_to_IPHostEntry (info, h_name, h_aliases, h_addr_list, FALSE, &error);
2607         mono_error_set_pending_exception (&error);
2608         return result;
2609 }
2610
2611 MonoBoolean
2612 ves_icall_System_Net_Dns_GetHostName_internal (MonoString **h_name)
2613 {
2614         gchar hostname [NI_MAXHOST] = { 0 };
2615         int ret;
2616
2617         ret = gethostname (hostname, sizeof (hostname));
2618         if (ret == -1)
2619                 return FALSE;
2620
2621         *h_name = mono_string_new (mono_domain_get (), hostname);
2622
2623         return TRUE;
2624 }
2625
2626 #if G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT | HAVE_UWP_WINAPI_SUPPORT)
2627 gboolean
2628 ves_icall_System_Net_Sockets_Socket_SendFile_internal (gsize sock, MonoString *filename, MonoArray *pre_buffer, MonoArray *post_buffer, gint flags, gint32 *werror, gboolean blocking)
2629 {
2630         HANDLE file;
2631         gboolean ret;
2632         gboolean interrupted;
2633         TRANSMIT_FILE_BUFFERS buffers;
2634
2635         if (filename == NULL)
2636                 return FALSE;
2637
2638         /* FIXME: replace file by a proper fd that we can call open and close on, as they are interruptible */
2639
2640         file = ves_icall_System_IO_MonoIO_Open (filename, FileMode_Open, FileAccess_Read, FileShare_Read, 0, werror);
2641
2642         if (file == INVALID_HANDLE_VALUE) {
2643                 SetLastError (*werror);
2644                 return FALSE;
2645         }
2646
2647         memset (&buffers, 0, sizeof (buffers));
2648         if (pre_buffer != NULL) {
2649                 buffers.Head = mono_array_addr (pre_buffer, guchar, 0);
2650                 buffers.HeadLength = mono_array_length (pre_buffer);
2651         }
2652         if (post_buffer != NULL) {
2653                 buffers.Tail = mono_array_addr (post_buffer, guchar, 0);
2654                 buffers.TailLength = mono_array_length (post_buffer);
2655         }
2656
2657         mono_thread_info_install_interrupt (abort_syscall, (gpointer) (gsize) mono_native_thread_id_get (), &interrupted);
2658         if (interrupted) {
2659                 CloseHandle (file);
2660                 SetLastError (WSAEINTR);
2661                 return FALSE;
2662         }
2663
2664         MONO_ENTER_GC_SAFE;
2665         ret = mono_w32socket_transmit_file (sock, file, &buffers, flags, blocking);
2666         MONO_EXIT_GC_SAFE;
2667
2668         if (!ret)
2669                 *werror = mono_w32socket_get_last_error ();
2670
2671         mono_thread_info_uninstall_interrupt (&interrupted);
2672         if (interrupted) {
2673                 CloseHandle (file);
2674                 *werror = WSAEINTR;
2675                 return FALSE;
2676         }
2677
2678         MONO_ENTER_GC_SAFE;
2679
2680         CloseHandle (file);
2681
2682         MONO_EXIT_GC_SAFE;
2683
2684         if (*werror)
2685                 return FALSE;
2686
2687         return ret;
2688 }
2689 #endif /* G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT | HAVE_UWP_WINAPI_SUPPORT) */
2690
2691 void
2692 mono_network_init (void)
2693 {
2694         mono_networking_init ();
2695         mono_w32socket_initialize ();
2696 }
2697
2698 void
2699 mono_network_cleanup (void)
2700 {
2701         mono_w32socket_cleanup ();
2702         mono_networking_shutdown ();
2703 }
2704
2705 void
2706 icall_cancel_blocking_socket_operation (MonoThread *thread)
2707 {
2708         MonoInternalThread *internal;
2709
2710         internal = thread->internal_thread;
2711         g_assert (internal);
2712
2713         mono_thread_info_abort_socket_syscall_for_close (MONO_UINT_TO_NATIVE_THREAD_ID (internal->tid));
2714 }
2715
2716 #endif /* #ifndef DISABLE_SOCKETS */