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