mono/metadata/w32socket.c

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