2 * Server-side socket management
4 * Copyright (C) 1999 Marcus Meissner, Ove Kåven
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 * FIXME: we use read|write access in all cases. Shouldn't we depend that
21 * on the access of the current handle?
39 #ifdef HAVE_NETINET_IN_H
40 # include <netinet/in.h>
42 #ifdef HAVE_NETINET_TCP_H
43 # include <netinet/tcp.h>
47 #include <sys/types.h>
48 #include <sys/socket.h>
49 #include <sys/ioctl.h>
50 #ifdef HAVE_SYS_FILIO_H
51 # include <sys/filio.h>
56 #ifdef HAVE_LINUX_FILTER_H
57 # include <linux/filter.h>
59 #ifdef HAVE_LINUX_RTNETLINK_H
60 # include <linux/rtnetlink.h>
63 #ifdef HAVE_NETIPX_IPX_H
64 # include <netipx/ipx.h>
66 #elif defined(HAVE_LINUX_IPX_H)
67 # ifdef HAVE_ASM_TYPES_H
68 # include <asm/types.h>
70 # ifdef HAVE_LINUX_TYPES_H
71 # include <linux/types.h>
73 # include <linux/ipx.h>
79 #ifdef HAVE_LINUX_IRDA_H
80 # ifdef HAVE_LINUX_TYPES_H
81 # include <linux/types.h>
83 # include <linux/irda.h>
88 #define WIN32_NO_STATUS
98 #include "wine/rbtree.h"
107 #if defined(linux) && !defined(IP_UNICAST_IF)
108 #define IP_UNICAST_IF 50
111 static const char magic_loopback_addr
[] = {127, 12, 34, 56};
115 struct WS_sockaddr addr
;
116 struct WS_sockaddr_in in
;
117 struct WS_sockaddr_in6 in6
;
118 struct WS_sockaddr_ipx ipx
;
124 struct sockaddr addr
;
125 struct sockaddr_in in
;
126 struct sockaddr_in6 in6
;
128 struct sockaddr_ipx ipx
;
131 struct sockaddr_irda irda
;
135 static struct list poll_list
= LIST_INIT( poll_list
);
142 struct timeout_user
*timeout
;
143 timeout_t orig_timeout
;
162 struct sock
*sock
, *acceptsock
;
164 unsigned int recv_len
, local_len
;
172 unsigned int addr_len
, send_len
, send_cursor
;
181 enum connection_state
192 struct rb_entry entry
;
193 union unix_sockaddr addr
;
198 #define MAX_ICMP_HISTORY_LENGTH 8
200 #define MIN_RCVBUF 65536
204 struct object obj
; /* object header */
205 struct fd
*fd
; /* socket file descriptor */
206 enum connection_state state
; /* connection state */
207 unsigned int mask
; /* event mask */
208 /* pending AFD_POLL_* events which have not yet been reported to the application */
209 unsigned int pending_events
;
210 /* AFD_POLL_* events which have already been reported and should not be
211 * selected for again until reset by a relevant call.
213 * For example, if AFD_POLL_READ is set here and not in pending_events, it
214 * has already been reported and consumed, and we should not report it
215 * again, even if POLLIN is signaled, until it is reset by e.g recv().
217 * If an event has been signaled and not consumed yet, it will be set in
218 * both pending_events and reported_events (as we should only ever report
219 * any event once until it is reset.) */
220 unsigned int reported_events
;
221 unsigned short proto
; /* socket protocol */
222 unsigned short type
; /* socket type */
223 unsigned short family
; /* socket family */
224 struct event
*event
; /* event object */
225 user_handle_t window
; /* window to send the message to */
226 unsigned int message
; /* message to send */
227 obj_handle_t wparam
; /* message wparam (socket handle) */
228 int errors
[AFD_POLL_BIT_COUNT
]; /* event errors */
229 timeout_t connect_time
;/* time the socket was connected */
230 struct sock
*deferred
; /* socket that waits for a deferred accept */
231 struct async_queue read_q
; /* queue for asynchronous reads */
232 struct async_queue write_q
; /* queue for asynchronous writes */
233 struct async_queue ifchange_q
; /* queue for interface change notifications */
234 struct async_queue accept_q
; /* queue for asynchronous accepts */
235 struct async_queue connect_q
; /* queue for asynchronous connects */
236 struct async_queue poll_q
; /* queue for asynchronous polls */
237 struct object
*ifchange_obj
; /* the interface change notification object */
238 struct list ifchange_entry
; /* entry in ifchange notification list */
239 struct list accept_list
; /* list of pending accept requests */
240 struct accept_req
*accept_recv_req
; /* pending accept-into request which will recv on this socket */
241 struct connect_req
*connect_req
; /* pending connection request */
242 struct poll_req
*main_poll
; /* main poll */
243 union win_sockaddr addr
; /* socket name */
244 int addr_len
; /* socket name length */
245 union win_sockaddr peer_addr
; /* peer name */
246 int peer_addr_len
; /* peer name length */
247 unsigned int rcvbuf
; /* advisory recv buffer size */
248 unsigned int sndbuf
; /* advisory send buffer size */
249 unsigned int rcvtimeo
; /* receive timeout in ms */
250 unsigned int sndtimeo
; /* send timeout in ms */
253 unsigned short icmp_id
;
254 unsigned short icmp_seq
;
256 icmp_fixup_data
[MAX_ICMP_HISTORY_LENGTH
]; /* Sent ICMP packets history used to fixup reply id. */
257 struct bound_addr
*bound_addr
[2]; /* Links to the entries in bound addresses tree. */
258 unsigned int icmp_fixup_data_len
; /* Sent ICMP packets history length. */
259 unsigned int rd_shutdown
: 1; /* is the read end shut down? */
260 unsigned int wr_shutdown
: 1; /* is the write end shut down? */
261 unsigned int wr_shutdown_pending
: 1; /* is a write shutdown pending? */
262 unsigned int hangup
: 1; /* has the read end received a hangup? */
263 unsigned int aborted
: 1; /* did we get a POLLERR or irregular POLLHUP? */
264 unsigned int nonblocking
: 1; /* is the socket nonblocking? */
265 unsigned int bound
: 1; /* is the socket bound? */
266 unsigned int reset
: 1; /* did we get a TCP reset? */
267 unsigned int reuseaddr
: 1; /* winsock SO_REUSEADDR option value */
268 unsigned int exclusiveaddruse
: 1; /* winsock SO_EXCLUSIVEADDRUSE option value */
271 static int is_tcp_socket( struct sock
*sock
)
273 return sock
->type
== WS_SOCK_STREAM
&& (sock
->family
== WS_AF_INET
|| sock
->family
== WS_AF_INET6
);
276 static int addr_compare( const void *key
, const struct wine_rb_entry
*entry
)
278 const struct bound_addr
*bound_addr
= RB_ENTRY_VALUE(entry
, struct bound_addr
, entry
);
279 const struct bound_addr
*addr
= key
;
281 if (addr
->addr
.addr
.sa_family
!= bound_addr
->addr
.addr
.sa_family
)
282 return addr
->addr
.addr
.sa_family
< bound_addr
->addr
.addr
.sa_family
? -1 : 1;
284 if (addr
->addr
.addr
.sa_family
== AF_INET
)
286 if (addr
->addr
.in
.sin_port
!= bound_addr
->addr
.in
.sin_port
)
287 return addr
->addr
.in
.sin_port
< bound_addr
->addr
.in
.sin_port
? -1 : 1;
288 if (bound_addr
->match_any_addr
|| addr
->match_any_addr
289 || addr
->addr
.in
.sin_addr
.s_addr
== bound_addr
->addr
.in
.sin_addr
.s_addr
)
291 return addr
->addr
.in
.sin_addr
.s_addr
< bound_addr
->addr
.in
.sin_addr
.s_addr
? -1 : 1;
294 assert( addr
->addr
.addr
.sa_family
== AF_INET6
);
295 if (addr
->addr
.in6
.sin6_port
!= bound_addr
->addr
.in6
.sin6_port
)
296 return addr
->addr
.in6
.sin6_port
< bound_addr
->addr
.in6
.sin6_port
? -1 : 1;
297 if (bound_addr
->match_any_addr
|| addr
->match_any_addr
) return 0;
298 return memcmp( &addr
->addr
.in6
.sin6_addr
, &bound_addr
->addr
.in6
.sin6_addr
, sizeof(addr
->addr
.in6
.sin6_addr
) );
301 static int ipv4addr_from_v6( union unix_sockaddr
*v4addr
, const struct sockaddr_in6
*in6
, int map_unspecified
)
303 v4addr
->in
.sin_family
= AF_INET
;
304 v4addr
->in
.sin_port
= in6
->sin6_port
;
306 if (map_unspecified
&& IN6_IS_ADDR_UNSPECIFIED(&in6
->sin6_addr
))
308 v4addr
->in
.sin_addr
.s_addr
= htonl( INADDR_ANY
);
311 if (IN6_IS_ADDR_V4COMPAT(&in6
->sin6_addr
) || IN6_IS_ADDR_V4MAPPED(&in6
->sin6_addr
))
313 memcpy( &v4addr
->in
.sin_addr
.s_addr
, &in6
->sin6_addr
.s6_addr
[12], sizeof(v4addr
->in
.sin_addr
.s_addr
) );
319 static struct rb_tree bound_addresses_tree
= { addr_compare
};
321 static int should_track_conflicts_for_addr( struct sock
*sock
, const union unix_sockaddr
*addr
)
323 if (!is_tcp_socket( sock
)) return 0;
325 if (sock
->family
== WS_AF_INET
&& addr
->addr
.sa_family
== AF_INET
&& addr
->in
.sin_port
)
327 else if (sock
->family
== WS_AF_INET6
&& addr
->addr
.sa_family
== AF_INET6
&& addr
->in6
.sin6_port
)
333 static int is_any_addr( const union unix_sockaddr
*addr
)
335 if (addr
->addr
.sa_family
== AF_INET
&& addr
->in
.sin_addr
.s_addr
== htonl( INADDR_ANY
))
337 if (addr
->addr
.sa_family
== AF_INET6
&& IN6_IS_ADDR_UNSPECIFIED(&addr
->in6
.sin6_addr
))
342 static int check_addr_usage( struct sock
*sock
, const union unix_sockaddr
*addr
, int v6only
)
344 struct bound_addr
*bound_addr
, search_addr
;
345 struct rb_entry
*entry
;
347 if (!should_track_conflicts_for_addr( sock
, addr
)) return 0;
349 search_addr
.addr
= *addr
;
350 search_addr
.match_any_addr
= sock
->exclusiveaddruse
&& is_any_addr( addr
);
352 if ((entry
= rb_get( &bound_addresses_tree
, &search_addr
)))
354 bound_addr
= WINE_RB_ENTRY_VALUE(entry
, struct bound_addr
, entry
);
355 if (bound_addr
->reuse_count
== -1 || !sock
->reuseaddr
)
357 set_error( sock
->reuseaddr
|| bound_addr
->match_any_addr
358 ? STATUS_ACCESS_DENIED
: STATUS_SHARING_VIOLATION
);
363 if (sock
->family
!= WS_AF_INET6
|| v6only
) return 0;
364 if (!ipv4addr_from_v6( &search_addr
.addr
, &addr
->in6
, sock
->exclusiveaddruse
)) return 0;
366 search_addr
.match_any_addr
= sock
->exclusiveaddruse
&& is_any_addr( &search_addr
.addr
);
367 if ((entry
= rb_get( &bound_addresses_tree
, &search_addr
)))
369 bound_addr
= WINE_RB_ENTRY_VALUE(entry
, struct bound_addr
, entry
);
370 if (bound_addr
->reuse_count
== -1 || !sock
->reuseaddr
)
372 set_error( sock
->reuseaddr
|| bound_addr
->match_any_addr
373 ? STATUS_ACCESS_DENIED
: STATUS_SHARING_VIOLATION
);
380 static struct bound_addr
*register_bound_address( struct sock
*sock
, const union unix_sockaddr
*addr
)
382 struct bound_addr
*bound_addr
, *temp
;
384 if (!(bound_addr
= mem_alloc( sizeof(*bound_addr
) )))
387 bound_addr
->addr
= *addr
;
388 bound_addr
->match_any_addr
= sock
->exclusiveaddruse
&& is_any_addr( addr
);
390 if (rb_put( &bound_addresses_tree
, bound_addr
, &bound_addr
->entry
))
393 bound_addr
= WINE_RB_ENTRY_VALUE(rb_get( &bound_addresses_tree
, temp
), struct bound_addr
, entry
);
395 if (bound_addr
->reuse_count
== -1)
398 fprintf( stderr
, "register_bound_address: address being updated is already exclusively bound\n" );
401 ++bound_addr
->reuse_count
;
405 bound_addr
->reuse_count
= sock
->reuseaddr
? 1 : -1;
410 static void update_addr_usage( struct sock
*sock
, const union unix_sockaddr
*addr
, int v6only
)
412 union unix_sockaddr v4addr
;
414 assert( !sock
->bound_addr
[0] && !sock
->bound_addr
[1] );
416 if (!should_track_conflicts_for_addr( sock
, addr
)) return;
418 sock
->bound_addr
[0] = register_bound_address( sock
, addr
);
420 if (sock
->family
!= WS_AF_INET6
|| v6only
) return;
422 if (!ipv4addr_from_v6( &v4addr
, &addr
->in6
, sock
->exclusiveaddruse
)) return;
424 sock
->bound_addr
[1] = register_bound_address( sock
, &v4addr
);
427 static void sock_dump( struct object
*obj
, int verbose
);
428 static struct fd
*sock_get_fd( struct object
*obj
);
429 static int sock_close_handle( struct object
*obj
, struct process
*process
, obj_handle_t handle
);
430 static void sock_destroy( struct object
*obj
);
431 static struct object
*sock_get_ifchange( struct sock
*sock
);
432 static void sock_release_ifchange( struct sock
*sock
);
434 static int sock_get_poll_events( struct fd
*fd
);
435 static void sock_poll_event( struct fd
*fd
, int event
);
436 static enum server_fd_type
sock_get_fd_type( struct fd
*fd
);
437 static void sock_ioctl( struct fd
*fd
, ioctl_code_t code
, struct async
*async
);
438 static void sock_cancel_async( struct fd
*fd
, struct async
*async
);
439 static void sock_reselect_async( struct fd
*fd
, struct async_queue
*queue
);
441 static int accept_into_socket( struct sock
*sock
, struct sock
*acceptsock
);
442 static struct sock
*accept_socket( struct sock
*sock
);
443 static int sock_get_ntstatus( int err
);
444 static unsigned int sock_get_error( int err
);
445 static void poll_socket( struct sock
*poll_sock
, struct async
*async
, int exclusive
, timeout_t timeout
,
446 unsigned int count
, const struct afd_poll_socket_64
*sockets
);
448 static const struct object_ops sock_ops
=
450 sizeof(struct sock
), /* size */
451 &file_type
, /* type */
452 sock_dump
, /* dump */
453 add_queue
, /* add_queue */
454 remove_queue
, /* remove_queue */
455 default_fd_signaled
, /* signaled */
456 no_satisfied
, /* satisfied */
457 no_signal
, /* signal */
458 sock_get_fd
, /* get_fd */
459 default_map_access
, /* map_access */
460 default_get_sd
, /* get_sd */
461 default_set_sd
, /* set_sd */
462 no_get_full_name
, /* get_full_name */
463 no_lookup_name
, /* lookup_name */
464 no_link_name
, /* link_name */
465 NULL
, /* unlink_name */
466 no_open_file
, /* open_file */
467 no_kernel_obj_list
, /* get_kernel_obj_list */
468 sock_close_handle
, /* close_handle */
469 sock_destroy
/* destroy */
472 static const struct fd_ops sock_fd_ops
=
474 sock_get_poll_events
, /* get_poll_events */
475 sock_poll_event
, /* poll_event */
476 sock_get_fd_type
, /* get_fd_type */
477 no_fd_read
, /* read */
478 no_fd_write
, /* write */
479 no_fd_flush
, /* flush */
480 default_fd_get_file_info
, /* get_file_info */
481 no_fd_get_volume_info
, /* get_volume_info */
482 sock_ioctl
, /* ioctl */
483 sock_cancel_async
, /* cancel_async */
484 no_fd_queue_async
, /* queue_async */
485 sock_reselect_async
/* reselect_async */
488 static int sockaddr_from_unix( const union unix_sockaddr
*uaddr
, struct WS_sockaddr
*wsaddr
, socklen_t wsaddrlen
)
490 memset( wsaddr
, 0, wsaddrlen
);
492 switch (uaddr
->addr
.sa_family
)
496 struct WS_sockaddr_in win
= {0};
498 if (wsaddrlen
< sizeof(win
)) return -1;
499 win
.sin_family
= WS_AF_INET
;
500 win
.sin_port
= uaddr
->in
.sin_port
;
501 memcpy( &win
.sin_addr
, &uaddr
->in
.sin_addr
, sizeof(win
.sin_addr
) );
502 memcpy( wsaddr
, &win
, sizeof(win
) );
508 struct WS_sockaddr_in6 win
= {0};
510 if (wsaddrlen
< sizeof(win
)) return -1;
511 win
.sin6_family
= WS_AF_INET6
;
512 win
.sin6_port
= uaddr
->in6
.sin6_port
;
513 win
.sin6_flowinfo
= uaddr
->in6
.sin6_flowinfo
;
514 memcpy( &win
.sin6_addr
, &uaddr
->in6
.sin6_addr
, sizeof(win
.sin6_addr
) );
515 #ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID
516 win
.sin6_scope_id
= uaddr
->in6
.sin6_scope_id
;
518 memcpy( wsaddr
, &win
, sizeof(win
) );
525 struct WS_sockaddr_ipx win
= {0};
527 if (wsaddrlen
< sizeof(win
)) return -1;
528 win
.sa_family
= WS_AF_IPX
;
529 memcpy( win
.sa_netnum
, &uaddr
->ipx
.sipx_network
, sizeof(win
.sa_netnum
) );
530 memcpy( win
.sa_nodenum
, &uaddr
->ipx
.sipx_node
, sizeof(win
.sa_nodenum
) );
531 win
.sa_socket
= uaddr
->ipx
.sipx_port
;
532 memcpy( wsaddr
, &win
, sizeof(win
) );
542 if (wsaddrlen
< sizeof(win
)) return -1;
543 win
.irdaAddressFamily
= WS_AF_IRDA
;
544 memcpy( win
.irdaDeviceID
, &uaddr
->irda
.sir_addr
, sizeof(win
.irdaDeviceID
) );
545 if (uaddr
->irda
.sir_lsap_sel
!= LSAP_ANY
)
546 snprintf( win
.irdaServiceName
, sizeof(win
.irdaServiceName
), "LSAP-SEL%u", uaddr
->irda
.sir_lsap_sel
);
548 memcpy( win
.irdaServiceName
, uaddr
->irda
.sir_name
, sizeof(win
.irdaServiceName
) );
549 memcpy( wsaddr
, &win
, sizeof(win
) );
563 static socklen_t
sockaddr_to_unix( const struct WS_sockaddr
*wsaddr
, int wsaddrlen
, union unix_sockaddr
*uaddr
)
565 memset( uaddr
, 0, sizeof(*uaddr
) );
567 switch (wsaddr
->sa_family
)
571 struct WS_sockaddr_in win
= {0};
573 if (wsaddrlen
< sizeof(win
)) return 0;
574 memcpy( &win
, wsaddr
, sizeof(win
) );
575 uaddr
->in
.sin_family
= AF_INET
;
576 uaddr
->in
.sin_port
= win
.sin_port
;
577 memcpy( &uaddr
->in
.sin_addr
, &win
.sin_addr
, sizeof(win
.sin_addr
) );
578 return sizeof(uaddr
->in
);
583 struct WS_sockaddr_in6 win
= {0};
585 if (wsaddrlen
< sizeof(win
)) return 0;
586 memcpy( &win
, wsaddr
, sizeof(win
) );
587 uaddr
->in6
.sin6_family
= AF_INET6
;
588 uaddr
->in6
.sin6_port
= win
.sin6_port
;
589 uaddr
->in6
.sin6_flowinfo
= win
.sin6_flowinfo
;
590 memcpy( &uaddr
->in6
.sin6_addr
, &win
.sin6_addr
, sizeof(win
.sin6_addr
) );
591 #ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID
592 uaddr
->in6
.sin6_scope_id
= win
.sin6_scope_id
;
594 return sizeof(uaddr
->in6
);
600 struct WS_sockaddr_ipx win
= {0};
602 if (wsaddrlen
< sizeof(win
)) return 0;
603 memcpy( &win
, wsaddr
, sizeof(win
) );
604 uaddr
->ipx
.sipx_family
= AF_IPX
;
605 memcpy( &uaddr
->ipx
.sipx_network
, win
.sa_netnum
, sizeof(win
.sa_netnum
) );
606 memcpy( &uaddr
->ipx
.sipx_node
, win
.sa_nodenum
, sizeof(win
.sa_nodenum
) );
607 uaddr
->ipx
.sipx_port
= win
.sa_socket
;
608 return sizeof(uaddr
->ipx
);
615 SOCKADDR_IRDA win
= {0};
616 unsigned int lsap_sel
;
618 if (wsaddrlen
< sizeof(win
)) return 0;
619 memcpy( &win
, wsaddr
, sizeof(win
) );
620 uaddr
->irda
.sir_family
= AF_IRDA
;
621 if (sscanf( win
.irdaServiceName
, "LSAP-SEL%u", &lsap_sel
) == 1)
622 uaddr
->irda
.sir_lsap_sel
= lsap_sel
;
625 uaddr
->irda
.sir_lsap_sel
= LSAP_ANY
;
626 memcpy( uaddr
->irda
.sir_name
, win
.irdaServiceName
, sizeof(win
.irdaServiceName
) );
628 memcpy( &uaddr
->irda
.sir_addr
, win
.irdaDeviceID
, sizeof(win
.irdaDeviceID
) );
629 return sizeof(uaddr
->irda
);
636 default: /* likely an ipv4 address */
637 case sizeof(struct WS_sockaddr_in
):
638 return sizeof(uaddr
->in
);
641 case sizeof(struct WS_sockaddr_ipx
):
642 return sizeof(uaddr
->ipx
);
646 case sizeof(SOCKADDR_IRDA
):
647 return sizeof(uaddr
->irda
);
650 case sizeof(struct WS_sockaddr_in6
):
651 return sizeof(uaddr
->in6
);
659 static socklen_t
get_unix_sockaddr_any( union unix_sockaddr
*uaddr
, int ws_family
)
661 memset( uaddr
, 0, sizeof(*uaddr
) );
665 uaddr
->in
.sin_family
= AF_INET
;
666 return sizeof(uaddr
->in
);
668 uaddr
->in6
.sin6_family
= AF_INET6
;
669 return sizeof(uaddr
->in6
);
672 uaddr
->ipx
.sipx_family
= AF_IPX
;
673 return sizeof(uaddr
->ipx
);
677 uaddr
->irda
.sir_family
= AF_IRDA
;
678 return sizeof(uaddr
->irda
);
685 /* some events are generated at the same time but must be sent in a particular
686 * order (e.g. CONNECT must be sent before READ) */
687 static const enum afd_poll_bit event_bitorder
[] =
689 AFD_POLL_BIT_CONNECT
,
690 AFD_POLL_BIT_CONNECT_ERR
,
701 SOCK_SHUTDOWN_ERROR
= -1,
702 SOCK_SHUTDOWN_EOF
= 0,
703 SOCK_SHUTDOWN_POLLHUP
= 1
706 static sock_shutdown_t sock_shutdown_type
= SOCK_SHUTDOWN_ERROR
;
708 static sock_shutdown_t
sock_check_pollhup(void)
710 sock_shutdown_t ret
= SOCK_SHUTDOWN_ERROR
;
715 if ( socketpair( AF_UNIX
, SOCK_STREAM
, 0, fd
) ) return ret
;
716 if ( shutdown( fd
[0], 1 ) ) goto out
;
722 /* Solaris' poll() sometimes returns nothing if given a 0ms timeout here */
723 n
= poll( &pfd
, 1, 1 );
724 if ( n
!= 1 ) goto out
; /* error or timeout */
725 if ( pfd
.revents
& POLLHUP
)
726 ret
= SOCK_SHUTDOWN_POLLHUP
;
727 else if ( pfd
.revents
& POLLIN
&&
728 read( fd
[1], &dummy
, 1 ) == 0 )
729 ret
= SOCK_SHUTDOWN_EOF
;
739 sock_shutdown_type
= sock_check_pollhup();
741 switch ( sock_shutdown_type
)
743 case SOCK_SHUTDOWN_EOF
:
744 if (debug_level
) fprintf( stderr
, "sock_init: shutdown() causes EOF\n" );
746 case SOCK_SHUTDOWN_POLLHUP
:
747 if (debug_level
) fprintf( stderr
, "sock_init: shutdown() causes POLLHUP\n" );
750 fprintf( stderr
, "sock_init: ERROR in sock_check_pollhup()\n" );
751 sock_shutdown_type
= SOCK_SHUTDOWN_EOF
;
755 static void sock_reselect( struct sock
*sock
)
757 int ev
= sock_get_poll_events( sock
->fd
);
760 fprintf(stderr
,"sock_reselect(%p): new mask %x\n", sock
, ev
);
762 set_fd_events( sock
->fd
, ev
);
765 static unsigned int afd_poll_flag_to_win32( unsigned int flags
)
767 static const unsigned int map
[] =
771 FD_WRITE
, /* WRITE */
773 FD_CLOSE
, /* RESET */
775 FD_CONNECT
, /* CONNECT */
776 FD_ACCEPT
, /* ACCEPT */
777 FD_CONNECT
, /* CONNECT_ERR */
780 unsigned int i
, ret
= 0;
782 for (i
= 0; i
< ARRAY_SIZE(map
); ++i
)
784 if (flags
& (1 << i
)) ret
|= map
[i
];
790 /* wake anybody waiting on the socket event or send the associated message */
791 static void sock_wake_up( struct sock
*sock
)
793 unsigned int events
= sock
->pending_events
& sock
->mask
;
798 if (debug_level
) fprintf(stderr
, "signalling events %x ptr %p\n", events
, sock
->event
);
800 set_event( sock
->event
);
804 if (debug_level
) fprintf(stderr
, "signalling events %x win %08x\n", events
, sock
->window
);
805 for (i
= 0; i
< ARRAY_SIZE(event_bitorder
); i
++)
807 enum afd_poll_bit event
= event_bitorder
[i
];
808 if (events
& (1 << event
))
810 lparam_t lparam
= afd_poll_flag_to_win32(1 << event
) | (sock_get_error( sock
->errors
[event
] ) << 16);
811 post_message( sock
->window
, sock
->message
, sock
->wparam
, lparam
);
814 sock
->pending_events
= 0;
815 sock_reselect( sock
);
819 static inline int sock_error( struct sock
*sock
)
822 socklen_t len
= sizeof(error
);
824 getsockopt( get_unix_fd(sock
->fd
), SOL_SOCKET
, SO_ERROR
, (void *)&error
, &len
);
828 case SOCK_UNCONNECTED
:
831 case SOCK_CONNECTING
:
833 sock
->errors
[AFD_POLL_BIT_CONNECT_ERR
] = error
;
835 error
= sock
->errors
[AFD_POLL_BIT_CONNECT_ERR
];
840 sock
->errors
[AFD_POLL_BIT_ACCEPT
] = error
;
842 error
= sock
->errors
[AFD_POLL_BIT_ACCEPT
];
846 case SOCK_CONNECTIONLESS
:
847 if (error
== ECONNRESET
|| error
== EPIPE
)
853 sock
->errors
[AFD_POLL_BIT_HUP
] = error
;
855 error
= sock
->errors
[AFD_POLL_BIT_HUP
];
862 static void free_accept_req( void *private )
864 struct accept_req
*req
= private;
865 list_remove( &req
->entry
);
868 req
->acceptsock
->accept_recv_req
= NULL
;
869 release_object( req
->acceptsock
);
871 release_object( req
->async
);
872 release_object( req
->iosb
);
873 release_object( req
->sock
);
877 static void fill_accept_output( struct accept_req
*req
)
879 const data_size_t out_size
= req
->iosb
->out_size
;
880 struct async
*async
= req
->async
;
881 union unix_sockaddr unix_addr
;
882 struct WS_sockaddr
*win_addr
;
883 unsigned int remote_len
;
889 if (!(out_data
= mem_alloc( out_size
)))
891 async_terminate( async
, get_error() );
895 fd
= get_unix_fd( req
->acceptsock
->fd
);
897 if (req
->recv_len
&& (size
= recv( fd
, out_data
, req
->recv_len
, 0 )) < 0)
899 if (!req
->accepted
&& errno
== EWOULDBLOCK
)
902 sock_reselect( req
->acceptsock
);
906 async_terminate( async
, sock_get_ntstatus( errno
) );
913 if (req
->local_len
< sizeof(int))
915 async_terminate( async
, STATUS_BUFFER_TOO_SMALL
);
920 unix_len
= sizeof(unix_addr
);
921 win_addr
= (struct WS_sockaddr
*)(out_data
+ req
->recv_len
+ sizeof(int));
922 if (getsockname( fd
, &unix_addr
.addr
, &unix_len
) < 0 ||
923 (win_len
= sockaddr_from_unix( &unix_addr
, win_addr
, req
->local_len
- sizeof(int) )) < 0)
925 async_terminate( async
, sock_get_ntstatus( errno
) );
929 memcpy( out_data
+ req
->recv_len
, &win_len
, sizeof(int) );
932 unix_len
= sizeof(unix_addr
);
933 win_addr
= (struct WS_sockaddr
*)(out_data
+ req
->recv_len
+ req
->local_len
+ sizeof(int));
934 remote_len
= out_size
- req
->recv_len
- req
->local_len
;
935 if (getpeername( fd
, &unix_addr
.addr
, &unix_len
) < 0 ||
936 (win_len
= sockaddr_from_unix( &unix_addr
, win_addr
, remote_len
- sizeof(int) )) < 0)
938 async_terminate( async
, sock_get_ntstatus( errno
) );
942 memcpy( out_data
+ req
->recv_len
+ req
->local_len
, &win_len
, sizeof(int) );
944 async_request_complete( req
->async
, STATUS_SUCCESS
, size
, out_size
, out_data
);
947 static void complete_async_accept( struct sock
*sock
, struct accept_req
*req
)
949 struct sock
*acceptsock
= req
->acceptsock
;
950 struct async
*async
= req
->async
;
952 if (debug_level
) fprintf( stderr
, "completing accept request for socket %p\n", sock
);
956 if (!accept_into_socket( sock
, acceptsock
))
958 async_terminate( async
, get_error() );
961 fill_accept_output( req
);
967 if (!(acceptsock
= accept_socket( sock
)))
969 async_terminate( async
, get_error() );
972 handle
= alloc_handle_no_access_check( async_get_thread( async
)->process
, &acceptsock
->obj
,
973 GENERIC_READ
| GENERIC_WRITE
| SYNCHRONIZE
, OBJ_INHERIT
);
974 acceptsock
->wparam
= handle
;
975 sock_reselect( acceptsock
);
976 release_object( acceptsock
);
979 async_terminate( async
, get_error() );
983 async_request_complete_alloc( req
->async
, STATUS_SUCCESS
, 0, sizeof(handle
), &handle
);
987 static void complete_async_accept_recv( struct accept_req
*req
)
989 if (debug_level
) fprintf( stderr
, "completing accept recv request for socket %p\n", req
->acceptsock
);
991 assert( req
->recv_len
);
993 fill_accept_output( req
);
996 static void free_connect_req( void *private )
998 struct connect_req
*req
= private;
1000 req
->sock
->connect_req
= NULL
;
1001 release_object( req
->async
);
1002 release_object( req
->iosb
);
1003 release_object( req
->sock
);
1007 static void complete_async_connect( struct sock
*sock
)
1009 struct connect_req
*req
= sock
->connect_req
;
1010 const char *in_buffer
;
1014 if (debug_level
) fprintf( stderr
, "completing connect request for socket %p\n", sock
);
1018 async_terminate( req
->async
, STATUS_SUCCESS
);
1022 in_buffer
= (const char *)req
->iosb
->in_data
+ sizeof(struct afd_connect_params
) + req
->addr_len
;
1023 len
= req
->send_len
- req
->send_cursor
;
1025 ret
= send( get_unix_fd( sock
->fd
), in_buffer
+ req
->send_cursor
, len
, 0 );
1026 if (ret
< 0 && errno
!= EWOULDBLOCK
)
1027 async_terminate( req
->async
, sock_get_ntstatus( errno
) );
1028 else if (ret
== len
)
1029 async_request_complete( req
->async
, STATUS_SUCCESS
, req
->send_len
, 0, NULL
);
1031 req
->send_cursor
+= ret
;
1034 static void free_poll_req( void *private )
1036 struct poll_req
*req
= private;
1039 if (req
->timeout
) remove_timeout_user( req
->timeout
);
1041 for (i
= 0; i
< req
->count
; ++i
)
1042 release_object( req
->sockets
[i
].sock
);
1043 release_object( req
->async
);
1044 release_object( req
->iosb
);
1045 list_remove( &req
->entry
);
1049 static int is_oobinline( struct sock
*sock
)
1052 socklen_t len
= sizeof(oobinline
);
1053 return !getsockopt( get_unix_fd( sock
->fd
), SOL_SOCKET
, SO_OOBINLINE
, (char *)&oobinline
, &len
) && oobinline
;
1056 static int get_poll_flags( struct sock
*sock
, int event
)
1060 /* A connection-mode socket which has never been connected does not return
1061 * write or hangup events, but Linux reports POLLOUT | POLLHUP. */
1062 if (sock
->state
== SOCK_UNCONNECTED
)
1063 event
&= ~(POLLOUT
| POLLHUP
);
1067 if (sock
->state
== SOCK_LISTENING
)
1068 flags
|= AFD_POLL_ACCEPT
;
1070 flags
|= AFD_POLL_READ
;
1072 if (event
& POLLPRI
)
1073 flags
|= is_oobinline( sock
) ? AFD_POLL_READ
: AFD_POLL_OOB
;
1074 if (event
& POLLOUT
)
1075 flags
|= AFD_POLL_WRITE
;
1076 if (sock
->state
== SOCK_CONNECTED
)
1077 flags
|= AFD_POLL_CONNECT
;
1078 if (event
& POLLHUP
)
1079 flags
|= AFD_POLL_HUP
;
1080 if (event
& POLLERR
)
1081 flags
|= AFD_POLL_CONNECT_ERR
;
1083 flags
|= AFD_POLL_RESET
;
1088 static void complete_async_poll( struct poll_req
*req
, unsigned int status
)
1090 unsigned int i
, signaled_count
= 0;
1092 for (i
= 0; i
< req
->count
; ++i
)
1094 struct sock
*sock
= req
->sockets
[i
].sock
;
1096 if (sock
->main_poll
== req
)
1097 sock
->main_poll
= NULL
;
1102 for (i
= 0; i
< req
->count
; ++i
)
1104 if (req
->sockets
[i
].flags
)
1109 if (is_machine_64bit( async_get_thread( req
->async
)->process
->machine
))
1111 size_t output_size
= offsetof( struct afd_poll_params_64
, sockets
[signaled_count
] );
1112 struct afd_poll_params_64
*output
;
1114 if (!(output
= mem_alloc( output_size
)))
1116 async_terminate( req
->async
, get_error() );
1119 memset( output
, 0, output_size
);
1120 output
->timeout
= req
->orig_timeout
;
1121 output
->exclusive
= req
->exclusive
;
1122 for (i
= 0; i
< req
->count
; ++i
)
1124 if (!req
->sockets
[i
].flags
) continue;
1125 output
->sockets
[output
->count
].socket
= req
->sockets
[i
].handle
;
1126 output
->sockets
[output
->count
].flags
= req
->sockets
[i
].flags
;
1127 output
->sockets
[output
->count
].status
= req
->sockets
[i
].status
;
1130 assert( output
->count
== signaled_count
);
1132 async_request_complete( req
->async
, status
, output_size
, output_size
, output
);
1136 size_t output_size
= offsetof( struct afd_poll_params_32
, sockets
[signaled_count
] );
1137 struct afd_poll_params_32
*output
;
1139 if (!(output
= mem_alloc( output_size
)))
1141 async_terminate( req
->async
, get_error() );
1144 memset( output
, 0, output_size
);
1145 output
->timeout
= req
->orig_timeout
;
1146 output
->exclusive
= req
->exclusive
;
1147 for (i
= 0; i
< req
->count
; ++i
)
1149 if (!req
->sockets
[i
].flags
) continue;
1150 output
->sockets
[output
->count
].socket
= req
->sockets
[i
].handle
;
1151 output
->sockets
[output
->count
].flags
= req
->sockets
[i
].flags
;
1152 output
->sockets
[output
->count
].status
= req
->sockets
[i
].status
;
1155 assert( output
->count
== signaled_count
);
1157 async_request_complete( req
->async
, status
, output_size
, output_size
, output
);
1161 static void complete_async_polls( struct sock
*sock
, int event
, int error
)
1163 int flags
= get_poll_flags( sock
, event
);
1164 struct poll_req
*req
, *next
;
1166 LIST_FOR_EACH_ENTRY_SAFE( req
, next
, &poll_list
, struct poll_req
, entry
)
1170 if (req
->iosb
->status
!= STATUS_PENDING
) continue;
1172 for (i
= 0; i
< req
->count
; ++i
)
1174 if (req
->sockets
[i
].sock
!= sock
) continue;
1175 if (!(req
->sockets
[i
].mask
& flags
)) continue;
1178 fprintf( stderr
, "completing poll for socket %p, wanted %#x got %#x\n",
1179 sock
, req
->sockets
[i
].mask
, flags
);
1181 req
->sockets
[i
].flags
= req
->sockets
[i
].mask
& flags
;
1182 req
->sockets
[i
].status
= sock_get_ntstatus( error
);
1186 complete_async_poll( req
, STATUS_SUCCESS
);
1193 static void async_poll_timeout( void *private )
1195 struct poll_req
*req
= private;
1197 req
->timeout
= NULL
;
1199 if (req
->iosb
->status
!= STATUS_PENDING
) return;
1201 complete_async_poll( req
, STATUS_TIMEOUT
);
1204 static int sock_dispatch_asyncs( struct sock
*sock
, int event
, int error
)
1206 if (event
& (POLLIN
| POLLPRI
))
1208 struct accept_req
*req
;
1210 LIST_FOR_EACH_ENTRY( req
, &sock
->accept_list
, struct accept_req
, entry
)
1212 if (req
->iosb
->status
== STATUS_PENDING
&& !req
->accepted
)
1214 complete_async_accept( sock
, req
);
1220 if (sock
->accept_recv_req
&& sock
->accept_recv_req
->iosb
->status
== STATUS_PENDING
)
1221 complete_async_accept_recv( sock
->accept_recv_req
);
1224 if ((event
& POLLOUT
) && sock
->connect_req
&& sock
->connect_req
->iosb
->status
== STATUS_PENDING
)
1225 complete_async_connect( sock
);
1227 if ((event
& (POLLIN
| POLLPRI
)) && async_queued( &sock
->read_q
))
1229 if (async_waiting( &sock
->read_q
))
1231 if (debug_level
) fprintf( stderr
, "activating read queue for socket %p\n", sock
);
1232 async_wake_up( &sock
->read_q
, STATUS_ALERTED
);
1234 event
&= ~(POLLIN
| POLLPRI
);
1237 if ((event
& POLLOUT
) && async_queued( &sock
->write_q
))
1239 if (async_waiting( &sock
->write_q
))
1241 if (debug_level
) fprintf( stderr
, "activating write queue for socket %p\n", sock
);
1242 async_wake_up( &sock
->write_q
, STATUS_ALERTED
);
1247 if (event
& (POLLERR
| POLLHUP
))
1249 int status
= sock_get_ntstatus( error
);
1250 struct accept_req
*req
, *next
;
1252 async_wake_up( &sock
->read_q
, status
);
1253 async_wake_up( &sock
->write_q
, status
);
1255 LIST_FOR_EACH_ENTRY_SAFE( req
, next
, &sock
->accept_list
, struct accept_req
, entry
)
1257 if (req
->iosb
->status
== STATUS_PENDING
)
1258 async_terminate( req
->async
, status
);
1261 if (sock
->accept_recv_req
&& sock
->accept_recv_req
->iosb
->status
== STATUS_PENDING
)
1262 async_terminate( sock
->accept_recv_req
->async
, status
);
1264 if (sock
->connect_req
)
1265 async_terminate( sock
->connect_req
->async
, status
);
1270 async_wake_up( &sock
->read_q
, STATUS_CONNECTION_RESET
);
1271 async_wake_up( &sock
->write_q
, STATUS_CONNECTION_RESET
);
1273 if (sock
->accept_recv_req
&& sock
->accept_recv_req
->iosb
->status
== STATUS_PENDING
)
1274 async_terminate( sock
->accept_recv_req
->async
, STATUS_CONNECTION_RESET
);
1280 static void post_socket_event( struct sock
*sock
, enum afd_poll_bit event_bit
)
1282 unsigned int event
= (1 << event_bit
);
1284 if (!(sock
->reported_events
& event
))
1286 sock
->pending_events
|= event
;
1287 sock
->reported_events
|= event
;
1291 static void sock_dispatch_events( struct sock
*sock
, enum connection_state prevstate
, int event
)
1295 case SOCK_UNCONNECTED
:
1298 case SOCK_CONNECTING
:
1299 if (event
& POLLOUT
)
1301 post_socket_event( sock
, AFD_POLL_BIT_CONNECT
);
1302 post_socket_event( sock
, AFD_POLL_BIT_WRITE
);
1304 if (event
& (POLLERR
| POLLHUP
))
1305 post_socket_event( sock
, AFD_POLL_BIT_CONNECT_ERR
);
1308 case SOCK_LISTENING
:
1309 if (event
& (POLLIN
| POLLERR
| POLLHUP
))
1310 post_socket_event( sock
, AFD_POLL_BIT_ACCEPT
);
1313 case SOCK_CONNECTED
:
1314 case SOCK_CONNECTIONLESS
:
1316 post_socket_event( sock
, AFD_POLL_BIT_RESET
);
1319 post_socket_event( sock
, AFD_POLL_BIT_READ
);
1321 if (event
& POLLOUT
)
1322 post_socket_event( sock
, AFD_POLL_BIT_WRITE
);
1324 if (event
& POLLPRI
)
1325 post_socket_event( sock
, AFD_POLL_BIT_OOB
);
1327 if (event
& (POLLERR
| POLLHUP
))
1328 post_socket_event( sock
, AFD_POLL_BIT_HUP
);
1332 sock_wake_up( sock
);
1335 static void sock_poll_event( struct fd
*fd
, int event
)
1337 struct sock
*sock
= get_fd_user( fd
);
1338 int hangup_seen
= 0;
1339 enum connection_state prevstate
= sock
->state
;
1342 assert( sock
->obj
.ops
== &sock_ops
);
1343 grab_object( sock
);
1346 fprintf(stderr
, "socket %p select event: %x\n", sock
, event
);
1348 if (event
& (POLLERR
| POLLHUP
))
1349 error
= sock_error( sock
);
1351 switch (sock
->state
)
1353 case SOCK_UNCONNECTED
:
1356 case SOCK_CONNECTING
:
1357 if (event
& (POLLERR
|POLLHUP
))
1359 sock
->state
= SOCK_UNCONNECTED
;
1362 else if (event
& POLLOUT
)
1364 sock
->state
= SOCK_CONNECTED
;
1365 sock
->connect_time
= current_time
;
1366 sock
->errors
[AFD_POLL_BIT_CONNECT_ERR
] = 0;
1370 case SOCK_LISTENING
:
1373 case SOCK_CONNECTED
:
1374 case SOCK_CONNECTIONLESS
:
1376 event
&= ~(POLLIN
| POLLERR
| POLLHUP
);
1378 if (sock
->type
== WS_SOCK_STREAM
&& (event
& POLLIN
))
1383 /* Linux 2.4 doesn't report POLLHUP if only one side of the socket
1384 * has been closed, so we need to check for it explicitly here */
1385 nr
= recv( get_unix_fd( fd
), &dummy
, 1, MSG_PEEK
);
1394 /* EAGAIN can happen if an async recv() falls between the server's poll()
1395 call and the invocation of this routine */
1396 if (errno
== ECONNRESET
|| errno
== EPIPE
)
1400 else if (errno
!= EAGAIN
)
1404 sock
->errors
[AFD_POLL_BIT_HUP
] = error
;
1406 fprintf( stderr
, "recv error on socket %p: %d\n", sock
, errno
);
1411 if (hangup_seen
|| (sock_shutdown_type
== SOCK_SHUTDOWN_POLLHUP
&& (event
& POLLHUP
)))
1415 else if (event
& (POLLHUP
| POLLERR
))
1420 fprintf( stderr
, "socket %p aborted by error %d, event %#x\n", sock
, error
, event
);
1428 event
= sock_dispatch_asyncs( sock
, event
, error
);
1429 sock_dispatch_events( sock
, prevstate
, event
);
1430 complete_async_polls( sock
, event
, error
);
1432 sock_reselect( sock
);
1433 release_object( sock
);
1436 static void sock_dump( struct object
*obj
, int verbose
)
1438 struct sock
*sock
= (struct sock
*)obj
;
1439 assert( obj
->ops
== &sock_ops
);
1440 fprintf( stderr
, "Socket fd=%p, state=%x, mask=%x, pending=%x, reported=%x\n",
1441 sock
->fd
, sock
->state
,
1442 sock
->mask
, sock
->pending_events
, sock
->reported_events
);
1445 static int poll_flags_from_afd( struct sock
*sock
, int flags
)
1449 /* A connection-mode socket which has never been connected does
1450 * not return write or hangup events, but Linux returns
1451 * POLLOUT | POLLHUP. */
1452 if (sock
->state
== SOCK_UNCONNECTED
)
1455 if (flags
& (AFD_POLL_READ
| AFD_POLL_ACCEPT
))
1457 if ((flags
& AFD_POLL_HUP
) && sock
->type
== WS_SOCK_STREAM
)
1459 if (flags
& AFD_POLL_OOB
)
1460 ev
|= is_oobinline( sock
) ? POLLIN
: POLLPRI
;
1461 if (flags
& AFD_POLL_WRITE
)
1467 static int sock_get_poll_events( struct fd
*fd
)
1469 struct sock
*sock
= get_fd_user( fd
);
1470 unsigned int mask
= sock
->mask
& ~sock
->reported_events
;
1471 struct poll_req
*req
;
1474 assert( sock
->obj
.ops
== &sock_ops
);
1476 if (!sock
->type
) /* not initialized yet */
1479 LIST_FOR_EACH_ENTRY( req
, &poll_list
, struct poll_req
, entry
)
1483 if (req
->iosb
->status
!= STATUS_PENDING
) continue;
1485 for (i
= 0; i
< req
->count
; ++i
)
1487 if (req
->sockets
[i
].sock
!= sock
) continue;
1489 ev
|= poll_flags_from_afd( sock
, req
->sockets
[i
].mask
);
1493 switch (sock
->state
)
1495 case SOCK_UNCONNECTED
:
1496 /* A connection-mode Windows socket which has never been connected does
1497 * not return any events, but Linux returns POLLOUT | POLLHUP. Hence we
1498 * need to return -1 here, to prevent the socket from being polled on at
1502 case SOCK_CONNECTING
:
1505 case SOCK_LISTENING
:
1506 if (!list_empty( &sock
->accept_list
) || (mask
& AFD_POLL_ACCEPT
))
1510 case SOCK_CONNECTED
:
1511 case SOCK_CONNECTIONLESS
:
1512 if (sock
->hangup
&& sock
->wr_shutdown
&& !sock
->wr_shutdown_pending
)
1514 /* Linux returns POLLHUP if a socket is both SHUT_RD and SHUT_WR, or
1515 * if both the socket and its peer are SHUT_WR.
1517 * We don't use SHUT_RD, so we can only encounter this in the latter
1518 * case. In that case there can't be any pending read requests (they
1519 * would have already been completed with a length of zero), the
1520 * above condition ensures that we don't have any pending write
1521 * requests, and nothing that can change about the socket state that
1522 * would complete a pending poll request. */
1526 if (sock
->aborted
|| sock
->reset
)
1529 if (sock
->accept_recv_req
)
1533 else if (async_queued( &sock
->read_q
))
1535 /* Clear POLLIN and POLLPRI if we have an alerted async, even if
1536 * we're polling this socket for READ or OOB. We can't signal the
1537 * poll if the pending async will read all of the data [cf. the
1538 * matching logic in sock_dispatch_asyncs()], but we also don't
1539 * want to spin polling for POLLIN if we're not going to use it. */
1540 if (async_waiting( &sock
->read_q
))
1541 ev
|= POLLIN
| POLLPRI
;
1543 ev
&= ~(POLLIN
| POLLPRI
);
1547 /* Don't ask for POLLIN if we got a hangup. We won't receive more
1548 * data anyway, but we will get POLLIN if SOCK_SHUTDOWN_EOF. */
1551 if (mask
& AFD_POLL_READ
)
1553 if (mask
& AFD_POLL_OOB
)
1557 /* We use POLLIN with 0 bytes recv() as hangup indication for stream sockets. */
1558 if (sock
->state
== SOCK_CONNECTED
&& (mask
& AFD_POLL_HUP
) && !(sock
->reported_events
& AFD_POLL_READ
))
1562 if (async_queued( &sock
->write_q
))
1564 /* As with read asyncs above, clear POLLOUT if we have an alerted
1566 if (async_waiting( &sock
->write_q
))
1571 else if (!sock
->wr_shutdown
&& (mask
& AFD_POLL_WRITE
))
1582 static enum server_fd_type
sock_get_fd_type( struct fd
*fd
)
1584 return FD_TYPE_SOCKET
;
1587 static void sock_cancel_async( struct fd
*fd
, struct async
*async
)
1589 struct poll_req
*req
;
1591 LIST_FOR_EACH_ENTRY( req
, &poll_list
, struct poll_req
, entry
)
1595 if (req
->async
!= async
)
1598 for (i
= 0; i
< req
->count
; i
++)
1600 struct sock
*sock
= req
->sockets
[i
].sock
;
1602 if (sock
->main_poll
== req
)
1603 sock
->main_poll
= NULL
;
1607 async_terminate( async
, STATUS_CANCELLED
);
1610 static void sock_reselect_async( struct fd
*fd
, struct async_queue
*queue
)
1612 struct sock
*sock
= get_fd_user( fd
);
1614 if (sock
->wr_shutdown_pending
&& list_empty( &sock
->write_q
.queue
))
1616 shutdown( get_unix_fd( sock
->fd
), SHUT_WR
);
1617 sock
->wr_shutdown_pending
= 0;
1620 /* Don't reselect the ifchange queue; we always ask for POLLIN.
1621 * Don't reselect an uninitialized socket; we can't call set_fd_events() on
1623 if (queue
!= &sock
->ifchange_q
&& sock
->type
)
1624 sock_reselect( sock
);
1627 static struct fd
*sock_get_fd( struct object
*obj
)
1629 struct sock
*sock
= (struct sock
*)obj
;
1630 return (struct fd
*)grab_object( sock
->fd
);
1633 static int sock_close_handle( struct object
*obj
, struct process
*process
, obj_handle_t handle
)
1635 struct sock
*sock
= (struct sock
*)obj
;
1637 if (sock
->obj
.handle_count
== 1) /* last handle */
1639 struct accept_req
*accept_req
, *accept_next
;
1640 struct poll_req
*poll_req
, *poll_next
;
1642 if (sock
->accept_recv_req
)
1643 async_terminate( sock
->accept_recv_req
->async
, STATUS_CANCELLED
);
1645 LIST_FOR_EACH_ENTRY_SAFE( accept_req
, accept_next
, &sock
->accept_list
, struct accept_req
, entry
)
1646 async_terminate( accept_req
->async
, STATUS_CANCELLED
);
1648 if (sock
->connect_req
)
1649 async_terminate( sock
->connect_req
->async
, STATUS_CANCELLED
);
1651 LIST_FOR_EACH_ENTRY_SAFE( poll_req
, poll_next
, &poll_list
, struct poll_req
, entry
)
1653 struct iosb
*iosb
= poll_req
->iosb
;
1654 BOOL signaled
= FALSE
;
1657 if (iosb
->status
!= STATUS_PENDING
) continue;
1659 for (i
= 0; i
< poll_req
->count
; ++i
)
1661 if (poll_req
->sockets
[i
].sock
== sock
)
1664 poll_req
->sockets
[i
].flags
= AFD_POLL_CLOSE
;
1665 poll_req
->sockets
[i
].status
= 0;
1669 if (signaled
) complete_async_poll( poll_req
, STATUS_SUCCESS
);
1672 return async_close_obj_handle( obj
, process
, handle
);
1675 static void sock_destroy( struct object
*obj
)
1677 struct sock
*sock
= (struct sock
*)obj
;
1680 assert( obj
->ops
== &sock_ops
);
1682 /* FIXME: special socket shutdown stuff? */
1684 for (i
= 0; i
< 2; ++i
)
1686 if (sock
->bound_addr
[i
] && --sock
->bound_addr
[i
]->reuse_count
<= 0)
1688 rb_remove( &bound_addresses_tree
, &sock
->bound_addr
[i
]->entry
);
1689 free( sock
->bound_addr
[i
] );
1693 if ( sock
->deferred
)
1694 release_object( sock
->deferred
);
1696 async_wake_up( &sock
->ifchange_q
, STATUS_CANCELLED
);
1697 sock_release_ifchange( sock
);
1698 free_async_queue( &sock
->read_q
);
1699 free_async_queue( &sock
->write_q
);
1700 free_async_queue( &sock
->ifchange_q
);
1701 free_async_queue( &sock
->accept_q
);
1702 free_async_queue( &sock
->connect_q
);
1703 free_async_queue( &sock
->poll_q
);
1704 if (sock
->event
) release_object( sock
->event
);
1705 if (sock
->fd
) release_object( sock
->fd
);
1708 static struct sock
*create_socket(void)
1712 if (!(sock
= alloc_object( &sock_ops
))) return NULL
;
1714 sock
->state
= SOCK_UNCONNECTED
;
1716 sock
->pending_events
= 0;
1717 sock
->reported_events
= 0;
1725 sock
->connect_time
= 0;
1726 sock
->deferred
= NULL
;
1727 sock
->ifchange_obj
= NULL
;
1728 sock
->accept_recv_req
= NULL
;
1729 sock
->connect_req
= NULL
;
1730 sock
->main_poll
= NULL
;
1731 memset( &sock
->addr
, 0, sizeof(sock
->addr
) );
1733 memset( &sock
->peer_addr
, 0, sizeof(sock
->peer_addr
) );
1734 sock
->peer_addr_len
= 0;
1735 sock
->rd_shutdown
= 0;
1736 sock
->wr_shutdown
= 0;
1737 sock
->wr_shutdown_pending
= 0;
1740 sock
->nonblocking
= 0;
1743 sock
->reuseaddr
= 0;
1744 sock
->exclusiveaddruse
= 0;
1749 sock
->icmp_fixup_data_len
= 0;
1750 sock
->bound_addr
[0] = sock
->bound_addr
[1] = NULL
;
1751 init_async_queue( &sock
->read_q
);
1752 init_async_queue( &sock
->write_q
);
1753 init_async_queue( &sock
->ifchange_q
);
1754 init_async_queue( &sock
->accept_q
);
1755 init_async_queue( &sock
->connect_q
);
1756 init_async_queue( &sock
->poll_q
);
1757 memset( sock
->errors
, 0, sizeof(sock
->errors
) );
1758 list_init( &sock
->accept_list
);
1762 static int get_unix_family( int family
)
1766 case WS_AF_INET
: return AF_INET
;
1767 case WS_AF_INET6
: return AF_INET6
;
1769 case WS_AF_IPX
: return AF_IPX
;
1772 case WS_AF_IRDA
: return AF_IRDA
;
1774 case WS_AF_UNSPEC
: return AF_UNSPEC
;
1779 static int get_unix_type( int type
)
1783 case WS_SOCK_DGRAM
: return SOCK_DGRAM
;
1784 case WS_SOCK_RAW
: return SOCK_RAW
;
1785 case WS_SOCK_STREAM
: return SOCK_STREAM
;
1790 static int get_unix_protocol( int protocol
)
1792 if (protocol
>= WS_NSPROTO_IPX
&& protocol
<= WS_NSPROTO_IPX
+ 255)
1797 case WS_IPPROTO_ICMP
: return IPPROTO_ICMP
;
1798 case WS_IPPROTO_IGMP
: return IPPROTO_IGMP
;
1799 case WS_IPPROTO_IP
: return IPPROTO_IP
;
1800 case WS_IPPROTO_IPV4
: return IPPROTO_IPIP
;
1801 case WS_IPPROTO_IPV6
: return IPPROTO_IPV6
;
1802 case WS_IPPROTO_RAW
: return IPPROTO_RAW
;
1803 case WS_IPPROTO_TCP
: return IPPROTO_TCP
;
1804 case WS_IPPROTO_UDP
: return IPPROTO_UDP
;
1809 static void set_dont_fragment( int fd
, int level
, int value
)
1813 if (level
== IPPROTO_IP
)
1816 optname
= IP_DONTFRAG
;
1817 #elif defined(IP_MTU_DISCOVER) && defined(IP_PMTUDISC_DO) && defined(IP_PMTUDISC_DONT)
1818 optname
= IP_MTU_DISCOVER
;
1819 value
= value
? IP_PMTUDISC_DO
: IP_PMTUDISC_DONT
;
1826 #ifdef IPV6_DONTFRAG
1827 optname
= IPV6_DONTFRAG
;
1828 #elif defined(IPV6_MTU_DISCOVER) && defined(IPV6_PMTUDISC_DO) && defined(IPV6_PMTUDISC_DONT)
1829 optname
= IPV6_MTU_DISCOVER
;
1830 value
= value
? IPV6_PMTUDISC_DO
: IPV6_PMTUDISC_DONT
;
1836 setsockopt( fd
, level
, optname
, &value
, sizeof(value
) );
1839 static int init_socket( struct sock
*sock
, int family
, int type
, int protocol
)
1841 unsigned int options
= 0;
1842 int sockfd
, unix_type
, unix_family
, unix_protocol
, value
;
1845 unix_family
= get_unix_family( family
);
1846 unix_type
= get_unix_type( type
);
1847 unix_protocol
= get_unix_protocol( protocol
);
1849 if (unix_protocol
< 0)
1851 if (type
&& unix_type
< 0)
1852 set_win32_error( WSAESOCKTNOSUPPORT
);
1854 set_win32_error( WSAEPROTONOSUPPORT
);
1857 if (unix_family
< 0)
1859 if (family
>= 0 && unix_type
< 0)
1860 set_win32_error( WSAESOCKTNOSUPPORT
);
1862 set_win32_error( WSAEAFNOSUPPORT
);
1866 sockfd
= socket( unix_family
, unix_type
, unix_protocol
);
1869 if (sockfd
== -1 && errno
== EPERM
&& unix_family
== AF_INET
1870 && unix_type
== SOCK_RAW
&& unix_protocol
== IPPROTO_ICMP
)
1872 sockfd
= socket( unix_family
, SOCK_DGRAM
, unix_protocol
);
1877 setsockopt( sockfd
, IPPROTO_IP
, IP_RECVTTL
, (const char *)&val
, sizeof(val
) );
1878 setsockopt( sockfd
, IPPROTO_IP
, IP_RECVTOS
, (const char *)&val
, sizeof(val
) );
1879 setsockopt( sockfd
, IPPROTO_IP
, IP_PKTINFO
, (const char *)&val
, sizeof(val
) );
1886 if (errno
== EINVAL
) set_win32_error( WSAESOCKTNOSUPPORT
);
1887 else set_win32_error( sock_get_error( errno
));
1890 fcntl(sockfd
, F_SETFL
, O_NONBLOCK
); /* make socket nonblocking */
1892 if (family
== WS_AF_IPX
&& protocol
>= WS_NSPROTO_IPX
&& protocol
<= WS_NSPROTO_IPX
+ 255)
1895 int ipx_type
= protocol
- WS_NSPROTO_IPX
;
1898 setsockopt( sockfd
, SOL_IPX
, IPX_TYPE
, &ipx_type
, sizeof(ipx_type
) );
1901 /* Should we retrieve val using a getsockopt call and then
1902 * set the modified one? */
1903 val
.ipx_pt
= ipx_type
;
1904 setsockopt( sockfd
, 0, SO_DEFAULT_HEADERS
, &val
, sizeof(val
) );
1909 if (unix_family
== AF_INET
|| unix_family
== AF_INET6
)
1911 /* ensure IP_DONTFRAGMENT is disabled for SOCK_DGRAM and SOCK_RAW, enabled for SOCK_STREAM */
1912 if (unix_type
== SOCK_DGRAM
|| unix_type
== SOCK_RAW
) /* in Linux the global default can be enabled */
1913 set_dont_fragment( sockfd
, unix_family
== AF_INET6
? IPPROTO_IPV6
: IPPROTO_IP
, FALSE
);
1914 else if (unix_type
== SOCK_STREAM
)
1915 set_dont_fragment( sockfd
, unix_family
== AF_INET6
? IPPROTO_IPV6
: IPPROTO_IP
, TRUE
);
1919 if (unix_family
== AF_INET6
)
1921 static const int enable
= 1;
1922 setsockopt( sockfd
, IPPROTO_IPV6
, IPV6_V6ONLY
, &enable
, sizeof(enable
) );
1926 len
= sizeof(value
);
1927 if (!getsockopt( sockfd
, SOL_SOCKET
, SO_RCVBUF
, &value
, &len
))
1929 if (value
< MIN_RCVBUF
)
1932 setsockopt( sockfd
, SOL_SOCKET
, SO_RCVBUF
, &value
, sizeof(value
) );
1934 sock
->rcvbuf
= value
;
1937 len
= sizeof(value
);
1938 if (!getsockopt( sockfd
, SOL_SOCKET
, SO_SNDBUF
, &value
, &len
))
1939 sock
->sndbuf
= value
;
1941 sock
->state
= (type
== WS_SOCK_STREAM
? SOCK_UNCONNECTED
: SOCK_CONNECTIONLESS
);
1942 sock
->proto
= protocol
;
1944 sock
->family
= family
;
1946 if (is_tcp_socket( sock
))
1949 setsockopt( sockfd
, SOL_SOCKET
, SO_REUSEADDR
, &value
, sizeof(value
) );
1952 setsockopt( sockfd
, IPPROTO_TCP
, TCP_SYNCNT
, &value
, sizeof(value
) );
1958 options
= get_fd_options( sock
->fd
);
1959 release_object( sock
->fd
);
1962 if (!(sock
->fd
= create_anonymous_fd( &sock_fd_ops
, sockfd
, &sock
->obj
, options
)))
1967 /* We can't immediately allow caching for a connection-mode socket, since it
1968 * might be accepted into (changing the underlying fd object.) */
1969 if (sock
->type
!= WS_SOCK_STREAM
) allow_fd_caching( sock
->fd
);
1974 /* accepts a socket and inits it */
1975 static int accept_new_fd( struct sock
*sock
)
1978 /* Try to accept(2). We can't be safe that this an already connected socket
1979 * or that accept() is allowed on it. In those cases we will get -1/errno
1982 struct sockaddr saddr
;
1983 socklen_t slen
= sizeof(saddr
);
1984 int acceptfd
= accept( get_unix_fd(sock
->fd
), &saddr
, &slen
);
1986 fcntl( acceptfd
, F_SETFL
, O_NONBLOCK
);
1988 set_error( sock_get_ntstatus( errno
));
1992 /* accept a socket (creates a new fd) */
1993 static struct sock
*accept_socket( struct sock
*sock
)
1995 struct sock
*acceptsock
;
1998 if (get_unix_fd( sock
->fd
) == -1) return NULL
;
2000 if ( sock
->deferred
)
2002 acceptsock
= sock
->deferred
;
2003 sock
->deferred
= NULL
;
2007 union unix_sockaddr unix_addr
;
2010 if ((acceptfd
= accept_new_fd( sock
)) == -1) return NULL
;
2011 if (!(acceptsock
= create_socket()))
2017 /* newly created socket gets the same properties of the listening socket */
2018 acceptsock
->state
= SOCK_CONNECTED
;
2019 acceptsock
->bound
= 1;
2020 acceptsock
->nonblocking
= sock
->nonblocking
;
2021 acceptsock
->mask
= sock
->mask
;
2022 acceptsock
->proto
= sock
->proto
;
2023 acceptsock
->type
= sock
->type
;
2024 acceptsock
->family
= sock
->family
;
2025 acceptsock
->window
= sock
->window
;
2026 acceptsock
->message
= sock
->message
;
2027 acceptsock
->reuseaddr
= sock
->reuseaddr
;
2028 acceptsock
->exclusiveaddruse
= sock
->exclusiveaddruse
;
2029 acceptsock
->sndbuf
= sock
->sndbuf
;
2030 acceptsock
->rcvbuf
= sock
->rcvbuf
;
2031 acceptsock
->sndtimeo
= sock
->sndtimeo
;
2032 acceptsock
->rcvtimeo
= sock
->rcvtimeo
;
2033 acceptsock
->connect_time
= current_time
;
2035 if (sock
->event
) acceptsock
->event
= (struct event
*)grab_object( sock
->event
);
2036 if (!(acceptsock
->fd
= create_anonymous_fd( &sock_fd_ops
, acceptfd
, &acceptsock
->obj
,
2037 get_fd_options( sock
->fd
) )))
2039 release_object( acceptsock
);
2042 unix_len
= sizeof(unix_addr
);
2043 if (!getsockname( acceptfd
, &unix_addr
.addr
, &unix_len
))
2045 acceptsock
->addr_len
= sockaddr_from_unix( &unix_addr
, &acceptsock
->addr
.addr
, sizeof(acceptsock
->addr
) );
2046 if (!getpeername( acceptfd
, &unix_addr
.addr
, &unix_len
))
2047 acceptsock
->peer_addr_len
= sockaddr_from_unix( &unix_addr
,
2048 &acceptsock
->peer_addr
.addr
,
2049 sizeof(acceptsock
->peer_addr
) );
2054 sock
->pending_events
&= ~AFD_POLL_ACCEPT
;
2055 sock
->reported_events
&= ~AFD_POLL_ACCEPT
;
2056 sock_reselect( sock
);
2060 static int accept_into_socket( struct sock
*sock
, struct sock
*acceptsock
)
2062 union unix_sockaddr unix_addr
;
2067 if (get_unix_fd( sock
->fd
) == -1) return FALSE
;
2069 if ( sock
->deferred
)
2071 newfd
= dup_fd_object( sock
->deferred
->fd
, 0, 0,
2072 get_fd_options( acceptsock
->fd
) );
2076 set_fd_user( newfd
, &sock_fd_ops
, &acceptsock
->obj
);
2078 release_object( sock
->deferred
);
2079 sock
->deferred
= NULL
;
2083 if ((acceptfd
= accept_new_fd( sock
)) == -1)
2086 if (!(newfd
= create_anonymous_fd( &sock_fd_ops
, acceptfd
, &acceptsock
->obj
,
2087 get_fd_options( acceptsock
->fd
) )))
2091 acceptsock
->state
= SOCK_CONNECTED
;
2092 acceptsock
->bound
= 1;
2093 acceptsock
->pending_events
= 0;
2094 acceptsock
->reported_events
= 0;
2095 acceptsock
->proto
= sock
->proto
;
2096 acceptsock
->type
= sock
->type
;
2097 acceptsock
->family
= sock
->family
;
2098 acceptsock
->wparam
= 0;
2099 acceptsock
->deferred
= NULL
;
2100 acceptsock
->connect_time
= current_time
;
2101 fd_copy_completion( acceptsock
->fd
, newfd
);
2102 release_object( acceptsock
->fd
);
2103 acceptsock
->fd
= newfd
;
2105 unix_len
= sizeof(unix_addr
);
2106 if (!getsockname( get_unix_fd( newfd
), &unix_addr
.addr
, &unix_len
))
2108 acceptsock
->addr_len
= sockaddr_from_unix( &unix_addr
, &acceptsock
->addr
.addr
, sizeof(acceptsock
->addr
) );
2109 if (!getpeername( get_unix_fd( newfd
), &unix_addr
.addr
, &unix_len
))
2110 acceptsock
->peer_addr_len
= sockaddr_from_unix( &unix_addr
,
2111 &acceptsock
->peer_addr
.addr
,
2112 sizeof(acceptsock
->peer_addr
) );
2116 sock
->pending_events
&= ~AFD_POLL_ACCEPT
;
2117 sock
->reported_events
&= ~AFD_POLL_ACCEPT
;
2118 sock_reselect( sock
);
2125 static int bind_to_iface_name( int fd
, in_addr_t bind_addr
, const char *name
)
2127 static const int enable
= 1;
2130 if (!(index
= if_nametoindex( name
)))
2133 if (setsockopt( fd
, IPPROTO_IP
, IP_BOUND_IF
, &index
, sizeof(index
) ))
2136 return setsockopt( fd
, SOL_SOCKET
, SO_REUSEADDR
, &enable
, sizeof(enable
) );
2139 #elif defined(IP_UNICAST_IF) && defined(SO_ATTACH_FILTER) && defined(SO_BINDTODEVICE)
2141 struct interface_filter
2143 struct sock_filter iface_memaddr
;
2144 struct sock_filter iface_rule
;
2145 struct sock_filter ip_memaddr
;
2146 struct sock_filter ip_rule
;
2147 struct sock_filter return_keep
;
2148 struct sock_filter return_dump
;
2150 # define FILTER_JUMP_DUMP(here) (u_char)(offsetof(struct interface_filter, return_dump) \
2151 -offsetof(struct interface_filter, here)-sizeof(struct sock_filter)) \
2152 /sizeof(struct sock_filter)
2153 # define FILTER_JUMP_KEEP(here) (u_char)(offsetof(struct interface_filter, return_keep) \
2154 -offsetof(struct interface_filter, here)-sizeof(struct sock_filter)) \
2155 /sizeof(struct sock_filter)
2156 # define FILTER_JUMP_NEXT() (u_char)(0)
2157 # define SKF_NET_DESTIP 16 /* offset in the network header to the destination IP */
2158 static struct interface_filter generic_interface_filter
=
2160 /* This filter rule allows incoming packets on the specified interface, which works for all
2161 * remotely generated packets and for locally generated broadcast packets. */
2162 BPF_STMT(BPF_LD
+BPF_W
+BPF_ABS
, SKF_AD_OFF
+SKF_AD_IFINDEX
),
2163 BPF_JUMP(BPF_JMP
+BPF_JEQ
+BPF_K
, 0xdeadbeef, FILTER_JUMP_KEEP(iface_rule
), FILTER_JUMP_NEXT()),
2164 /* This rule allows locally generated packets targeted at the specific IP address of the chosen
2165 * adapter (local packets not destined for the broadcast address do not have IFINDEX set) */
2166 BPF_STMT(BPF_LD
+BPF_W
+BPF_ABS
, SKF_NET_OFF
+SKF_NET_DESTIP
),
2167 BPF_JUMP(BPF_JMP
+BPF_JEQ
+BPF_K
, 0xdeadbeef, FILTER_JUMP_KEEP(ip_rule
), FILTER_JUMP_DUMP(ip_rule
)),
2168 BPF_STMT(BPF_RET
+BPF_K
, (u_int
)-1), /* keep packet */
2169 BPF_STMT(BPF_RET
+BPF_K
, 0) /* dump packet */
2172 static int bind_to_iface_name( int fd
, in_addr_t bind_addr
, const char *name
)
2174 struct interface_filter specific_interface_filter
;
2175 struct sock_fprog filter_prog
;
2176 static const int enable
= 1;
2180 if (!setsockopt( fd
, SOL_SOCKET
, SO_BINDTODEVICE
, name
, strlen( name
) + 1 ))
2183 /* SO_BINDTODEVICE requires NET_CAP_RAW until Linux 5.7. */
2185 fprintf( stderr
, "setsockopt SO_BINDTODEVICE fd %d, name %s failed: %s, falling back to SO_REUSE_ADDR\n",
2186 fd
, name
, strerror( errno
));
2188 if (!(index
= if_nametoindex( name
)))
2191 ifindex
= htonl( index
);
2192 if (setsockopt( fd
, IPPROTO_IP
, IP_UNICAST_IF
, &ifindex
, sizeof(ifindex
) ) < 0)
2195 specific_interface_filter
= generic_interface_filter
;
2196 specific_interface_filter
.iface_rule
.k
= index
;
2197 specific_interface_filter
.ip_rule
.k
= htonl( bind_addr
);
2198 filter_prog
.len
= sizeof(generic_interface_filter
) / sizeof(struct sock_filter
);
2199 filter_prog
.filter
= (struct sock_filter
*)&specific_interface_filter
;
2200 if (setsockopt( fd
, SOL_SOCKET
, SO_ATTACH_FILTER
, &filter_prog
, sizeof(filter_prog
) ))
2203 return setsockopt( fd
, SOL_SOCKET
, SO_REUSEADDR
, &enable
, sizeof(enable
) );
2208 static int bind_to_iface_name( int fd
, in_addr_t bind_addr
, const char *name
)
2214 #endif /* LINUX_BOUND_IF */
2216 /* Take bind() calls on any name corresponding to a local network adapter and
2217 * restrict the given socket to operating only on the specified interface. This
2218 * restriction consists of two components:
2219 * 1) An outgoing packet restriction suggesting the egress interface for all
2221 * 2) An incoming packet restriction dropping packets not meant for the
2223 * If the function succeeds in placing these restrictions, then the name for the
2224 * bind() may safely be changed to INADDR_ANY, permitting the transmission and
2225 * receipt of broadcast packets on the socket. This behavior is only relevant to
2226 * UDP sockets and is needed for applications that expect to be able to receive
2227 * broadcast packets on a socket that is bound to a specific network interface.
2229 static int bind_to_interface( struct sock
*sock
, const struct sockaddr_in
*addr
)
2231 in_addr_t bind_addr
= addr
->sin_addr
.s_addr
;
2232 struct ifaddrs
*ifaddrs
, *ifaddr
;
2233 int fd
= get_unix_fd( sock
->fd
);
2236 if (bind_addr
== htonl( INADDR_ANY
) || bind_addr
== htonl( INADDR_LOOPBACK
))
2238 if (sock
->type
!= WS_SOCK_DGRAM
)
2241 if (getifaddrs( &ifaddrs
) < 0) return 0;
2243 for (ifaddr
= ifaddrs
; ifaddr
!= NULL
; ifaddr
= ifaddr
->ifa_next
)
2245 if (ifaddr
->ifa_addr
&& ifaddr
->ifa_addr
->sa_family
== AF_INET
2246 && ((struct sockaddr_in
*)ifaddr
->ifa_addr
)->sin_addr
.s_addr
== bind_addr
)
2248 if ((err
= bind_to_iface_name( fd
, bind_addr
, ifaddr
->ifa_name
)) < 0)
2251 fprintf( stderr
, "failed to bind to interface: %s\n", strerror( errno
) );
2256 freeifaddrs( ifaddrs
);
2260 #ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID
2261 static unsigned int get_ipv6_interface_index( const struct in6_addr
*addr
)
2263 struct ifaddrs
*ifaddrs
, *ifaddr
;
2265 if (getifaddrs( &ifaddrs
) < 0) return 0;
2267 for (ifaddr
= ifaddrs
; ifaddr
!= NULL
; ifaddr
= ifaddr
->ifa_next
)
2269 if (ifaddr
->ifa_addr
&& ifaddr
->ifa_addr
->sa_family
== AF_INET6
2270 && !memcmp( &((struct sockaddr_in6
*)ifaddr
->ifa_addr
)->sin6_addr
, addr
, sizeof(*addr
) ))
2272 unsigned int index
= if_nametoindex( ifaddr
->ifa_name
);
2277 fprintf( stderr
, "Unable to look up interface index for %s: %s\n",
2278 ifaddr
->ifa_name
, strerror( errno
) );
2282 freeifaddrs( ifaddrs
);
2287 freeifaddrs( ifaddrs
);
2292 /* return an errno value mapped to a WSA error */
2293 static unsigned int sock_get_error( int err
)
2297 case EINTR
: return WSAEINTR
;
2298 case EBADF
: return WSAEBADF
;
2300 case EACCES
: return WSAEACCES
;
2301 case EFAULT
: return WSAEFAULT
;
2302 case EINVAL
: return WSAEINVAL
;
2303 case EMFILE
: return WSAEMFILE
;
2305 case EWOULDBLOCK
: return WSAEWOULDBLOCK
;
2306 case EALREADY
: return WSAEALREADY
;
2307 case ENOTSOCK
: return WSAENOTSOCK
;
2308 case EDESTADDRREQ
: return WSAEDESTADDRREQ
;
2309 case EMSGSIZE
: return WSAEMSGSIZE
;
2310 case EPROTOTYPE
: return WSAEPROTOTYPE
;
2311 case ENOPROTOOPT
: return WSAENOPROTOOPT
;
2312 case EPROTONOSUPPORT
: return WSAEPROTONOSUPPORT
;
2313 case ESOCKTNOSUPPORT
: return WSAESOCKTNOSUPPORT
;
2314 case EOPNOTSUPP
: return WSAEOPNOTSUPP
;
2315 case EPFNOSUPPORT
: return WSAEPFNOSUPPORT
;
2316 case EAFNOSUPPORT
: return WSAEAFNOSUPPORT
;
2317 case EADDRINUSE
: return WSAEADDRINUSE
;
2318 case EADDRNOTAVAIL
: return WSAEADDRNOTAVAIL
;
2319 case ENETDOWN
: return WSAENETDOWN
;
2320 case ENETUNREACH
: return WSAENETUNREACH
;
2321 case ENETRESET
: return WSAENETRESET
;
2322 case ECONNABORTED
: return WSAECONNABORTED
;
2324 case ECONNRESET
: return WSAECONNRESET
;
2325 case ENOBUFS
: return WSAENOBUFS
;
2326 case EISCONN
: return WSAEISCONN
;
2327 case ENOTCONN
: return WSAENOTCONN
;
2328 case ESHUTDOWN
: return WSAESHUTDOWN
;
2329 case ETOOMANYREFS
: return WSAETOOMANYREFS
;
2330 case ETIMEDOUT
: return WSAETIMEDOUT
;
2331 case ECONNREFUSED
: return WSAECONNREFUSED
;
2332 case ELOOP
: return WSAELOOP
;
2333 case ENAMETOOLONG
: return WSAENAMETOOLONG
;
2334 case EHOSTDOWN
: return WSAEHOSTDOWN
;
2335 case EHOSTUNREACH
: return WSAEHOSTUNREACH
;
2336 case ENOTEMPTY
: return WSAENOTEMPTY
;
2338 case EPROCLIM
: return WSAEPROCLIM
;
2341 case EUSERS
: return WSAEUSERS
;
2344 case EDQUOT
: return WSAEDQUOT
;
2347 case ESTALE
: return WSAESTALE
;
2350 case EREMOTE
: return WSAEREMOTE
;
2356 perror("wineserver: sock_get_error() can't map error");
2361 static int sock_get_ntstatus( int err
)
2365 case EBADF
: return STATUS_INVALID_HANDLE
;
2366 case EBUSY
: return STATUS_DEVICE_BUSY
;
2368 case EACCES
: return STATUS_ACCESS_DENIED
;
2369 case EFAULT
: return STATUS_ACCESS_VIOLATION
;
2370 case EINVAL
: return STATUS_INVALID_PARAMETER
;
2372 case EMFILE
: return STATUS_TOO_MANY_OPENED_FILES
;
2374 case EWOULDBLOCK
: return STATUS_DEVICE_NOT_READY
;
2375 case EALREADY
: return STATUS_NETWORK_BUSY
;
2376 case ENOTSOCK
: return STATUS_OBJECT_TYPE_MISMATCH
;
2377 case EDESTADDRREQ
: return STATUS_INVALID_PARAMETER
;
2378 case EMSGSIZE
: return STATUS_BUFFER_OVERFLOW
;
2379 case EPROTONOSUPPORT
:
2380 case ESOCKTNOSUPPORT
:
2383 case EPROTOTYPE
: return STATUS_NOT_SUPPORTED
;
2384 case ENOPROTOOPT
: return STATUS_INVALID_PARAMETER
;
2385 case EOPNOTSUPP
: return STATUS_NOT_SUPPORTED
;
2386 case EADDRINUSE
: return STATUS_SHARING_VIOLATION
;
2387 /* Linux returns ENODEV when specifying an invalid sin6_scope_id;
2388 * Windows returns STATUS_INVALID_ADDRESS_COMPONENT */
2390 case EADDRNOTAVAIL
: return STATUS_INVALID_ADDRESS_COMPONENT
;
2391 case ECONNREFUSED
: return STATUS_CONNECTION_REFUSED
;
2392 case ESHUTDOWN
: return STATUS_PIPE_DISCONNECTED
;
2393 case ENOTCONN
: return STATUS_INVALID_CONNECTION
;
2394 case ETIMEDOUT
: return STATUS_IO_TIMEOUT
;
2395 case ENETUNREACH
: return STATUS_NETWORK_UNREACHABLE
;
2396 case EHOSTUNREACH
: return STATUS_HOST_UNREACHABLE
;
2397 case ENETDOWN
: return STATUS_NETWORK_BUSY
;
2399 case ECONNRESET
: return STATUS_CONNECTION_RESET
;
2400 case ECONNABORTED
: return STATUS_CONNECTION_ABORTED
;
2401 case EISCONN
: return STATUS_CONNECTION_ACTIVE
;
2403 case 0: return STATUS_SUCCESS
;
2406 perror("wineserver: sock_get_ntstatus() can't map error");
2407 return STATUS_UNSUCCESSFUL
;
2411 static struct accept_req
*alloc_accept_req( struct sock
*sock
, struct sock
*acceptsock
, struct async
*async
,
2412 const struct afd_accept_into_params
*params
)
2414 struct accept_req
*req
= mem_alloc( sizeof(*req
) );
2418 req
->async
= (struct async
*)grab_object( async
);
2419 req
->iosb
= async_get_iosb( async
);
2420 req
->sock
= (struct sock
*)grab_object( sock
);
2421 req
->acceptsock
= acceptsock
;
2422 if (acceptsock
) grab_object( acceptsock
);
2428 req
->recv_len
= params
->recv_len
;
2429 req
->local_len
= params
->local_len
;
2435 static void sock_ioctl( struct fd
*fd
, ioctl_code_t code
, struct async
*async
)
2437 struct sock
*sock
= get_fd_user( fd
);
2440 assert( sock
->obj
.ops
== &sock_ops
);
2442 if (code
!= IOCTL_AFD_WINE_CREATE
&& code
!= IOCTL_AFD_POLL
&& (unix_fd
= get_unix_fd( fd
)) < 0)
2447 case IOCTL_AFD_WINE_CREATE
:
2449 const struct afd_create_params
*params
= get_req_data();
2451 if (get_req_data_size() != sizeof(*params
))
2453 set_error( STATUS_INVALID_PARAMETER
);
2456 init_socket( sock
, params
->family
, params
->type
, params
->protocol
);
2460 case IOCTL_AFD_WINE_ACCEPT
:
2462 struct sock
*acceptsock
;
2463 obj_handle_t handle
;
2465 if (get_reply_max_size() != sizeof(handle
))
2467 set_error( STATUS_BUFFER_TOO_SMALL
);
2471 if (!(acceptsock
= accept_socket( sock
)))
2473 struct accept_req
*req
;
2475 if (sock
->nonblocking
) return;
2476 if (get_error() != STATUS_DEVICE_NOT_READY
) return;
2478 if (!(req
= alloc_accept_req( sock
, NULL
, async
, NULL
))) return;
2479 list_add_tail( &sock
->accept_list
, &req
->entry
);
2481 async_set_completion_callback( async
, free_accept_req
, req
);
2482 queue_async( &sock
->accept_q
, async
);
2483 sock_reselect( sock
);
2484 set_error( STATUS_PENDING
);
2487 handle
= alloc_handle( current
->process
, &acceptsock
->obj
,
2488 GENERIC_READ
| GENERIC_WRITE
| SYNCHRONIZE
, OBJ_INHERIT
);
2489 acceptsock
->wparam
= handle
;
2490 sock_reselect( acceptsock
);
2491 release_object( acceptsock
);
2492 set_reply_data( &handle
, sizeof(handle
) );
2496 case IOCTL_AFD_WINE_ACCEPT_INTO
:
2498 static const int access
= FILE_READ_ATTRIBUTES
| FILE_WRITE_ATTRIBUTES
| FILE_READ_DATA
;
2499 const struct afd_accept_into_params
*params
= get_req_data();
2500 struct sock
*acceptsock
;
2501 unsigned int remote_len
;
2502 struct accept_req
*req
;
2504 if (get_req_data_size() != sizeof(*params
) ||
2505 get_reply_max_size() < params
->recv_len
||
2506 get_reply_max_size() - params
->recv_len
< params
->local_len
)
2508 set_error( STATUS_BUFFER_TOO_SMALL
);
2512 remote_len
= get_reply_max_size() - params
->recv_len
- params
->local_len
;
2513 if (remote_len
< sizeof(int))
2515 set_error( STATUS_INVALID_PARAMETER
);
2519 if (!(acceptsock
= (struct sock
*)get_handle_obj( current
->process
, params
->accept_handle
, access
, &sock_ops
)))
2522 if (acceptsock
->accept_recv_req
)
2524 release_object( acceptsock
);
2525 set_error( STATUS_INVALID_PARAMETER
);
2529 if (!(req
= alloc_accept_req( sock
, acceptsock
, async
, params
)))
2531 release_object( acceptsock
);
2534 list_add_tail( &sock
->accept_list
, &req
->entry
);
2535 acceptsock
->accept_recv_req
= req
;
2536 release_object( acceptsock
);
2538 acceptsock
->wparam
= params
->accept_handle
;
2539 async_set_completion_callback( async
, free_accept_req
, req
);
2540 queue_async( &sock
->accept_q
, async
);
2541 sock_reselect( sock
);
2542 set_error( STATUS_PENDING
);
2546 case IOCTL_AFD_LISTEN
:
2548 const struct afd_listen_params
*params
= get_req_data();
2550 if (get_req_data_size() < sizeof(*params
))
2552 set_error( STATUS_INVALID_PARAMETER
);
2556 if (sock
->type
== WS_SOCK_DGRAM
)
2558 set_error( STATUS_NOT_SUPPORTED
);
2564 set_error( STATUS_INVALID_PARAMETER
);
2568 if (listen( unix_fd
, params
->backlog
) < 0)
2570 set_error( sock_get_ntstatus( errno
) );
2574 sock
->state
= SOCK_LISTENING
;
2576 /* a listening socket can no longer be accepted into */
2577 allow_fd_caching( sock
->fd
);
2579 /* we may already be selecting for AFD_POLL_ACCEPT */
2580 sock_reselect( sock
);
2584 case IOCTL_AFD_WINE_CONNECT
:
2586 const struct afd_connect_params
*params
= get_req_data();
2587 const struct WS_sockaddr
*addr
;
2588 union unix_sockaddr unix_addr
, peer_addr
;
2589 struct connect_req
*req
;
2593 if (get_req_data_size() < sizeof(*params
) ||
2594 get_req_data_size() - sizeof(*params
) < params
->addr_len
)
2596 set_error( STATUS_BUFFER_TOO_SMALL
);
2599 send_len
= get_req_data_size() - sizeof(*params
) - params
->addr_len
;
2600 addr
= (const struct WS_sockaddr
*)(params
+ 1);
2602 if (!params
->synchronous
&& !sock
->bound
)
2604 set_error( STATUS_INVALID_PARAMETER
);
2608 if (sock
->accept_recv_req
)
2610 set_error( STATUS_INVALID_PARAMETER
);
2614 if (sock
->connect_req
)
2616 set_error( STATUS_INVALID_PARAMETER
);
2620 switch (sock
->state
)
2622 case SOCK_LISTENING
:
2623 set_error( STATUS_INVALID_PARAMETER
);
2626 case SOCK_CONNECTING
:
2627 /* FIXME: STATUS_ADDRESS_ALREADY_ASSOCIATED probably isn't right,
2628 * but there's no status code that maps to WSAEALREADY... */
2629 set_error( params
->synchronous
? STATUS_ADDRESS_ALREADY_ASSOCIATED
: STATUS_INVALID_PARAMETER
);
2632 case SOCK_CONNECTED
:
2633 set_error( STATUS_CONNECTION_ACTIVE
);
2636 case SOCK_UNCONNECTED
:
2637 case SOCK_CONNECTIONLESS
:
2641 unix_len
= sockaddr_to_unix( addr
, params
->addr_len
, &unix_addr
);
2644 set_error( STATUS_INVALID_ADDRESS
);
2647 if (unix_addr
.addr
.sa_family
== AF_INET
&& !memcmp( &unix_addr
.in
.sin_addr
, magic_loopback_addr
, 4 ))
2648 unix_addr
.in
.sin_addr
.s_addr
= htonl( INADDR_LOOPBACK
);
2650 memcpy( &peer_addr
, &unix_addr
, sizeof(unix_addr
) );
2651 ret
= connect( unix_fd
, &unix_addr
.addr
, unix_len
);
2652 if (ret
< 0 && errno
== ECONNABORTED
)
2654 /* On Linux with nonblocking socket if the previous connect() failed for any reason (including
2655 * timeout), next connect will fail. If the error code was queried by getsockopt( SO_ERROR )
2656 * the error code returned now is ECONNABORTED (otherwise that is the actual connect() failure
2657 * error code). If we got here after previous connect attempt on the socket that means
2658 * we already queried SO_ERROR in sock_error(), so retrying on ECONNABORTED only is
2660 ret
= connect( unix_fd
, &unix_addr
.addr
, unix_len
);
2663 if (ret
< 0 && errno
!= EINPROGRESS
)
2665 set_error( sock_get_ntstatus( errno
) );
2669 /* a connected or connecting socket can no longer be accepted into */
2670 allow_fd_caching( sock
->fd
);
2672 unix_len
= sizeof(unix_addr
);
2673 getsockname( unix_fd
, &unix_addr
.addr
, &unix_len
);
2674 sock
->addr_len
= sockaddr_from_unix( &unix_addr
, &sock
->addr
.addr
, sizeof(sock
->addr
) );
2675 sock
->peer_addr_len
= sockaddr_from_unix( &peer_addr
, &sock
->peer_addr
.addr
, sizeof(sock
->peer_addr
));
2681 if (sock
->type
!= WS_SOCK_DGRAM
)
2683 sock
->state
= SOCK_CONNECTED
;
2684 sock
->connect_time
= current_time
;
2687 if (!send_len
) return;
2690 if (sock
->type
!= WS_SOCK_DGRAM
)
2691 sock
->state
= SOCK_CONNECTING
;
2693 if (params
->synchronous
&& sock
->nonblocking
)
2695 sock_reselect( sock
);
2696 set_error( STATUS_DEVICE_NOT_READY
);
2700 if (!(req
= mem_alloc( sizeof(*req
) )))
2703 req
->async
= (struct async
*)grab_object( async
);
2704 req
->iosb
= async_get_iosb( async
);
2705 req
->sock
= (struct sock
*)grab_object( sock
);
2706 req
->addr_len
= params
->addr_len
;
2707 req
->send_len
= send_len
;
2708 req
->send_cursor
= 0;
2710 async_set_completion_callback( async
, free_connect_req
, req
);
2711 sock
->connect_req
= req
;
2712 queue_async( &sock
->connect_q
, async
);
2713 sock_reselect( sock
);
2714 set_error( STATUS_PENDING
);
2718 case IOCTL_AFD_WINE_SHUTDOWN
:
2722 if (get_req_data_size() < sizeof(int))
2724 set_error( STATUS_BUFFER_TOO_SMALL
);
2727 how
= *(int *)get_req_data();
2731 set_error( STATUS_INVALID_PARAMETER
);
2735 if (sock
->state
!= SOCK_CONNECTED
&& sock
->state
!= SOCK_CONNECTIONLESS
)
2737 set_error( STATUS_INVALID_CONNECTION
);
2743 sock
->rd_shutdown
= 1;
2745 if (how
!= SD_RECEIVE
)
2747 sock
->wr_shutdown
= 1;
2748 if (list_empty( &sock
->write_q
.queue
))
2749 shutdown( unix_fd
, SHUT_WR
);
2751 sock
->wr_shutdown_pending
= 1;
2756 if (sock
->event
) release_object( sock
->event
);
2760 sock
->nonblocking
= 1;
2763 sock_reselect( sock
);
2767 case IOCTL_AFD_WINE_ADDRESS_LIST_CHANGE
:
2771 if (get_req_data_size() < sizeof(int))
2773 set_error( STATUS_BUFFER_TOO_SMALL
);
2776 force_async
= *(int *)get_req_data();
2778 if (sock
->nonblocking
&& !force_async
)
2780 set_error( STATUS_DEVICE_NOT_READY
);
2783 if (!sock_get_ifchange( sock
)) return;
2784 queue_async( &sock
->ifchange_q
, async
);
2785 set_error( STATUS_PENDING
);
2789 case IOCTL_AFD_WINE_FIONBIO
:
2790 if (get_req_data_size() < sizeof(int))
2792 set_error( STATUS_BUFFER_TOO_SMALL
);
2795 if (*(int *)get_req_data())
2797 sock
->nonblocking
= 1;
2803 set_error( STATUS_INVALID_PARAMETER
);
2806 sock
->nonblocking
= 0;
2810 case IOCTL_AFD_EVENT_SELECT
:
2812 struct event
*event
= NULL
;
2813 obj_handle_t event_handle
;
2816 set_async_pending( async
);
2818 if (is_machine_64bit( current
->process
->machine
))
2820 const struct afd_event_select_params_64
*params
= get_req_data();
2822 if (get_req_data_size() < sizeof(*params
))
2824 set_error( STATUS_INVALID_PARAMETER
);
2828 event_handle
= params
->event
;
2829 mask
= params
->mask
;
2833 const struct afd_event_select_params_32
*params
= get_req_data();
2835 if (get_req_data_size() < sizeof(*params
))
2837 set_error( STATUS_INVALID_PARAMETER
);
2841 event_handle
= params
->event
;
2842 mask
= params
->mask
;
2845 if ((event_handle
|| mask
) &&
2846 !(event
= get_event_obj( current
->process
, event_handle
, EVENT_MODIFY_STATE
)))
2848 set_error( STATUS_INVALID_PARAMETER
);
2852 if (sock
->event
) release_object( sock
->event
);
2853 sock
->event
= event
;
2858 sock
->nonblocking
= 1;
2860 sock_reselect( sock
);
2861 /* Explicitly wake the socket up if the mask causes it to become
2862 * signaled. Note that reselecting isn't enough, since we might already
2863 * have had events recorded in sock->reported_events and we don't want
2864 * to select for them again. */
2865 sock_wake_up( sock
);
2870 case IOCTL_AFD_WINE_MESSAGE_SELECT
:
2872 const struct afd_message_select_params
*params
= get_req_data();
2874 if (get_req_data_size() < sizeof(params
))
2876 set_error( STATUS_BUFFER_TOO_SMALL
);
2880 if (sock
->event
) release_object( sock
->event
);
2884 sock
->pending_events
= 0;
2885 sock
->reported_events
= 0;
2888 sock
->mask
= params
->mask
;
2889 sock
->window
= params
->window
;
2890 sock
->message
= params
->message
;
2891 sock
->wparam
= params
->handle
;
2892 sock
->nonblocking
= 1;
2894 sock_reselect( sock
);
2899 case IOCTL_AFD_BIND
:
2901 const struct afd_bind_params
*params
= get_req_data();
2902 union unix_sockaddr unix_addr
, bind_addr
;
2903 data_size_t in_size
;
2907 /* the ioctl is METHOD_NEITHER, so ntdll gives us the output buffer as
2909 if (get_req_data_size() < get_reply_max_size())
2911 set_error( STATUS_BUFFER_TOO_SMALL
);
2914 in_size
= get_req_data_size() - get_reply_max_size();
2915 if (in_size
< offsetof(struct afd_bind_params
, addr
.sa_data
)
2916 || get_reply_max_size() < in_size
- sizeof(int))
2918 set_error( STATUS_INVALID_PARAMETER
);
2924 set_error( STATUS_ADDRESS_ALREADY_ASSOCIATED
);
2928 unix_len
= sockaddr_to_unix( ¶ms
->addr
, in_size
- sizeof(int), &unix_addr
);
2931 set_error( STATUS_INVALID_ADDRESS
);
2934 bind_addr
= unix_addr
;
2936 if (unix_addr
.addr
.sa_family
== AF_INET
)
2938 if (!memcmp( &unix_addr
.in
.sin_addr
, magic_loopback_addr
, 4 )
2939 || bind_to_interface( sock
, &unix_addr
.in
))
2940 bind_addr
.in
.sin_addr
.s_addr
= htonl( INADDR_ANY
);
2942 else if (unix_addr
.addr
.sa_family
== AF_INET6
)
2944 #ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID
2945 /* Windows allows specifying zero to use the default scope. Linux
2946 * interprets it as an interface index and requires that it be
2948 if (!unix_addr
.in6
.sin6_scope_id
)
2949 bind_addr
.in6
.sin6_scope_id
= get_ipv6_interface_index( &unix_addr
.in6
.sin6_addr
);
2953 set_async_pending( async
);
2956 if (sock
->family
== WS_AF_INET6
)
2958 socklen_t len
= sizeof(v6only
);
2960 getsockopt( get_unix_fd(sock
->fd
), IPPROTO_IPV6
, IPV6_V6ONLY
, &v6only
, &len
);
2964 if (check_addr_usage( sock
, &bind_addr
, v6only
))
2967 if (bind( unix_fd
, &bind_addr
.addr
, unix_len
) < 0)
2969 if (errno
== EADDRINUSE
&& sock
->reuseaddr
)
2972 set_error( sock_get_ntstatus( errno
) );
2978 unix_len
= sizeof(bind_addr
);
2979 if (!getsockname( unix_fd
, &bind_addr
.addr
, &unix_len
))
2981 /* store the interface or magic loopback address instead of the
2982 * actual unix address */
2983 if (bind_addr
.addr
.sa_family
== AF_INET
)
2984 bind_addr
.in
.sin_addr
= unix_addr
.in
.sin_addr
;
2985 sock
->addr_len
= sockaddr_from_unix( &bind_addr
, &sock
->addr
.addr
, sizeof(sock
->addr
) );
2988 update_addr_usage( sock
, &bind_addr
, v6only
);
2990 if (get_reply_max_size() >= sock
->addr_len
)
2991 set_reply_data( &sock
->addr
, sock
->addr_len
);
2995 case IOCTL_AFD_GETSOCKNAME
:
2998 set_error( STATUS_INVALID_PARAMETER
);
3002 if (get_reply_max_size() < sock
->addr_len
)
3004 set_error( STATUS_BUFFER_TOO_SMALL
);
3008 set_reply_data( &sock
->addr
, sock
->addr_len
);
3011 case IOCTL_AFD_WINE_GETPEERNAME
:
3012 if (sock
->state
!= SOCK_CONNECTED
&&
3013 sock
->state
!= SOCK_CONNECTING
&&
3014 sock
->state
!= SOCK_CONNECTIONLESS
)
3016 set_error( STATUS_INVALID_CONNECTION
);
3020 /* If ConnectEx() hasn't finished connecting (or failing to connect) the provided
3021 * socket, getpeername() can't be called on it. This seems to be undocumented
3022 * and is *not* the case for connect(), but we do test for it in ws2_32.
3023 * connect_req is non-NULL iff ConnectEx() was used and has not finished,
3024 * so we can use it as a check for ConnectEx() usage here. */
3025 if (sock
->connect_req
)
3027 set_error( STATUS_INVALID_CONNECTION
);
3031 if (!sock
->peer_addr_len
&& sock
->type
== WS_SOCK_DGRAM
)
3033 set_error( STATUS_INVALID_CONNECTION
);
3037 if (get_reply_max_size() < sock
->peer_addr_len
)
3039 set_error( STATUS_BUFFER_TOO_SMALL
);
3043 set_reply_data( &sock
->peer_addr
, sock
->peer_addr_len
);
3046 case IOCTL_AFD_WINE_DEFER
:
3048 const obj_handle_t
*handle
= get_req_data();
3049 struct sock
*acceptsock
;
3051 if (get_req_data_size() < sizeof(*handle
))
3053 set_error( STATUS_BUFFER_TOO_SMALL
);
3057 acceptsock
= (struct sock
*)get_handle_obj( current
->process
, *handle
, 0, &sock_ops
);
3058 if (!acceptsock
) return;
3060 sock
->deferred
= acceptsock
;
3064 case IOCTL_AFD_WINE_GET_INFO
:
3066 struct afd_get_info_params params
;
3068 if (get_reply_max_size() < sizeof(params
))
3070 set_error( STATUS_BUFFER_TOO_SMALL
);
3074 params
.family
= sock
->family
;
3075 params
.type
= sock
->type
;
3076 params
.protocol
= sock
->proto
;
3077 set_reply_data( ¶ms
, sizeof(params
) );
3081 case IOCTL_AFD_WINE_GET_SO_ACCEPTCONN
:
3083 int listening
= (sock
->state
== SOCK_LISTENING
);
3085 if (get_reply_max_size() < sizeof(listening
))
3087 set_error( STATUS_BUFFER_TOO_SMALL
);
3091 set_reply_data( &listening
, sizeof(listening
) );
3095 case IOCTL_AFD_WINE_GET_SO_ERROR
:
3100 if (get_reply_max_size() < sizeof(error
))
3102 set_error( STATUS_BUFFER_TOO_SMALL
);
3106 error
= sock_error( sock
);
3109 for (i
= 0; i
< ARRAY_SIZE( sock
->errors
); ++i
)
3111 if (sock
->errors
[i
])
3113 error
= sock
->errors
[i
];
3119 error
= sock_get_error( error
);
3120 set_reply_data( &error
, sizeof(error
) );
3124 case IOCTL_AFD_WINE_GET_SO_RCVBUF
:
3126 int rcvbuf
= sock
->rcvbuf
;
3128 if (get_reply_max_size() < sizeof(rcvbuf
))
3130 set_error( STATUS_BUFFER_TOO_SMALL
);
3134 set_reply_data( &rcvbuf
, sizeof(rcvbuf
) );
3138 case IOCTL_AFD_WINE_SET_SO_RCVBUF
:
3140 DWORD rcvbuf
, set_rcvbuf
;
3142 if (get_req_data_size() < sizeof(rcvbuf
))
3144 set_error( STATUS_BUFFER_TOO_SMALL
);
3147 rcvbuf
= *(DWORD
*)get_req_data();
3148 set_rcvbuf
= max( rcvbuf
, MIN_RCVBUF
);
3150 if (!setsockopt( unix_fd
, SOL_SOCKET
, SO_RCVBUF
, (char *)&set_rcvbuf
, sizeof(set_rcvbuf
) ))
3151 sock
->rcvbuf
= rcvbuf
;
3153 set_error( sock_get_ntstatus( errno
) );
3157 case IOCTL_AFD_WINE_GET_SO_RCVTIMEO
:
3159 DWORD rcvtimeo
= sock
->rcvtimeo
;
3161 if (get_reply_max_size() < sizeof(rcvtimeo
))
3163 set_error( STATUS_BUFFER_TOO_SMALL
);
3167 set_reply_data( &rcvtimeo
, sizeof(rcvtimeo
) );
3171 case IOCTL_AFD_WINE_SET_SO_RCVTIMEO
:
3175 if (get_req_data_size() < sizeof(rcvtimeo
))
3177 set_error( STATUS_BUFFER_TOO_SMALL
);
3180 rcvtimeo
= *(DWORD
*)get_req_data();
3182 sock
->rcvtimeo
= rcvtimeo
;
3186 /* BSD socket SO_REUSEADDR is not compatible with winsock semantics. */
3187 case IOCTL_AFD_WINE_SET_SO_REUSEADDR
:
3191 if (get_req_data_size() < sizeof(reuse
))
3193 set_error( STATUS_BUFFER_TOO_SMALL
);
3197 reuse
= *(int *)get_req_data();
3199 if (reuse
&& sock
->exclusiveaddruse
)
3201 set_error( STATUS_INVALID_PARAMETER
);
3205 if (is_tcp_socket( sock
))
3208 ret
= setsockopt( unix_fd
, SOL_SOCKET
, SO_REUSEADDR
, &reuse
, sizeof(reuse
) );
3210 if (!ret
) ret
= setsockopt( unix_fd
, SOL_SOCKET
, SO_REUSEPORT
, &reuse
, sizeof(reuse
) );
3213 set_error( sock_get_ntstatus( errno
) );
3215 sock
->reuseaddr
= !!reuse
;
3219 case IOCTL_AFD_WINE_SET_SO_EXCLUSIVEADDRUSE
:
3223 if (get_req_data_size() < sizeof(exclusive
))
3225 set_error( STATUS_BUFFER_TOO_SMALL
);
3229 exclusive
= *(int *)get_req_data();
3230 if (exclusive
&& sock
->reuseaddr
)
3232 set_error( STATUS_INVALID_PARAMETER
);
3235 sock
->exclusiveaddruse
= !!exclusive
;
3239 case IOCTL_AFD_WINE_GET_SO_SNDBUF
:
3241 int sndbuf
= sock
->sndbuf
;
3243 if (get_reply_max_size() < sizeof(sndbuf
))
3245 set_error( STATUS_BUFFER_TOO_SMALL
);
3249 set_reply_data( &sndbuf
, sizeof(sndbuf
) );
3253 case IOCTL_AFD_WINE_SET_SO_SNDBUF
:
3257 if (get_req_data_size() < sizeof(sndbuf
))
3259 set_error( STATUS_BUFFER_TOO_SMALL
);
3262 sndbuf
= *(DWORD
*)get_req_data();
3267 /* setsockopt fails if a zero value is passed */
3268 sock
->sndbuf
= sndbuf
;
3273 if (!setsockopt( unix_fd
, SOL_SOCKET
, SO_SNDBUF
, (char *)&sndbuf
, sizeof(sndbuf
) ))
3274 sock
->sndbuf
= sndbuf
;
3276 set_error( sock_get_ntstatus( errno
) );
3280 case IOCTL_AFD_WINE_GET_SO_SNDTIMEO
:
3282 DWORD sndtimeo
= sock
->sndtimeo
;
3284 if (get_reply_max_size() < sizeof(sndtimeo
))
3286 set_error( STATUS_BUFFER_TOO_SMALL
);
3290 set_reply_data( &sndtimeo
, sizeof(sndtimeo
) );
3294 case IOCTL_AFD_WINE_SET_SO_SNDTIMEO
:
3298 if (get_req_data_size() < sizeof(sndtimeo
))
3300 set_error( STATUS_BUFFER_TOO_SMALL
);
3303 sndtimeo
= *(DWORD
*)get_req_data();
3305 sock
->sndtimeo
= sndtimeo
;
3309 case IOCTL_AFD_WINE_GET_SO_CONNECT_TIME
:
3313 if (get_reply_max_size() < sizeof(time
))
3315 set_error( STATUS_BUFFER_TOO_SMALL
);
3319 if (sock
->state
== SOCK_CONNECTED
)
3320 time
= (current_time
- sock
->connect_time
) / 10000000;
3322 set_reply_data( &time
, sizeof(time
) );
3326 case IOCTL_AFD_WINE_GET_SO_REUSEADDR
:
3330 if (!get_reply_max_size())
3332 set_error( STATUS_BUFFER_TOO_SMALL
);
3336 reuse
= sock
->reuseaddr
;
3337 set_reply_data( &reuse
, min( sizeof(reuse
), get_reply_max_size() ));
3341 case IOCTL_AFD_WINE_GET_SO_EXCLUSIVEADDRUSE
:
3345 if (!get_reply_max_size())
3347 set_error( STATUS_BUFFER_TOO_SMALL
);
3351 exclusive
= sock
->exclusiveaddruse
;
3352 set_reply_data( &exclusive
, min( sizeof(exclusive
), get_reply_max_size() ));
3356 case IOCTL_AFD_POLL
:
3358 if (get_reply_max_size() < get_req_data_size())
3360 set_error( STATUS_INVALID_PARAMETER
);
3364 if (is_machine_64bit( current
->process
->machine
))
3366 const struct afd_poll_params_64
*params
= get_req_data();
3368 if (get_req_data_size() < sizeof(struct afd_poll_params_64
) ||
3369 get_req_data_size() < offsetof( struct afd_poll_params_64
, sockets
[params
->count
] ))
3371 set_error( STATUS_INVALID_PARAMETER
);
3375 poll_socket( sock
, async
, params
->exclusive
, params
->timeout
, params
->count
, params
->sockets
);
3379 const struct afd_poll_params_32
*params
= get_req_data();
3380 struct afd_poll_socket_64
*sockets
;
3383 if (get_req_data_size() < sizeof(struct afd_poll_params_32
) ||
3384 get_req_data_size() < offsetof( struct afd_poll_params_32
, sockets
[params
->count
] ))
3386 set_error( STATUS_INVALID_PARAMETER
);
3390 if (!(sockets
= mem_alloc( params
->count
* sizeof(*sockets
) ))) return;
3391 for (i
= 0; i
< params
->count
; ++i
)
3393 sockets
[i
].socket
= params
->sockets
[i
].socket
;
3394 sockets
[i
].flags
= params
->sockets
[i
].flags
;
3395 sockets
[i
].status
= params
->sockets
[i
].status
;
3398 poll_socket( sock
, async
, params
->exclusive
, params
->timeout
, params
->count
, sockets
);
3406 set_error( STATUS_NOT_SUPPORTED
);
3411 static void handle_exclusive_poll(struct poll_req
*req
)
3415 for (i
= 0; i
< req
->count
; ++i
)
3417 struct sock
*sock
= req
->sockets
[i
].sock
;
3418 struct poll_req
*main_poll
= sock
->main_poll
;
3420 if (main_poll
&& main_poll
->exclusive
&& req
->exclusive
)
3422 complete_async_poll( main_poll
, STATUS_SUCCESS
);
3427 sock
->main_poll
= req
;
3431 static void poll_socket( struct sock
*poll_sock
, struct async
*async
, int exclusive
, timeout_t timeout
,
3432 unsigned int count
, const struct afd_poll_socket_64
*sockets
)
3434 BOOL signaled
= FALSE
;
3435 struct poll_req
*req
;
3440 set_error( STATUS_INVALID_PARAMETER
);
3444 if (!(req
= mem_alloc( offsetof( struct poll_req
, sockets
[count
] ) )))
3447 req
->timeout
= NULL
;
3449 if (timeout
&& timeout
!= TIMEOUT_INFINITE
&&
3450 !(req
->timeout
= add_timeout_user( timeout
, async_poll_timeout
, req
)))
3455 req
->orig_timeout
= timeout
;
3457 for (i
= 0; i
< count
; ++i
)
3459 req
->sockets
[i
].sock
= (struct sock
*)get_handle_obj( current
->process
, sockets
[i
].socket
, 0, &sock_ops
);
3460 if (!req
->sockets
[i
].sock
)
3462 for (j
= 0; j
< i
; ++j
) release_object( req
->sockets
[j
].sock
);
3463 if (req
->timeout
) remove_timeout_user( req
->timeout
);
3467 req
->sockets
[i
].handle
= sockets
[i
].socket
;
3468 req
->sockets
[i
].mask
= sockets
[i
].flags
;
3469 req
->sockets
[i
].flags
= 0;
3472 req
->exclusive
= exclusive
;
3474 req
->async
= (struct async
*)grab_object( async
);
3475 req
->iosb
= async_get_iosb( async
);
3477 handle_exclusive_poll(req
);
3479 list_add_tail( &poll_list
, &req
->entry
);
3480 async_set_completion_callback( async
, free_poll_req
, req
);
3481 queue_async( &poll_sock
->poll_q
, async
);
3483 for (i
= 0; i
< count
; ++i
)
3485 struct sock
*sock
= req
->sockets
[i
].sock
;
3486 int mask
= req
->sockets
[i
].mask
;
3487 struct pollfd pollfd
;
3489 pollfd
.fd
= get_unix_fd( sock
->fd
);
3490 pollfd
.events
= poll_flags_from_afd( sock
, mask
);
3491 if (pollfd
.events
>= 0 && poll( &pollfd
, 1, 0 ) >= 0)
3492 sock_poll_event( sock
->fd
, pollfd
.revents
);
3494 /* FIXME: do other error conditions deserve a similar treatment? */
3495 if (sock
->state
!= SOCK_CONNECTING
&& sock
->errors
[AFD_POLL_BIT_CONNECT_ERR
] && (mask
& AFD_POLL_CONNECT_ERR
))
3497 req
->sockets
[i
].flags
|= AFD_POLL_CONNECT_ERR
;
3498 req
->sockets
[i
].status
= sock_get_ntstatus( sock
->errors
[AFD_POLL_BIT_CONNECT_ERR
] );
3501 if (req
->sockets
[i
].flags
)
3505 if (!timeout
|| signaled
)
3506 complete_async_poll( req
, STATUS_SUCCESS
);
3510 for (i
= 0; i
< req
->count
; ++i
)
3511 sock_reselect( req
->sockets
[i
].sock
);
3512 set_error( STATUS_PENDING
);
3515 #ifdef HAVE_LINUX_RTNETLINK_H
3517 /* only keep one ifchange object around, all sockets waiting for wakeups will look to it */
3518 static struct object
*ifchange_object
;
3520 static void ifchange_dump( struct object
*obj
, int verbose
);
3521 static struct fd
*ifchange_get_fd( struct object
*obj
);
3522 static void ifchange_destroy( struct object
*obj
);
3524 static int ifchange_get_poll_events( struct fd
*fd
);
3525 static void ifchange_poll_event( struct fd
*fd
, int event
);
3529 struct object obj
; /* object header */
3530 struct fd
*fd
; /* interface change file descriptor */
3531 struct list sockets
; /* list of sockets to send interface change notifications */
3534 static const struct object_ops ifchange_ops
=
3536 sizeof(struct ifchange
), /* size */
3537 &no_type
, /* type */
3538 ifchange_dump
, /* dump */
3539 no_add_queue
, /* add_queue */
3540 NULL
, /* remove_queue */
3541 NULL
, /* signaled */
3542 no_satisfied
, /* satisfied */
3543 no_signal
, /* signal */
3544 ifchange_get_fd
, /* get_fd */
3545 default_map_access
, /* map_access */
3546 default_get_sd
, /* get_sd */
3547 default_set_sd
, /* set_sd */
3548 no_get_full_name
, /* get_full_name */
3549 no_lookup_name
, /* lookup_name */
3550 no_link_name
, /* link_name */
3551 NULL
, /* unlink_name */
3552 no_open_file
, /* open_file */
3553 no_kernel_obj_list
, /* get_kernel_obj_list */
3554 no_close_handle
, /* close_handle */
3555 ifchange_destroy
/* destroy */
3558 static const struct fd_ops ifchange_fd_ops
=
3560 ifchange_get_poll_events
, /* get_poll_events */
3561 ifchange_poll_event
, /* poll_event */
3562 NULL
, /* get_fd_type */
3563 no_fd_read
, /* read */
3564 no_fd_write
, /* write */
3565 no_fd_flush
, /* flush */
3566 no_fd_get_file_info
, /* get_file_info */
3567 no_fd_get_volume_info
, /* get_volume_info */
3568 no_fd_ioctl
, /* ioctl */
3569 NULL
, /* cancel_async */
3570 NULL
, /* queue_async */
3571 NULL
/* reselect_async */
3574 static void ifchange_dump( struct object
*obj
, int verbose
)
3576 assert( obj
->ops
== &ifchange_ops
);
3577 fprintf( stderr
, "Interface change\n" );
3580 static struct fd
*ifchange_get_fd( struct object
*obj
)
3582 struct ifchange
*ifchange
= (struct ifchange
*)obj
;
3583 return (struct fd
*)grab_object( ifchange
->fd
);
3586 static void ifchange_destroy( struct object
*obj
)
3588 struct ifchange
*ifchange
= (struct ifchange
*)obj
;
3589 assert( obj
->ops
== &ifchange_ops
);
3591 release_object( ifchange
->fd
);
3593 /* reset the global ifchange object so that it will be recreated if it is needed again */
3594 assert( obj
== ifchange_object
);
3595 ifchange_object
= NULL
;
3598 static int ifchange_get_poll_events( struct fd
*fd
)
3603 /* wake up all the sockets waiting for a change notification event */
3604 static void ifchange_wake_up( struct object
*obj
, unsigned int status
)
3606 struct ifchange
*ifchange
= (struct ifchange
*)obj
;
3607 struct list
*ptr
, *next
;
3608 assert( obj
->ops
== &ifchange_ops
);
3609 assert( obj
== ifchange_object
);
3611 LIST_FOR_EACH_SAFE( ptr
, next
, &ifchange
->sockets
)
3613 struct sock
*sock
= LIST_ENTRY( ptr
, struct sock
, ifchange_entry
);
3615 assert( sock
->ifchange_obj
);
3616 async_wake_up( &sock
->ifchange_q
, status
); /* issue ifchange notification for the socket */
3617 sock_release_ifchange( sock
); /* remove socket from list and decrement ifchange refcount */
3621 static void ifchange_poll_event( struct fd
*fd
, int event
)
3623 struct object
*ifchange
= get_fd_user( fd
);
3624 unsigned int status
= STATUS_PENDING
;
3625 char buffer
[PIPE_BUF
];
3628 r
= recv( get_unix_fd(fd
), buffer
, sizeof(buffer
), MSG_DONTWAIT
);
3631 if (errno
== EWOULDBLOCK
|| (EWOULDBLOCK
!= EAGAIN
&& errno
== EAGAIN
))
3632 return; /* retry when poll() says the socket is ready */
3633 status
= sock_get_ntstatus( errno
);
3637 struct nlmsghdr
*nlh
;
3639 for (nlh
= (struct nlmsghdr
*)buffer
; NLMSG_OK(nlh
, r
); nlh
= NLMSG_NEXT(nlh
, r
))
3641 if (nlh
->nlmsg_type
== NLMSG_DONE
)
3643 if (nlh
->nlmsg_type
== RTM_NEWADDR
|| nlh
->nlmsg_type
== RTM_DELADDR
)
3644 status
= STATUS_SUCCESS
;
3647 else status
= STATUS_CANCELLED
;
3649 if (status
!= STATUS_PENDING
) ifchange_wake_up( ifchange
, status
);
3654 /* we only need one of these interface notification objects, all of the sockets dependent upon
3655 * it will wake up when a notification event occurs */
3656 static struct object
*get_ifchange( void )
3658 #ifdef HAVE_LINUX_RTNETLINK_H
3659 struct ifchange
*ifchange
;
3660 struct sockaddr_nl addr
;
3663 if (ifchange_object
)
3665 /* increment the refcount for each socket that uses the ifchange object */
3666 return grab_object( ifchange_object
);
3669 /* create the socket we need for processing interface change notifications */
3670 unix_fd
= socket( PF_NETLINK
, SOCK_RAW
, NETLINK_ROUTE
);
3673 set_error( sock_get_ntstatus( errno
));
3676 fcntl( unix_fd
, F_SETFL
, O_NONBLOCK
); /* make socket nonblocking */
3677 memset( &addr
, 0, sizeof(addr
) );
3678 addr
.nl_family
= AF_NETLINK
;
3679 addr
.nl_groups
= RTMGRP_IPV4_IFADDR
;
3680 /* bind the socket to the special netlink kernel interface */
3681 if (bind( unix_fd
, (struct sockaddr
*)&addr
, sizeof(addr
) ) == -1)
3684 set_error( sock_get_ntstatus( errno
));
3687 if (!(ifchange
= alloc_object( &ifchange_ops
)))
3690 set_error( STATUS_NO_MEMORY
);
3693 list_init( &ifchange
->sockets
);
3694 if (!(ifchange
->fd
= create_anonymous_fd( &ifchange_fd_ops
, unix_fd
, &ifchange
->obj
, 0 )))
3696 release_object( ifchange
);
3697 set_error( STATUS_NO_MEMORY
);
3700 set_fd_events( ifchange
->fd
, POLLIN
); /* enable read wakeup on the file descriptor */
3702 /* the ifchange object is now successfully configured */
3703 ifchange_object
= &ifchange
->obj
;
3704 return &ifchange
->obj
;
3706 set_error( STATUS_NOT_SUPPORTED
);
3711 /* add the socket to the interface change notification list */
3712 static void ifchange_add_sock( struct object
*obj
, struct sock
*sock
)
3714 #ifdef HAVE_LINUX_RTNETLINK_H
3715 struct ifchange
*ifchange
= (struct ifchange
*)obj
;
3717 list_add_tail( &ifchange
->sockets
, &sock
->ifchange_entry
);
3721 /* create a new ifchange queue for a specific socket or, if one already exists, reuse the existing one */
3722 static struct object
*sock_get_ifchange( struct sock
*sock
)
3724 struct object
*ifchange
;
3726 if (sock
->ifchange_obj
) /* reuse existing ifchange_obj for this socket */
3727 return sock
->ifchange_obj
;
3729 if (!(ifchange
= get_ifchange()))
3732 /* add the socket to the ifchange notification list */
3733 ifchange_add_sock( ifchange
, sock
);
3734 sock
->ifchange_obj
= ifchange
;
3738 /* destroy an existing ifchange queue for a specific socket */
3739 static void sock_release_ifchange( struct sock
*sock
)
3741 if (sock
->ifchange_obj
)
3743 list_remove( &sock
->ifchange_entry
);
3744 release_object( sock
->ifchange_obj
);
3745 sock
->ifchange_obj
= NULL
;
3749 static void socket_device_dump( struct object
*obj
, int verbose
);
3750 static struct object
*socket_device_lookup_name( struct object
*obj
, struct unicode_str
*name
,
3751 unsigned int attr
, struct object
*root
);
3752 static struct object
*socket_device_open_file( struct object
*obj
, unsigned int access
,
3753 unsigned int sharing
, unsigned int options
);
3755 static const struct object_ops socket_device_ops
=
3757 sizeof(struct object
), /* size */
3758 &device_type
, /* type */
3759 socket_device_dump
, /* dump */
3760 no_add_queue
, /* add_queue */
3761 NULL
, /* remove_queue */
3762 NULL
, /* signaled */
3763 no_satisfied
, /* satisfied */
3764 no_signal
, /* signal */
3765 no_get_fd
, /* get_fd */
3766 default_map_access
, /* map_access */
3767 default_get_sd
, /* get_sd */
3768 default_set_sd
, /* set_sd */
3769 default_get_full_name
, /* get_full_name */
3770 socket_device_lookup_name
, /* lookup_name */
3771 directory_link_name
, /* link_name */
3772 default_unlink_name
, /* unlink_name */
3773 socket_device_open_file
, /* open_file */
3774 no_kernel_obj_list
, /* get_kernel_obj_list */
3775 no_close_handle
, /* close_handle */
3776 no_destroy
/* destroy */
3779 static void socket_device_dump( struct object
*obj
, int verbose
)
3781 fputs( "Socket device\n", stderr
);
3784 static struct object
*socket_device_lookup_name( struct object
*obj
, struct unicode_str
*name
,
3785 unsigned int attr
, struct object
*root
)
3787 if (name
) name
->len
= 0;
3791 static struct object
*socket_device_open_file( struct object
*obj
, unsigned int access
,
3792 unsigned int sharing
, unsigned int options
)
3796 if (!(sock
= create_socket())) return NULL
;
3797 if (!(sock
->fd
= alloc_pseudo_fd( &sock_fd_ops
, &sock
->obj
, options
)))
3799 release_object( sock
);
3805 struct object
*create_socket_device( struct object
*root
, const struct unicode_str
*name
,
3806 unsigned int attr
, const struct security_descriptor
*sd
)
3808 return create_named_object( root
, &socket_device_ops
, name
, attr
, sd
);
3811 DECL_HANDLER(recv_socket
)
3813 struct sock
*sock
= (struct sock
*)get_handle_obj( current
->process
, req
->async
.handle
, 0, &sock_ops
);
3814 unsigned int status
= STATUS_PENDING
;
3815 timeout_t timeout
= 0;
3816 struct async
*async
;
3822 if (!req
->force_async
&& !sock
->nonblocking
&& is_fd_overlapped( fd
))
3823 timeout
= (timeout_t
)sock
->rcvtimeo
* -10000;
3825 if (sock
->rd_shutdown
) status
= STATUS_PIPE_DISCONNECTED
;
3826 else if (!async_queued( &sock
->read_q
))
3828 /* If read_q is not empty, we cannot really tell if the already queued
3829 * asyncs will not consume all available data; if there's no data
3830 * available, the current request won't be immediately satiable.
3832 if ((!req
->force_async
&& sock
->nonblocking
) ||
3833 check_fd_events( sock
->fd
, req
->oob
&& !is_oobinline( sock
) ? POLLPRI
: POLLIN
))
3835 /* Give the client opportunity to complete synchronously.
3836 * If it turns out that the I/O request is not actually immediately satiable,
3837 * the client may then choose to re-queue the async (with STATUS_PENDING).
3839 * Note: If the nonblocking flag is set, we don't poll the socket
3840 * here and always opt for synchronous completion first. This is
3841 * because the application has probably seen POLLIN already from a
3842 * preceding select()/poll() call before it requested to receive
3845 status
= STATUS_ALERTED
;
3849 if (status
== STATUS_PENDING
&& !req
->force_async
&& sock
->nonblocking
)
3850 status
= STATUS_DEVICE_NOT_READY
;
3852 sock
->pending_events
&= ~(req
->oob
? AFD_POLL_OOB
: AFD_POLL_READ
);
3853 sock
->reported_events
&= ~(req
->oob
? AFD_POLL_OOB
: AFD_POLL_READ
);
3855 if ((async
= create_request_async( fd
, get_fd_comp_flags( fd
), &req
->async
)))
3857 set_error( status
);
3860 async_set_timeout( async
, timeout
, STATUS_IO_TIMEOUT
);
3862 if (status
== STATUS_PENDING
|| status
== STATUS_ALERTED
)
3863 queue_async( &sock
->read_q
, async
);
3865 /* always reselect; we changed reported_events above */
3866 sock_reselect( sock
);
3868 reply
->wait
= async_handoff( async
, NULL
, 0 );
3869 reply
->options
= get_fd_options( fd
);
3870 reply
->nonblocking
= sock
->nonblocking
;
3871 release_object( async
);
3873 release_object( sock
);
3876 static void send_socket_completion_callback( void *private )
3878 struct send_req
*send_req
= private;
3879 struct iosb
*iosb
= send_req
->iosb
;
3880 struct sock
*sock
= send_req
->sock
;
3882 if (iosb
->status
!= STATUS_SUCCESS
)
3884 /* send() calls only clear and reselect events if unsuccessful. */
3885 sock
->pending_events
&= ~AFD_POLL_WRITE
;
3886 sock
->reported_events
&= ~AFD_POLL_WRITE
;
3887 sock_reselect( sock
);
3890 release_object( iosb
);
3891 release_object( sock
);
3895 DECL_HANDLER(send_socket
)
3897 struct sock
*sock
= (struct sock
*)get_handle_obj( current
->process
, req
->async
.handle
, 0, &sock_ops
);
3898 unsigned int status
= STATUS_PENDING
;
3899 timeout_t timeout
= 0;
3900 struct async
*async
;
3907 if (sock
->type
== WS_SOCK_DGRAM
&& !sock
->bound
)
3909 union unix_sockaddr unix_addr
;
3911 int unix_fd
= get_unix_fd( fd
);
3913 unix_len
= get_unix_sockaddr_any( &unix_addr
, sock
->family
);
3914 if (bind( unix_fd
, &unix_addr
.addr
, unix_len
) < 0)
3917 if (getsockname( unix_fd
, &unix_addr
.addr
, &unix_len
) >= 0)
3919 sock
->addr_len
= sockaddr_from_unix( &unix_addr
, &sock
->addr
.addr
, sizeof(sock
->addr
) );
3922 else if (!bind_errno
) bind_errno
= errno
;
3925 if (!req
->force_async
&& !sock
->nonblocking
&& is_fd_overlapped( fd
))
3926 timeout
= (timeout_t
)sock
->sndtimeo
* -10000;
3928 if (bind_errno
) status
= sock_get_ntstatus( bind_errno
);
3929 else if (sock
->wr_shutdown
) status
= STATUS_PIPE_DISCONNECTED
;
3930 else if (!async_queued( &sock
->write_q
))
3932 /* If write_q is not empty, we cannot really tell if the already queued
3933 * asyncs will not consume all available space; if there's no space
3934 * available, the current request won't be immediately satiable.
3936 if ((!req
->force_async
&& sock
->nonblocking
) || check_fd_events( sock
->fd
, POLLOUT
))
3938 /* Give the client opportunity to complete synchronously.
3939 * If it turns out that the I/O request is not actually immediately satiable,
3940 * the client may then choose to re-queue the async (with STATUS_PENDING).
3942 * Note: If the nonblocking flag is set, we don't poll the socket
3943 * here and always opt for synchronous completion first. This is
3944 * because the application has probably seen POLLOUT already from a
3945 * preceding select()/poll() call before it requested to send data.
3947 * Furthermore, some applications expect that any send() call on a
3948 * socket that has indicated POLLOUT beforehand never fails with
3949 * WSAEWOULDBLOCK. It's possible that Linux poll() may yield
3950 * POLLOUT on the first call but not the second, even if no send()
3951 * call has been made in the meanwhile. This can happen for a
3952 * number of reasons; for example, TCP fragmentation may consume
3953 * extra buffer space for each packet that has been split out, or
3954 * the TCP/IP networking stack may decide to shrink the send buffer
3955 * due to memory pressure.
3957 status
= STATUS_ALERTED
;
3961 if (status
== STATUS_PENDING
&& !req
->force_async
&& sock
->nonblocking
)
3962 status
= STATUS_DEVICE_NOT_READY
;
3964 if ((async
= create_request_async( fd
, get_fd_comp_flags( fd
), &req
->async
)))
3966 struct send_req
*send_req
;
3967 struct iosb
*iosb
= async_get_iosb( async
);
3969 if ((send_req
= mem_alloc( sizeof(*send_req
) )))
3971 send_req
->iosb
= (struct iosb
*)grab_object( iosb
);
3972 send_req
->sock
= (struct sock
*)grab_object( sock
);
3973 async_set_completion_callback( async
, send_socket_completion_callback
, send_req
);
3975 else if (status
== STATUS_PENDING
|| status
== STATUS_DEVICE_NOT_READY
)
3976 status
= STATUS_NO_MEMORY
;
3978 release_object( iosb
);
3980 set_error( status
);
3983 async_set_timeout( async
, timeout
, STATUS_IO_TIMEOUT
);
3985 if (status
== STATUS_PENDING
|| status
== STATUS_ALERTED
)
3987 queue_async( &sock
->write_q
, async
);
3988 sock_reselect( sock
);
3991 reply
->wait
= async_handoff( async
, NULL
, 0 );
3992 reply
->options
= get_fd_options( fd
);
3993 reply
->nonblocking
= sock
->nonblocking
;
3994 release_object( async
);
3996 release_object( sock
);
3999 DECL_HANDLER(socket_get_events
)
4001 struct sock
*sock
= (struct sock
*)get_handle_obj( current
->process
, req
->handle
, 0, &sock_ops
);
4002 unsigned int status
[13];
4003 struct event
*event
= NULL
;
4006 if (get_reply_max_size() < sizeof(status
))
4008 set_error( STATUS_INVALID_PARAMETER
);
4016 if (!(event
= get_event_obj( current
->process
, req
->event
, EVENT_MODIFY_STATE
)))
4018 release_object( sock
);
4023 reply
->flags
= sock
->pending_events
& sock
->mask
;
4024 for (i
= 0; i
< ARRAY_SIZE( status
); ++i
)
4025 status
[i
] = sock_get_ntstatus( sock
->errors
[i
] );
4027 sock
->pending_events
&= ~sock
->mask
;
4028 sock_reselect( sock
);
4032 reset_event( event
);
4033 release_object( event
);
4036 set_reply_data( status
, sizeof(status
) );
4038 release_object( sock
);
4041 DECL_HANDLER(socket_send_icmp_id
)
4043 struct sock
*sock
= (struct sock
*)get_handle_obj( current
->process
, req
->handle
, 0, &sock_ops
);
4047 if (sock
->icmp_fixup_data_len
== MAX_ICMP_HISTORY_LENGTH
)
4049 memmove( sock
->icmp_fixup_data
, sock
->icmp_fixup_data
+ 1,
4050 sizeof(*sock
->icmp_fixup_data
) * (MAX_ICMP_HISTORY_LENGTH
- 1) );
4051 --sock
->icmp_fixup_data_len
;
4054 sock
->icmp_fixup_data
[sock
->icmp_fixup_data_len
].icmp_id
= req
->icmp_id
;
4055 sock
->icmp_fixup_data
[sock
->icmp_fixup_data_len
].icmp_seq
= req
->icmp_seq
;
4056 ++sock
->icmp_fixup_data_len
;
4058 release_object( sock
);
4061 DECL_HANDLER(socket_get_icmp_id
)
4063 struct sock
*sock
= (struct sock
*)get_handle_obj( current
->process
, req
->handle
, 0, &sock_ops
);
4068 for (i
= 0; i
< sock
->icmp_fixup_data_len
; ++i
)
4070 if (sock
->icmp_fixup_data
[i
].icmp_seq
== req
->icmp_seq
)
4072 reply
->icmp_id
= sock
->icmp_fixup_data
[i
].icmp_id
;
4073 --sock
->icmp_fixup_data_len
;
4074 memmove( &sock
->icmp_fixup_data
[i
], &sock
->icmp_fixup_data
[i
+ 1],
4075 (sock
->icmp_fixup_data_len
- i
) * sizeof(*sock
->icmp_fixup_data
) );
4076 release_object( sock
);
4081 set_error( STATUS_NOT_FOUND
);
4082 release_object( sock
);