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