mono/metadata/socket-io.c

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