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?
33 #ifdef HAVE_NETINET_IN_H
34 # include <netinet/in.h>
40 #include <sys/types.h>
41 #ifdef HAVE_SYS_SOCKET_H
42 # include <sys/socket.h>
44 #ifdef HAVE_SYS_IOCTL_H
45 #include <sys/ioctl.h>
47 #ifdef HAVE_SYS_FILIO_H
48 # include <sys/filio.h>
53 #ifdef HAVE_LINUX_RTNETLINK_H
54 # include <linux/rtnetlink.h>
57 #ifdef HAVE_NETIPX_IPX_H
58 # include <netipx/ipx.h>
59 #elif defined(HAVE_LINUX_IPX_H)
60 # ifdef HAVE_ASM_TYPES_H
61 # include <asm/types.h>
63 # ifdef HAVE_LINUX_TYPES_H
64 # include <linux/types.h>
66 # include <linux/ipx.h>
68 #if defined(SOL_IPX) || defined(SO_DEFAULT_HEADERS)
72 #ifdef HAVE_LINUX_IRDA_H
73 # ifdef HAVE_LINUX_TYPES_H
74 # include <linux/types.h>
76 # include <linux/irda.h>
81 #define WIN32_NO_STATUS
99 static struct list poll_list
= LIST_INIT( poll_list
);
106 struct timeout_user
*timeout
;
108 struct poll_socket_output
*output
;
121 struct sock
*sock
, *acceptsock
;
123 unsigned int recv_len
, local_len
;
131 unsigned int addr_len
, send_len
, send_cursor
;
134 enum connection_state
145 struct object obj
; /* object header */
146 struct fd
*fd
; /* socket file descriptor */
147 enum connection_state state
; /* connection state */
148 unsigned int mask
; /* event mask */
149 /* pending AFD_POLL_* events which have not yet been reported to the application */
150 unsigned int pending_events
;
151 /* AFD_POLL_* events which have already been reported and should not be
152 * selected for again until reset by a relevant call.
154 * For example, if AFD_POLL_READ is set here and not in pending_events, it
155 * has already been reported and consumed, and we should not report it
156 * again, even if POLLIN is signaled, until it is reset by e.g recv().
158 * If an event has been signaled and not consumed yet, it will be set in
159 * both pending_events and reported_events (as we should only ever report
160 * any event once until it is reset.) */
161 unsigned int reported_events
;
162 unsigned int flags
; /* socket flags */
163 unsigned short proto
; /* socket protocol */
164 unsigned short type
; /* socket type */
165 unsigned short family
; /* socket family */
166 struct event
*event
; /* event object */
167 user_handle_t window
; /* window to send the message to */
168 unsigned int message
; /* message to send */
169 obj_handle_t wparam
; /* message wparam (socket handle) */
170 int errors
[AFD_POLL_BIT_COUNT
]; /* event errors */
171 timeout_t connect_time
;/* time the socket was connected */
172 struct sock
*deferred
; /* socket that waits for a deferred accept */
173 struct async_queue read_q
; /* queue for asynchronous reads */
174 struct async_queue write_q
; /* queue for asynchronous writes */
175 struct async_queue ifchange_q
; /* queue for interface change notifications */
176 struct async_queue accept_q
; /* queue for asynchronous accepts */
177 struct async_queue connect_q
; /* queue for asynchronous connects */
178 struct async_queue poll_q
; /* queue for asynchronous polls */
179 struct object
*ifchange_obj
; /* the interface change notification object */
180 struct list ifchange_entry
; /* entry in ifchange notification list */
181 struct list accept_list
; /* list of pending accept requests */
182 struct accept_req
*accept_recv_req
; /* pending accept-into request which will recv on this socket */
183 struct connect_req
*connect_req
; /* pending connection request */
184 unsigned int rd_shutdown
: 1; /* is the read end shut down? */
185 unsigned int wr_shutdown
: 1; /* is the write end shut down? */
186 unsigned int wr_shutdown_pending
: 1; /* is a write shutdown pending? */
187 unsigned int nonblocking
: 1; /* is the socket nonblocking? */
190 static void sock_dump( struct object
*obj
, int verbose
);
191 static struct fd
*sock_get_fd( struct object
*obj
);
192 static int sock_close_handle( struct object
*obj
, struct process
*process
, obj_handle_t handle
);
193 static void sock_destroy( struct object
*obj
);
194 static struct object
*sock_get_ifchange( struct sock
*sock
);
195 static void sock_release_ifchange( struct sock
*sock
);
197 static int sock_get_poll_events( struct fd
*fd
);
198 static void sock_poll_event( struct fd
*fd
, int event
);
199 static enum server_fd_type
sock_get_fd_type( struct fd
*fd
);
200 static int sock_ioctl( struct fd
*fd
, ioctl_code_t code
, struct async
*async
);
201 static void sock_queue_async( struct fd
*fd
, struct async
*async
, int type
, int count
);
202 static void sock_reselect_async( struct fd
*fd
, struct async_queue
*queue
);
204 static int accept_into_socket( struct sock
*sock
, struct sock
*acceptsock
);
205 static struct sock
*accept_socket( struct sock
*sock
);
206 static int sock_get_ntstatus( int err
);
207 static unsigned int sock_get_error( int err
);
209 static const struct object_ops sock_ops
=
211 sizeof(struct sock
), /* size */
212 &file_type
, /* type */
213 sock_dump
, /* dump */
214 add_queue
, /* add_queue */
215 remove_queue
, /* remove_queue */
216 default_fd_signaled
, /* signaled */
217 no_satisfied
, /* satisfied */
218 no_signal
, /* signal */
219 sock_get_fd
, /* get_fd */
220 default_map_access
, /* map_access */
221 default_get_sd
, /* get_sd */
222 default_set_sd
, /* set_sd */
223 no_get_full_name
, /* get_full_name */
224 no_lookup_name
, /* lookup_name */
225 no_link_name
, /* link_name */
226 NULL
, /* unlink_name */
227 no_open_file
, /* open_file */
228 no_kernel_obj_list
, /* get_kernel_obj_list */
229 sock_close_handle
, /* close_handle */
230 sock_destroy
/* destroy */
233 static const struct fd_ops sock_fd_ops
=
235 sock_get_poll_events
, /* get_poll_events */
236 sock_poll_event
, /* poll_event */
237 sock_get_fd_type
, /* get_fd_type */
238 no_fd_read
, /* read */
239 no_fd_write
, /* write */
240 no_fd_flush
, /* flush */
241 default_fd_get_file_info
, /* get_file_info */
242 no_fd_get_volume_info
, /* get_volume_info */
243 sock_ioctl
, /* ioctl */
244 sock_queue_async
, /* queue_async */
245 sock_reselect_async
/* reselect_async */
250 struct sockaddr addr
;
251 struct sockaddr_in in
;
252 struct sockaddr_in6 in6
;
254 struct sockaddr_ipx ipx
;
257 struct sockaddr_irda irda
;
261 static int sockaddr_from_unix( const union unix_sockaddr
*uaddr
, struct WS_sockaddr
*wsaddr
, socklen_t wsaddrlen
)
263 memset( wsaddr
, 0, wsaddrlen
);
265 switch (uaddr
->addr
.sa_family
)
269 struct WS_sockaddr_in win
= {0};
271 if (wsaddrlen
< sizeof(win
)) return -1;
272 win
.sin_family
= WS_AF_INET
;
273 win
.sin_port
= uaddr
->in
.sin_port
;
274 memcpy( &win
.sin_addr
, &uaddr
->in
.sin_addr
, sizeof(win
.sin_addr
) );
275 memcpy( wsaddr
, &win
, sizeof(win
) );
281 struct WS_sockaddr_in6 win
= {0};
283 if (wsaddrlen
< sizeof(struct WS_sockaddr_in6_old
)) return -1;
284 win
.sin6_family
= WS_AF_INET6
;
285 win
.sin6_port
= uaddr
->in6
.sin6_port
;
286 win
.sin6_flowinfo
= uaddr
->in6
.sin6_flowinfo
;
287 memcpy( &win
.sin6_addr
, &uaddr
->in6
.sin6_addr
, sizeof(win
.sin6_addr
) );
288 #ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID
289 win
.sin6_scope_id
= uaddr
->in6
.sin6_scope_id
;
291 if (wsaddrlen
>= sizeof(struct WS_sockaddr_in6
))
293 memcpy( wsaddr
, &win
, sizeof(struct WS_sockaddr_in6
) );
294 return sizeof(struct WS_sockaddr_in6
);
296 memcpy( wsaddr
, &win
, sizeof(struct WS_sockaddr_in6_old
) );
297 return sizeof(struct WS_sockaddr_in6_old
);
303 struct WS_sockaddr_ipx win
= {0};
305 if (wsaddrlen
< sizeof(win
)) return -1;
306 win
.sa_family
= WS_AF_IPX
;
307 memcpy( win
.sa_netnum
, &uaddr
->ipx
.sipx_network
, sizeof(win
.sa_netnum
) );
308 memcpy( win
.sa_nodenum
, &uaddr
->ipx
.sipx_node
, sizeof(win
.sa_nodenum
) );
309 win
.sa_socket
= uaddr
->ipx
.sipx_port
;
310 memcpy( wsaddr
, &win
, sizeof(win
) );
320 if (wsaddrlen
< sizeof(win
)) return -1;
321 win
.irdaAddressFamily
= WS_AF_IRDA
;
322 memcpy( win
.irdaDeviceID
, &uaddr
->irda
.sir_addr
, sizeof(win
.irdaDeviceID
) );
323 if (uaddr
->irda
.sir_lsap_sel
!= LSAP_ANY
)
324 snprintf( win
.irdaServiceName
, sizeof(win
.irdaServiceName
), "LSAP-SEL%u", uaddr
->irda
.sir_lsap_sel
);
326 memcpy( win
.irdaServiceName
, uaddr
->irda
.sir_name
, sizeof(win
.irdaServiceName
) );
327 memcpy( wsaddr
, &win
, sizeof(win
) );
341 /* some events are generated at the same time but must be sent in a particular
342 * order (e.g. CONNECT must be sent before READ) */
343 static const enum afd_poll_bit event_bitorder
[] =
345 AFD_POLL_BIT_CONNECT
,
346 AFD_POLL_BIT_CONNECT_ERR
,
357 SOCK_SHUTDOWN_ERROR
= -1,
358 SOCK_SHUTDOWN_EOF
= 0,
359 SOCK_SHUTDOWN_POLLHUP
= 1
362 static sock_shutdown_t sock_shutdown_type
= SOCK_SHUTDOWN_ERROR
;
364 static sock_shutdown_t
sock_check_pollhup(void)
366 sock_shutdown_t ret
= SOCK_SHUTDOWN_ERROR
;
371 if ( socketpair( AF_UNIX
, SOCK_STREAM
, 0, fd
) ) return ret
;
372 if ( shutdown( fd
[0], 1 ) ) goto out
;
378 /* Solaris' poll() sometimes returns nothing if given a 0ms timeout here */
379 n
= poll( &pfd
, 1, 1 );
380 if ( n
!= 1 ) goto out
; /* error or timeout */
381 if ( pfd
.revents
& POLLHUP
)
382 ret
= SOCK_SHUTDOWN_POLLHUP
;
383 else if ( pfd
.revents
& POLLIN
&&
384 read( fd
[1], &dummy
, 1 ) == 0 )
385 ret
= SOCK_SHUTDOWN_EOF
;
395 sock_shutdown_type
= sock_check_pollhup();
397 switch ( sock_shutdown_type
)
399 case SOCK_SHUTDOWN_EOF
:
400 if (debug_level
) fprintf( stderr
, "sock_init: shutdown() causes EOF\n" );
402 case SOCK_SHUTDOWN_POLLHUP
:
403 if (debug_level
) fprintf( stderr
, "sock_init: shutdown() causes POLLHUP\n" );
406 fprintf( stderr
, "sock_init: ERROR in sock_check_pollhup()\n" );
407 sock_shutdown_type
= SOCK_SHUTDOWN_EOF
;
411 static int sock_reselect( struct sock
*sock
)
413 int ev
= sock_get_poll_events( sock
->fd
);
416 fprintf(stderr
,"sock_reselect(%p): new mask %x\n", sock
, ev
);
418 set_fd_events( sock
->fd
, ev
);
422 static unsigned int afd_poll_flag_to_win32( unsigned int flags
)
424 static const unsigned int map
[] =
428 FD_WRITE
, /* WRITE */
430 FD_CLOSE
, /* RESET */
432 FD_CONNECT
, /* CONNECT */
433 FD_ACCEPT
, /* ACCEPT */
434 FD_CONNECT
, /* CONNECT_ERR */
437 unsigned int i
, ret
= 0;
439 for (i
= 0; i
< ARRAY_SIZE(map
); ++i
)
441 if (flags
& (1 << i
)) ret
|= map
[i
];
447 static unsigned int afd_poll_flag_from_win32( unsigned int flags
)
449 static const unsigned int map
[] =
455 AFD_POLL_CONNECT
| AFD_POLL_CONNECT_ERR
,
456 AFD_POLL_RESET
| AFD_POLL_HUP
,
459 unsigned int i
, ret
= 0;
461 for (i
= 0; i
< ARRAY_SIZE(map
); ++i
)
463 if (flags
& (1 << i
)) ret
|= map
[i
];
469 /* wake anybody waiting on the socket event or send the associated message */
470 static void sock_wake_up( struct sock
*sock
)
472 unsigned int events
= sock
->pending_events
& sock
->mask
;
477 if (debug_level
) fprintf(stderr
, "signalling events %x ptr %p\n", events
, sock
->event
);
479 set_event( sock
->event
);
483 if (debug_level
) fprintf(stderr
, "signalling events %x win %08x\n", events
, sock
->window
);
484 for (i
= 0; i
< ARRAY_SIZE(event_bitorder
); i
++)
486 enum afd_poll_bit event
= event_bitorder
[i
];
487 if (events
& (1 << event
))
489 lparam_t lparam
= afd_poll_flag_to_win32(1 << event
) | (sock_get_error( sock
->errors
[event
] ) << 16);
490 post_message( sock
->window
, sock
->message
, sock
->wparam
, lparam
);
493 sock
->pending_events
= 0;
494 sock_reselect( sock
);
498 static inline int sock_error( struct fd
*fd
)
500 unsigned int optval
= 0;
501 socklen_t optlen
= sizeof(optval
);
503 getsockopt( get_unix_fd(fd
), SOL_SOCKET
, SO_ERROR
, (void *) &optval
, &optlen
);
507 static void free_accept_req( void *private )
509 struct accept_req
*req
= private;
510 list_remove( &req
->entry
);
513 req
->acceptsock
->accept_recv_req
= NULL
;
514 release_object( req
->acceptsock
);
516 release_object( req
->async
);
517 release_object( req
->iosb
);
518 release_object( req
->sock
);
522 static void fill_accept_output( struct accept_req
*req
)
524 struct iosb
*iosb
= req
->iosb
;
525 union unix_sockaddr unix_addr
;
526 struct WS_sockaddr
*win_addr
;
527 unsigned int remote_len
;
533 if (!(out_data
= mem_alloc( iosb
->out_size
))) return;
535 fd
= get_unix_fd( req
->acceptsock
->fd
);
537 if (req
->recv_len
&& (size
= recv( fd
, out_data
, req
->recv_len
, 0 )) < 0)
539 if (!req
->accepted
&& errno
== EWOULDBLOCK
)
542 sock_reselect( req
->acceptsock
);
543 set_error( STATUS_PENDING
);
547 set_error( sock_get_ntstatus( errno
) );
554 if (req
->local_len
< sizeof(int))
556 set_error( STATUS_BUFFER_TOO_SMALL
);
561 unix_len
= sizeof(unix_addr
);
562 win_addr
= (struct WS_sockaddr
*)(out_data
+ req
->recv_len
+ sizeof(int));
563 if (getsockname( fd
, &unix_addr
.addr
, &unix_len
) < 0 ||
564 (win_len
= sockaddr_from_unix( &unix_addr
, win_addr
, req
->local_len
- sizeof(int) )) < 0)
566 set_error( sock_get_ntstatus( errno
) );
570 memcpy( out_data
+ req
->recv_len
, &win_len
, sizeof(int) );
573 unix_len
= sizeof(unix_addr
);
574 win_addr
= (struct WS_sockaddr
*)(out_data
+ req
->recv_len
+ req
->local_len
+ sizeof(int));
575 remote_len
= iosb
->out_size
- req
->recv_len
- req
->local_len
;
576 if (getpeername( fd
, &unix_addr
.addr
, &unix_len
) < 0 ||
577 (win_len
= sockaddr_from_unix( &unix_addr
, win_addr
, remote_len
- sizeof(int) )) < 0)
579 set_error( sock_get_ntstatus( errno
) );
583 memcpy( out_data
+ req
->recv_len
+ req
->local_len
, &win_len
, sizeof(int) );
585 iosb
->status
= STATUS_SUCCESS
;
587 iosb
->out_data
= out_data
;
588 set_error( STATUS_ALERTED
);
591 static void complete_async_accept( struct sock
*sock
, struct accept_req
*req
)
593 struct sock
*acceptsock
= req
->acceptsock
;
594 struct async
*async
= req
->async
;
596 if (debug_level
) fprintf( stderr
, "completing accept request for socket %p\n", sock
);
600 if (!accept_into_socket( sock
, acceptsock
)) return;
601 fill_accept_output( req
);
605 struct iosb
*iosb
= req
->iosb
;
608 if (!(acceptsock
= accept_socket( sock
))) return;
609 handle
= alloc_handle_no_access_check( async_get_thread( async
)->process
, &acceptsock
->obj
,
610 GENERIC_READ
| GENERIC_WRITE
| SYNCHRONIZE
, OBJ_INHERIT
);
611 acceptsock
->wparam
= handle
;
612 release_object( acceptsock
);
615 if (!(iosb
->out_data
= malloc( sizeof(handle
) ))) return;
617 iosb
->status
= STATUS_SUCCESS
;
618 iosb
->out_size
= sizeof(handle
);
619 memcpy( iosb
->out_data
, &handle
, sizeof(handle
) );
620 set_error( STATUS_ALERTED
);
624 static void complete_async_accept_recv( struct accept_req
*req
)
626 if (debug_level
) fprintf( stderr
, "completing accept recv request for socket %p\n", req
->acceptsock
);
628 assert( req
->recv_len
);
630 fill_accept_output( req
);
633 static void free_connect_req( void *private )
635 struct connect_req
*req
= private;
637 req
->sock
->connect_req
= NULL
;
638 release_object( req
->async
);
639 release_object( req
->iosb
);
640 release_object( req
->sock
);
644 static void complete_async_connect( struct sock
*sock
)
646 struct connect_req
*req
= sock
->connect_req
;
647 const char *in_buffer
;
652 if (debug_level
) fprintf( stderr
, "completing connect request for socket %p\n", sock
);
654 sock
->state
= SOCK_CONNECTED
;
658 set_error( STATUS_SUCCESS
);
663 in_buffer
= (const char *)iosb
->in_data
+ sizeof(struct afd_connect_params
) + req
->addr_len
;
664 len
= req
->send_len
- req
->send_cursor
;
666 ret
= send( get_unix_fd( sock
->fd
), in_buffer
+ req
->send_cursor
, len
, 0 );
667 if (ret
< 0 && errno
!= EWOULDBLOCK
)
668 set_error( sock_get_ntstatus( errno
) );
671 iosb
->result
= req
->send_len
;
672 iosb
->status
= STATUS_SUCCESS
;
673 set_error( STATUS_ALERTED
);
677 req
->send_cursor
+= ret
;
678 set_error( STATUS_PENDING
);
682 static void free_poll_req( void *private )
684 struct poll_req
*req
= private;
687 if (req
->timeout
) remove_timeout_user( req
->timeout
);
689 for (i
= 0; i
< req
->count
; ++i
)
690 release_object( req
->sockets
[i
].sock
);
691 release_object( req
->async
);
692 release_object( req
->iosb
);
693 list_remove( &req
->entry
);
697 static int is_oobinline( struct sock
*sock
)
700 socklen_t len
= sizeof(oobinline
);
701 return !getsockopt( get_unix_fd( sock
->fd
), SOL_SOCKET
, SO_OOBINLINE
, (char *)&oobinline
, &len
) && oobinline
;
704 static int get_poll_flags( struct sock
*sock
, int event
)
708 /* A connection-mode socket which has never been connected does not return
709 * write or hangup events, but Linux reports POLLOUT | POLLHUP. */
710 if (sock
->state
== SOCK_UNCONNECTED
)
711 event
&= ~(POLLOUT
| POLLHUP
);
715 if (sock
->state
== SOCK_LISTENING
)
716 flags
|= AFD_POLL_ACCEPT
;
718 flags
|= AFD_POLL_READ
;
721 flags
|= is_oobinline( sock
) ? AFD_POLL_READ
: AFD_POLL_OOB
;
723 flags
|= AFD_POLL_WRITE
;
724 if (sock
->state
== SOCK_CONNECTED
)
725 flags
|= AFD_POLL_CONNECT
;
727 flags
|= AFD_POLL_HUP
;
729 flags
|= AFD_POLL_CONNECT_ERR
;
734 static void complete_async_polls( struct sock
*sock
, int event
, int error
)
736 int flags
= get_poll_flags( sock
, event
);
737 struct poll_req
*req
, *next
;
739 LIST_FOR_EACH_ENTRY_SAFE( req
, next
, &poll_list
, struct poll_req
, entry
)
741 struct iosb
*iosb
= req
->iosb
;
744 if (iosb
->status
!= STATUS_PENDING
) continue;
746 for (i
= 0; i
< req
->count
; ++i
)
748 if (req
->sockets
[i
].sock
!= sock
) continue;
749 if (!(req
->sockets
[i
].flags
& flags
)) continue;
752 fprintf( stderr
, "completing poll for socket %p, wanted %#x got %#x\n",
753 sock
, req
->sockets
[i
].flags
, flags
);
755 req
->output
[i
].flags
= req
->sockets
[i
].flags
& flags
;
756 req
->output
[i
].status
= sock_get_ntstatus( error
);
758 iosb
->status
= STATUS_SUCCESS
;
759 iosb
->out_data
= req
->output
;
760 iosb
->out_size
= req
->count
* sizeof(*req
->output
);
761 async_terminate( req
->async
, STATUS_ALERTED
);
767 static void async_poll_timeout( void *private )
769 struct poll_req
*req
= private;
770 struct iosb
*iosb
= req
->iosb
;
774 if (iosb
->status
!= STATUS_PENDING
) return;
776 iosb
->status
= STATUS_TIMEOUT
;
777 iosb
->out_data
= req
->output
;
778 iosb
->out_size
= req
->count
* sizeof(*req
->output
);
779 async_terminate( req
->async
, STATUS_ALERTED
);
782 static int sock_dispatch_asyncs( struct sock
*sock
, int event
, int error
)
784 if (event
& (POLLIN
| POLLPRI
))
786 struct accept_req
*req
;
788 LIST_FOR_EACH_ENTRY( req
, &sock
->accept_list
, struct accept_req
, entry
)
790 if (req
->iosb
->status
== STATUS_PENDING
&& !req
->accepted
)
792 complete_async_accept( sock
, req
);
793 if (get_error() != STATUS_PENDING
)
794 async_terminate( req
->async
, get_error() );
799 if (sock
->accept_recv_req
&& sock
->accept_recv_req
->iosb
->status
== STATUS_PENDING
)
801 complete_async_accept_recv( sock
->accept_recv_req
);
802 if (get_error() != STATUS_PENDING
)
803 async_terminate( sock
->accept_recv_req
->async
, get_error() );
807 if ((event
& POLLOUT
) && sock
->connect_req
&& sock
->connect_req
->iosb
->status
== STATUS_PENDING
)
809 complete_async_connect( sock
);
810 if (get_error() != STATUS_PENDING
)
811 async_terminate( sock
->connect_req
->async
, get_error() );
814 if (event
& (POLLIN
| POLLPRI
) && async_waiting( &sock
->read_q
))
816 if (debug_level
) fprintf( stderr
, "activating read queue for socket %p\n", sock
);
817 async_wake_up( &sock
->read_q
, STATUS_ALERTED
);
818 event
&= ~(POLLIN
| POLLPRI
);
821 if (event
& POLLOUT
&& async_waiting( &sock
->write_q
))
823 if (debug_level
) fprintf( stderr
, "activating write queue for socket %p\n", sock
);
824 async_wake_up( &sock
->write_q
, STATUS_ALERTED
);
828 if (event
& (POLLERR
| POLLHUP
))
830 int status
= sock_get_ntstatus( error
);
831 struct accept_req
*req
, *next
;
833 if (sock
->rd_shutdown
)
834 async_wake_up( &sock
->read_q
, status
);
835 if (sock
->wr_shutdown
)
836 async_wake_up( &sock
->write_q
, status
);
838 LIST_FOR_EACH_ENTRY_SAFE( req
, next
, &sock
->accept_list
, struct accept_req
, entry
)
840 if (req
->iosb
->status
== STATUS_PENDING
)
841 async_terminate( req
->async
, status
);
844 if (sock
->accept_recv_req
&& sock
->accept_recv_req
->iosb
->status
== STATUS_PENDING
)
845 async_terminate( sock
->accept_recv_req
->async
, status
);
847 if (sock
->connect_req
)
848 async_terminate( sock
->connect_req
->async
, status
);
854 static void post_socket_event( struct sock
*sock
, enum afd_poll_bit event_bit
, int error
)
856 unsigned int event
= (1 << event_bit
);
858 if (!(sock
->reported_events
& event
))
860 sock
->pending_events
|= event
;
861 sock
->reported_events
|= event
;
862 sock
->errors
[event_bit
] = error
;
866 static void sock_dispatch_events( struct sock
*sock
, enum connection_state prevstate
, int event
, int error
)
870 case SOCK_UNCONNECTED
:
873 case SOCK_CONNECTING
:
875 post_socket_event( sock
, AFD_POLL_BIT_CONNECT
, 0 );
876 if (event
& (POLLERR
| POLLHUP
))
877 post_socket_event( sock
, AFD_POLL_BIT_CONNECT_ERR
, error
);
881 if (event
& (POLLIN
| POLLERR
| POLLHUP
))
882 post_socket_event( sock
, AFD_POLL_BIT_ACCEPT
, error
);
886 case SOCK_CONNECTIONLESS
:
888 post_socket_event( sock
, AFD_POLL_BIT_READ
, 0 );
891 post_socket_event( sock
, AFD_POLL_BIT_WRITE
, 0 );
894 post_socket_event( sock
, AFD_POLL_BIT_OOB
, 0 );
896 if (event
& (POLLERR
| POLLHUP
))
897 post_socket_event( sock
, AFD_POLL_BIT_HUP
, error
);
901 sock_wake_up( sock
);
904 static void sock_poll_event( struct fd
*fd
, int event
)
906 struct sock
*sock
= get_fd_user( fd
);
908 enum connection_state prevstate
= sock
->state
;
911 assert( sock
->obj
.ops
== &sock_ops
);
913 fprintf(stderr
, "socket %p select event: %x\n", sock
, event
);
915 /* we may change event later, remove from loop here */
916 if (event
& (POLLERR
|POLLHUP
)) set_fd_events( sock
->fd
, -1 );
920 case SOCK_UNCONNECTED
:
923 case SOCK_CONNECTING
:
924 if (event
& (POLLERR
|POLLHUP
))
926 sock
->state
= SOCK_UNCONNECTED
;
928 error
= sock_error( fd
);
930 else if (event
& POLLOUT
)
932 sock
->state
= SOCK_CONNECTED
;
933 sock
->connect_time
= current_time
;
938 if (event
& (POLLERR
|POLLHUP
))
939 error
= sock_error( fd
);
943 case SOCK_CONNECTIONLESS
:
944 if (sock
->type
== WS_SOCK_STREAM
&& (event
& POLLIN
))
949 /* Linux 2.4 doesn't report POLLHUP if only one side of the socket
950 * has been closed, so we need to check for it explicitly here */
951 nr
= recv( get_unix_fd( fd
), &dummy
, 1, MSG_PEEK
);
960 /* EAGAIN can happen if an async recv() falls between the server's poll()
961 call and the invocation of this routine */
962 if ( errno
!= EAGAIN
)
967 fprintf( stderr
, "recv error on socket %p: %d\n", sock
, errno
);
972 if ((hangup_seen
|| event
& (POLLHUP
| POLLERR
)) && (!sock
->rd_shutdown
|| !sock
->wr_shutdown
))
974 error
= error
? error
: sock_error( fd
);
975 if ( (event
& POLLERR
) || ( sock_shutdown_type
== SOCK_SHUTDOWN_EOF
&& (event
& POLLHUP
) ))
976 sock
->wr_shutdown
= 1;
977 sock
->rd_shutdown
= 1;
980 fprintf(stderr
, "socket %p aborted by error %d, event: %x\n", sock
, error
, event
);
988 complete_async_polls( sock
, event
, error
);
990 event
= sock_dispatch_asyncs( sock
, event
, error
);
991 sock_dispatch_events( sock
, prevstate
, event
, error
);
993 sock_reselect( sock
);
996 static void sock_dump( struct object
*obj
, int verbose
)
998 struct sock
*sock
= (struct sock
*)obj
;
999 assert( obj
->ops
== &sock_ops
);
1000 fprintf( stderr
, "Socket fd=%p, state=%x, mask=%x, pending=%x, reported=%x\n",
1001 sock
->fd
, sock
->state
,
1002 sock
->mask
, sock
->pending_events
, sock
->reported_events
);
1005 static int poll_flags_from_afd( struct sock
*sock
, int flags
)
1009 /* A connection-mode socket which has never been connected does
1010 * not return write or hangup events, but Linux returns
1011 * POLLOUT | POLLHUP. */
1012 if (sock
->state
== SOCK_UNCONNECTED
)
1015 if (flags
& (AFD_POLL_READ
| AFD_POLL_ACCEPT
))
1017 if ((flags
& AFD_POLL_HUP
) && sock
->type
== WS_SOCK_STREAM
)
1019 if (flags
& AFD_POLL_OOB
)
1020 ev
|= is_oobinline( sock
) ? POLLIN
: POLLPRI
;
1021 if (flags
& AFD_POLL_WRITE
)
1027 static int sock_get_poll_events( struct fd
*fd
)
1029 struct sock
*sock
= get_fd_user( fd
);
1030 unsigned int mask
= sock
->mask
& ~sock
->reported_events
;
1031 struct poll_req
*req
;
1034 assert( sock
->obj
.ops
== &sock_ops
);
1036 if (!sock
->type
) /* not initialized yet */
1039 switch (sock
->state
)
1041 case SOCK_UNCONNECTED
:
1042 /* A connection-mode Windows socket which has never been connected does
1043 * not return any events, but Linux returns POLLOUT | POLLHUP. Hence we
1044 * need to return -1 here, to prevent the socket from being polled on at
1048 case SOCK_CONNECTING
:
1051 case SOCK_LISTENING
:
1052 if (!list_empty( &sock
->accept_list
) || (mask
& AFD_POLL_ACCEPT
))
1056 case SOCK_CONNECTED
:
1057 case SOCK_CONNECTIONLESS
:
1058 if (sock
->accept_recv_req
)
1062 else if (async_queued( &sock
->read_q
))
1064 if (async_waiting( &sock
->read_q
)) ev
|= POLLIN
| POLLPRI
;
1066 else if (!sock
->rd_shutdown
&& (mask
& AFD_POLL_READ
))
1067 ev
|= POLLIN
| POLLPRI
;
1068 /* We use POLLIN with 0 bytes recv() as hangup indication for stream sockets. */
1069 else if (sock
->state
== SOCK_CONNECTED
&& (mask
& AFD_POLL_HUP
) && !(sock
->reported_events
& AFD_POLL_READ
))
1072 if (async_queued( &sock
->write_q
))
1074 if (async_waiting( &sock
->write_q
)) ev
|= POLLOUT
;
1076 else if (!sock
->wr_shutdown
&& (mask
& AFD_POLL_WRITE
))
1084 LIST_FOR_EACH_ENTRY( req
, &poll_list
, struct poll_req
, entry
)
1088 for (i
= 0; i
< req
->count
; ++i
)
1090 if (req
->sockets
[i
].sock
!= sock
) continue;
1092 ev
|= poll_flags_from_afd( sock
, req
->sockets
[i
].flags
);
1099 static enum server_fd_type
sock_get_fd_type( struct fd
*fd
)
1101 return FD_TYPE_SOCKET
;
1104 static void sock_queue_async( struct fd
*fd
, struct async
*async
, int type
, int count
)
1106 struct sock
*sock
= get_fd_user( fd
);
1107 struct async_queue
*queue
;
1109 assert( sock
->obj
.ops
== &sock_ops
);
1113 case ASYNC_TYPE_READ
:
1114 if (sock
->rd_shutdown
)
1116 set_error( STATUS_PIPE_DISCONNECTED
);
1119 queue
= &sock
->read_q
;
1122 case ASYNC_TYPE_WRITE
:
1123 if (sock
->wr_shutdown
)
1125 set_error( STATUS_PIPE_DISCONNECTED
);
1128 queue
= &sock
->write_q
;
1132 set_error( STATUS_INVALID_PARAMETER
);
1136 if (sock
->state
!= SOCK_CONNECTED
)
1138 set_error( STATUS_PIPE_DISCONNECTED
);
1142 queue_async( queue
, async
);
1143 sock_reselect( sock
);
1145 set_error( STATUS_PENDING
);
1148 static void sock_reselect_async( struct fd
*fd
, struct async_queue
*queue
)
1150 struct sock
*sock
= get_fd_user( fd
);
1152 if (sock
->wr_shutdown_pending
&& list_empty( &sock
->write_q
.queue
))
1153 shutdown( get_unix_fd( sock
->fd
), SHUT_WR
);
1155 /* Don't reselect the ifchange queue; we always ask for POLLIN.
1156 * Don't reselect an uninitialized socket; we can't call set_fd_events() on
1158 if (queue
!= &sock
->ifchange_q
&& sock
->type
)
1159 sock_reselect( sock
);
1162 static struct fd
*sock_get_fd( struct object
*obj
)
1164 struct sock
*sock
= (struct sock
*)obj
;
1165 return (struct fd
*)grab_object( sock
->fd
);
1168 static int sock_close_handle( struct object
*obj
, struct process
*process
, obj_handle_t handle
)
1170 struct sock
*sock
= (struct sock
*)obj
;
1172 if (sock
->obj
.handle_count
== 1) /* last handle */
1174 struct accept_req
*accept_req
, *accept_next
;
1175 struct poll_req
*poll_req
, *poll_next
;
1177 if (sock
->accept_recv_req
)
1178 async_terminate( sock
->accept_recv_req
->async
, STATUS_CANCELLED
);
1180 LIST_FOR_EACH_ENTRY_SAFE( accept_req
, accept_next
, &sock
->accept_list
, struct accept_req
, entry
)
1181 async_terminate( accept_req
->async
, STATUS_CANCELLED
);
1183 if (sock
->connect_req
)
1184 async_terminate( sock
->connect_req
->async
, STATUS_CANCELLED
);
1186 LIST_FOR_EACH_ENTRY_SAFE( poll_req
, poll_next
, &poll_list
, struct poll_req
, entry
)
1188 struct iosb
*iosb
= poll_req
->iosb
;
1191 if (iosb
->status
!= STATUS_PENDING
) continue;
1193 for (i
= 0; i
< poll_req
->count
; ++i
)
1195 if (poll_req
->sockets
[i
].sock
== sock
)
1197 iosb
->status
= STATUS_SUCCESS
;
1198 poll_req
->output
[i
].flags
= AFD_POLL_CLOSE
;
1199 poll_req
->output
[i
].status
= 0;
1203 if (iosb
->status
!= STATUS_PENDING
)
1205 iosb
->out_data
= poll_req
->output
;
1206 iosb
->out_size
= poll_req
->count
* sizeof(*poll_req
->output
);
1207 async_terminate( poll_req
->async
, STATUS_ALERTED
);
1215 static void sock_destroy( struct object
*obj
)
1217 struct sock
*sock
= (struct sock
*)obj
;
1219 assert( obj
->ops
== &sock_ops
);
1221 /* FIXME: special socket shutdown stuff? */
1223 if ( sock
->deferred
)
1224 release_object( sock
->deferred
);
1226 async_wake_up( &sock
->ifchange_q
, STATUS_CANCELLED
);
1227 sock_release_ifchange( sock
);
1228 free_async_queue( &sock
->read_q
);
1229 free_async_queue( &sock
->write_q
);
1230 free_async_queue( &sock
->ifchange_q
);
1231 free_async_queue( &sock
->accept_q
);
1232 free_async_queue( &sock
->connect_q
);
1233 free_async_queue( &sock
->poll_q
);
1234 if (sock
->event
) release_object( sock
->event
);
1237 /* shut the socket down to force pending poll() calls in the client to return */
1238 shutdown( get_unix_fd(sock
->fd
), SHUT_RDWR
);
1239 release_object( sock
->fd
);
1243 static struct sock
*create_socket(void)
1247 if (!(sock
= alloc_object( &sock_ops
))) return NULL
;
1249 sock
->state
= SOCK_UNCONNECTED
;
1251 sock
->pending_events
= 0;
1252 sock
->reported_events
= 0;
1261 sock
->connect_time
= 0;
1262 sock
->deferred
= NULL
;
1263 sock
->ifchange_obj
= NULL
;
1264 sock
->accept_recv_req
= NULL
;
1265 sock
->connect_req
= NULL
;
1266 sock
->rd_shutdown
= 0;
1267 sock
->wr_shutdown
= 0;
1268 sock
->wr_shutdown_pending
= 0;
1269 sock
->nonblocking
= 0;
1270 init_async_queue( &sock
->read_q
);
1271 init_async_queue( &sock
->write_q
);
1272 init_async_queue( &sock
->ifchange_q
);
1273 init_async_queue( &sock
->accept_q
);
1274 init_async_queue( &sock
->connect_q
);
1275 init_async_queue( &sock
->poll_q
);
1276 memset( sock
->errors
, 0, sizeof(sock
->errors
) );
1277 list_init( &sock
->accept_list
);
1281 static int get_unix_family( int family
)
1285 case WS_AF_INET
: return AF_INET
;
1286 case WS_AF_INET6
: return AF_INET6
;
1288 case WS_AF_IPX
: return AF_IPX
;
1291 case WS_AF_IRDA
: return AF_IRDA
;
1293 case WS_AF_UNSPEC
: return AF_UNSPEC
;
1298 static int get_unix_type( int type
)
1302 case WS_SOCK_DGRAM
: return SOCK_DGRAM
;
1303 case WS_SOCK_RAW
: return SOCK_RAW
;
1304 case WS_SOCK_STREAM
: return SOCK_STREAM
;
1309 static int get_unix_protocol( int protocol
)
1311 if (protocol
>= WS_NSPROTO_IPX
&& protocol
<= WS_NSPROTO_IPX
+ 255)
1316 case WS_IPPROTO_ICMP
: return IPPROTO_ICMP
;
1317 case WS_IPPROTO_IGMP
: return IPPROTO_IGMP
;
1318 case WS_IPPROTO_IP
: return IPPROTO_IP
;
1319 case WS_IPPROTO_IPV4
: return IPPROTO_IPIP
;
1320 case WS_IPPROTO_IPV6
: return IPPROTO_IPV6
;
1321 case WS_IPPROTO_RAW
: return IPPROTO_RAW
;
1322 case WS_IPPROTO_TCP
: return IPPROTO_TCP
;
1323 case WS_IPPROTO_UDP
: return IPPROTO_UDP
;
1328 static void set_dont_fragment( int fd
, int level
, int value
)
1332 if (level
== IPPROTO_IP
)
1335 optname
= IP_DONTFRAG
;
1336 #elif defined(IP_MTU_DISCOVER) && defined(IP_PMTUDISC_DO) && defined(IP_PMTUDISC_DONT)
1337 optname
= IP_MTU_DISCOVER
;
1338 value
= value
? IP_PMTUDISC_DO
: IP_PMTUDISC_DONT
;
1345 #ifdef IPV6_DONTFRAG
1346 optname
= IPV6_DONTFRAG
;
1347 #elif defined(IPV6_MTU_DISCOVER) && defined(IPV6_PMTUDISC_DO) && defined(IPV6_PMTUDISC_DONT)
1348 optname
= IPV6_MTU_DISCOVER
;
1349 value
= value
? IPV6_PMTUDISC_DO
: IPV6_PMTUDISC_DONT
;
1355 setsockopt( fd
, level
, optname
, &value
, sizeof(value
) );
1358 static int init_socket( struct sock
*sock
, int family
, int type
, int protocol
, unsigned int flags
)
1360 unsigned int options
= 0;
1361 int sockfd
, unix_type
, unix_family
, unix_protocol
;
1363 unix_family
= get_unix_family( family
);
1364 unix_type
= get_unix_type( type
);
1365 unix_protocol
= get_unix_protocol( protocol
);
1367 if (unix_protocol
< 0)
1369 if (type
&& unix_type
< 0)
1370 set_win32_error( WSAESOCKTNOSUPPORT
);
1372 set_win32_error( WSAEPROTONOSUPPORT
);
1375 if (unix_family
< 0)
1377 if (family
>= 0 && unix_type
< 0)
1378 set_win32_error( WSAESOCKTNOSUPPORT
);
1380 set_win32_error( WSAEAFNOSUPPORT
);
1384 sockfd
= socket( unix_family
, unix_type
, unix_protocol
);
1387 if (errno
== EINVAL
) set_win32_error( WSAESOCKTNOSUPPORT
);
1388 else set_win32_error( sock_get_error( errno
));
1391 fcntl(sockfd
, F_SETFL
, O_NONBLOCK
); /* make socket nonblocking */
1393 if (family
== WS_AF_IPX
&& protocol
>= WS_NSPROTO_IPX
&& protocol
<= WS_NSPROTO_IPX
+ 255)
1396 int ipx_type
= protocol
- WS_NSPROTO_IPX
;
1399 setsockopt( sockfd
, SOL_IPX
, IPX_TYPE
, &ipx_type
, sizeof(ipx_type
) );
1402 /* Should we retrieve val using a getsockopt call and then
1403 * set the modified one? */
1404 val
.ipx_pt
= ipx_type
;
1405 setsockopt( sockfd
, 0, SO_DEFAULT_HEADERS
, &val
, sizeof(val
) );
1410 if (unix_family
== AF_INET
|| unix_family
== AF_INET6
)
1412 /* ensure IP_DONTFRAGMENT is disabled for SOCK_DGRAM and SOCK_RAW, enabled for SOCK_STREAM */
1413 if (unix_type
== SOCK_DGRAM
|| unix_type
== SOCK_RAW
) /* in Linux the global default can be enabled */
1414 set_dont_fragment( sockfd
, unix_family
== AF_INET6
? IPPROTO_IPV6
: IPPROTO_IP
, FALSE
);
1415 else if (unix_type
== SOCK_STREAM
)
1416 set_dont_fragment( sockfd
, unix_family
== AF_INET6
? IPPROTO_IPV6
: IPPROTO_IP
, TRUE
);
1420 if (unix_family
== AF_INET6
)
1422 static const int enable
= 1;
1423 setsockopt( sockfd
, IPPROTO_IPV6
, IPV6_V6ONLY
, &enable
, sizeof(enable
) );
1427 sock
->state
= (type
== WS_SOCK_STREAM
? SOCK_UNCONNECTED
: SOCK_CONNECTIONLESS
);
1428 sock
->flags
= flags
;
1429 sock
->proto
= protocol
;
1431 sock
->family
= family
;
1435 options
= get_fd_options( sock
->fd
);
1436 release_object( sock
->fd
);
1439 if (!(sock
->fd
= create_anonymous_fd( &sock_fd_ops
, sockfd
, &sock
->obj
, options
)))
1444 /* We can't immediately allow caching for a connection-mode socket, since it
1445 * might be accepted into (changing the underlying fd object.) */
1446 if (sock
->type
!= WS_SOCK_STREAM
) allow_fd_caching( sock
->fd
);
1451 /* accepts a socket and inits it */
1452 static int accept_new_fd( struct sock
*sock
)
1455 /* Try to accept(2). We can't be safe that this an already connected socket
1456 * or that accept() is allowed on it. In those cases we will get -1/errno
1459 struct sockaddr saddr
;
1460 socklen_t slen
= sizeof(saddr
);
1461 int acceptfd
= accept( get_unix_fd(sock
->fd
), &saddr
, &slen
);
1463 fcntl( acceptfd
, F_SETFL
, O_NONBLOCK
);
1465 set_error( sock_get_ntstatus( errno
));
1469 /* accept a socket (creates a new fd) */
1470 static struct sock
*accept_socket( struct sock
*sock
)
1472 struct sock
*acceptsock
;
1475 if (get_unix_fd( sock
->fd
) == -1) return NULL
;
1477 if ( sock
->deferred
)
1479 acceptsock
= sock
->deferred
;
1480 sock
->deferred
= NULL
;
1484 if ((acceptfd
= accept_new_fd( sock
)) == -1) return NULL
;
1485 if (!(acceptsock
= create_socket()))
1491 /* newly created socket gets the same properties of the listening socket */
1492 acceptsock
->state
= SOCK_CONNECTED
;
1493 acceptsock
->nonblocking
= sock
->nonblocking
;
1494 acceptsock
->mask
= sock
->mask
;
1495 acceptsock
->proto
= sock
->proto
;
1496 acceptsock
->type
= sock
->type
;
1497 acceptsock
->family
= sock
->family
;
1498 acceptsock
->window
= sock
->window
;
1499 acceptsock
->message
= sock
->message
;
1500 acceptsock
->connect_time
= current_time
;
1501 if (sock
->event
) acceptsock
->event
= (struct event
*)grab_object( sock
->event
);
1502 acceptsock
->flags
= sock
->flags
;
1503 if (!(acceptsock
->fd
= create_anonymous_fd( &sock_fd_ops
, acceptfd
, &acceptsock
->obj
,
1504 get_fd_options( sock
->fd
) )))
1506 release_object( acceptsock
);
1511 sock
->pending_events
&= ~AFD_POLL_ACCEPT
;
1512 sock
->reported_events
&= ~AFD_POLL_ACCEPT
;
1513 sock_reselect( sock
);
1517 static int accept_into_socket( struct sock
*sock
, struct sock
*acceptsock
)
1522 if (get_unix_fd( sock
->fd
) == -1) return FALSE
;
1524 if ( sock
->deferred
)
1526 newfd
= dup_fd_object( sock
->deferred
->fd
, 0, 0,
1527 get_fd_options( acceptsock
->fd
) );
1531 set_fd_user( newfd
, &sock_fd_ops
, &acceptsock
->obj
);
1533 release_object( sock
->deferred
);
1534 sock
->deferred
= NULL
;
1538 if ((acceptfd
= accept_new_fd( sock
)) == -1)
1541 if (!(newfd
= create_anonymous_fd( &sock_fd_ops
, acceptfd
, &acceptsock
->obj
,
1542 get_fd_options( acceptsock
->fd
) )))
1546 acceptsock
->state
= SOCK_CONNECTED
;
1547 acceptsock
->pending_events
= 0;
1548 acceptsock
->reported_events
= 0;
1549 acceptsock
->proto
= sock
->proto
;
1550 acceptsock
->type
= sock
->type
;
1551 acceptsock
->family
= sock
->family
;
1552 acceptsock
->wparam
= 0;
1553 acceptsock
->deferred
= NULL
;
1554 acceptsock
->connect_time
= current_time
;
1555 fd_copy_completion( acceptsock
->fd
, newfd
);
1556 release_object( acceptsock
->fd
);
1557 acceptsock
->fd
= newfd
;
1560 sock
->pending_events
&= ~AFD_POLL_ACCEPT
;
1561 sock
->reported_events
&= ~AFD_POLL_ACCEPT
;
1562 sock_reselect( sock
);
1567 /* return an errno value mapped to a WSA error */
1568 static unsigned int sock_get_error( int err
)
1572 case EINTR
: return WSAEINTR
;
1573 case EBADF
: return WSAEBADF
;
1575 case EACCES
: return WSAEACCES
;
1576 case EFAULT
: return WSAEFAULT
;
1577 case EINVAL
: return WSAEINVAL
;
1578 case EMFILE
: return WSAEMFILE
;
1580 case EWOULDBLOCK
: return WSAEWOULDBLOCK
;
1581 case EALREADY
: return WSAEALREADY
;
1582 case ENOTSOCK
: return WSAENOTSOCK
;
1583 case EDESTADDRREQ
: return WSAEDESTADDRREQ
;
1584 case EMSGSIZE
: return WSAEMSGSIZE
;
1585 case EPROTOTYPE
: return WSAEPROTOTYPE
;
1586 case ENOPROTOOPT
: return WSAENOPROTOOPT
;
1587 case EPROTONOSUPPORT
: return WSAEPROTONOSUPPORT
;
1588 case ESOCKTNOSUPPORT
: return WSAESOCKTNOSUPPORT
;
1589 case EOPNOTSUPP
: return WSAEOPNOTSUPP
;
1590 case EPFNOSUPPORT
: return WSAEPFNOSUPPORT
;
1591 case EAFNOSUPPORT
: return WSAEAFNOSUPPORT
;
1592 case EADDRINUSE
: return WSAEADDRINUSE
;
1593 case EADDRNOTAVAIL
: return WSAEADDRNOTAVAIL
;
1594 case ENETDOWN
: return WSAENETDOWN
;
1595 case ENETUNREACH
: return WSAENETUNREACH
;
1596 case ENETRESET
: return WSAENETRESET
;
1597 case ECONNABORTED
: return WSAECONNABORTED
;
1599 case ECONNRESET
: return WSAECONNRESET
;
1600 case ENOBUFS
: return WSAENOBUFS
;
1601 case EISCONN
: return WSAEISCONN
;
1602 case ENOTCONN
: return WSAENOTCONN
;
1603 case ESHUTDOWN
: return WSAESHUTDOWN
;
1604 case ETOOMANYREFS
: return WSAETOOMANYREFS
;
1605 case ETIMEDOUT
: return WSAETIMEDOUT
;
1606 case ECONNREFUSED
: return WSAECONNREFUSED
;
1607 case ELOOP
: return WSAELOOP
;
1608 case ENAMETOOLONG
: return WSAENAMETOOLONG
;
1609 case EHOSTDOWN
: return WSAEHOSTDOWN
;
1610 case EHOSTUNREACH
: return WSAEHOSTUNREACH
;
1611 case ENOTEMPTY
: return WSAENOTEMPTY
;
1613 case EPROCLIM
: return WSAEPROCLIM
;
1616 case EUSERS
: return WSAEUSERS
;
1619 case EDQUOT
: return WSAEDQUOT
;
1622 case ESTALE
: return WSAESTALE
;
1625 case EREMOTE
: return WSAEREMOTE
;
1631 perror("wineserver: sock_get_error() can't map error");
1636 static int sock_get_ntstatus( int err
)
1640 case EBADF
: return STATUS_INVALID_HANDLE
;
1641 case EBUSY
: return STATUS_DEVICE_BUSY
;
1643 case EACCES
: return STATUS_ACCESS_DENIED
;
1644 case EFAULT
: return STATUS_ACCESS_VIOLATION
;
1645 case EINVAL
: return STATUS_INVALID_PARAMETER
;
1647 case EMFILE
: return STATUS_TOO_MANY_OPENED_FILES
;
1649 case EWOULDBLOCK
: return STATUS_DEVICE_NOT_READY
;
1650 case EALREADY
: return STATUS_NETWORK_BUSY
;
1651 case ENOTSOCK
: return STATUS_OBJECT_TYPE_MISMATCH
;
1652 case EDESTADDRREQ
: return STATUS_INVALID_PARAMETER
;
1653 case EMSGSIZE
: return STATUS_BUFFER_OVERFLOW
;
1654 case EPROTONOSUPPORT
:
1655 case ESOCKTNOSUPPORT
:
1658 case EPROTOTYPE
: return STATUS_NOT_SUPPORTED
;
1659 case ENOPROTOOPT
: return STATUS_INVALID_PARAMETER
;
1660 case EOPNOTSUPP
: return STATUS_NOT_SUPPORTED
;
1661 case EADDRINUSE
: return STATUS_SHARING_VIOLATION
;
1662 case EADDRNOTAVAIL
: return STATUS_INVALID_PARAMETER
;
1663 case ECONNREFUSED
: return STATUS_CONNECTION_REFUSED
;
1664 case ESHUTDOWN
: return STATUS_PIPE_DISCONNECTED
;
1665 case ENOTCONN
: return STATUS_INVALID_CONNECTION
;
1666 case ETIMEDOUT
: return STATUS_IO_TIMEOUT
;
1667 case ENETUNREACH
: return STATUS_NETWORK_UNREACHABLE
;
1668 case EHOSTUNREACH
: return STATUS_HOST_UNREACHABLE
;
1669 case ENETDOWN
: return STATUS_NETWORK_BUSY
;
1671 case ECONNRESET
: return STATUS_CONNECTION_RESET
;
1672 case ECONNABORTED
: return STATUS_CONNECTION_ABORTED
;
1673 case EISCONN
: return STATUS_CONNECTION_ACTIVE
;
1675 case 0: return STATUS_SUCCESS
;
1678 perror("wineserver: sock_get_ntstatus() can't map error");
1679 return STATUS_UNSUCCESSFUL
;
1683 static struct accept_req
*alloc_accept_req( struct sock
*sock
, struct sock
*acceptsock
, struct async
*async
,
1684 const struct afd_accept_into_params
*params
)
1686 struct accept_req
*req
= mem_alloc( sizeof(*req
) );
1690 req
->async
= (struct async
*)grab_object( async
);
1691 req
->iosb
= async_get_iosb( async
);
1692 req
->sock
= (struct sock
*)grab_object( sock
);
1693 req
->acceptsock
= acceptsock
;
1694 if (acceptsock
) grab_object( acceptsock
);
1700 req
->recv_len
= params
->recv_len
;
1701 req
->local_len
= params
->local_len
;
1707 static int sock_ioctl( struct fd
*fd
, ioctl_code_t code
, struct async
*async
)
1709 struct sock
*sock
= get_fd_user( fd
);
1712 assert( sock
->obj
.ops
== &sock_ops
);
1714 if (code
!= IOCTL_AFD_WINE_CREATE
&& (unix_fd
= get_unix_fd( fd
)) < 0) return 0;
1718 case IOCTL_AFD_WINE_CREATE
:
1720 const struct afd_create_params
*params
= get_req_data();
1722 if (get_req_data_size() != sizeof(*params
))
1724 set_error( STATUS_INVALID_PARAMETER
);
1727 init_socket( sock
, params
->family
, params
->type
, params
->protocol
, params
->flags
);
1731 case IOCTL_AFD_WINE_ACCEPT
:
1733 struct sock
*acceptsock
;
1734 obj_handle_t handle
;
1736 if (get_reply_max_size() != sizeof(handle
))
1738 set_error( STATUS_BUFFER_TOO_SMALL
);
1742 if (!(acceptsock
= accept_socket( sock
)))
1744 struct accept_req
*req
;
1746 if (sock
->nonblocking
) return 0;
1747 if (get_error() != STATUS_DEVICE_NOT_READY
) return 0;
1749 if (!(req
= alloc_accept_req( sock
, NULL
, async
, NULL
))) return 0;
1750 list_add_tail( &sock
->accept_list
, &req
->entry
);
1752 async_set_completion_callback( async
, free_accept_req
, req
);
1753 queue_async( &sock
->accept_q
, async
);
1754 sock_reselect( sock
);
1755 set_error( STATUS_PENDING
);
1758 handle
= alloc_handle( current
->process
, &acceptsock
->obj
,
1759 GENERIC_READ
| GENERIC_WRITE
| SYNCHRONIZE
, OBJ_INHERIT
);
1760 acceptsock
->wparam
= handle
;
1761 release_object( acceptsock
);
1762 set_reply_data( &handle
, sizeof(handle
) );
1766 case IOCTL_AFD_WINE_ACCEPT_INTO
:
1768 static const int access
= FILE_READ_ATTRIBUTES
| FILE_WRITE_ATTRIBUTES
| FILE_READ_DATA
;
1769 const struct afd_accept_into_params
*params
= get_req_data();
1770 struct sock
*acceptsock
;
1771 unsigned int remote_len
;
1772 struct accept_req
*req
;
1774 if (get_req_data_size() != sizeof(*params
) ||
1775 get_reply_max_size() < params
->recv_len
||
1776 get_reply_max_size() - params
->recv_len
< params
->local_len
)
1778 set_error( STATUS_BUFFER_TOO_SMALL
);
1782 remote_len
= get_reply_max_size() - params
->recv_len
- params
->local_len
;
1783 if (remote_len
< sizeof(int))
1785 set_error( STATUS_INVALID_PARAMETER
);
1789 if (!(acceptsock
= (struct sock
*)get_handle_obj( current
->process
, params
->accept_handle
, access
, &sock_ops
)))
1792 if (acceptsock
->accept_recv_req
)
1794 release_object( acceptsock
);
1795 set_error( STATUS_INVALID_PARAMETER
);
1799 if (!(req
= alloc_accept_req( sock
, acceptsock
, async
, params
)))
1801 release_object( acceptsock
);
1804 list_add_tail( &sock
->accept_list
, &req
->entry
);
1805 acceptsock
->accept_recv_req
= req
;
1806 release_object( acceptsock
);
1808 acceptsock
->wparam
= params
->accept_handle
;
1809 async_set_completion_callback( async
, free_accept_req
, req
);
1810 queue_async( &sock
->accept_q
, async
);
1811 sock_reselect( sock
);
1812 set_error( STATUS_PENDING
);
1816 case IOCTL_AFD_LISTEN
:
1818 const struct afd_listen_params
*params
= get_req_data();
1820 if (get_req_data_size() < sizeof(*params
))
1822 set_error( STATUS_INVALID_PARAMETER
);
1826 if (listen( unix_fd
, params
->backlog
) < 0)
1828 set_error( sock_get_ntstatus( errno
) );
1832 sock
->state
= SOCK_LISTENING
;
1834 /* a listening socket can no longer be accepted into */
1835 allow_fd_caching( sock
->fd
);
1837 /* we may already be selecting for AFD_POLL_ACCEPT */
1838 sock_reselect( sock
);
1842 case IOCTL_AFD_WINE_CONNECT
:
1844 const struct afd_connect_params
*params
= get_req_data();
1845 const struct sockaddr
*addr
;
1846 struct connect_req
*req
;
1849 if (get_req_data_size() < sizeof(*params
) ||
1850 get_req_data_size() - sizeof(*params
) < params
->addr_len
)
1852 set_error( STATUS_BUFFER_TOO_SMALL
);
1855 send_len
= get_req_data_size() - sizeof(*params
) - params
->addr_len
;
1856 addr
= (const struct sockaddr
*)(params
+ 1);
1858 if (sock
->accept_recv_req
)
1860 set_error( STATUS_INVALID_PARAMETER
);
1864 if (sock
->connect_req
)
1866 set_error( STATUS_INVALID_PARAMETER
);
1870 if (sock
->state
== SOCK_CONNECTING
)
1872 /* FIXME: STATUS_ADDRESS_ALREADY_ASSOCIATED probably isn't right,
1873 * but there's no status code that maps to WSAEALREADY... */
1874 set_error( params
->synchronous
? STATUS_ADDRESS_ALREADY_ASSOCIATED
: STATUS_INVALID_PARAMETER
);
1878 ret
= connect( unix_fd
, addr
, params
->addr_len
);
1879 if (ret
< 0 && errno
!= EINPROGRESS
)
1881 set_error( sock_get_ntstatus( errno
) );
1885 /* a connected or connecting socket can no longer be accepted into */
1886 allow_fd_caching( sock
->fd
);
1890 sock
->state
= SOCK_CONNECTED
;
1892 if (!send_len
) return 1;
1895 if (!(req
= mem_alloc( sizeof(*req
) )))
1898 sock
->state
= SOCK_CONNECTING
;
1900 if (params
->synchronous
&& sock
->nonblocking
)
1902 sock_reselect( sock
);
1903 set_error( STATUS_DEVICE_NOT_READY
);
1907 req
->async
= (struct async
*)grab_object( async
);
1908 req
->iosb
= async_get_iosb( async
);
1909 req
->sock
= (struct sock
*)grab_object( sock
);
1910 req
->addr_len
= params
->addr_len
;
1911 req
->send_len
= send_len
;
1912 req
->send_cursor
= 0;
1914 async_set_completion_callback( async
, free_connect_req
, req
);
1915 sock
->connect_req
= req
;
1916 queue_async( &sock
->connect_q
, async
);
1917 sock_reselect( sock
);
1918 set_error( STATUS_PENDING
);
1922 case IOCTL_AFD_WINE_SHUTDOWN
:
1926 if (get_req_data_size() < sizeof(int))
1928 set_error( STATUS_BUFFER_TOO_SMALL
);
1931 how
= *(int *)get_req_data();
1935 set_error( STATUS_INVALID_PARAMETER
);
1939 if (sock
->state
!= SOCK_CONNECTED
&& sock
->state
!= SOCK_CONNECTIONLESS
)
1941 set_error( STATUS_INVALID_CONNECTION
);
1947 sock
->rd_shutdown
= 1;
1949 if (how
!= SD_RECEIVE
)
1951 sock
->wr_shutdown
= 1;
1952 if (list_empty( &sock
->write_q
.queue
))
1953 shutdown( unix_fd
, SHUT_WR
);
1955 sock
->wr_shutdown_pending
= 1;
1960 if (sock
->event
) release_object( sock
->event
);
1964 sock
->nonblocking
= 1;
1967 sock_reselect( sock
);
1971 case IOCTL_AFD_WINE_ADDRESS_LIST_CHANGE
:
1975 if (get_req_data_size() < sizeof(int))
1977 set_error( STATUS_BUFFER_TOO_SMALL
);
1980 force_async
= *(int *)get_req_data();
1982 if (sock
->nonblocking
&& !force_async
)
1984 set_error( STATUS_DEVICE_NOT_READY
);
1987 if (!sock_get_ifchange( sock
)) return 0;
1988 queue_async( &sock
->ifchange_q
, async
);
1989 set_error( STATUS_PENDING
);
1993 case IOCTL_AFD_WINE_FIONBIO
:
1994 if (get_req_data_size() < sizeof(int))
1996 set_error( STATUS_BUFFER_TOO_SMALL
);
1999 if (*(int *)get_req_data())
2001 sock
->nonblocking
= 1;
2007 set_error( STATUS_INVALID_PARAMETER
);
2010 sock
->nonblocking
= 0;
2014 case IOCTL_AFD_EVENT_SELECT
:
2016 struct event
*event
= NULL
;
2017 obj_handle_t event_handle
;
2020 if (is_machine_64bit( current
->process
->machine
))
2022 const struct afd_event_select_params_64
*params
= get_req_data();
2024 if (get_req_data_size() < sizeof(params
))
2026 set_error( STATUS_INVALID_PARAMETER
);
2030 event_handle
= params
->event
;
2031 mask
= params
->mask
;
2035 const struct afd_event_select_params_32
*params
= get_req_data();
2037 if (get_req_data_size() < sizeof(params
))
2039 set_error( STATUS_INVALID_PARAMETER
);
2043 event_handle
= params
->event
;
2044 mask
= params
->mask
;
2047 if ((event_handle
|| mask
) &&
2048 !(event
= get_event_obj( current
->process
, event_handle
, EVENT_MODIFY_STATE
)))
2050 set_error( STATUS_INVALID_PARAMETER
);
2054 if (sock
->event
) release_object( sock
->event
);
2055 sock
->event
= event
;
2060 sock
->nonblocking
= 1;
2062 sock_reselect( sock
);
2068 set_error( STATUS_NOT_SUPPORTED
);
2073 static int poll_socket( struct sock
*poll_sock
, struct async
*async
, timeout_t timeout
,
2074 unsigned int count
, const struct poll_socket_input
*input
)
2076 struct poll_socket_output
*output
;
2077 struct poll_req
*req
;
2080 if (!(output
= mem_alloc( count
* sizeof(*output
) )))
2082 memset( output
, 0, count
* sizeof(*output
) );
2084 if (!(req
= mem_alloc( offsetof( struct poll_req
, sockets
[count
] ) )))
2090 req
->timeout
= NULL
;
2091 if (timeout
&& timeout
!= TIMEOUT_INFINITE
&&
2092 !(req
->timeout
= add_timeout_user( timeout
, async_poll_timeout
, req
)))
2099 for (i
= 0; i
< count
; ++i
)
2101 req
->sockets
[i
].sock
= (struct sock
*)get_handle_obj( current
->process
, input
[i
].socket
, 0, &sock_ops
);
2102 if (!req
->sockets
[i
].sock
)
2104 for (j
= 0; j
< i
; ++j
) release_object( req
->sockets
[i
].sock
);
2105 if (req
->timeout
) remove_timeout_user( req
->timeout
);
2110 req
->sockets
[i
].flags
= input
[i
].flags
;
2114 req
->async
= (struct async
*)grab_object( async
);
2115 req
->iosb
= async_get_iosb( async
);
2116 req
->output
= output
;
2118 list_add_tail( &poll_list
, &req
->entry
);
2119 async_set_completion_callback( async
, free_poll_req
, req
);
2120 queue_async( &poll_sock
->poll_q
, async
);
2122 if (!timeout
) req
->iosb
->status
= STATUS_SUCCESS
;
2124 for (i
= 0; i
< count
; ++i
)
2126 struct sock
*sock
= req
->sockets
[i
].sock
;
2127 struct pollfd pollfd
;
2130 pollfd
.fd
= get_unix_fd( sock
->fd
);
2131 pollfd
.events
= poll_flags_from_afd( sock
, req
->sockets
[i
].flags
);
2132 if (pollfd
.events
< 0 || poll( &pollfd
, 1, 0 ) < 0) continue;
2134 if ((req
->sockets
[i
].flags
& AFD_POLL_HUP
) && (pollfd
.revents
& POLLIN
) &&
2135 sock
->type
== WS_SOCK_STREAM
)
2139 if (!recv( get_unix_fd( sock
->fd
), &dummy
, 1, MSG_PEEK
))
2141 pollfd
.revents
&= ~POLLIN
;
2142 pollfd
.revents
|= POLLHUP
;
2146 flags
= get_poll_flags( sock
, pollfd
.revents
) & req
->sockets
[i
].flags
;
2149 req
->iosb
->status
= STATUS_SUCCESS
;
2150 output
[i
].flags
= flags
;
2151 output
[i
].status
= sock_get_ntstatus( sock_error( sock
->fd
) );
2155 if (req
->iosb
->status
!= STATUS_PENDING
)
2157 req
->iosb
->out_data
= output
;
2158 req
->iosb
->out_size
= count
* sizeof(*output
);
2159 async_terminate( req
->async
, STATUS_ALERTED
);
2162 for (i
= 0; i
< req
->count
; ++i
)
2163 sock_reselect( req
->sockets
[i
].sock
);
2164 set_error( STATUS_PENDING
);
2168 #ifdef HAVE_LINUX_RTNETLINK_H
2170 /* only keep one ifchange object around, all sockets waiting for wakeups will look to it */
2171 static struct object
*ifchange_object
;
2173 static void ifchange_dump( struct object
*obj
, int verbose
);
2174 static struct fd
*ifchange_get_fd( struct object
*obj
);
2175 static void ifchange_destroy( struct object
*obj
);
2177 static int ifchange_get_poll_events( struct fd
*fd
);
2178 static void ifchange_poll_event( struct fd
*fd
, int event
);
2182 struct object obj
; /* object header */
2183 struct fd
*fd
; /* interface change file descriptor */
2184 struct list sockets
; /* list of sockets to send interface change notifications */
2187 static const struct object_ops ifchange_ops
=
2189 sizeof(struct ifchange
), /* size */
2190 &no_type
, /* type */
2191 ifchange_dump
, /* dump */
2192 no_add_queue
, /* add_queue */
2193 NULL
, /* remove_queue */
2194 NULL
, /* signaled */
2195 no_satisfied
, /* satisfied */
2196 no_signal
, /* signal */
2197 ifchange_get_fd
, /* get_fd */
2198 default_map_access
, /* map_access */
2199 default_get_sd
, /* get_sd */
2200 default_set_sd
, /* set_sd */
2201 no_get_full_name
, /* get_full_name */
2202 no_lookup_name
, /* lookup_name */
2203 no_link_name
, /* link_name */
2204 NULL
, /* unlink_name */
2205 no_open_file
, /* open_file */
2206 no_kernel_obj_list
, /* get_kernel_obj_list */
2207 no_close_handle
, /* close_handle */
2208 ifchange_destroy
/* destroy */
2211 static const struct fd_ops ifchange_fd_ops
=
2213 ifchange_get_poll_events
, /* get_poll_events */
2214 ifchange_poll_event
, /* poll_event */
2215 NULL
, /* get_fd_type */
2216 no_fd_read
, /* read */
2217 no_fd_write
, /* write */
2218 no_fd_flush
, /* flush */
2219 no_fd_get_file_info
, /* get_file_info */
2220 no_fd_get_volume_info
, /* get_volume_info */
2221 no_fd_ioctl
, /* ioctl */
2222 NULL
, /* queue_async */
2223 NULL
/* reselect_async */
2226 static void ifchange_dump( struct object
*obj
, int verbose
)
2228 assert( obj
->ops
== &ifchange_ops
);
2229 fprintf( stderr
, "Interface change\n" );
2232 static struct fd
*ifchange_get_fd( struct object
*obj
)
2234 struct ifchange
*ifchange
= (struct ifchange
*)obj
;
2235 return (struct fd
*)grab_object( ifchange
->fd
);
2238 static void ifchange_destroy( struct object
*obj
)
2240 struct ifchange
*ifchange
= (struct ifchange
*)obj
;
2241 assert( obj
->ops
== &ifchange_ops
);
2243 release_object( ifchange
->fd
);
2245 /* reset the global ifchange object so that it will be recreated if it is needed again */
2246 assert( obj
== ifchange_object
);
2247 ifchange_object
= NULL
;
2250 static int ifchange_get_poll_events( struct fd
*fd
)
2255 /* wake up all the sockets waiting for a change notification event */
2256 static void ifchange_wake_up( struct object
*obj
, unsigned int status
)
2258 struct ifchange
*ifchange
= (struct ifchange
*)obj
;
2259 struct list
*ptr
, *next
;
2260 assert( obj
->ops
== &ifchange_ops
);
2261 assert( obj
== ifchange_object
);
2263 LIST_FOR_EACH_SAFE( ptr
, next
, &ifchange
->sockets
)
2265 struct sock
*sock
= LIST_ENTRY( ptr
, struct sock
, ifchange_entry
);
2267 assert( sock
->ifchange_obj
);
2268 async_wake_up( &sock
->ifchange_q
, status
); /* issue ifchange notification for the socket */
2269 sock_release_ifchange( sock
); /* remove socket from list and decrement ifchange refcount */
2273 static void ifchange_poll_event( struct fd
*fd
, int event
)
2275 struct object
*ifchange
= get_fd_user( fd
);
2276 unsigned int status
= STATUS_PENDING
;
2277 char buffer
[PIPE_BUF
];
2280 r
= recv( get_unix_fd(fd
), buffer
, sizeof(buffer
), MSG_DONTWAIT
);
2283 if (errno
== EWOULDBLOCK
|| (EWOULDBLOCK
!= EAGAIN
&& errno
== EAGAIN
))
2284 return; /* retry when poll() says the socket is ready */
2285 status
= sock_get_ntstatus( errno
);
2289 struct nlmsghdr
*nlh
;
2291 for (nlh
= (struct nlmsghdr
*)buffer
; NLMSG_OK(nlh
, r
); nlh
= NLMSG_NEXT(nlh
, r
))
2293 if (nlh
->nlmsg_type
== NLMSG_DONE
)
2295 if (nlh
->nlmsg_type
== RTM_NEWADDR
|| nlh
->nlmsg_type
== RTM_DELADDR
)
2296 status
= STATUS_SUCCESS
;
2299 else status
= STATUS_CANCELLED
;
2301 if (status
!= STATUS_PENDING
) ifchange_wake_up( ifchange
, status
);
2306 /* we only need one of these interface notification objects, all of the sockets dependent upon
2307 * it will wake up when a notification event occurs */
2308 static struct object
*get_ifchange( void )
2310 #ifdef HAVE_LINUX_RTNETLINK_H
2311 struct ifchange
*ifchange
;
2312 struct sockaddr_nl addr
;
2315 if (ifchange_object
)
2317 /* increment the refcount for each socket that uses the ifchange object */
2318 return grab_object( ifchange_object
);
2321 /* create the socket we need for processing interface change notifications */
2322 unix_fd
= socket( PF_NETLINK
, SOCK_RAW
, NETLINK_ROUTE
);
2325 set_error( sock_get_ntstatus( errno
));
2328 fcntl( unix_fd
, F_SETFL
, O_NONBLOCK
); /* make socket nonblocking */
2329 memset( &addr
, 0, sizeof(addr
) );
2330 addr
.nl_family
= AF_NETLINK
;
2331 addr
.nl_groups
= RTMGRP_IPV4_IFADDR
;
2332 /* bind the socket to the special netlink kernel interface */
2333 if (bind( unix_fd
, (struct sockaddr
*)&addr
, sizeof(addr
) ) == -1)
2336 set_error( sock_get_ntstatus( errno
));
2339 if (!(ifchange
= alloc_object( &ifchange_ops
)))
2342 set_error( STATUS_NO_MEMORY
);
2345 list_init( &ifchange
->sockets
);
2346 if (!(ifchange
->fd
= create_anonymous_fd( &ifchange_fd_ops
, unix_fd
, &ifchange
->obj
, 0 )))
2348 release_object( ifchange
);
2349 set_error( STATUS_NO_MEMORY
);
2352 set_fd_events( ifchange
->fd
, POLLIN
); /* enable read wakeup on the file descriptor */
2354 /* the ifchange object is now successfully configured */
2355 ifchange_object
= &ifchange
->obj
;
2356 return &ifchange
->obj
;
2358 set_error( STATUS_NOT_SUPPORTED
);
2363 /* add the socket to the interface change notification list */
2364 static void ifchange_add_sock( struct object
*obj
, struct sock
*sock
)
2366 #ifdef HAVE_LINUX_RTNETLINK_H
2367 struct ifchange
*ifchange
= (struct ifchange
*)obj
;
2369 list_add_tail( &ifchange
->sockets
, &sock
->ifchange_entry
);
2373 /* create a new ifchange queue for a specific socket or, if one already exists, reuse the existing one */
2374 static struct object
*sock_get_ifchange( struct sock
*sock
)
2376 struct object
*ifchange
;
2378 if (sock
->ifchange_obj
) /* reuse existing ifchange_obj for this socket */
2379 return sock
->ifchange_obj
;
2381 if (!(ifchange
= get_ifchange()))
2384 /* add the socket to the ifchange notification list */
2385 ifchange_add_sock( ifchange
, sock
);
2386 sock
->ifchange_obj
= ifchange
;
2390 /* destroy an existing ifchange queue for a specific socket */
2391 static void sock_release_ifchange( struct sock
*sock
)
2393 if (sock
->ifchange_obj
)
2395 list_remove( &sock
->ifchange_entry
);
2396 release_object( sock
->ifchange_obj
);
2397 sock
->ifchange_obj
= NULL
;
2401 static void socket_device_dump( struct object
*obj
, int verbose
);
2402 static struct object
*socket_device_lookup_name( struct object
*obj
, struct unicode_str
*name
,
2403 unsigned int attr
, struct object
*root
);
2404 static struct object
*socket_device_open_file( struct object
*obj
, unsigned int access
,
2405 unsigned int sharing
, unsigned int options
);
2407 static const struct object_ops socket_device_ops
=
2409 sizeof(struct object
), /* size */
2410 &device_type
, /* type */
2411 socket_device_dump
, /* dump */
2412 no_add_queue
, /* add_queue */
2413 NULL
, /* remove_queue */
2414 NULL
, /* signaled */
2415 no_satisfied
, /* satisfied */
2416 no_signal
, /* signal */
2417 no_get_fd
, /* get_fd */
2418 default_map_access
, /* map_access */
2419 default_get_sd
, /* get_sd */
2420 default_set_sd
, /* set_sd */
2421 default_get_full_name
, /* get_full_name */
2422 socket_device_lookup_name
, /* lookup_name */
2423 directory_link_name
, /* link_name */
2424 default_unlink_name
, /* unlink_name */
2425 socket_device_open_file
, /* open_file */
2426 no_kernel_obj_list
, /* get_kernel_obj_list */
2427 no_close_handle
, /* close_handle */
2428 no_destroy
/* destroy */
2431 static void socket_device_dump( struct object
*obj
, int verbose
)
2433 fputs( "Socket device\n", stderr
);
2436 static struct object
*socket_device_lookup_name( struct object
*obj
, struct unicode_str
*name
,
2437 unsigned int attr
, struct object
*root
)
2439 if (name
) name
->len
= 0;
2443 static struct object
*socket_device_open_file( struct object
*obj
, unsigned int access
,
2444 unsigned int sharing
, unsigned int options
)
2448 if (!(sock
= create_socket())) return NULL
;
2449 if (!(sock
->fd
= alloc_pseudo_fd( &sock_fd_ops
, &sock
->obj
, options
)))
2451 release_object( sock
);
2457 struct object
*create_socket_device( struct object
*root
, const struct unicode_str
*name
,
2458 unsigned int attr
, const struct security_descriptor
*sd
)
2460 return create_named_object( root
, &socket_device_ops
, name
, attr
, sd
);
2463 /* set socket event parameters */
2464 DECL_HANDLER(set_socket_event
)
2467 struct event
*old_event
;
2469 if (!(sock
= (struct sock
*)get_handle_obj( current
->process
, req
->handle
,
2470 FILE_WRITE_ATTRIBUTES
, &sock_ops
))) return;
2471 if (get_unix_fd( sock
->fd
) == -1) return;
2472 old_event
= sock
->event
;
2473 sock
->mask
= afd_poll_flag_from_win32( req
->mask
);
2476 sock
->pending_events
&= ~sock
->mask
;
2477 sock
->reported_events
&= ~sock
->mask
;
2480 sock
->window
= req
->window
;
2481 sock
->message
= req
->msg
;
2482 sock
->wparam
= req
->handle
; /* wparam is the socket handle */
2483 if (req
->event
) sock
->event
= get_event_obj( current
->process
, req
->event
, EVENT_MODIFY_STATE
);
2485 if (debug_level
&& sock
->event
) fprintf(stderr
, "event ptr: %p\n", sock
->event
);
2487 sock_reselect( sock
);
2489 sock
->nonblocking
= 1;
2491 /* if a network event is pending, signal the event object
2492 it is possible that CONNECT or ACCEPT network events has happened
2493 before a WSAEventSelect() was done on it.
2494 (when dealing with Asynchronous socket) */
2495 sock_wake_up( sock
);
2497 if (old_event
) release_object( old_event
); /* we're through with it */
2498 release_object( &sock
->obj
);
2501 /* get socket event parameters */
2502 DECL_HANDLER(get_socket_event
)
2504 unsigned int errors
[FD_MAX_EVENTS
] = {0};
2507 if (!(sock
= (struct sock
*)get_handle_obj( current
->process
, req
->handle
,
2508 FILE_READ_ATTRIBUTES
, &sock_ops
))) return;
2509 if (get_unix_fd( sock
->fd
) == -1) return;
2510 reply
->mask
= afd_poll_flag_to_win32( sock
->mask
);
2511 reply
->pmask
= afd_poll_flag_to_win32( sock
->pending_events
);
2513 errors
[FD_READ_BIT
] = sock_get_error( sock
->errors
[AFD_POLL_BIT_READ
] );
2514 errors
[FD_WRITE_BIT
] = sock_get_error( sock
->errors
[AFD_POLL_BIT_WRITE
] );
2515 errors
[FD_OOB_BIT
] = sock_get_error( sock
->errors
[AFD_POLL_BIT_OOB
] );
2516 errors
[FD_ACCEPT_BIT
] = sock_get_error( sock
->errors
[AFD_POLL_BIT_ACCEPT
] );
2517 errors
[FD_CONNECT_BIT
] = sock_get_error( sock
->errors
[AFD_POLL_BIT_CONNECT_ERR
] );
2518 if (!(errors
[FD_CLOSE_BIT
] = sock_get_error( sock
->errors
[AFD_POLL_BIT_HUP
] )))
2519 errors
[FD_CLOSE_BIT
] = sock_get_error( sock
->errors
[AFD_POLL_BIT_RESET
] );
2520 set_reply_data( errors
, min( get_reply_max_size(), sizeof(errors
) ));
2526 struct event
*cevent
= get_event_obj( current
->process
, req
->c_event
,
2527 EVENT_MODIFY_STATE
);
2530 reset_event( cevent
);
2531 release_object( cevent
);
2534 sock
->pending_events
= 0;
2535 sock_reselect( sock
);
2537 release_object( &sock
->obj
);
2540 DECL_HANDLER(set_socket_deferred
)
2542 struct sock
*sock
, *acceptsock
;
2544 sock
=(struct sock
*)get_handle_obj( current
->process
, req
->handle
, FILE_WRITE_ATTRIBUTES
, &sock_ops
);
2548 acceptsock
= (struct sock
*)get_handle_obj( current
->process
, req
->deferred
, 0, &sock_ops
);
2551 release_object( sock
);
2554 sock
->deferred
= acceptsock
;
2555 release_object( sock
);
2558 DECL_HANDLER(get_socket_info
)
2562 sock
= (struct sock
*)get_handle_obj( current
->process
, req
->handle
, FILE_READ_ATTRIBUTES
, &sock_ops
);
2565 if (get_unix_fd( sock
->fd
) == -1) return;
2567 reply
->family
= sock
->family
;
2568 reply
->type
= sock
->type
;
2569 reply
->protocol
= sock
->proto
;
2571 release_object( &sock
->obj
);
2574 DECL_HANDLER(recv_socket
)
2576 struct sock
*sock
= (struct sock
*)get_handle_obj( current
->process
, req
->async
.handle
, 0, &sock_ops
);
2577 unsigned int status
= req
->status
;
2578 timeout_t timeout
= 0;
2579 struct async
*async
;
2585 /* recv() returned EWOULDBLOCK, i.e. no data available yet */
2586 if (status
== STATUS_DEVICE_NOT_READY
&& !sock
->nonblocking
)
2590 socklen_t len
= sizeof(tv
);
2592 /* Set a timeout on the async if necessary.
2594 * We want to do this *only* if the client gave us STATUS_DEVICE_NOT_READY.
2595 * If the client gave us STATUS_PENDING, it expects the async to always
2596 * block (it was triggered by WSARecv*() with a valid OVERLAPPED
2597 * structure) and for the timeout not to be respected. */
2598 if (is_fd_overlapped( fd
) && !getsockopt( get_unix_fd( fd
), SOL_SOCKET
, SO_RCVTIMEO
, (char *)&tv
, &len
))
2599 timeout
= tv
.tv_sec
* -10000000 + tv
.tv_usec
* -10;
2602 status
= STATUS_PENDING
;
2605 if (status
== STATUS_PENDING
&& sock
->rd_shutdown
) status
= STATUS_PIPE_DISCONNECTED
;
2607 sock
->pending_events
&= ~(req
->oob
? AFD_POLL_OOB
: AFD_POLL_READ
);
2608 sock
->reported_events
&= ~(req
->oob
? AFD_POLL_OOB
: AFD_POLL_READ
);
2610 if ((async
= create_request_async( fd
, get_fd_comp_flags( fd
), &req
->async
)))
2614 if (status
== STATUS_SUCCESS
)
2616 struct iosb
*iosb
= async_get_iosb( async
);
2617 iosb
->result
= req
->total
;
2618 release_object( iosb
);
2621 else if (status
== STATUS_PENDING
)
2625 set_error( status
);
2628 async_set_timeout( async
, timeout
, STATUS_IO_TIMEOUT
);
2630 if (status
== STATUS_PENDING
)
2631 queue_async( &sock
->read_q
, async
);
2633 /* always reselect; we changed reported_events above */
2634 sock_reselect( sock
);
2636 reply
->wait
= async_handoff( async
, success
, NULL
, 0 );
2637 reply
->options
= get_fd_options( fd
);
2638 release_object( async
);
2640 release_object( sock
);
2643 DECL_HANDLER(poll_socket
)
2645 struct sock
*sock
= (struct sock
*)get_handle_obj( current
->process
, req
->async
.handle
, 0, &sock_ops
);
2646 const struct poll_socket_input
*input
= get_req_data();
2647 struct async
*async
;
2652 count
= get_req_data_size() / sizeof(*input
);
2654 if ((async
= create_request_async( sock
->fd
, get_fd_comp_flags( sock
->fd
), &req
->async
)))
2656 reply
->wait
= async_handoff( async
, poll_socket( sock
, async
, req
->timeout
, count
, input
), NULL
, 0 );
2657 reply
->options
= get_fd_options( sock
->fd
);
2658 release_object( async
);
2661 release_object( sock
);
2664 DECL_HANDLER(send_socket
)
2666 struct sock
*sock
= (struct sock
*)get_handle_obj( current
->process
, req
->async
.handle
, 0, &sock_ops
);
2667 unsigned int status
= req
->status
;
2668 timeout_t timeout
= 0;
2669 struct async
*async
;
2675 if (status
!= STATUS_SUCCESS
)
2677 /* send() calls only clear and reselect events if unsuccessful. */
2678 sock
->pending_events
&= ~AFD_POLL_WRITE
;
2679 sock
->reported_events
&= ~AFD_POLL_WRITE
;
2682 /* If we had a short write and the socket is nonblocking (and the client is
2683 * not trying to force the operation to be asynchronous), return success.
2684 * Windows actually refuses to send any data in this case, and returns
2685 * EWOULDBLOCK, but we have no way of doing that. */
2686 if (status
== STATUS_DEVICE_NOT_READY
&& req
->total
&& sock
->nonblocking
)
2687 status
= STATUS_SUCCESS
;
2689 /* send() returned EWOULDBLOCK or a short write, i.e. cannot send all data yet */
2690 if (status
== STATUS_DEVICE_NOT_READY
&& !sock
->nonblocking
)
2694 socklen_t len
= sizeof(tv
);
2696 /* Set a timeout on the async if necessary.
2698 * We want to do this *only* if the client gave us STATUS_DEVICE_NOT_READY.
2699 * If the client gave us STATUS_PENDING, it expects the async to always
2700 * block (it was triggered by WSASend*() with a valid OVERLAPPED
2701 * structure) and for the timeout not to be respected. */
2702 if (is_fd_overlapped( fd
) && !getsockopt( get_unix_fd( fd
), SOL_SOCKET
, SO_SNDTIMEO
, (char *)&tv
, &len
))
2703 timeout
= tv
.tv_sec
* -10000000 + tv
.tv_usec
* -10;
2706 status
= STATUS_PENDING
;
2709 if (status
== STATUS_PENDING
&& sock
->wr_shutdown
) status
= STATUS_PIPE_DISCONNECTED
;
2711 if ((async
= create_request_async( fd
, get_fd_comp_flags( fd
), &req
->async
)))
2715 if (status
== STATUS_SUCCESS
)
2717 struct iosb
*iosb
= async_get_iosb( async
);
2718 iosb
->result
= req
->total
;
2719 release_object( iosb
);
2722 else if (status
== STATUS_PENDING
)
2726 set_error( status
);
2729 async_set_timeout( async
, timeout
, STATUS_IO_TIMEOUT
);
2731 if (status
== STATUS_PENDING
)
2732 queue_async( &sock
->write_q
, async
);
2734 /* always reselect; we changed reported_events above */
2735 sock_reselect( sock
);
2737 reply
->wait
= async_handoff( async
, success
, NULL
, 0 );
2738 reply
->options
= get_fd_options( fd
);
2739 release_object( async
);
2741 release_object( sock
);