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