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 #ifdef HAVE_STRUCT_SOCKADDR_IN6
 922         } else if (saddr->sa_family == AF_INET6) {
 923                 struct sockaddr_in6 *sa_in = (struct sockaddr_in6 *)saddr;
 924                 int i;
 925                 int buffer_size = 28;
 926
 927                 guint16 port = ntohs (sa_in->sin6_port);
 928
 929                 if (sa_size < buffer_size) {
 930                         mono_error_set_exception_instance (error, mono_exception_from_name (mono_get_corlib (), "System", "SystemException"));
 931                         return NULL;
 932                 }
 933
 934                 mono_array_set (data, guint8, 2, (port>>8) & 0xff);
 935                 mono_array_set (data, guint8, 3, (port) & 0xff);
 936
 937                 if (is_ipv4_mapped_any (&sa_in->sin6_addr)) {
 938                         // Map ::ffff:0:0 to :: (bug #5502)
 939                         for (i = 0; i < 16; i++)
 940                                 mono_array_set (data, guint8, 8 + i, 0);
 941                 } else {
 942                         for (i = 0; i < 16; i++) {
 943                                 mono_array_set (data, guint8, 8 + i,
 944                                                                 sa_in->sin6_addr.s6_addr [i]);
 945                         }
 946                 }
 947
 948                 mono_array_set (data, guint8, 24, sa_in->sin6_scope_id & 0xff);
 949                 mono_array_set (data, guint8, 25,
 950                                                 (sa_in->sin6_scope_id >> 8) & 0xff);
 951                 mono_array_set (data, guint8, 26,
 952                                                 (sa_in->sin6_scope_id >> 16) & 0xff);
 953                 mono_array_set (data, guint8, 27,
 954                                                 (sa_in->sin6_scope_id >> 24) & 0xff);
 955
 956                 mono_field_set_value (sockaddr_obj, domain->sockaddr_data_field, data);
 957                 mono_field_set_value (sockaddr_obj, domain->sockaddr_data_length_field, &buffer_size);
 958
 959                 return sockaddr_obj;
 960         }
 961 #endif
 962 #ifdef HAVE_SYS_UN_H
 963         else if (saddr->sa_family == AF_UNIX) {
 964                 int i;
 965                 int buffer_size = sa_size + 2;
 966
 967                 for (i = 0; i < sa_size; i++)
 968                         mono_array_set (data, guint8, i + 2, saddr->sa_data [i]);
 969
 970                 mono_field_set_value (sockaddr_obj, domain->sockaddr_data_field, data);
 971                 mono_field_set_value (sockaddr_obj, domain->sockaddr_data_length_field, &buffer_size);
 972
 973                 return sockaddr_obj;
 974         }
 975 #endif
 976         else {
 977                 *werror = WSAEAFNOSUPPORT;
 978                 return NULL;
 979         }
 980 }
 981
 982 static int
 983 get_sockaddr_size (int family)
 984 {
 985         int size;
 986
 987         size = 0;
 988         if (family == AF_INET) {
 989                 size = sizeof (struct sockaddr_in);
 990 #ifdef HAVE_STRUCT_SOCKADDR_IN6
 991         } else if (family == AF_INET6) {
 992                 size = sizeof (struct sockaddr_in6);
 993         }
 994 #endif
 995 #ifdef HAVE_SYS_UN_H
 996         else if (family == AF_UNIX) {
 997                 size = sizeof (struct sockaddr_un);
 998         }
 999 #endif
1000         return size;
1001 }
1002
1003 MonoObject*
1004 ves_icall_System_Net_Sockets_Socket_LocalEndPoint_internal (gsize sock, gint32 af, gint32 *werror)
1005 {
1006         gchar *sa;
1007         socklen_t salen;
1008         int ret;
1009         MonoObject *result;
1010         MonoError error;
1011
1012         *werror = 0;
1013
1014         salen = get_sockaddr_size (convert_family ((MonoAddressFamily)af));
1015         if (salen == 0) {
1016                 *werror = WSAEAFNOSUPPORT;
1017                 return NULL;
1018         }
1019         sa = (salen <= 128) ? (gchar *)alloca (salen) : (gchar *)g_malloc0 (salen);
1020
1021         MONO_ENTER_GC_SAFE;
1022
1023         ret = mono_w32socket_getsockname (sock, (struct sockaddr *)sa, &salen);
1024
1025         MONO_EXIT_GC_SAFE;
1026
1027         if (ret == SOCKET_ERROR) {
1028                 *werror = mono_w32socket_get_last_error ();
1029                 if (salen > 128)
1030                         g_free (sa);
1031                 return NULL;
1032         }
1033
1034         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)));
1035
1036         result = create_object_from_sockaddr ((struct sockaddr *)sa, salen, werror, &error);
1037         if (salen > 128)
1038                 g_free (sa);
1039         if (!mono_error_ok (&error))
1040                 mono_error_set_pending_exception (&error);
1041         return result;
1042 }
1043
1044 MonoObject*
1045 ves_icall_System_Net_Sockets_Socket_RemoteEndPoint_internal (gsize sock, gint32 af, gint32 *werror)
1046 {
1047         gchar *sa;
1048         socklen_t salen;
1049         int ret;
1050         MonoObject *result;
1051         MonoError error;
1052
1053         *werror = 0;
1054
1055         salen = get_sockaddr_size (convert_family ((MonoAddressFamily)af));
1056         if (salen == 0) {
1057                 *werror = WSAEAFNOSUPPORT;
1058                 return NULL;
1059         }
1060         sa = (salen <= 128) ? (gchar *)alloca (salen) : (gchar *)g_malloc0 (salen);
1061         /* Note: linux returns just 2 for AF_UNIX. Always. */
1062
1063         MONO_ENTER_GC_SAFE;
1064
1065         ret = mono_w32socket_getpeername (sock, (struct sockaddr *)sa, &salen);
1066
1067         MONO_EXIT_GC_SAFE;
1068
1069         if (ret == SOCKET_ERROR) {
1070                 *werror = mono_w32socket_get_last_error ();
1071                 if (salen > 128)
1072                         g_free (sa);
1073                 return NULL;
1074         }
1075
1076         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)));
1077
1078         result = create_object_from_sockaddr ((struct sockaddr *)sa, salen, werror, &error);
1079         if (salen > 128)
1080                 g_free (sa);
1081         if (!mono_error_ok (&error))
1082                 mono_error_set_pending_exception (&error);
1083         return result;
1084 }
1085
1086 static struct sockaddr*
1087 create_sockaddr_from_object (MonoObject *saddr_obj, socklen_t *sa_size, gint32 *werror, MonoError *error)
1088 {
1089         MonoDomain *domain = mono_domain_get ();
1090         MonoArray *data;
1091         gint32 family;
1092         int len;
1093
1094         error_init (error);
1095
1096         if (!domain->sockaddr_class)
1097                 domain->sockaddr_class = mono_class_load_from_name (get_socket_assembly (), "System.Net", "SocketAddress");
1098
1099         /* Locate the SocketAddress data buffer in the object */
1100         if (!domain->sockaddr_data_field) {
1101                 domain->sockaddr_data_field = mono_class_get_field_from_name (domain->sockaddr_class, "m_Buffer");
1102                 g_assert (domain->sockaddr_data_field);
1103         }
1104
1105         /* Locate the SocketAddress data buffer length in the object */
1106         if (!domain->sockaddr_data_length_field) {
1107                 domain->sockaddr_data_length_field = mono_class_get_field_from_name (domain->sockaddr_class, "m_Size");
1108                 g_assert (domain->sockaddr_data_length_field);
1109         }
1110
1111         data = *(MonoArray **)(((char *)saddr_obj) + domain->sockaddr_data_field->offset);
1112
1113         /* The data buffer is laid out as follows:
1114          * byte 0 is the address family low byte
1115          * byte 1 is the address family high byte
1116          * INET:
1117          *      bytes 2 and 3 are the port info
1118          *      the rest is the address info
1119          * UNIX:
1120          *      the rest is the file name
1121          */
1122         len = *(int *)(((char *)saddr_obj) + domain->sockaddr_data_length_field->offset);
1123         g_assert (len >= 2);
1124
1125         family = convert_family ((MonoAddressFamily)(mono_array_get (data, guint8, 0) + (mono_array_get (data, guint8, 1) << 8)));
1126         if (family == AF_INET) {
1127                 struct sockaddr_in *sa;
1128                 guint16 port;
1129                 guint32 address;
1130
1131                 if (len < 8) {
1132                         mono_error_set_exception_instance (error, mono_exception_from_name (mono_get_corlib (), "System", "SystemException"));
1133                         return NULL;
1134                 }
1135
1136                 sa = g_new0 (struct sockaddr_in, 1);
1137                 port = (mono_array_get (data, guint8, 2) << 8) +
1138                         mono_array_get (data, guint8, 3);
1139                 address = (mono_array_get (data, guint8, 4) << 24) +
1140                         (mono_array_get (data, guint8, 5) << 16 ) +
1141                         (mono_array_get (data, guint8, 6) << 8) +
1142                         mono_array_get (data, guint8, 7);
1143
1144                 sa->sin_family = family;
1145                 sa->sin_addr.s_addr = htonl (address);
1146                 sa->sin_port = htons (port);
1147
1148                 *sa_size = sizeof (struct sockaddr_in);
1149                 return (struct sockaddr *)sa;
1150 #ifdef HAVE_STRUCT_SOCKADDR_IN6
1151         } else if (family == AF_INET6) {
1152                 struct sockaddr_in6 *sa;
1153                 int i;
1154                 guint16 port;
1155                 guint32 scopeid;
1156
1157                 if (len < 28) {
1158                         mono_error_set_exception_instance (error, mono_exception_from_name (mono_get_corlib (), "System", "SystemException"));
1159                         return NULL;
1160                 }
1161
1162                 sa = g_new0 (struct sockaddr_in6, 1);
1163                 port = mono_array_get (data, guint8, 3) +
1164                         (mono_array_get (data, guint8, 2) << 8);
1165                 scopeid = mono_array_get (data, guint8, 24) +
1166                         (mono_array_get (data, guint8, 25) << 8) +
1167                         (mono_array_get (data, guint8, 26) << 16) +
1168                         (mono_array_get (data, guint8, 27) << 24);
1169
1170                 sa->sin6_family = family;
1171                 sa->sin6_port = htons (port);
1172                 sa->sin6_scope_id = scopeid;
1173
1174                 for (i = 0; i < 16; i++)
1175                         sa->sin6_addr.s6_addr [i] = mono_array_get (data, guint8, 8 + i);
1176
1177                 *sa_size = sizeof (struct sockaddr_in6);
1178                 return (struct sockaddr *)sa;
1179         }
1180 #endif
1181 #ifdef HAVE_SYS_UN_H
1182         else if (family == AF_UNIX) {
1183                 struct sockaddr_un *sock_un;
1184                 int i;
1185
1186                 /* Need a byte for the '\0' terminator/prefix, and the first
1187                  * two bytes hold the SocketAddress family
1188                  */
1189                 if (len - 2 >= sizeof (sock_un->sun_path)) {
1190                         mono_error_set_exception_instance (error, mono_get_exception_index_out_of_range ());
1191                         return NULL;
1192                 }
1193
1194                 sock_un = g_new0 (struct sockaddr_un, 1);
1195
1196                 sock_un->sun_family = family;
1197                 for (i = 0; i < len - 2; i++)
1198                         sock_un->sun_path [i] = mono_array_get (data, guint8, i + 2);
1199
1200                 *sa_size = len;
1201                 return (struct sockaddr *)sock_un;
1202         }
1203 #endif
1204         else {
1205                 *werror = WSAEAFNOSUPPORT;
1206                 return 0;
1207         }
1208 }
1209
1210 void
1211 ves_icall_System_Net_Sockets_Socket_Bind_internal (gsize sock, MonoObject *sockaddr, gint32 *werror)
1212 {
1213         MonoError error;
1214         struct sockaddr *sa;
1215         socklen_t sa_size;
1216         int ret;
1217
1218         *werror = 0;
1219
1220         sa = create_sockaddr_from_object (sockaddr, &sa_size, werror, &error);
1221         if (*werror != 0)
1222                 return;
1223         if (!mono_error_ok (&error)) {
1224                 mono_error_set_pending_exception (&error);
1225                 return;
1226         }
1227
1228         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)));
1229
1230         ret = mono_w32socket_bind (sock, sa, sa_size);
1231
1232         if (ret == SOCKET_ERROR)
1233                 *werror = mono_w32socket_get_last_error ();
1234
1235         g_free (sa);
1236 }
1237
1238 enum {
1239         SelectModeRead,
1240         SelectModeWrite,
1241         SelectModeError
1242 };
1243
1244 MonoBoolean
1245 ves_icall_System_Net_Sockets_Socket_Poll_internal (gsize sock, gint mode,
1246                                                                                                    gint timeout, gint32 *werror)
1247 {
1248         MonoInternalThread *thread = mono_thread_internal_current ();
1249         mono_pollfd *pfds;
1250         int ret;
1251         gboolean interrupted;
1252         time_t start;
1253
1254         *werror = 0;
1255
1256         pfds = g_new0 (mono_pollfd, 1);
1257         pfds->fd = GPOINTER_TO_INT (sock);
1258
1259         switch (mode) {
1260         case SelectModeRead:
1261                 pfds->events = MONO_POLLIN;
1262                 break;
1263         case SelectModeWrite:
1264                 pfds->events = MONO_POLLOUT;
1265                 break;
1266         default:
1267                 pfds->events = MONO_POLLERR | MONO_POLLHUP | MONO_POLLNVAL;
1268                 break;
1269         }
1270
1271         timeout = (timeout >= 0) ? (timeout / 1000) : -1;
1272         start = time (NULL);
1273
1274         do {
1275                 mono_thread_info_install_interrupt (abort_syscall, (gpointer) (gsize) mono_native_thread_id_get (), &interrupted);
1276                 if (interrupted) {
1277                         g_free (pfds);
1278                         *werror = WSAEINTR;
1279                         return FALSE;
1280                 }
1281
1282                 MONO_ENTER_GC_SAFE;
1283
1284                 ret = mono_poll (pfds, 1, timeout);
1285
1286                 MONO_EXIT_GC_SAFE;
1287
1288                 mono_thread_info_uninstall_interrupt (&interrupted);
1289                 if (interrupted) {
1290                         g_free (pfds);
1291                         *werror = WSAEINTR;
1292                         return FALSE;
1293                 }
1294
1295                 if (timeout > 0 && ret < 0) {
1296                         int err = errno;
1297                         int sec = time (NULL) - start;
1298
1299                         timeout -= sec * 1000;
1300                         if (timeout < 0) {
1301                                 timeout = 0;
1302                         }
1303
1304                         errno = err;
1305                 }
1306
1307                 if (ret == -1 && errno == EINTR) {
1308                         if (mono_thread_test_state (thread, ThreadState_AbortRequested)) {
1309                                 g_free (pfds);
1310                                 return FALSE;
1311                         }
1312
1313                         /* Suspend requested? */
1314                         mono_thread_interruption_checkpoint ();
1315
1316                         errno = EINTR;
1317                 }
1318         } while (ret == -1 && errno == EINTR);
1319
1320         if (ret == -1) {
1321                 *werror = mono_w32socket_convert_error (errno);
1322                 g_free (pfds);
1323                 return FALSE;
1324         }
1325
1326         g_free (pfds);
1327         return ret != 0;
1328 }
1329
1330 void
1331 ves_icall_System_Net_Sockets_Socket_Connect_internal (gsize sock, MonoObject *sockaddr, gint32 *werror, gboolean blocking)
1332 {
1333         MonoError error;
1334         struct sockaddr *sa;
1335         socklen_t sa_size;
1336         int ret;
1337         gboolean interrupted;
1338
1339         *werror = 0;
1340
1341         sa = create_sockaddr_from_object (sockaddr, &sa_size, werror, &error);
1342         if (*werror != 0)
1343                 return;
1344         if (!mono_error_ok (&error)) {
1345                 mono_error_set_pending_exception (&error);
1346                 return;
1347         }
1348
1349         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)));
1350
1351         mono_thread_info_install_interrupt (abort_syscall, (gpointer) (gsize) mono_native_thread_id_get (), &interrupted);
1352         if (interrupted) {
1353                 *werror = WSAEINTR;
1354                 return;
1355         }
1356
1357         MONO_ENTER_GC_SAFE;
1358         ret = mono_w32socket_connect (sock, sa, sa_size, blocking);
1359         MONO_EXIT_GC_SAFE;
1360
1361         if (ret == SOCKET_ERROR)
1362                 *werror = mono_w32socket_get_last_error ();
1363
1364         mono_thread_info_uninstall_interrupt (&interrupted);
1365         if (interrupted)
1366                 *werror = WSAEINTR;
1367
1368         g_free (sa);
1369 }
1370
1371 #if G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT | HAVE_UWP_WINAPI_SUPPORT)
1372
1373 void
1374 ves_icall_System_Net_Sockets_Socket_Disconnect_internal (gsize sock, MonoBoolean reuse, gint32 *werror)
1375 {
1376         gboolean interrupted;
1377
1378         LOGDEBUG (g_message("%s: disconnecting from socket %p (reuse %d)", __func__, sock, reuse));
1379
1380         mono_thread_info_install_interrupt (abort_syscall, (gpointer) (gsize) mono_native_thread_id_get (), &interrupted);
1381         if (interrupted) {
1382                 *werror = WSAEINTR;
1383                 return;
1384         }
1385
1386         MONO_ENTER_GC_SAFE;
1387         *werror = mono_w32socket_disconnect (sock, reuse);
1388         MONO_EXIT_GC_SAFE;
1389
1390         mono_thread_info_uninstall_interrupt (&interrupted);
1391         if (interrupted)
1392                 *werror = WSAEINTR;
1393 }
1394 #endif /* G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT | HAVE_UWP_WINAPI_SUPPORT) */
1395
1396 gint32
1397 ves_icall_System_Net_Sockets_Socket_Receive_internal (gsize sock, MonoArray *buffer, gint32 offset, gint32 count, gint32 flags, gint32 *werror, gboolean blocking)
1398 {
1399         int ret;
1400         gchar *buf;
1401         gint32 alen;
1402         int recvflags = 0;
1403         gboolean interrupted;
1404         MonoInternalThread* curthread G_GNUC_UNUSED = mono_thread_internal_current ();
1405
1406         *werror = 0;
1407
1408         alen = mono_array_length (buffer);
1409         if (offset > alen - count)
1410                 return 0;
1411
1412         buf = mono_array_addr (buffer, gchar, offset);
1413
1414         recvflags = convert_socketflags (flags);
1415         if (recvflags == -1) {
1416                 *werror = WSAEOPNOTSUPP;
1417                 return 0;
1418         }
1419
1420         mono_thread_info_install_interrupt (abort_syscall, (gpointer) (gsize) mono_native_thread_id_get (), &interrupted);
1421         if (interrupted)
1422                 return 0;
1423
1424         MONO_ENTER_GC_SAFE;
1425         ret = mono_w32socket_recv (sock, buf, count, recvflags, blocking);
1426         MONO_EXIT_GC_SAFE;
1427
1428         if (ret == SOCKET_ERROR)
1429                 *werror = mono_w32socket_get_last_error ();
1430
1431         mono_thread_info_uninstall_interrupt (&interrupted);
1432         if (interrupted)
1433                 *werror = WSAEINTR;
1434
1435         if (*werror)
1436                 return 0;
1437
1438         return ret;
1439 }
1440
1441 gint32
1442 ves_icall_System_Net_Sockets_Socket_Receive_array_internal (gsize sock, MonoArray *buffers, gint32 flags, gint32 *werror, gboolean blocking)
1443 {
1444         int ret, count;
1445         gboolean interrupted;
1446         guint32 recv;
1447         WSABUF *wsabufs;
1448         guint32 recvflags = 0;
1449
1450         *werror = 0;
1451
1452         wsabufs = mono_array_addr (buffers, WSABUF, 0);
1453         count = mono_array_length (buffers);
1454
1455         recvflags = convert_socketflags (flags);
1456         if (recvflags == -1) {
1457                 *werror = WSAEOPNOTSUPP;
1458                 return 0;
1459         }
1460
1461         mono_thread_info_install_interrupt (abort_syscall, (gpointer) (gsize) mono_native_thread_id_get (), &interrupted);
1462         if (interrupted) {
1463                 *werror = WSAEINTR;
1464                 return 0;
1465         }
1466
1467         MONO_ENTER_GC_SAFE;
1468         ret = mono_w32socket_recvbuffers (sock, wsabufs, count, &recv, &recvflags, NULL, NULL, blocking);
1469         MONO_EXIT_GC_SAFE;
1470
1471         if (ret == SOCKET_ERROR)
1472                 *werror = mono_w32socket_get_last_error ();
1473
1474         mono_thread_info_uninstall_interrupt (&interrupted);
1475         if (interrupted)
1476                 *werror = WSAEINTR;
1477
1478         if (*werror)
1479                 return 0;
1480
1481         return recv;
1482 }
1483
1484 gint32
1485 ves_icall_System_Net_Sockets_Socket_ReceiveFrom_internal (gsize sock, MonoArray *buffer, gint32 offset, gint32 count, gint32 flags, MonoObject **sockaddr, gint32 *werror, gboolean blocking)
1486 {
1487         MonoError error;
1488         int ret;
1489         gchar *buf;
1490         gint32 alen;
1491         int recvflags = 0;
1492         struct sockaddr *sa;
1493         socklen_t sa_size;
1494         gboolean interrupted;
1495
1496         *werror = 0;
1497
1498         alen = mono_array_length (buffer);
1499         if (offset > alen - count)
1500                 return 0;
1501
1502         sa = create_sockaddr_from_object (*sockaddr, &sa_size, werror, &error);
1503         if (*werror != 0)
1504                 return 0;
1505         if (!mono_error_ok (&error)) {
1506                 mono_error_set_pending_exception (&error);
1507                 return 0;
1508         }
1509
1510         buf = mono_array_addr (buffer, gchar, offset);
1511
1512         recvflags = convert_socketflags (flags);
1513         if (recvflags == -1) {
1514                 *werror = WSAEOPNOTSUPP;
1515                 return 0;
1516         }
1517
1518         mono_thread_info_install_interrupt (abort_syscall, (gpointer) (gsize) mono_native_thread_id_get (), &interrupted);
1519         if (interrupted) {
1520                 g_free (sa);
1521                 *werror = WSAEINTR;
1522                 return 0;
1523         }
1524
1525         MONO_ENTER_GC_SAFE;
1526         ret = mono_w32socket_recvfrom (sock, buf, count, recvflags, sa, &sa_size, blocking);
1527         MONO_EXIT_GC_SAFE;
1528
1529         if (ret == SOCKET_ERROR)
1530                 *werror = mono_w32socket_get_last_error ();
1531
1532         mono_thread_info_uninstall_interrupt (&interrupted);
1533
1534         if (interrupted)
1535                 *werror = WSAEINTR;
1536
1537         if (*werror) {
1538                 g_free(sa);
1539                 return 0;
1540         }
1541
1542         /* If we didn't get a socket size, then we're probably a
1543          * connected connection-oriented socket and the stack hasn't
1544          * returned the remote address. All we can do is return null.
1545          */
1546         if (sa_size) {
1547                 *sockaddr = create_object_from_sockaddr (sa, sa_size, werror, &error);
1548                 if (!mono_error_ok (&error)) {
1549                         mono_error_set_pending_exception (&error);
1550                         g_free (sa);
1551                         return 0;
1552                 }
1553         } else {
1554                 *sockaddr = NULL;
1555         }
1556
1557         g_free (sa);
1558
1559         return ret;
1560 }
1561
1562 gint32
1563 ves_icall_System_Net_Sockets_Socket_Send_internal (gsize sock, MonoArray *buffer, gint32 offset, gint32 count, gint32 flags, gint32 *werror, gboolean blocking)
1564 {
1565         int ret;
1566         gchar *buf;
1567         gint32 alen;
1568         int sendflags = 0;
1569         gboolean interrupted;
1570
1571         *werror = 0;
1572
1573         alen = mono_array_length (buffer);
1574         if (offset > alen - count)
1575                 return 0;
1576
1577         LOGDEBUG (g_message("%s: alen: %d", __func__, alen));
1578
1579         buf = mono_array_addr (buffer, gchar, offset);
1580
1581         LOGDEBUG (g_message("%s: Sending %d bytes", __func__, count));
1582
1583         sendflags = convert_socketflags (flags);
1584         if (sendflags == -1) {
1585                 *werror = WSAEOPNOTSUPP;
1586                 return 0;
1587         }
1588
1589         mono_thread_info_install_interrupt (abort_syscall, (gpointer) (gsize) mono_native_thread_id_get (), &interrupted);
1590         if (interrupted) {
1591                 *werror = WSAEINTR;
1592                 return 0;
1593         }
1594
1595         MONO_ENTER_GC_SAFE;
1596         ret = mono_w32socket_send (sock, buf, count, sendflags, blocking);
1597         MONO_EXIT_GC_SAFE;
1598
1599         if (ret == SOCKET_ERROR)
1600                 *werror = mono_w32socket_get_last_error ();
1601
1602         mono_thread_info_uninstall_interrupt (&interrupted);
1603         if (interrupted)
1604                 *werror = WSAEINTR;
1605
1606         if (*werror)
1607                 return 0;
1608
1609         return ret;
1610 }
1611
1612 gint32
1613 ves_icall_System_Net_Sockets_Socket_Send_array_internal (gsize sock, MonoArray *buffers, gint32 flags, gint32 *werror, gboolean blocking)
1614 {
1615         int ret, count;
1616         guint32 sent;
1617         WSABUF *wsabufs;
1618         guint32 sendflags = 0;
1619         gboolean interrupted;
1620
1621         *werror = 0;
1622
1623         wsabufs = mono_array_addr (buffers, WSABUF, 0);
1624         count = mono_array_length (buffers);
1625
1626         sendflags = convert_socketflags (flags);
1627         if (sendflags == -1) {
1628                 *werror = WSAEOPNOTSUPP;
1629                 return 0;
1630         }
1631
1632         mono_thread_info_install_interrupt (abort_syscall, (gpointer) (gsize) mono_native_thread_id_get (), &interrupted);
1633         if (interrupted) {
1634                 *werror = WSAEINTR;
1635                 return 0;
1636         }
1637
1638         MONO_ENTER_GC_SAFE;
1639         ret = mono_w32socket_sendbuffers (sock, wsabufs, count, &sent, sendflags, NULL, NULL, blocking);
1640         MONO_EXIT_GC_SAFE;
1641
1642         if (ret == SOCKET_ERROR)
1643                 *werror = mono_w32socket_get_last_error ();
1644
1645         mono_thread_info_uninstall_interrupt (&interrupted);
1646         if (interrupted)
1647                 *werror = WSAEINTR;
1648
1649         if (*werror)
1650                 return 0;
1651
1652         return sent;
1653 }
1654
1655 gint32
1656 ves_icall_System_Net_Sockets_Socket_SendTo_internal (gsize sock, MonoArray *buffer, gint32 offset, gint32 count, gint32 flags, MonoObject *sockaddr, gint32 *werror, gboolean blocking)
1657 {
1658         MonoError error;
1659         int ret;
1660         gchar *buf;
1661         gint32 alen;
1662         int sendflags = 0;
1663         struct sockaddr *sa;
1664         socklen_t sa_size;
1665         gboolean interrupted;
1666
1667         *werror = 0;
1668
1669         alen = mono_array_length (buffer);
1670         if (offset > alen - count) {
1671                 return 0;
1672         }
1673
1674         sa = create_sockaddr_from_object(sockaddr, &sa_size, werror, &error);
1675         if (*werror != 0)
1676                 return 0;
1677         if (!mono_error_ok (&error)) {
1678                 mono_error_set_pending_exception (&error);
1679                 return 0;
1680         }
1681
1682         LOGDEBUG (g_message ("%s: alen: %d", __func__, alen));
1683
1684         buf = mono_array_addr (buffer, gchar, offset);
1685
1686         LOGDEBUG (g_message("%s: Sending %d bytes", __func__, count));
1687
1688         sendflags = convert_socketflags (flags);
1689         if (sendflags == -1) {
1690                 g_free (sa);
1691                 *werror = WSAEOPNOTSUPP;
1692                 return 0;
1693         }
1694
1695         mono_thread_info_install_interrupt (abort_syscall, (gpointer) (gsize) mono_native_thread_id_get (), &interrupted);
1696         if (interrupted) {
1697                 g_free (sa);
1698                 *werror = WSAEINTR;
1699                 return 0;
1700         }
1701
1702         MONO_ENTER_GC_SAFE;
1703         ret = mono_w32socket_sendto (sock, buf, count, sendflags, sa, sa_size, blocking);
1704         MONO_EXIT_GC_SAFE;
1705
1706         if (ret == SOCKET_ERROR)
1707                 *werror = mono_w32socket_get_last_error ();
1708
1709         mono_thread_info_uninstall_interrupt (&interrupted);
1710         if (interrupted)
1711                 *werror = WSAEINTR;
1712
1713         g_free(sa);
1714
1715         if (*werror)
1716                 return 0;
1717
1718         return ret;
1719 }
1720
1721 static SOCKET
1722 Socket_to_SOCKET (MonoObject *sockobj)
1723 {
1724         MonoSafeHandle *safe_handle;
1725         MonoClassField *field;
1726
1727         field = mono_class_get_field_from_name (sockobj->vtable->klass, "m_Handle");
1728         safe_handle = ((MonoSafeHandle *)(*(gpointer *)(((char *)sockobj) + field->offset)));
1729
1730         if (safe_handle == NULL)
1731                 return -1;
1732
1733         return (SOCKET)safe_handle->handle;
1734 }
1735
1736 #define POLL_ERRORS (MONO_POLLERR | MONO_POLLHUP | MONO_POLLNVAL)
1737
1738 void
1739 ves_icall_System_Net_Sockets_Socket_Select_internal (MonoArray **sockets, gint32 timeout, gint32 *werror)
1740 {
1741         MonoError error;
1742         MonoInternalThread *thread = mono_thread_internal_current ();
1743         MonoObject *obj;
1744         mono_pollfd *pfds;
1745         int nfds, idx;
1746         int ret;
1747         int i, count;
1748         int mode;
1749         MonoClass *sock_arr_class;
1750         MonoArray *socks;
1751         time_t start;
1752         uintptr_t socks_size;
1753         gboolean interrupted;
1754
1755         *werror = 0;
1756
1757         /* *sockets -> READ, null, WRITE, null, ERROR, null */
1758         count = mono_array_length (*sockets);
1759         nfds = count - 3; /* NULL separators */
1760         pfds = g_new0 (mono_pollfd, nfds);
1761         mode = idx = 0;
1762         for (i = 0; i < count; i++) {
1763                 obj = mono_array_get (*sockets, MonoObject *, i);
1764                 if (obj == NULL) {
1765                         mode++;
1766                         continue;
1767                 }
1768
1769                 if (idx >= nfds) {
1770                         /* The socket array was bogus */
1771                         g_free (pfds);
1772                         *werror = WSAEFAULT;
1773                         return;
1774                 }
1775
1776                 pfds [idx].fd = Socket_to_SOCKET (obj);
1777                 pfds [idx].events = (mode == 0) ? MONO_POLLIN : (mode == 1) ? MONO_POLLOUT : POLL_ERRORS;
1778                 idx++;
1779         }
1780
1781         timeout = (timeout >= 0) ? (timeout / 1000) : -1;
1782         start = time (NULL);
1783         do {
1784                 mono_thread_info_install_interrupt (abort_syscall, (gpointer) (gsize) mono_native_thread_id_get (), &interrupted);
1785                 if (interrupted) {
1786                         g_free (pfds);
1787                         *werror = WSAEINTR;
1788                         return;
1789                 }
1790
1791                 MONO_ENTER_GC_SAFE;
1792
1793                 ret = mono_poll (pfds, nfds, timeout);
1794
1795                 MONO_EXIT_GC_SAFE;
1796
1797                 mono_thread_info_uninstall_interrupt (&interrupted);
1798                 if (interrupted) {
1799                         g_free (pfds);
1800                         *werror = WSAEINTR;
1801                         return;
1802                 }
1803
1804                 if (timeout > 0 && ret < 0) {
1805                         int err = errno;
1806                         int sec = time (NULL) - start;
1807
1808                         timeout -= sec * 1000;
1809                         if (timeout < 0)
1810                                 timeout = 0;
1811                         errno = err;
1812                 }
1813
1814                 if (ret == -1 && errno == EINTR) {
1815                         if (mono_thread_test_state (thread, ThreadState_AbortRequested)) {
1816                                 g_free (pfds);
1817                                 *sockets = NULL;
1818                                 return;
1819                         }
1820
1821                         /* Suspend requested? */
1822                         mono_thread_interruption_checkpoint ();
1823
1824                         errno = EINTR;
1825                 }
1826         } while (ret == -1 && errno == EINTR);
1827
1828         if (ret == -1) {
1829                 *werror = mono_w32socket_convert_error (errno);
1830                 g_free (pfds);
1831                 return;
1832         }
1833
1834         if (ret == 0) {
1835                 g_free (pfds);
1836                 *sockets = NULL;
1837                 return;
1838         }
1839
1840         sock_arr_class = ((MonoObject *)*sockets)->vtable->klass;
1841         socks_size = ((uintptr_t)ret) + 3; /* space for the NULL delimiters */
1842         socks = mono_array_new_full_checked (mono_domain_get (), sock_arr_class, &socks_size, NULL, &error);
1843         if (!mono_error_ok (&error)) {
1844                 mono_error_set_pending_exception (&error);
1845                 g_free (pfds);
1846                 return;
1847         }
1848
1849         mode = idx = 0;
1850         for (i = 0; i < count && ret > 0; i++) {
1851                 mono_pollfd *pfd;
1852
1853                 obj = mono_array_get (*sockets, MonoObject *, i);
1854                 if (obj == NULL) {
1855                         mode++;
1856                         idx++;
1857                         continue;
1858                 }
1859
1860                 pfd = &pfds [i - mode];
1861                 if (pfd->revents == 0)
1862                         continue;
1863
1864                 ret--;
1865                 if (mode == 0 && (pfd->revents & (MONO_POLLIN | POLL_ERRORS)) != 0) {
1866                         mono_array_setref (socks, idx++, obj);
1867                 } else if (mode == 1 && (pfd->revents & (MONO_POLLOUT | POLL_ERRORS)) != 0) {
1868                         mono_array_setref (socks, idx++, obj);
1869                 } else if ((pfd->revents & POLL_ERRORS) != 0) {
1870                         mono_array_setref (socks, idx++, obj);
1871                 }
1872         }
1873
1874         *sockets = socks;
1875         g_free (pfds);
1876 }
1877
1878 static MonoObject*
1879 int_to_object (MonoDomain *domain, int val, MonoError *error)
1880 {
1881         return mono_value_box_checked (domain, mono_get_int32_class (), &val, error);
1882 }
1883
1884 void
1885 ves_icall_System_Net_Sockets_Socket_GetSocketOption_obj_internal (gsize sock, gint32 level, gint32 name, MonoObject **obj_val, gint32 *werror)
1886 {
1887         int system_level = 0;
1888         int system_name = 0;
1889         int ret;
1890         int val = 0;
1891         socklen_t valsize = sizeof (val);
1892         struct linger linger;
1893         socklen_t lingersize = sizeof (linger);
1894         int time_ms = 0;
1895         socklen_t time_ms_size = sizeof (time_ms);
1896 #ifdef SO_PEERCRED
1897 #  if defined(__OpenBSD__)
1898         struct sockpeercred cred;
1899 #  else
1900         struct ucred cred;
1901 #  endif
1902         socklen_t credsize = sizeof (cred);
1903 #endif
1904         MonoError error;
1905         MonoDomain *domain = mono_domain_get ();
1906         MonoObject *obj;
1907         MonoClass *obj_class;
1908         MonoClassField *field;
1909
1910         *werror = 0;
1911
1912 #if !defined(SO_EXCLUSIVEADDRUSE) && defined(SO_REUSEADDR)
1913         if (level == SocketOptionLevel_Socket && name == SocketOptionName_ExclusiveAddressUse) {
1914                 system_level = SOL_SOCKET;
1915                 system_name = SO_REUSEADDR;
1916                 ret = 0;
1917         } else
1918 #endif
1919         {
1920                 ret = convert_sockopt_level_and_name ((MonoSocketOptionLevel)level, (MonoSocketOptionName)name, &system_level, &system_name);
1921         }
1922
1923         if (ret == -1) {
1924                 *werror = WSAENOPROTOOPT;
1925                 return;
1926         }
1927         if (ret == -2) {
1928                 *obj_val = int_to_object (domain, 0, &error);
1929                 mono_error_set_pending_exception (&error);
1930                 return;
1931         }
1932
1933         MONO_ENTER_GC_SAFE;
1934
1935         /* No need to deal with MulticastOption names here, because
1936          * you cant getsockopt AddMembership or DropMembership (the
1937          * int getsockopt will error, causing an exception)
1938          */
1939         switch (name) {
1940         case SocketOptionName_Linger:
1941         case SocketOptionName_DontLinger:
1942                 ret = mono_w32socket_getsockopt (sock, system_level, system_name, &linger, &lingersize);
1943                 break;
1944
1945         case SocketOptionName_SendTimeout:
1946         case SocketOptionName_ReceiveTimeout:
1947                 ret = mono_w32socket_getsockopt (sock, system_level, system_name, (char *)&time_ms, &time_ms_size);
1948                 break;
1949
1950 #ifdef SO_PEERCRED
1951         case SocketOptionName_PeerCred:
1952                 ret = mono_w32socket_getsockopt (sock, system_level, system_name, &cred, &credsize);
1953                 break;
1954 #endif
1955
1956         default:
1957                 ret = mono_w32socket_getsockopt (sock, system_level, system_name, &val, &valsize);
1958         }
1959
1960         MONO_EXIT_GC_SAFE;
1961
1962         if (ret == SOCKET_ERROR) {
1963                 *werror = mono_w32socket_get_last_error ();
1964                 return;
1965         }
1966
1967         switch (name) {
1968         case SocketOptionName_Linger:
1969                 /* build a System.Net.Sockets.LingerOption */
1970                 obj_class = mono_class_load_from_name (get_socket_assembly (),
1971                                                                                            "System.Net.Sockets",
1972                                                                                            "LingerOption");
1973                 obj = mono_object_new_checked (domain, obj_class, &error);
1974                 if (!mono_error_ok (&error)) {
1975                         mono_error_set_pending_exception (&error);
1976                         return;
1977                 }
1978
1979                 /* Locate and set the fields "bool enabled" and "int
1980                  * lingerTime"
1981                  */
1982                 field = mono_class_get_field_from_name(obj_class, "enabled");
1983                 *(guint8 *)(((char *)obj)+field->offset) = linger.l_onoff;
1984
1985                 field = mono_class_get_field_from_name(obj_class, "lingerTime");
1986                 *(guint32 *)(((char *)obj)+field->offset)=linger.l_linger;
1987                 break;
1988         case SocketOptionName_DontLinger:
1989                 /* construct a bool int in val - true if linger is off */
1990                 obj = int_to_object (domain, !linger.l_onoff, &error);
1991                 mono_error_set_pending_exception (&error);
1992                 break;
1993         case SocketOptionName_SendTimeout:
1994         case SocketOptionName_ReceiveTimeout:
1995                 obj = int_to_object (domain, time_ms, &error);
1996                 mono_error_set_pending_exception (&error);
1997                 break;
1998
1999 #ifdef SO_PEERCRED
2000         case SocketOptionName_PeerCred:  {
2001                 /*
2002                  * build a Mono.Posix.PeerCred+PeerCredData if
2003                  * possible
2004                  */
2005                 static MonoImage *mono_posix_image = NULL;
2006                 MonoPeerCredData *cred_data;
2007
2008                 if (mono_posix_image == NULL) {
2009                         mono_posix_image = mono_image_loaded ("Mono.Posix");
2010                         if (!mono_posix_image) {
2011                                 MonoAssembly *sa = mono_assembly_open_predicate ("Mono.Posix.dll", FALSE, FALSE, NULL, NULL, NULL);
2012                                 if (!sa) {
2013                                         *werror = WSAENOPROTOOPT;
2014                                         return;
2015                                 } else {
2016                                         mono_posix_image = mono_assembly_get_image (sa);
2017                                 }
2018                         }
2019                 }
2020
2021                 obj_class = mono_class_load_from_name (mono_posix_image,
2022                                                  "Mono.Posix",
2023                                                  "PeerCredData");
2024                 obj = mono_object_new_checked (domain, obj_class, &error);
2025                 if (!mono_error_ok (&error)) {
2026                         mono_error_set_pending_exception (&error);
2027                         return;
2028                 }
2029                 cred_data = (MonoPeerCredData *)obj;
2030                 cred_data->pid = cred.pid;
2031                 cred_data->uid = cred.uid;
2032                 cred_data->gid = cred.gid;
2033                 break;
2034         }
2035 #endif
2036
2037         default:
2038 #if !defined(SO_EXCLUSIVEADDRUSE) && defined(SO_REUSEADDR)
2039                 if (level == SocketOptionLevel_Socket && name == SocketOptionName_ExclusiveAddressUse)
2040                         val = val ? 0 : 1;
2041 #endif
2042                 obj = int_to_object (domain, val, &error);
2043                 mono_error_set_pending_exception (&error);
2044         }
2045
2046         *obj_val = obj;
2047 }
2048
2049 void
2050 ves_icall_System_Net_Sockets_Socket_GetSocketOption_arr_internal (gsize sock, gint32 level, gint32 name, MonoArray **byte_val, gint32 *werror)
2051 {
2052         int system_level = 0;
2053         int system_name = 0;
2054         int ret;
2055         guchar *buf;
2056         socklen_t valsize;
2057
2058         *werror = 0;
2059
2060         ret = convert_sockopt_level_and_name((MonoSocketOptionLevel)level, (MonoSocketOptionName)name, &system_level,
2061                                                                                  &system_name);
2062         if (ret == -1) {
2063                 *werror = WSAENOPROTOOPT;
2064                 return;
2065         }
2066         if (ret == -2)
2067                 return;
2068
2069         valsize = mono_array_length (*byte_val);
2070         buf = mono_array_addr (*byte_val, guchar, 0);
2071
2072         MONO_ENTER_GC_SAFE;
2073
2074         ret = mono_w32socket_getsockopt (sock, system_level, system_name, buf, &valsize);
2075
2076         MONO_EXIT_GC_SAFE;
2077
2078         if (ret == SOCKET_ERROR)
2079                 *werror = mono_w32socket_get_last_error ();
2080 }
2081
2082 #if defined(HAVE_STRUCT_IP_MREQN) || defined(HAVE_STRUCT_IP_MREQ)
2083 static struct in_addr
2084 ipaddress_to_struct_in_addr (MonoObject *ipaddr)
2085 {
2086         struct in_addr inaddr;
2087         MonoClassField *field;
2088
2089         field = mono_class_get_field_from_name (ipaddr->vtable->klass, "m_Address");
2090
2091         /* No idea why .net uses a 64bit type to hold a 32bit value...
2092          *
2093          * Internal value of IPAddess is in little-endian order
2094          */
2095         inaddr.s_addr = GUINT_FROM_LE ((guint32)*(guint64 *)(((char *)ipaddr) + field->offset));
2096
2097         return inaddr;
2098 }
2099
2100 #ifdef HAVE_STRUCT_SOCKADDR_IN6
2101 static struct in6_addr
2102 ipaddress_to_struct_in6_addr (MonoObject *ipaddr)
2103 {
2104         struct in6_addr in6addr;
2105         MonoClassField *field;
2106         MonoArray *data;
2107         int i;
2108
2109         field = mono_class_get_field_from_name (ipaddr->vtable->klass, "m_Numbers");
2110         g_assert (field);
2111         data = *(MonoArray **)(((char *)ipaddr) + field->offset);
2112
2113         for (i = 0; i < 8; i++) {
2114                 const guint16 s = GUINT16_TO_BE (mono_array_get (data, guint16, i));
2115
2116 /* Solaris/MacOS have only the 8 bit version. */
2117 #ifndef s6_addr16
2118                 in6addr.s6_addr[2 * i + 1] = (s >> 8) & 0xff;
2119                 in6addr.s6_addr[2 * i] = s & 0xff;
2120 #else
2121                 in6addr.s6_addr16[i] = s;
2122 #endif
2123         }
2124         return in6addr;
2125 }
2126 #endif
2127 #endif
2128
2129 #if defined(__APPLE__) || defined(__FreeBSD__)
2130
2131 static int
2132 get_local_interface_id (int family)
2133 {
2134 #if !defined(HAVE_GETIFADDRS) || !defined(HAVE_IF_NAMETOINDEX)
2135         return 0;
2136 #else
2137         struct ifaddrs *ifap = NULL, *ptr;
2138         int idx = 0;
2139
2140         if (getifaddrs (&ifap))
2141                 return 0;
2142
2143         for (ptr = ifap; ptr; ptr = ptr->ifa_next) {
2144                 if (!ptr->ifa_addr || !ptr->ifa_name)
2145                         continue;
2146                 if (ptr->ifa_addr->sa_family != family)
2147                         continue;
2148                 if ((ptr->ifa_flags & IFF_LOOPBACK) != 0)
2149                         continue;
2150                 if ((ptr->ifa_flags & IFF_MULTICAST) == 0)
2151                         continue;
2152
2153                 idx = if_nametoindex (ptr->ifa_name);
2154                 break;
2155         }
2156
2157         freeifaddrs (ifap);
2158         return idx;
2159 #endif
2160 }
2161
2162 #endif /* defined(__APPLE__) || defined(__FreeBSD__) */
2163
2164 void
2165 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)
2166 {
2167         struct linger linger;
2168         int system_level = 0;
2169         int system_name = 0;
2170         int ret;
2171         int sol_ip;
2172         int sol_ipv6;
2173
2174         *werror = 0;
2175
2176         sol_ipv6 = mono_networking_get_ipv6_protocol ();
2177         sol_ip = mono_networking_get_ip_protocol ();
2178
2179         ret = convert_sockopt_level_and_name ((MonoSocketOptionLevel)level, (MonoSocketOptionName)name, &system_level,
2180                                                                                   &system_name);
2181
2182 #if !defined(SO_EXCLUSIVEADDRUSE) && defined(SO_REUSEADDR)
2183         if (level == SocketOptionLevel_Socket && name == SocketOptionName_ExclusiveAddressUse) {
2184                 system_name = SO_REUSEADDR;
2185                 int_val = int_val ? 0 : 1;
2186                 ret = 0;
2187         }
2188 #endif
2189
2190         if (ret == -1) {
2191                 *werror = WSAENOPROTOOPT;
2192                 return;
2193         }
2194         if (ret == -2)
2195                 return;
2196
2197         /* Only one of obj_val, byte_val or int_val has data */
2198         if (obj_val) {
2199                 MonoClassField *field;
2200                 int valsize;
2201
2202                 switch (name) {
2203                 case SocketOptionName_Linger:
2204                         /* Dig out "bool enabled" and "int lingerTime"
2205                          * fields
2206                          */
2207                         field = mono_class_get_field_from_name (obj_val->vtable->klass, "enabled");
2208                         linger.l_onoff = *(guint8 *)(((char *)obj_val) + field->offset);
2209                         field = mono_class_get_field_from_name (obj_val->vtable->klass, "lingerTime");
2210                         linger.l_linger = *(guint32 *)(((char *)obj_val) + field->offset);
2211
2212                         valsize = sizeof (linger);
2213                         ret = mono_w32socket_setsockopt (sock, system_level, system_name, &linger, valsize);
2214                         break;
2215                 case SocketOptionName_AddMembership:
2216                 case SocketOptionName_DropMembership:
2217 #if defined(HAVE_STRUCT_IP_MREQN) || defined(HAVE_STRUCT_IP_MREQ)
2218                 {
2219                         MonoObject *address = NULL;
2220 #ifdef HAVE_STRUCT_SOCKADDR_IN6
2221                         if (system_level == sol_ipv6) {
2222                                 struct ipv6_mreq mreq6;
2223
2224                                 /*
2225                                  *      Get group address
2226                                  */
2227                                 field = mono_class_get_field_from_name (obj_val->vtable->klass, "m_Group");
2228                                 g_assert (field);
2229                                 address = *(MonoObject **)(((char *)obj_val) + field->offset);
2230
2231                                 if (address)
2232                                         mreq6.ipv6mr_multiaddr = ipaddress_to_struct_in6_addr (address);
2233
2234                                 field = mono_class_get_field_from_name (obj_val->vtable->klass, "m_Interface");
2235                                 mreq6.ipv6mr_interface = *(guint64 *)(((char *)obj_val) + field->offset);
2236
2237 #if defined(__APPLE__) || defined(__FreeBSD__)
2238                                 /*
2239                                 * Bug #5504:
2240                                 *
2241                                 * Mac OS Lion doesn't allow ipv6mr_interface = 0.
2242                                 *
2243                                 * Tests on Windows and Linux show that the multicast group is only
2244                                 * joined on one NIC when interface = 0, so we simply use the interface
2245                                 * id from the first non-loopback interface (this is also what
2246                                 * Dns.GetHostName (string.Empty) would return).
2247                                 */
2248                                 if (!mreq6.ipv6mr_interface)
2249                                         mreq6.ipv6mr_interface = get_local_interface_id (AF_INET6);
2250 #endif
2251
2252                                 ret = mono_w32socket_setsockopt (sock, system_level, system_name, &mreq6, sizeof (mreq6));
2253
2254                         } else
2255 #endif
2256                         if (system_level == sol_ip) {
2257 #ifdef HAVE_STRUCT_IP_MREQN
2258                                 struct ip_mreqn mreq = {{0}};
2259 #else
2260                                 struct ip_mreq mreq = {{0}};
2261 #endif /* HAVE_STRUCT_IP_MREQN */
2262
2263                                 /*
2264                                  * pain! MulticastOption holds two IPAddress
2265                                  * members, so I have to dig the value out of
2266                                  * those :-(
2267                                  */
2268                                 field = mono_class_get_field_from_name (obj_val->vtable->klass, "group");
2269                                 address = *(MonoObject **)(((char *)obj_val) + field->offset);
2270
2271                                 /* address might not be defined and if so, set the address to ADDR_ANY.
2272                                  */
2273                                 if (address)
2274                                         mreq.imr_multiaddr = ipaddress_to_struct_in_addr (address);
2275
2276                                 field = mono_class_get_field_from_name (obj_val->vtable->klass, "localAddress");
2277                                 address = *(MonoObject **)(((char *)obj_val) + field->offset);
2278
2279 #ifdef HAVE_STRUCT_IP_MREQN
2280                                 if (address)
2281                                         mreq.imr_address = ipaddress_to_struct_in_addr (address);
2282
2283                                 field = mono_class_get_field_from_name (obj_val->vtable->klass, "ifIndex");
2284                                 mreq.imr_ifindex = *(gint32 *)(((char *)obj_val) + field->offset);
2285 #else
2286                                 if (address)
2287                                         mreq.imr_interface = ipaddress_to_struct_in_addr (address);
2288 #endif /* HAVE_STRUCT_IP_MREQN */
2289
2290                                 ret = mono_w32socket_setsockopt (sock, system_level, system_name, &mreq, sizeof (mreq));
2291                         }
2292                         break;
2293                 }
2294 #endif /* HAVE_STRUCT_IP_MREQN || HAVE_STRUCT_IP_MREQ */
2295                 default:
2296                         /* Cause an exception to be thrown */
2297                         *werror = WSAEINVAL;
2298                         return;
2299                 }
2300         } else if (byte_val!=NULL) {
2301                 int valsize = mono_array_length (byte_val);
2302                 guchar *buf = mono_array_addr (byte_val, guchar, 0);
2303
2304                 switch(name) {
2305                 case SocketOptionName_DontLinger:
2306                         if (valsize == 1) {
2307                                 linger.l_onoff = (*buf) ? 0 : 1;
2308                                 linger.l_linger = 0;
2309                                 ret = mono_w32socket_setsockopt (sock, system_level, system_name, &linger, sizeof (linger));
2310                         } else {
2311                                 *werror = WSAEINVAL;
2312                         }
2313                         break;
2314                 default:
2315                         ret = mono_w32socket_setsockopt (sock, system_level, system_name, buf, valsize);
2316                         break;
2317                 }
2318         } else {
2319                 /* ReceiveTimeout/SendTimeout get here */
2320                 switch (name) {
2321                 case SocketOptionName_DontLinger:
2322                         linger.l_onoff = !int_val;
2323                         linger.l_linger = 0;
2324                         ret = mono_w32socket_setsockopt (sock, system_level, system_name, &linger, sizeof (linger));
2325                         break;
2326                 case SocketOptionName_MulticastInterface:
2327 #ifndef HOST_WIN32
2328 #ifdef HAVE_STRUCT_IP_MREQN
2329                         int_val = GUINT32_FROM_BE (int_val);
2330                         if ((int_val & 0xff000000) == 0) {
2331                                 /* int_val is interface index */
2332                                 struct ip_mreqn mreq = {{0}};
2333                                 mreq.imr_ifindex = int_val;
2334                                 ret = mono_w32socket_setsockopt (sock, system_level, system_name, (char *) &mreq, sizeof (mreq));
2335                                 break;
2336                         }
2337                         int_val = GUINT32_TO_BE (int_val);
2338 #endif /* HAVE_STRUCT_IP_MREQN */
2339 #endif /* HOST_WIN32 */
2340                         /* int_val is in_addr */
2341                         ret = mono_w32socket_setsockopt (sock, system_level, system_name, (char *) &int_val, sizeof (int_val));
2342                         break;
2343                 case SocketOptionName_DontFragment:
2344 #ifdef HAVE_IP_MTU_DISCOVER
2345                         /* Fiddle with the value slightly if we're
2346                          * turning DF on
2347                          */
2348                         if (int_val == 1)
2349                                 int_val = IP_PMTUDISC_DO;
2350                         /* Fall through */
2351 #endif
2352
2353                 default:
2354                         ret = mono_w32socket_setsockopt (sock, system_level, system_name, (char *) &int_val, sizeof (int_val));
2355                 }
2356         }
2357
2358         if (ret == SOCKET_ERROR)
2359                 *werror = mono_w32socket_get_last_error ();
2360 }
2361
2362 void
2363 ves_icall_System_Net_Sockets_Socket_Shutdown_internal (gsize sock, gint32 how, gint32 *werror)
2364 {
2365         int ret;
2366         gboolean interrupted;
2367
2368         *werror = 0;
2369
2370         mono_thread_info_install_interrupt (abort_syscall, (gpointer) (gsize) mono_native_thread_id_get (), &interrupted);
2371         if (interrupted) {
2372                 *werror = WSAEINTR;
2373                 return;
2374         }
2375
2376         MONO_ENTER_GC_SAFE;
2377
2378         /* Currently, the values for how (recv=0, send=1, both=2) match the BSD API */
2379         ret = mono_w32socket_shutdown (sock, how);
2380
2381         MONO_EXIT_GC_SAFE;
2382
2383         if (ret == SOCKET_ERROR)
2384                 *werror = mono_w32socket_get_last_error ();
2385
2386         mono_thread_info_uninstall_interrupt (&interrupted);
2387         if (interrupted) {
2388                 *werror = WSAEINTR;
2389         }
2390
2391 }
2392
2393 gint
2394 ves_icall_System_Net_Sockets_Socket_IOControl_internal (gsize sock, gint32 code, MonoArray *input, MonoArray *output, gint32 *werror)
2395 {
2396         glong output_bytes = 0;
2397         gchar *i_buffer, *o_buffer;
2398         gint i_len, o_len;
2399         gint ret;
2400
2401         *werror = 0;
2402
2403         if ((guint32)code == FIONBIO)
2404                 /* Invalid command. Must use Socket.Blocking */
2405                 return -1;
2406
2407         if (input == NULL) {
2408                 i_buffer = NULL;
2409                 i_len = 0;
2410         } else {
2411                 i_buffer = mono_array_addr (input, gchar, 0);
2412                 i_len = mono_array_length (input);
2413         }
2414
2415         if (output == NULL) {
2416                 o_buffer = NULL;
2417                 o_len = 0;
2418         } else {
2419                 o_buffer = mono_array_addr (output, gchar, 0);
2420                 o_len = mono_array_length (output);
2421         }
2422
2423         MONO_ENTER_GC_SAFE;
2424
2425         ret = mono_w32socket_ioctl (sock, code, i_buffer, i_len, o_buffer, o_len, &output_bytes);
2426
2427         MONO_EXIT_GC_SAFE;
2428
2429         if (ret == SOCKET_ERROR) {
2430                 *werror = mono_w32socket_get_last_error ();
2431                 return -1;
2432         }
2433
2434         return (gint)output_bytes;
2435 }
2436
2437 static gboolean
2438 addrinfo_to_IPHostEntry (MonoAddressInfo *info, MonoString **h_name, MonoArray **h_aliases, MonoArray **h_addr_list, gboolean add_local_ips, MonoError *error)
2439 {
2440         gint32 count, i;
2441         MonoAddressEntry *ai = NULL;
2442         struct in_addr *local_in = NULL;
2443         int nlocal_in = 0;
2444         struct in6_addr *local_in6 = NULL;
2445         int nlocal_in6 = 0;
2446         int addr_index;
2447         MonoDomain *domain = mono_domain_get ();
2448
2449         error_init (error);
2450         addr_index = 0;
2451         *h_aliases = mono_array_new_checked (domain, mono_get_string_class (), 0, error);
2452         return_val_if_nok (error, FALSE);
2453         if (add_local_ips) {
2454                 local_in = (struct in_addr *) mono_get_local_interfaces (AF_INET, &nlocal_in);
2455                 local_in6 = (struct in6_addr *) mono_get_local_interfaces (AF_INET6, &nlocal_in6);
2456                 if (nlocal_in || nlocal_in6) {
2457                         char addr [INET6_ADDRSTRLEN];
2458                         *h_addr_list = mono_array_new_checked (domain, mono_get_string_class (), nlocal_in + nlocal_in6, error);
2459                         if (!is_ok (error))
2460                                 goto leave;
2461
2462                         if (nlocal_in) {
2463                                 MonoString *addr_string;
2464                                 int i;
2465
2466                                 for (i = 0; i < nlocal_in; i++) {
2467                                         MonoAddress maddr;
2468                                         mono_address_init (&maddr, AF_INET, &local_in [i]);
2469                                         if (mono_networking_addr_to_str (&maddr, addr, sizeof (addr))) {
2470                                                 addr_string = mono_string_new (domain, addr);
2471                                                 mono_array_setref (*h_addr_list, addr_index, addr_string);
2472                                                 addr_index++;
2473                                         }
2474                                 }
2475                         }
2476 #ifdef HAVE_STRUCT_SOCKADDR_IN6
2477                         if (nlocal_in6) {
2478                                 MonoString *addr_string;
2479                                 int i;
2480
2481                                 for (i = 0; i < nlocal_in6; i++) {
2482                                         MonoAddress maddr;
2483                                         mono_address_init (&maddr, AF_INET6, &local_in6 [i]);
2484                                         if (mono_networking_addr_to_str (&maddr, addr, sizeof (addr))) {
2485                                                 addr_string = mono_string_new (domain, addr);
2486                                                 mono_array_setref (*h_addr_list, addr_index, addr_string);
2487                                                 addr_index++;
2488                                         }
2489                                 }
2490                         }
2491 #endif
2492                 leave:
2493                         g_free (local_in);
2494                         g_free (local_in6);
2495                         if (info)
2496                                 mono_free_address_info (info);
2497                         return is_ok (error);;
2498                 }
2499
2500                 g_free (local_in);
2501                 g_free (local_in6);
2502         }
2503
2504         for (count = 0, ai = info->entries; ai != NULL; ai = ai->next) {
2505                 if (ai->family != AF_INET && ai->family != AF_INET6)
2506                         continue;
2507                 count++;
2508         }
2509
2510         *h_addr_list = mono_array_new_checked (domain, mono_get_string_class (), count, error);
2511         if (!is_ok (error))
2512                 goto leave2;
2513
2514         for (ai = info->entries, i = 0; ai != NULL; ai = ai->next) {
2515                 MonoAddress maddr;
2516                 MonoString *addr_string;
2517                 char buffer [INET6_ADDRSTRLEN]; /* Max. size for IPv6 */
2518
2519                 if ((ai->family != PF_INET) && (ai->family != PF_INET6))
2520                         continue;
2521
2522                 mono_address_init (&maddr, ai->family, &ai->address);
2523                 if (mono_networking_addr_to_str (&maddr, buffer, sizeof (buffer)))
2524                         addr_string = mono_string_new (domain, buffer);
2525                 else
2526                         addr_string = mono_string_new (domain, "");
2527
2528                 mono_array_setref (*h_addr_list, addr_index, addr_string);
2529
2530                 if (!i) {
2531                         i++;
2532                         if (ai->canonical_name != NULL) {
2533                                 *h_name = mono_string_new (domain, ai->canonical_name);
2534                         } else {
2535                                 *h_name = mono_string_new (domain, buffer);
2536                         }
2537                 }
2538
2539                 addr_index++;
2540         }
2541
2542 leave2:
2543         if (info)
2544                 mono_free_address_info (info);
2545
2546         return is_ok (error);
2547 }
2548
2549 MonoBoolean
2550 ves_icall_System_Net_Dns_GetHostByName_internal (MonoString *host, MonoString **h_name, MonoArray **h_aliases, MonoArray **h_addr_list, gint32 hint)
2551 {
2552         MonoError error;
2553         gboolean add_local_ips = FALSE, add_info_ok = TRUE;
2554         gchar this_hostname [256];
2555         MonoAddressInfo *info = NULL;
2556
2557         char *hostname = mono_string_to_utf8_checked (host, &error);
2558         if (mono_error_set_pending_exception (&error))
2559                 return FALSE;
2560
2561         if (*hostname == '\0') {
2562                 add_local_ips = TRUE;
2563                 *h_name = host;
2564         }
2565
2566         if (!add_local_ips && gethostname (this_hostname, sizeof (this_hostname)) != -1) {
2567                 if (!strcmp (hostname, this_hostname)) {
2568                         add_local_ips = TRUE;
2569                         *h_name = host;
2570                 }
2571         }
2572
2573 #ifdef HOST_WIN32
2574         // Win32 APIs already returns local interface addresses for empty hostname ("")
2575         // so we never want to add them manually.
2576         add_local_ips = FALSE;
2577         if (mono_get_address_info(hostname, 0, MONO_HINT_CANONICAL_NAME | hint, &info))
2578                 add_info_ok = FALSE;
2579 #else
2580         if (*hostname && mono_get_address_info (hostname, 0, MONO_HINT_CANONICAL_NAME | hint, &info))
2581                 add_info_ok = FALSE;
2582 #endif
2583
2584         g_free(hostname);
2585
2586         if (add_info_ok) {
2587                 MonoBoolean result = addrinfo_to_IPHostEntry (info, h_name, h_aliases, h_addr_list, add_local_ips, &error);
2588                 mono_error_set_pending_exception (&error);
2589                 return result;
2590         }
2591         return FALSE;
2592 }
2593
2594 MonoBoolean
2595 ves_icall_System_Net_Dns_GetHostByAddr_internal (MonoString *addr, MonoString **h_name, MonoArray **h_aliases, MonoArray **h_addr_list, gint32 hint)
2596 {
2597         char *address;
2598         struct sockaddr_in saddr;
2599 #ifdef HAVE_STRUCT_SOCKADDR_IN6
2600         struct sockaddr_in6 saddr6;
2601 #endif
2602         MonoAddressInfo *info = NULL;
2603         MonoError error;
2604         gint32 family;
2605         gchar hostname [NI_MAXHOST] = { 0 };
2606         gboolean ret;
2607
2608         address = mono_string_to_utf8_checked (addr, &error);
2609         if (mono_error_set_pending_exception (&error))
2610                 return FALSE;
2611
2612         if (inet_pton (AF_INET, address, &saddr.sin_addr ) == 1) {
2613                 family = AF_INET;
2614                 saddr.sin_family = AF_INET;
2615 #ifdef HAVE_STRUCT_SOCKADDR_IN6
2616         } else if (inet_pton (AF_INET6, address, &saddr6.sin6_addr) == 1) {
2617                 family = AF_INET6;
2618                 saddr6.sin6_family = AF_INET6;
2619 #endif
2620         } else {
2621                 g_free (address);
2622                 return FALSE;
2623         }
2624
2625         g_free (address);
2626
2627         MONO_ENTER_GC_SAFE;
2628
2629         switch (family) {
2630         case AF_INET: {
2631 #if HAVE_SOCKADDR_IN_SIN_LEN
2632                 saddr.sin_len = sizeof (saddr);
2633 #endif
2634                 ret = getnameinfo ((struct sockaddr*)&saddr, sizeof (saddr), hostname, sizeof (hostname), NULL, 0, 0) == 0;
2635                 break;
2636         }
2637 #ifdef HAVE_STRUCT_SOCKADDR_IN6
2638         case AF_INET6: {
2639 #if HAVE_SOCKADDR_IN6_SIN_LEN
2640                 saddr6.sin6_len = sizeof (saddr6);
2641 #endif
2642                 ret = getnameinfo ((struct sockaddr*)&saddr6, sizeof (saddr6), hostname, sizeof (hostname), NULL, 0, 0) == 0;
2643                 break;
2644         }
2645 #endif
2646         default:
2647                 g_assert_not_reached ();
2648         }
2649
2650         MONO_EXIT_GC_SAFE;
2651
2652         if (!ret)
2653                 return FALSE;
2654
2655         if (mono_get_address_info (hostname, 0, hint | MONO_HINT_CANONICAL_NAME | MONO_HINT_CONFIGURED_ONLY, &info) != 0)
2656                 return FALSE;
2657
2658         MonoBoolean result = addrinfo_to_IPHostEntry (info, h_name, h_aliases, h_addr_list, FALSE, &error);
2659         mono_error_set_pending_exception (&error);
2660         return result;
2661 }
2662
2663 MonoBoolean
2664 ves_icall_System_Net_Dns_GetHostName_internal (MonoString **h_name)
2665 {
2666         gchar hostname [NI_MAXHOST] = { 0 };
2667         int ret;
2668
2669         ret = gethostname (hostname, sizeof (hostname));
2670         if (ret == -1)
2671                 return FALSE;
2672
2673         *h_name = mono_string_new (mono_domain_get (), hostname);
2674
2675         return TRUE;
2676 }
2677
2678 #if G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT | HAVE_UWP_WINAPI_SUPPORT)
2679 gboolean
2680 ves_icall_System_Net_Sockets_Socket_SendFile_internal (gsize sock, MonoString *filename, MonoArray *pre_buffer, MonoArray *post_buffer, gint flags, gint32 *werror, gboolean blocking)
2681 {
2682         HANDLE file;
2683         gboolean ret;
2684         gboolean interrupted;
2685         TRANSMIT_FILE_BUFFERS buffers;
2686
2687         *werror = 0;
2688
2689         if (filename == NULL)
2690                 return FALSE;
2691
2692         /* FIXME: replace file by a proper fd that we can call open and close on, as they are interruptible */
2693
2694         file = mono_w32file_create (mono_string_chars (filename), GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, 0);
2695         if (file == INVALID_HANDLE_VALUE) {
2696                 *werror = mono_w32error_get_last ();
2697                 return FALSE;
2698         }
2699
2700         memset (&buffers, 0, sizeof (buffers));
2701         if (pre_buffer != NULL) {
2702                 buffers.Head = mono_array_addr (pre_buffer, guchar, 0);
2703                 buffers.HeadLength = mono_array_length (pre_buffer);
2704         }
2705         if (post_buffer != NULL) {
2706                 buffers.Tail = mono_array_addr (post_buffer, guchar, 0);
2707                 buffers.TailLength = mono_array_length (post_buffer);
2708         }
2709
2710         mono_thread_info_install_interrupt (abort_syscall, (gpointer) (gsize) mono_native_thread_id_get (), &interrupted);
2711         if (interrupted) {
2712                 mono_w32file_close (file);
2713                 mono_w32error_set_last (WSAEINTR);
2714                 return FALSE;
2715         }
2716
2717         MONO_ENTER_GC_SAFE;
2718         ret = mono_w32socket_transmit_file (sock, file, &buffers, flags, blocking);
2719         MONO_EXIT_GC_SAFE;
2720
2721         if (!ret)
2722                 *werror = mono_w32socket_get_last_error ();
2723
2724         mono_thread_info_uninstall_interrupt (&interrupted);
2725         if (interrupted) {
2726                 mono_w32file_close (file);
2727                 *werror = WSAEINTR;
2728                 return FALSE;
2729         }
2730
2731         mono_w32file_close (file);
2732
2733         if (*werror)
2734                 return FALSE;
2735
2736         return ret;
2737 }
2738 #endif /* G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT | HAVE_UWP_WINAPI_SUPPORT) */
2739
2740 void
2741 mono_network_init (void)
2742 {
2743         mono_networking_init ();
2744         mono_w32socket_initialize ();
2745 }
2746
2747 void
2748 mono_network_cleanup (void)
2749 {
2750         mono_w32socket_cleanup ();
2751         mono_networking_shutdown ();
2752 }
2753
2754 void
2755 icall_cancel_blocking_socket_operation (MonoThread *thread)
2756 {
2757         MonoInternalThread *internal;
2758
2759         internal = thread->internal_thread;
2760         g_assert (internal);
2761
2762         mono_thread_info_abort_socket_syscall_for_close (MONO_UINT_TO_NATIVE_THREAD_ID (internal->tid));
2763 }
2764
2765 #endif /* #ifndef DISABLE_SOCKETS */