?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
server: Avoid leaking the poll output buffer if the request is terminated irregularly...
[wine.git] / server / sock.c
blob03716cba90f58e51e1ba35ff08d91f3be8400736
1 /*
2 * Server-side socket management
3 *
4 * Copyright (C) 1999 Marcus Meissner, Ove Kåven
5 *
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.
10 *
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.
15 *
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
19 *
20 * FIXME: we use read|write access in all cases. Shouldn't we depend that
21 * on the access of the current handle?
22 */
23
24 #include "config.h"
25
26 #include <assert.h>
27 #include <fcntl.h>
28 #include <stdarg.h>
29 #include <stdio.h>
30 #include <string.h>
31 #include <stdlib.h>
32 #include <errno.h>
33 #ifdef HAVE_IFADDRS_H
34 # include <ifaddrs.h>
35 #endif
36 #ifdef HAVE_NET_IF_H
37 # include <net/if.h>
38 #endif
39 #ifdef HAVE_NETINET_IN_H
40 # include <netinet/in.h>
41 #endif
42 #ifdef HAVE_POLL_H
43 # include <poll.h>
44 #endif
45 #include <sys/time.h>
46 #include <sys/types.h>
47 #ifdef HAVE_SYS_SOCKET_H
48 # include <sys/socket.h>
49 #endif
50 #ifdef HAVE_SYS_IOCTL_H
51 #include <sys/ioctl.h>
52 #endif
53 #ifdef HAVE_SYS_FILIO_H
54 # include <sys/filio.h>
55 #endif
56 #include <time.h>
57 #include <unistd.h>
58 #include <limits.h>
59 #ifdef HAVE_LINUX_FILTER_H
60 # include <linux/filter.h>
61 #endif
62 #ifdef HAVE_LINUX_RTNETLINK_H
63 # include <linux/rtnetlink.h>
64 #endif
65
66 #ifdef HAVE_NETIPX_IPX_H
67 # include <netipx/ipx.h>
68 #elif defined(HAVE_LINUX_IPX_H)
69 # ifdef HAVE_ASM_TYPES_H
70 # include <asm/types.h>
71 # endif
72 # ifdef HAVE_LINUX_TYPES_H
73 # include <linux/types.h>
74 # endif
75 # include <linux/ipx.h>
76 #endif
77 #if defined(SOL_IPX) || defined(SO_DEFAULT_HEADERS)
78 # define HAS_IPX
79 #endif
80
81 #ifdef HAVE_LINUX_IRDA_H
82 # ifdef HAVE_LINUX_TYPES_H
83 # include <linux/types.h>
84 # endif
85 # include <linux/irda.h>
86 # define HAS_IRDA
87 #endif
88
89 #include "ntstatus.h"
90 #define WIN32_NO_STATUS
91 #include "windef.h"
92 #include "winternl.h"
93 #include "winerror.h"
94 #define USE_WS_PREFIX
95 #include "winsock2.h"
96 #include "ws2tcpip.h"
97 #include "wsipx.h"
98 #include "af_irda.h"
99 #include "wine/afd.h"
100
101 #include "process.h"
102 #include "file.h"
103 #include "handle.h"
104 #include "thread.h"
105 #include "request.h"
106 #include "user.h"
107
108 #if defined(linux) && !defined(IP_UNICAST_IF)
109 #define IP_UNICAST_IF 50
110 #endif
111
112 static const char magic_loopback_addr[] = {127, 12, 34, 56};
113
114 union win_sockaddr
115 {
116 struct WS_sockaddr addr;
117 struct WS_sockaddr_in in;
118 struct WS_sockaddr_in6 in6;
119 struct WS_sockaddr_ipx ipx;
120 SOCKADDR_IRDA irda;
121 };
122
123 static struct list poll_list = LIST_INIT( poll_list );
124
125 struct poll_req
126 {
127 struct list entry;
128 struct async *async;
129 struct iosb *iosb;
130 struct timeout_user *timeout;
131 int exclusive;
132 unsigned int count;
133 struct poll_socket_output *output;
134 struct
135 {
136 struct sock *sock;
137 int flags;
138 } sockets[1];
139 };
140
141 struct accept_req
142 {
143 struct list entry;
144 struct async *async;
145 struct iosb *iosb;
146 struct sock *sock, *acceptsock;
147 int accepted;
148 unsigned int recv_len, local_len;
149 };
150
151 struct connect_req
152 {
153 struct async *async;
154 struct iosb *iosb;
155 struct sock *sock;
156 unsigned int addr_len, send_len, send_cursor;
157 };
158
159 enum connection_state
160 {
161 SOCK_LISTENING,
162 SOCK_UNCONNECTED,
163 SOCK_CONNECTING,
164 SOCK_CONNECTED,
165 SOCK_CONNECTIONLESS,
166 };
167
168 struct sock
169 {
170 struct object obj; /* object header */
171 struct fd *fd; /* socket file descriptor */
172 enum connection_state state; /* connection state */
173 unsigned int mask; /* event mask */
174 /* pending AFD_POLL_* events which have not yet been reported to the application */
175 unsigned int pending_events;
176 /* AFD_POLL_* events which have already been reported and should not be
177 * selected for again until reset by a relevant call.
178 *
179 * For example, if AFD_POLL_READ is set here and not in pending_events, it
180 * has already been reported and consumed, and we should not report it
181 * again, even if POLLIN is signaled, until it is reset by e.g recv().
182 *
183 * If an event has been signaled and not consumed yet, it will be set in
184 * both pending_events and reported_events (as we should only ever report
185 * any event once until it is reset.) */
186 unsigned int reported_events;
187 unsigned int flags; /* socket flags */
188 unsigned short proto; /* socket protocol */
189 unsigned short type; /* socket type */
190 unsigned short family; /* socket family */
191 struct event *event; /* event object */
192 user_handle_t window; /* window to send the message to */
193 unsigned int message; /* message to send */
194 obj_handle_t wparam; /* message wparam (socket handle) */
195 int errors[AFD_POLL_BIT_COUNT]; /* event errors */
196 timeout_t connect_time;/* time the socket was connected */
197 struct sock *deferred; /* socket that waits for a deferred accept */
198 struct async_queue read_q; /* queue for asynchronous reads */
199 struct async_queue write_q; /* queue for asynchronous writes */
200 struct async_queue ifchange_q; /* queue for interface change notifications */
201 struct async_queue accept_q; /* queue for asynchronous accepts */
202 struct async_queue connect_q; /* queue for asynchronous connects */
203 struct async_queue poll_q; /* queue for asynchronous polls */
204 struct object *ifchange_obj; /* the interface change notification object */
205 struct list ifchange_entry; /* entry in ifchange notification list */
206 struct list accept_list; /* list of pending accept requests */
207 struct accept_req *accept_recv_req; /* pending accept-into request which will recv on this socket */
208 struct connect_req *connect_req; /* pending connection request */
209 struct poll_req *main_poll; /* main poll */
210 union win_sockaddr addr; /* socket name */
211 int addr_len; /* socket name length */
212 unsigned int rcvbuf; /* advisory recv buffer size */
213 unsigned int sndbuf; /* advisory send buffer size */
214 unsigned int rcvtimeo; /* receive timeout in ms */
215 unsigned int sndtimeo; /* send timeout in ms */
216 unsigned int rd_shutdown : 1; /* is the read end shut down? */
217 unsigned int wr_shutdown : 1; /* is the write end shut down? */
218 unsigned int wr_shutdown_pending : 1; /* is a write shutdown pending? */
219 unsigned int hangup : 1; /* has the read end received a hangup? */
220 unsigned int aborted : 1; /* did we get a POLLERR or irregular POLLHUP? */
221 unsigned int nonblocking : 1; /* is the socket nonblocking? */
222 unsigned int bound : 1; /* is the socket bound? */
223 };
224
225 static void sock_dump( struct object *obj, int verbose );
226 static struct fd *sock_get_fd( struct object *obj );
227 static int sock_close_handle( struct object *obj, struct process *process, obj_handle_t handle );
228 static void sock_destroy( struct object *obj );
229 static struct object *sock_get_ifchange( struct sock *sock );
230 static void sock_release_ifchange( struct sock *sock );
231
232 static int sock_get_poll_events( struct fd *fd );
233 static void sock_poll_event( struct fd *fd, int event );
234 static enum server_fd_type sock_get_fd_type( struct fd *fd );
235 static void sock_ioctl( struct fd *fd, ioctl_code_t code, struct async *async );
236 static void sock_cancel_async( struct fd *fd, struct async *async );
237 static void sock_queue_async( struct fd *fd, struct async *async, int type, int count );
238 static void sock_reselect_async( struct fd *fd, struct async_queue *queue );
239
240 static int accept_into_socket( struct sock *sock, struct sock *acceptsock );
241 static struct sock *accept_socket( struct sock *sock );
242 static int sock_get_ntstatus( int err );
243 static unsigned int sock_get_error( int err );
244
245 static const struct object_ops sock_ops =
246 {
247 sizeof(struct sock), /* size */
248 &file_type, /* type */
249 sock_dump, /* dump */
250 add_queue, /* add_queue */
251 remove_queue, /* remove_queue */
252 default_fd_signaled, /* signaled */
253 no_satisfied, /* satisfied */
254 no_signal, /* signal */
255 sock_get_fd, /* get_fd */
256 default_map_access, /* map_access */
257 default_get_sd, /* get_sd */
258 default_set_sd, /* set_sd */
259 no_get_full_name, /* get_full_name */
260 no_lookup_name, /* lookup_name */
261 no_link_name, /* link_name */
262 NULL, /* unlink_name */
263 no_open_file, /* open_file */
264 no_kernel_obj_list, /* get_kernel_obj_list */
265 sock_close_handle, /* close_handle */
266 sock_destroy /* destroy */
267 };
268
269 static const struct fd_ops sock_fd_ops =
270 {
271 sock_get_poll_events, /* get_poll_events */
272 sock_poll_event, /* poll_event */
273 sock_get_fd_type, /* get_fd_type */
274 no_fd_read, /* read */
275 no_fd_write, /* write */
276 no_fd_flush, /* flush */
277 default_fd_get_file_info, /* get_file_info */
278 no_fd_get_volume_info, /* get_volume_info */
279 sock_ioctl, /* ioctl */
280 sock_cancel_async, /* cancel_async */
281 sock_queue_async, /* queue_async */
282 sock_reselect_async /* reselect_async */
283 };
284
285 union unix_sockaddr
286 {
287 struct sockaddr addr;
288 struct sockaddr_in in;
289 struct sockaddr_in6 in6;
290 #ifdef HAS_IPX
291 struct sockaddr_ipx ipx;
292 #endif
293 #ifdef HAS_IRDA
294 struct sockaddr_irda irda;
295 #endif
296 };
297
298 static int sockaddr_from_unix( const union unix_sockaddr *uaddr, struct WS_sockaddr *wsaddr, socklen_t wsaddrlen )
299 {
300 memset( wsaddr, 0, wsaddrlen );
301
302 switch (uaddr->addr.sa_family)
303 {
304 case AF_INET:
305 {
306 struct WS_sockaddr_in win = {0};
307
308 if (wsaddrlen < sizeof(win)) return -1;
309 win.sin_family = WS_AF_INET;
310 win.sin_port = uaddr->in.sin_port;
311 memcpy( &win.sin_addr, &uaddr->in.sin_addr, sizeof(win.sin_addr) );
312 memcpy( wsaddr, &win, sizeof(win) );
313 return sizeof(win);
314 }
315
316 case AF_INET6:
317 {
318 struct WS_sockaddr_in6 win = {0};
319
320 if (wsaddrlen < sizeof(win)) return -1;
321 win.sin6_family = WS_AF_INET6;
322 win.sin6_port = uaddr->in6.sin6_port;
323 win.sin6_flowinfo = uaddr->in6.sin6_flowinfo;
324 memcpy( &win.sin6_addr, &uaddr->in6.sin6_addr, sizeof(win.sin6_addr) );
325 #ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID
326 win.sin6_scope_id = uaddr->in6.sin6_scope_id;
327 #endif
328 memcpy( wsaddr, &win, sizeof(win) );
329 return sizeof(win);
330 }
331
332 #ifdef HAS_IPX
333 case AF_IPX:
334 {
335 struct WS_sockaddr_ipx win = {0};
336
337 if (wsaddrlen < sizeof(win)) return -1;
338 win.sa_family = WS_AF_IPX;
339 memcpy( win.sa_netnum, &uaddr->ipx.sipx_network, sizeof(win.sa_netnum) );
340 memcpy( win.sa_nodenum, &uaddr->ipx.sipx_node, sizeof(win.sa_nodenum) );
341 win.sa_socket = uaddr->ipx.sipx_port;
342 memcpy( wsaddr, &win, sizeof(win) );
343 return sizeof(win);
344 }
345 #endif
346
347 #ifdef HAS_IRDA
348 case AF_IRDA:
349 {
350 SOCKADDR_IRDA win;
351
352 if (wsaddrlen < sizeof(win)) return -1;
353 win.irdaAddressFamily = WS_AF_IRDA;
354 memcpy( win.irdaDeviceID, &uaddr->irda.sir_addr, sizeof(win.irdaDeviceID) );
355 if (uaddr->irda.sir_lsap_sel != LSAP_ANY)
356 snprintf( win.irdaServiceName, sizeof(win.irdaServiceName), "LSAP-SEL%u", uaddr->irda.sir_lsap_sel );
357 else
358 memcpy( win.irdaServiceName, uaddr->irda.sir_name, sizeof(win.irdaServiceName) );
359 memcpy( wsaddr, &win, sizeof(win) );
360 return sizeof(win);
361 }
362 #endif
363
364 case AF_UNSPEC:
365 return 0;
366
367 default:
368 return -1;
369
370 }
371 }
372
373 static socklen_t sockaddr_to_unix( const struct WS_sockaddr *wsaddr, int wsaddrlen, union unix_sockaddr *uaddr )
374 {
375 memset( uaddr, 0, sizeof(*uaddr) );
376
377 switch (wsaddr->sa_family)
378 {
379 case WS_AF_INET:
380 {
381 struct WS_sockaddr_in win = {0};
382
383 if (wsaddrlen < sizeof(win)) return 0;
384 memcpy( &win, wsaddr, sizeof(win) );
385 uaddr->in.sin_family = AF_INET;
386 uaddr->in.sin_port = win.sin_port;
387 memcpy( &uaddr->in.sin_addr, &win.sin_addr, sizeof(win.sin_addr) );
388 return sizeof(uaddr->in);
389 }
390
391 case WS_AF_INET6:
392 {
393 struct WS_sockaddr_in6 win = {0};
394
395 if (wsaddrlen < sizeof(win)) return 0;
396 memcpy( &win, wsaddr, sizeof(win) );
397 uaddr->in6.sin6_family = AF_INET6;
398 uaddr->in6.sin6_port = win.sin6_port;
399 uaddr->in6.sin6_flowinfo = win.sin6_flowinfo;
400 memcpy( &uaddr->in6.sin6_addr, &win.sin6_addr, sizeof(win.sin6_addr) );
401 #ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID
402 uaddr->in6.sin6_scope_id = win.sin6_scope_id;
403 #endif
404 return sizeof(uaddr->in6);
405 }
406
407 #ifdef HAS_IPX
408 case WS_AF_IPX:
409 {
410 struct WS_sockaddr_ipx win = {0};
411
412 if (wsaddrlen < sizeof(win)) return 0;
413 memcpy( &win, wsaddr, sizeof(win) );
414 uaddr->ipx.sipx_family = AF_IPX;
415 memcpy( &uaddr->ipx.sipx_network, win.sa_netnum, sizeof(win.sa_netnum) );
416 memcpy( &uaddr->ipx.sipx_node, win.sa_nodenum, sizeof(win.sa_nodenum) );
417 uaddr->ipx.sipx_port = win.sa_socket;
418 return sizeof(uaddr->ipx);
419 }
420 #endif
421
422 #ifdef HAS_IRDA
423 case WS_AF_IRDA:
424 {
425 SOCKADDR_IRDA win = {0};
426 unsigned int lsap_sel;
427
428 if (wsaddrlen < sizeof(win)) return 0;
429 memcpy( &win, wsaddr, sizeof(win) );
430 uaddr->irda.sir_family = AF_IRDA;
431 if (sscanf( win.irdaServiceName, "LSAP-SEL%u", &lsap_sel ) == 1)
432 uaddr->irda.sir_lsap_sel = lsap_sel;
433 else
434 {
435 uaddr->irda.sir_lsap_sel = LSAP_ANY;
436 memcpy( uaddr->irda.sir_name, win.irdaServiceName, sizeof(win.irdaServiceName) );
437 }
438 memcpy( &uaddr->irda.sir_addr, win.irdaDeviceID, sizeof(win.irdaDeviceID) );
439 return sizeof(uaddr->irda);
440 }
441 #endif
442
443 case WS_AF_UNSPEC:
444 switch (wsaddrlen)
445 {
446 default: /* likely an ipv4 address */
447 case sizeof(struct WS_sockaddr_in):
448 return sizeof(uaddr->in);
449
450 #ifdef HAS_IPX
451 case sizeof(struct WS_sockaddr_ipx):
452 return sizeof(uaddr->ipx);
453 #endif
454
455 #ifdef HAS_IRDA
456 case sizeof(SOCKADDR_IRDA):
457 return sizeof(uaddr->irda);
458 #endif
459
460 case sizeof(struct WS_sockaddr_in6):
461 return sizeof(uaddr->in6);
462 }
463
464 default:
465 return 0;
466 }
467 }
468
469 /* some events are generated at the same time but must be sent in a particular
470 * order (e.g. CONNECT must be sent before READ) */
471 static const enum afd_poll_bit event_bitorder[] =
472 {
473 AFD_POLL_BIT_CONNECT,
474 AFD_POLL_BIT_CONNECT_ERR,
475 AFD_POLL_BIT_ACCEPT,
476 AFD_POLL_BIT_OOB,
477 AFD_POLL_BIT_WRITE,
478 AFD_POLL_BIT_READ,
479 AFD_POLL_BIT_RESET,
480 AFD_POLL_BIT_HUP,
481 AFD_POLL_BIT_CLOSE,
482 };
483
484 typedef enum {
485 SOCK_SHUTDOWN_ERROR = -1,
486 SOCK_SHUTDOWN_EOF = 0,
487 SOCK_SHUTDOWN_POLLHUP = 1
488 } sock_shutdown_t;
489
490 static sock_shutdown_t sock_shutdown_type = SOCK_SHUTDOWN_ERROR;
491
492 static sock_shutdown_t sock_check_pollhup(void)
493 {
494 sock_shutdown_t ret = SOCK_SHUTDOWN_ERROR;
495 int fd[2], n;
496 struct pollfd pfd;
497 char dummy;
498
499 if ( socketpair( AF_UNIX, SOCK_STREAM, 0, fd ) ) return ret;
500 if ( shutdown( fd[0], 1 ) ) goto out;
501
502 pfd.fd = fd[1];
503 pfd.events = POLLIN;
504 pfd.revents = 0;
505
506 /* Solaris' poll() sometimes returns nothing if given a 0ms timeout here */
507 n = poll( &pfd, 1, 1 );
508 if ( n != 1 ) goto out; /* error or timeout */
509 if ( pfd.revents & POLLHUP )
510 ret = SOCK_SHUTDOWN_POLLHUP;
511 else if ( pfd.revents & POLLIN &&
512 read( fd[1], &dummy, 1 ) == 0 )
513 ret = SOCK_SHUTDOWN_EOF;
514
515 out:
516 close( fd[0] );
517 close( fd[1] );
518 return ret;
519 }
520
521 void sock_init(void)
522 {
523 sock_shutdown_type = sock_check_pollhup();
524
525 switch ( sock_shutdown_type )
526 {
527 case SOCK_SHUTDOWN_EOF:
528 if (debug_level) fprintf( stderr, "sock_init: shutdown() causes EOF\n" );
529 break;
530 case SOCK_SHUTDOWN_POLLHUP:
531 if (debug_level) fprintf( stderr, "sock_init: shutdown() causes POLLHUP\n" );
532 break;
533 default:
534 fprintf( stderr, "sock_init: ERROR in sock_check_pollhup()\n" );
535 sock_shutdown_type = SOCK_SHUTDOWN_EOF;
536 }
537 }
538
539 static int sock_reselect( struct sock *sock )
540 {
541 int ev = sock_get_poll_events( sock->fd );
542
543 if (debug_level)
544 fprintf(stderr,"sock_reselect(%p): new mask %x\n", sock, ev);
545
546 set_fd_events( sock->fd, ev );
547 return ev;
548 }
549
550 static unsigned int afd_poll_flag_to_win32( unsigned int flags )
551 {
552 static const unsigned int map[] =
553 {
554 FD_READ, /* READ */
555 FD_OOB, /* OOB */
556 FD_WRITE, /* WRITE */
557 FD_CLOSE, /* HUP */
558 FD_CLOSE, /* RESET */
559 0, /* CLOSE */
560 FD_CONNECT, /* CONNECT */
561 FD_ACCEPT, /* ACCEPT */
562 FD_CONNECT, /* CONNECT_ERR */
563 };
564
565 unsigned int i, ret = 0;
566
567 for (i = 0; i < ARRAY_SIZE(map); ++i)
568 {
569 if (flags & (1 << i)) ret |= map[i];
570 }
571
572 return ret;
573 }
574
575 /* wake anybody waiting on the socket event or send the associated message */
576 static void sock_wake_up( struct sock *sock )
577 {
578 unsigned int events = sock->pending_events & sock->mask;
579 int i;
580
581 if (sock->event)
582 {
583 if (debug_level) fprintf(stderr, "signalling events %x ptr %p\n", events, sock->event );
584 if (events)
585 set_event( sock->event );
586 }
587 if (sock->window)
588 {
589 if (debug_level) fprintf(stderr, "signalling events %x win %08x\n", events, sock->window );
590 for (i = 0; i < ARRAY_SIZE(event_bitorder); i++)
591 {
592 enum afd_poll_bit event = event_bitorder[i];
593 if (events & (1 << event))
594 {
595 lparam_t lparam = afd_poll_flag_to_win32(1 << event) | (sock_get_error( sock->errors[event] ) << 16);
596 post_message( sock->window, sock->message, sock->wparam, lparam );
597 }
598 }
599 sock->pending_events = 0;
600 sock_reselect( sock );
601 }
602 }
603
604 static inline int sock_error( struct fd *fd )
605 {
606 unsigned int optval = 0;
607 socklen_t optlen = sizeof(optval);
608
609 getsockopt( get_unix_fd(fd), SOL_SOCKET, SO_ERROR, (void *) &optval, &optlen);
610 return optval;
611 }
612
613 static void free_accept_req( void *private )
614 {
615 struct accept_req *req = private;
616 list_remove( &req->entry );
617 if (req->acceptsock)
618 {
619 req->acceptsock->accept_recv_req = NULL;
620 release_object( req->acceptsock );
621 }
622 release_object( req->async );
623 release_object( req->iosb );
624 release_object( req->sock );
625 free( req );
626 }
627
628 static void fill_accept_output( struct accept_req *req )
629 {
630 const data_size_t out_size = req->iosb->out_size;
631 struct async *async = req->async;
632 union unix_sockaddr unix_addr;
633 struct WS_sockaddr *win_addr;
634 unsigned int remote_len;
635 socklen_t unix_len;
636 int fd, size = 0;
637 char *out_data;
638 int win_len;
639
640 if (!(out_data = mem_alloc( out_size )))
641 {
642 async_terminate( async, get_error() );
643 return;
644 }
645
646 fd = get_unix_fd( req->acceptsock->fd );
647
648 if (req->recv_len && (size = recv( fd, out_data, req->recv_len, 0 )) < 0)
649 {
650 if (!req->accepted && errno == EWOULDBLOCK)
651 {
652 req->accepted = 1;
653 sock_reselect( req->acceptsock );
654 return;
655 }
656
657 async_terminate( async, sock_get_ntstatus( errno ) );
658 free( out_data );
659 return;
660 }
661
662 if (req->local_len)
663 {
664 if (req->local_len < sizeof(int))
665 {
666 async_terminate( async, STATUS_BUFFER_TOO_SMALL );
667 free( out_data );
668 return;
669 }
670
671 unix_len = sizeof(unix_addr);
672 win_addr = (struct WS_sockaddr *)(out_data + req->recv_len + sizeof(int));
673 if (getsockname( fd, &unix_addr.addr, &unix_len ) < 0 ||
674 (win_len = sockaddr_from_unix( &unix_addr, win_addr, req->local_len - sizeof(int) )) < 0)
675 {
676 async_terminate( async, sock_get_ntstatus( errno ) );
677 free( out_data );
678 return;
679 }
680 memcpy( out_data + req->recv_len, &win_len, sizeof(int) );
681 }
682
683 unix_len = sizeof(unix_addr);
684 win_addr = (struct WS_sockaddr *)(out_data + req->recv_len + req->local_len + sizeof(int));
685 remote_len = out_size - req->recv_len - req->local_len;
686 if (getpeername( fd, &unix_addr.addr, &unix_len ) < 0 ||
687 (win_len = sockaddr_from_unix( &unix_addr, win_addr, remote_len - sizeof(int) )) < 0)
688 {
689 async_terminate( async, sock_get_ntstatus( errno ) );
690 free( out_data );
691 return;
692 }
693 memcpy( out_data + req->recv_len + req->local_len, &win_len, sizeof(int) );
694
695 async_request_complete( req->async, STATUS_SUCCESS, size, out_size, out_data );
696 }
697
698 static void complete_async_accept( struct sock *sock, struct accept_req *req )
699 {
700 struct sock *acceptsock = req->acceptsock;
701 struct async *async = req->async;
702
703 if (debug_level) fprintf( stderr, "completing accept request for socket %p\n", sock );
704
705 if (acceptsock)
706 {
707 if (!accept_into_socket( sock, acceptsock ))
708 {
709 async_terminate( async, get_error() );
710 return;
711 }
712 fill_accept_output( req );
713 }
714 else
715 {
716 obj_handle_t handle;
717
718 if (!(acceptsock = accept_socket( sock )))
719 {
720 async_terminate( async, get_error() );
721 return;
722 }
723 handle = alloc_handle_no_access_check( async_get_thread( async )->process, &acceptsock->obj,
724 GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE, OBJ_INHERIT );
725 acceptsock->wparam = handle;
726 release_object( acceptsock );
727 if (!handle)
728 {
729 async_terminate( async, get_error() );
730 return;
731 }
732
733 async_request_complete_alloc( req->async, STATUS_SUCCESS, 0, sizeof(handle), &handle );
734 }
735 }
736
737 static void complete_async_accept_recv( struct accept_req *req )
738 {
739 if (debug_level) fprintf( stderr, "completing accept recv request for socket %p\n", req->acceptsock );
740
741 assert( req->recv_len );
742
743 fill_accept_output( req );
744 }
745
746 static void free_connect_req( void *private )
747 {
748 struct connect_req *req = private;
749
750 req->sock->connect_req = NULL;
751 release_object( req->async );
752 release_object( req->iosb );
753 release_object( req->sock );
754 free( req );
755 }
756
757 static void complete_async_connect( struct sock *sock )
758 {
759 struct connect_req *req = sock->connect_req;
760 const char *in_buffer;
761 size_t len;
762 int ret;
763
764 if (debug_level) fprintf( stderr, "completing connect request for socket %p\n", sock );
765
766 sock->state = SOCK_CONNECTED;
767
768 if (!req->send_len)
769 {
770 async_terminate( req->async, STATUS_SUCCESS );
771 return;
772 }
773
774 in_buffer = (const char *)req->iosb->in_data + sizeof(struct afd_connect_params) + req->addr_len;
775 len = req->send_len - req->send_cursor;
776
777 ret = send( get_unix_fd( sock->fd ), in_buffer + req->send_cursor, len, 0 );
778 if (ret < 0 && errno != EWOULDBLOCK)
779 async_terminate( req->async, sock_get_ntstatus( errno ) );
780 else if (ret == len)
781 async_request_complete( req->async, STATUS_SUCCESS, req->send_len, 0, NULL );
782 else
783 req->send_cursor += ret;
784 }
785
786 static void free_poll_req( void *private )
787 {
788 struct poll_req *req = private;
789 unsigned int i;
790
791 if (req->timeout) remove_timeout_user( req->timeout );
792
793 for (i = 0; i < req->count; ++i)
794 release_object( req->sockets[i].sock );
795 release_object( req->async );
796 release_object( req->iosb );
797 list_remove( &req->entry );
798 free( req->output );
799 free( req );
800 }
801
802 static int is_oobinline( struct sock *sock )
803 {
804 int oobinline;
805 socklen_t len = sizeof(oobinline);
806 return !getsockopt( get_unix_fd( sock->fd ), SOL_SOCKET, SO_OOBINLINE, (char *)&oobinline, &len ) && oobinline;
807 }
808
809 static int get_poll_flags( struct sock *sock, int event )
810 {
811 int flags = 0;
812
813 /* A connection-mode socket which has never been connected does not return
814 * write or hangup events, but Linux reports POLLOUT | POLLHUP. */
815 if (sock->state == SOCK_UNCONNECTED)
816 event &= ~(POLLOUT | POLLHUP);
817
818 if (event & POLLIN)
819 {
820 if (sock->state == SOCK_LISTENING)
821 flags |= AFD_POLL_ACCEPT;
822 else
823 flags |= AFD_POLL_READ;
824 }
825 if (event & POLLPRI)
826 flags |= is_oobinline( sock ) ? AFD_POLL_READ : AFD_POLL_OOB;
827 if (event & POLLOUT)
828 flags |= AFD_POLL_WRITE;
829 if (sock->state == SOCK_CONNECTED)
830 flags |= AFD_POLL_CONNECT;
831 if (event & POLLHUP)
832 flags |= AFD_POLL_HUP;
833 if (event & POLLERR)
834 flags |= AFD_POLL_CONNECT_ERR;
835
836 return flags;
837 }
838
839 static void complete_async_poll( struct poll_req *req, unsigned int status )
840 {
841 unsigned int i;
842
843 for (i = 0; i < req->count; ++i)
844 {
845 struct sock *sock = req->sockets[i].sock;
846
847 if (sock->main_poll == req)
848 sock->main_poll = NULL;
849 }
850
851 /* pass 0 as result; client will set actual result size */
852 async_request_complete( req->async, status, 0, req->count * sizeof(*req->output), req->output );
853 req->output = NULL;
854 }
855
856 static void complete_async_polls( struct sock *sock, int event, int error )
857 {
858 int flags = get_poll_flags( sock, event );
859 struct poll_req *req, *next;
860
861 LIST_FOR_EACH_ENTRY_SAFE( req, next, &poll_list, struct poll_req, entry )
862 {
863 unsigned int i;
864
865 if (req->iosb->status != STATUS_PENDING) continue;
866
867 for (i = 0; i < req->count; ++i)
868 {
869 if (req->sockets[i].sock != sock) continue;
870 if (!(req->sockets[i].flags & flags)) continue;
871
872 if (debug_level)
873 fprintf( stderr, "completing poll for socket %p, wanted %#x got %#x\n",
874 sock, req->sockets[i].flags, flags );
875
876 req->output[i].flags = req->sockets[i].flags & flags;
877 req->output[i].status = sock_get_ntstatus( error );
878
879 complete_async_poll( req, STATUS_SUCCESS );
880 break;
881 }
882 }
883 }
884
885 static void async_poll_timeout( void *private )
886 {
887 struct poll_req *req = private;
888
889 req->timeout = NULL;
890
891 if (req->iosb->status != STATUS_PENDING) return;
892
893 complete_async_poll( req, STATUS_TIMEOUT );
894 }
895
896 static int sock_dispatch_asyncs( struct sock *sock, int event, int error )
897 {
898 if (event & (POLLIN | POLLPRI))
899 {
900 struct accept_req *req;
901
902 LIST_FOR_EACH_ENTRY( req, &sock->accept_list, struct accept_req, entry )
903 {
904 if (req->iosb->status == STATUS_PENDING && !req->accepted)
905 {
906 complete_async_accept( sock, req );
907 break;
908 }
909 }
910
911 if (sock->accept_recv_req && sock->accept_recv_req->iosb->status == STATUS_PENDING)
912 complete_async_accept_recv( sock->accept_recv_req );
913 }
914
915 if ((event & POLLOUT) && sock->connect_req && sock->connect_req->iosb->status == STATUS_PENDING)
916 complete_async_connect( sock );
917
918 if (event & (POLLIN | POLLPRI) && async_waiting( &sock->read_q ))
919 {
920 if (debug_level) fprintf( stderr, "activating read queue for socket %p\n", sock );
921 async_wake_up( &sock->read_q, STATUS_ALERTED );
922 event &= ~(POLLIN | POLLPRI);
923 }
924
925 if (event & POLLOUT && async_waiting( &sock->write_q ))
926 {
927 if (debug_level) fprintf( stderr, "activating write queue for socket %p\n", sock );
928 async_wake_up( &sock->write_q, STATUS_ALERTED );
929 event &= ~POLLOUT;
930 }
931
932 if (event & (POLLERR | POLLHUP))
933 {
934 int status = sock_get_ntstatus( error );
935 struct accept_req *req, *next;
936
937 if (sock->rd_shutdown || sock->hangup)
938 async_wake_up( &sock->read_q, status );
939 if (sock->wr_shutdown)
940 async_wake_up( &sock->write_q, status );
941
942 LIST_FOR_EACH_ENTRY_SAFE( req, next, &sock->accept_list, struct accept_req, entry )
943 {
944 if (req->iosb->status == STATUS_PENDING)
945 async_terminate( req->async, status );
946 }
947
948 if (sock->accept_recv_req && sock->accept_recv_req->iosb->status == STATUS_PENDING)
949 async_terminate( sock->accept_recv_req->async, status );
950
951 if (sock->connect_req)
952 async_terminate( sock->connect_req->async, status );
953 }
954
955 return event;
956 }
957
958 static void post_socket_event( struct sock *sock, enum afd_poll_bit event_bit, int error )
959 {
960 unsigned int event = (1 << event_bit);
961
962 if (!(sock->reported_events & event))
963 {
964 sock->pending_events |= event;
965 sock->reported_events |= event;
966 sock->errors[event_bit] = error;
967 }
968 }
969
970 static void sock_dispatch_events( struct sock *sock, enum connection_state prevstate, int event, int error )
971 {
972 switch (prevstate)
973 {
974 case SOCK_UNCONNECTED:
975 break;
976
977 case SOCK_CONNECTING:
978 if (event & POLLOUT)
979 {
980 post_socket_event( sock, AFD_POLL_BIT_CONNECT, 0 );
981 sock->errors[AFD_POLL_BIT_CONNECT_ERR] = 0;
982 }
983 if (event & (POLLERR | POLLHUP))
984 post_socket_event( sock, AFD_POLL_BIT_CONNECT_ERR, error );
985 break;
986
987 case SOCK_LISTENING:
988 if (event & (POLLIN | POLLERR | POLLHUP))
989 post_socket_event( sock, AFD_POLL_BIT_ACCEPT, error );
990 break;
991
992 case SOCK_CONNECTED:
993 case SOCK_CONNECTIONLESS:
994 if (event & POLLIN)
995 post_socket_event( sock, AFD_POLL_BIT_READ, 0 );
996
997 if (event & POLLOUT)
998 post_socket_event( sock, AFD_POLL_BIT_WRITE, 0 );
999
1000 if (event & POLLPRI)
1001 post_socket_event( sock, AFD_POLL_BIT_OOB, 0 );
1002
1003 if (event & (POLLERR | POLLHUP))
1004 post_socket_event( sock, AFD_POLL_BIT_HUP, error );
1005 break;
1006 }
1007
1008 sock_wake_up( sock );
1009 }
1010
1011 static void sock_poll_event( struct fd *fd, int event )
1012 {
1013 struct sock *sock = get_fd_user( fd );
1014 int hangup_seen = 0;
1015 enum connection_state prevstate = sock->state;
1016 int error = 0;
1017
1018 assert( sock->obj.ops == &sock_ops );
1019 if (debug_level)
1020 fprintf(stderr, "socket %p select event: %x\n", sock, event);
1021
1022 /* we may change event later, remove from loop here */
1023 if (event & (POLLERR|POLLHUP)) set_fd_events( sock->fd, -1 );
1024
1025 switch (sock->state)
1026 {
1027 case SOCK_UNCONNECTED:
1028 break;
1029
1030 case SOCK_CONNECTING:
1031 if (event & (POLLERR|POLLHUP))
1032 {
1033 sock->state = SOCK_UNCONNECTED;
1034 event &= ~POLLOUT;
1035 error = sock_error( fd );
1036 }
1037 else if (event & POLLOUT)
1038 {
1039 sock->state = SOCK_CONNECTED;
1040 sock->connect_time = current_time;
1041 }
1042 break;
1043
1044 case SOCK_LISTENING:
1045 if (event & (POLLERR|POLLHUP))
1046 error = sock_error( fd );
1047 break;
1048
1049 case SOCK_CONNECTED:
1050 case SOCK_CONNECTIONLESS:
1051 if (sock->type == WS_SOCK_STREAM && (event & POLLIN))
1052 {
1053 char dummy;
1054 int nr;
1055
1056 /* Linux 2.4 doesn't report POLLHUP if only one side of the socket
1057 * has been closed, so we need to check for it explicitly here */
1058 nr = recv( get_unix_fd( fd ), &dummy, 1, MSG_PEEK );
1059 if ( nr == 0 )
1060 {
1061 hangup_seen = 1;
1062 event &= ~POLLIN;
1063 }
1064 else if ( nr < 0 )
1065 {
1066 event &= ~POLLIN;
1067 /* EAGAIN can happen if an async recv() falls between the server's poll()
1068 call and the invocation of this routine */
1069 if ( errno != EAGAIN )
1070 {
1071 error = errno;
1072 event |= POLLERR;
1073 if ( debug_level )
1074 fprintf( stderr, "recv error on socket %p: %d\n", sock, errno );
1075 }
1076 }
1077 }
1078
1079 if (hangup_seen || (sock_shutdown_type == SOCK_SHUTDOWN_POLLHUP && (event & POLLHUP)))
1080 {
1081 sock->hangup = 1;
1082 }
1083 else if (event & (POLLHUP | POLLERR))
1084 {
1085 sock->aborted = 1;
1086
1087 if (debug_level)
1088 fprintf( stderr, "socket %p aborted by error %d, event %#x\n", sock, error, event );
1089 }
1090
1091 if (hangup_seen)
1092 event |= POLLHUP;
1093 break;
1094 }
1095
1096 complete_async_polls( sock, event, error );
1097
1098 event = sock_dispatch_asyncs( sock, event, error );
1099 sock_dispatch_events( sock, prevstate, event, error );
1100
1101 sock_reselect( sock );
1102 }
1103
1104 static void sock_dump( struct object *obj, int verbose )
1105 {
1106 struct sock *sock = (struct sock *)obj;
1107 assert( obj->ops == &sock_ops );
1108 fprintf( stderr, "Socket fd=%p, state=%x, mask=%x, pending=%x, reported=%x\n",
1109 sock->fd, sock->state,
1110 sock->mask, sock->pending_events, sock->reported_events );
1111 }
1112
1113 static int poll_flags_from_afd( struct sock *sock, int flags )
1114 {
1115 int ev = 0;
1116
1117 /* A connection-mode socket which has never been connected does
1118 * not return write or hangup events, but Linux returns
1119 * POLLOUT | POLLHUP. */
1120 if (sock->state == SOCK_UNCONNECTED)
1121 return -1;
1122
1123 if (flags & (AFD_POLL_READ | AFD_POLL_ACCEPT))
1124 ev |= POLLIN;
1125 if ((flags & AFD_POLL_HUP) && sock->type == WS_SOCK_STREAM)
1126 ev |= POLLIN;
1127 if (flags & AFD_POLL_OOB)
1128 ev |= is_oobinline( sock ) ? POLLIN : POLLPRI;
1129 if (flags & AFD_POLL_WRITE)
1130 ev |= POLLOUT;
1131
1132 return ev;
1133 }
1134
1135 static int sock_get_poll_events( struct fd *fd )
1136 {
1137 struct sock *sock = get_fd_user( fd );
1138 unsigned int mask = sock->mask & ~sock->reported_events;
1139 struct poll_req *req;
1140 int ev = 0;
1141
1142 assert( sock->obj.ops == &sock_ops );
1143
1144 if (!sock->type) /* not initialized yet */
1145 return -1;
1146
1147 switch (sock->state)
1148 {
1149 case SOCK_UNCONNECTED:
1150 /* A connection-mode Windows socket which has never been connected does
1151 * not return any events, but Linux returns POLLOUT | POLLHUP. Hence we
1152 * need to return -1 here, to prevent the socket from being polled on at
1153 * all. */
1154 return -1;
1155
1156 case SOCK_CONNECTING:
1157 return POLLOUT;
1158
1159 case SOCK_LISTENING:
1160 if (!list_empty( &sock->accept_list ) || (mask & AFD_POLL_ACCEPT))
1161 ev |= POLLIN;
1162 break;
1163
1164 case SOCK_CONNECTED:
1165 case SOCK_CONNECTIONLESS:
1166 if (sock->hangup && sock->wr_shutdown && !sock->wr_shutdown_pending)
1167 {
1168 /* Linux returns POLLHUP if a socket is both SHUT_RD and SHUT_WR, or
1169 * if both the socket and its peer are SHUT_WR.
1170 *
1171 * We don't use SHUT_RD, so we can only encounter this in the latter
1172 * case. In that case there can't be any pending read requests (they
1173 * would have already been completed with a length of zero), the
1174 * above condition ensures that we don't have any pending write
1175 * requests, and nothing that can change about the socket state that
1176 * would complete a pending poll request. */
1177 return -1;
1178 }
1179
1180 if (sock->aborted)
1181 return -1;
1182
1183 if (sock->accept_recv_req)
1184 {
1185 ev |= POLLIN;
1186 }
1187 else if (async_queued( &sock->read_q ))
1188 {
1189 if (async_waiting( &sock->read_q )) ev |= POLLIN | POLLPRI;
1190 }
1191 else
1192 {
1193 /* Don't ask for POLLIN if we got a hangup. We won't receive more
1194 * data anyway, but we will get POLLIN if SOCK_SHUTDOWN_EOF. */
1195 if (!sock->hangup)
1196 {
1197 if (mask & AFD_POLL_READ)
1198 ev |= POLLIN;
1199 if (mask & AFD_POLL_OOB)
1200 ev |= POLLPRI;
1201 }
1202
1203 /* We use POLLIN with 0 bytes recv() as hangup indication for stream sockets. */
1204 if (sock->state == SOCK_CONNECTED && (mask & AFD_POLL_HUP) && !(sock->reported_events & AFD_POLL_READ))
1205 ev |= POLLIN;
1206 }
1207
1208 if (async_queued( &sock->write_q ))
1209 {
1210 if (async_waiting( &sock->write_q )) ev |= POLLOUT;
1211 }
1212 else if (!sock->wr_shutdown && (mask & AFD_POLL_WRITE))
1213 {
1214 ev |= POLLOUT;
1215 }
1216
1217 break;
1218 }
1219
1220 LIST_FOR_EACH_ENTRY( req, &poll_list, struct poll_req, entry )
1221 {
1222 unsigned int i;
1223
1224 for (i = 0; i < req->count; ++i)
1225 {
1226 if (req->sockets[i].sock != sock) continue;
1227
1228 ev |= poll_flags_from_afd( sock, req->sockets[i].flags );
1229 }
1230 }
1231
1232 return ev;
1233 }
1234
1235 static enum server_fd_type sock_get_fd_type( struct fd *fd )
1236 {
1237 return FD_TYPE_SOCKET;
1238 }
1239
1240 static void sock_cancel_async( struct fd *fd, struct async *async )
1241 {
1242 struct poll_req *req;
1243
1244 LIST_FOR_EACH_ENTRY( req, &poll_list, struct poll_req, entry )
1245 {
1246 unsigned int i;
1247
1248 if (req->async != async)
1249 continue;
1250
1251 for (i = 0; i < req->count; i++)
1252 {
1253 struct sock *sock = req->sockets[i].sock;
1254
1255 if (sock->main_poll == req)
1256 sock->main_poll = NULL;
1257 }
1258 }
1259
1260 async_terminate( async, STATUS_CANCELLED );
1261 }
1262
1263 static void sock_queue_async( struct fd *fd, struct async *async, int type, int count )
1264 {
1265 struct sock *sock = get_fd_user( fd );
1266 struct async_queue *queue;
1267
1268 assert( sock->obj.ops == &sock_ops );
1269
1270 switch (type)
1271 {
1272 case ASYNC_TYPE_READ:
1273 if (sock->rd_shutdown)
1274 {
1275 set_error( STATUS_PIPE_DISCONNECTED );
1276 return;
1277 }
1278 queue = &sock->read_q;
1279 break;
1280
1281 case ASYNC_TYPE_WRITE:
1282 if (sock->wr_shutdown)
1283 {
1284 set_error( STATUS_PIPE_DISCONNECTED );
1285 return;
1286 }
1287 queue = &sock->write_q;
1288 break;
1289
1290 default:
1291 set_error( STATUS_INVALID_PARAMETER );
1292 return;
1293 }
1294
1295 if (sock->state != SOCK_CONNECTED)
1296 {
1297 set_error( STATUS_PIPE_DISCONNECTED );
1298 return;
1299 }
1300
1301 queue_async( queue, async );
1302 sock_reselect( sock );
1303
1304 set_error( STATUS_PENDING );
1305 }
1306
1307 static void sock_reselect_async( struct fd *fd, struct async_queue *queue )
1308 {
1309 struct sock *sock = get_fd_user( fd );
1310
1311 if (sock->wr_shutdown_pending && list_empty( &sock->write_q.queue ))
1312 {
1313 shutdown( get_unix_fd( sock->fd ), SHUT_WR );
1314 sock->wr_shutdown_pending = 0;
1315 }
1316
1317 /* Don't reselect the ifchange queue; we always ask for POLLIN.
1318 * Don't reselect an uninitialized socket; we can't call set_fd_events() on
1319 * a pseudo-fd. */
1320 if (queue != &sock->ifchange_q && sock->type)
1321 sock_reselect( sock );
1322 }
1323
1324 static struct fd *sock_get_fd( struct object *obj )
1325 {
1326 struct sock *sock = (struct sock *)obj;
1327 return (struct fd *)grab_object( sock->fd );
1328 }
1329
1330 static int sock_close_handle( struct object *obj, struct process *process, obj_handle_t handle )
1331 {
1332 struct sock *sock = (struct sock *)obj;
1333
1334 if (sock->obj.handle_count == 1) /* last handle */
1335 {
1336 struct accept_req *accept_req, *accept_next;
1337 struct poll_req *poll_req, *poll_next;
1338
1339 if (sock->accept_recv_req)
1340 async_terminate( sock->accept_recv_req->async, STATUS_CANCELLED );
1341
1342 LIST_FOR_EACH_ENTRY_SAFE( accept_req, accept_next, &sock->accept_list, struct accept_req, entry )
1343 async_terminate( accept_req->async, STATUS_CANCELLED );
1344
1345 if (sock->connect_req)
1346 async_terminate( sock->connect_req->async, STATUS_CANCELLED );
1347
1348 LIST_FOR_EACH_ENTRY_SAFE( poll_req, poll_next, &poll_list, struct poll_req, entry )
1349 {
1350 struct iosb *iosb = poll_req->iosb;
1351 BOOL signaled = FALSE;
1352 unsigned int i;
1353
1354 if (iosb->status != STATUS_PENDING) continue;
1355
1356 for (i = 0; i < poll_req->count; ++i)
1357 {
1358 if (poll_req->sockets[i].sock == sock)
1359 {
1360 signaled = TRUE;
1361 poll_req->output[i].flags = AFD_POLL_CLOSE;
1362 poll_req->output[i].status = 0;
1363 }
1364 }
1365
1366 if (signaled) complete_async_poll( poll_req, STATUS_SUCCESS );
1367 }
1368 }
1369
1370 return 1;
1371 }
1372
1373 static void sock_destroy( struct object *obj )
1374 {
1375 struct sock *sock = (struct sock *)obj;
1376
1377 assert( obj->ops == &sock_ops );
1378
1379 /* FIXME: special socket shutdown stuff? */
1380
1381 if ( sock->deferred )
1382 release_object( sock->deferred );
1383
1384 async_wake_up( &sock->ifchange_q, STATUS_CANCELLED );
1385 sock_release_ifchange( sock );
1386 free_async_queue( &sock->read_q );
1387 free_async_queue( &sock->write_q );
1388 free_async_queue( &sock->ifchange_q );
1389 free_async_queue( &sock->accept_q );
1390 free_async_queue( &sock->connect_q );
1391 free_async_queue( &sock->poll_q );
1392 if (sock->event) release_object( sock->event );
1393 if (sock->fd)
1394 {
1395 /* shut the socket down to force pending poll() calls in the client to return */
1396 shutdown( get_unix_fd(sock->fd), SHUT_RDWR );
1397 release_object( sock->fd );
1398 }
1399 }
1400
1401 static struct sock *create_socket(void)
1402 {
1403 struct sock *sock;
1404
1405 if (!(sock = alloc_object( &sock_ops ))) return NULL;
1406 sock->fd = NULL;
1407 sock->state = SOCK_UNCONNECTED;
1408 sock->mask = 0;
1409 sock->pending_events = 0;
1410 sock->reported_events = 0;
1411 sock->flags = 0;
1412 sock->proto = 0;
1413 sock->type = 0;
1414 sock->family = 0;
1415 sock->event = NULL;
1416 sock->window = 0;
1417 sock->message = 0;
1418 sock->wparam = 0;
1419 sock->connect_time = 0;
1420 sock->deferred = NULL;
1421 sock->ifchange_obj = NULL;
1422 sock->accept_recv_req = NULL;
1423 sock->connect_req = NULL;
1424 sock->main_poll = NULL;
1425 memset( &sock->addr, 0, sizeof(sock->addr) );
1426 sock->addr_len = 0;
1427 sock->rd_shutdown = 0;
1428 sock->wr_shutdown = 0;
1429 sock->wr_shutdown_pending = 0;
1430 sock->hangup = 0;
1431 sock->aborted = 0;
1432 sock->nonblocking = 0;
1433 sock->bound = 0;
1434 sock->rcvbuf = 0;
1435 sock->sndbuf = 0;
1436 sock->rcvtimeo = 0;
1437 sock->sndtimeo = 0;
1438 init_async_queue( &sock->read_q );
1439 init_async_queue( &sock->write_q );
1440 init_async_queue( &sock->ifchange_q );
1441 init_async_queue( &sock->accept_q );
1442 init_async_queue( &sock->connect_q );
1443 init_async_queue( &sock->poll_q );
1444 memset( sock->errors, 0, sizeof(sock->errors) );
1445 list_init( &sock->accept_list );
1446 return sock;
1447 }
1448
1449 static int get_unix_family( int family )
1450 {
1451 switch (family)
1452 {
1453 case WS_AF_INET: return AF_INET;
1454 case WS_AF_INET6: return AF_INET6;
1455 #ifdef HAS_IPX
1456 case WS_AF_IPX: return AF_IPX;
1457 #endif
1458 #ifdef AF_IRDA
1459 case WS_AF_IRDA: return AF_IRDA;
1460 #endif
1461 case WS_AF_UNSPEC: return AF_UNSPEC;
1462 default: return -1;
1463 }
1464 }
1465
1466 static int get_unix_type( int type )
1467 {
1468 switch (type)
1469 {
1470 case WS_SOCK_DGRAM: return SOCK_DGRAM;
1471 case WS_SOCK_RAW: return SOCK_RAW;
1472 case WS_SOCK_STREAM: return SOCK_STREAM;
1473 default: return -1;
1474 }
1475 }
1476
1477 static int get_unix_protocol( int protocol )
1478 {
1479 if (protocol >= WS_NSPROTO_IPX && protocol <= WS_NSPROTO_IPX + 255)
1480 return protocol;
1481
1482 switch (protocol)
1483 {
1484 case WS_IPPROTO_ICMP: return IPPROTO_ICMP;
1485 case WS_IPPROTO_IGMP: return IPPROTO_IGMP;
1486 case WS_IPPROTO_IP: return IPPROTO_IP;
1487 case WS_IPPROTO_IPV4: return IPPROTO_IPIP;
1488 case WS_IPPROTO_IPV6: return IPPROTO_IPV6;
1489 case WS_IPPROTO_RAW: return IPPROTO_RAW;
1490 case WS_IPPROTO_TCP: return IPPROTO_TCP;
1491 case WS_IPPROTO_UDP: return IPPROTO_UDP;
1492 default: return -1;
1493 }
1494 }
1495
1496 static void set_dont_fragment( int fd, int level, int value )
1497 {
1498 int optname;
1499
1500 if (level == IPPROTO_IP)
1501 {
1502 #ifdef IP_DONTFRAG
1503 optname = IP_DONTFRAG;
1504 #elif defined(IP_MTU_DISCOVER) && defined(IP_PMTUDISC_DO) && defined(IP_PMTUDISC_DONT)
1505 optname = IP_MTU_DISCOVER;
1506 value = value ? IP_PMTUDISC_DO : IP_PMTUDISC_DONT;
1507 #else
1508 return;
1509 #endif
1510 }
1511 else
1512 {
1513 #ifdef IPV6_DONTFRAG
1514 optname = IPV6_DONTFRAG;
1515 #elif defined(IPV6_MTU_DISCOVER) && defined(IPV6_PMTUDISC_DO) && defined(IPV6_PMTUDISC_DONT)
1516 optname = IPV6_MTU_DISCOVER;
1517 value = value ? IPV6_PMTUDISC_DO : IPV6_PMTUDISC_DONT;
1518 #else
1519 return;
1520 #endif
1521 }
1522
1523 setsockopt( fd, level, optname, &value, sizeof(value) );
1524 }
1525
1526 static int init_socket( struct sock *sock, int family, int type, int protocol, unsigned int flags )
1527 {
1528 unsigned int options = 0;
1529 int sockfd, unix_type, unix_family, unix_protocol, value;
1530 socklen_t len;
1531
1532 unix_family = get_unix_family( family );
1533 unix_type = get_unix_type( type );
1534 unix_protocol = get_unix_protocol( protocol );
1535
1536 if (unix_protocol < 0)
1537 {
1538 if (type && unix_type < 0)
1539 set_win32_error( WSAESOCKTNOSUPPORT );
1540 else
1541 set_win32_error( WSAEPROTONOSUPPORT );
1542 return -1;
1543 }
1544 if (unix_family < 0)
1545 {
1546 if (family >= 0 && unix_type < 0)
1547 set_win32_error( WSAESOCKTNOSUPPORT );
1548 else
1549 set_win32_error( WSAEAFNOSUPPORT );
1550 return -1;
1551 }
1552
1553 sockfd = socket( unix_family, unix_type, unix_protocol );
1554 if (sockfd == -1)
1555 {
1556 if (errno == EINVAL) set_win32_error( WSAESOCKTNOSUPPORT );
1557 else set_win32_error( sock_get_error( errno ));
1558 return -1;
1559 }
1560 fcntl(sockfd, F_SETFL, O_NONBLOCK); /* make socket nonblocking */
1561
1562 if (family == WS_AF_IPX && protocol >= WS_NSPROTO_IPX && protocol <= WS_NSPROTO_IPX + 255)
1563 {
1564 #ifdef HAS_IPX
1565 int ipx_type = protocol - WS_NSPROTO_IPX;
1566
1567 #ifdef SOL_IPX
1568 setsockopt( sockfd, SOL_IPX, IPX_TYPE, &ipx_type, sizeof(ipx_type) );
1569 #else
1570 struct ipx val;
1571 /* Should we retrieve val using a getsockopt call and then
1572 * set the modified one? */
1573 val.ipx_pt = ipx_type;
1574 setsockopt( sockfd, 0, SO_DEFAULT_HEADERS, &val, sizeof(val) );
1575 #endif
1576 #endif
1577 }
1578
1579 if (unix_family == AF_INET || unix_family == AF_INET6)
1580 {
1581 /* ensure IP_DONTFRAGMENT is disabled for SOCK_DGRAM and SOCK_RAW, enabled for SOCK_STREAM */
1582 if (unix_type == SOCK_DGRAM || unix_type == SOCK_RAW) /* in Linux the global default can be enabled */
1583 set_dont_fragment( sockfd, unix_family == AF_INET6 ? IPPROTO_IPV6 : IPPROTO_IP, FALSE );
1584 else if (unix_type == SOCK_STREAM)
1585 set_dont_fragment( sockfd, unix_family == AF_INET6 ? IPPROTO_IPV6 : IPPROTO_IP, TRUE );
1586 }
1587
1588 #ifdef IPV6_V6ONLY
1589 if (unix_family == AF_INET6)
1590 {
1591 static const int enable = 1;
1592 setsockopt( sockfd, IPPROTO_IPV6, IPV6_V6ONLY, &enable, sizeof(enable) );
1593 }
1594 #endif
1595
1596 len = sizeof(value);
1597 if (!getsockopt( sockfd, SOL_SOCKET, SO_RCVBUF, &value, &len ))
1598 sock->rcvbuf = value;
1599
1600 len = sizeof(value);
1601 if (!getsockopt( sockfd, SOL_SOCKET, SO_SNDBUF, &value, &len ))
1602 sock->sndbuf = value;
1603
1604 sock->state = (type == WS_SOCK_STREAM ? SOCK_UNCONNECTED : SOCK_CONNECTIONLESS);
1605 sock->flags = flags;
1606 sock->proto = protocol;
1607 sock->type = type;
1608 sock->family = family;
1609
1610 if (sock->fd)
1611 {
1612 options = get_fd_options( sock->fd );
1613 release_object( sock->fd );
1614 }
1615
1616 if (!(sock->fd = create_anonymous_fd( &sock_fd_ops, sockfd, &sock->obj, options )))
1617 {
1618 return -1;
1619 }
1620
1621 /* We can't immediately allow caching for a connection-mode socket, since it
1622 * might be accepted into (changing the underlying fd object.) */
1623 if (sock->type != WS_SOCK_STREAM) allow_fd_caching( sock->fd );
1624
1625 return 0;
1626 }
1627
1628 /* accepts a socket and inits it */
1629 static int accept_new_fd( struct sock *sock )
1630 {
1631
1632 /* Try to accept(2). We can't be safe that this an already connected socket
1633 * or that accept() is allowed on it. In those cases we will get -1/errno
1634 * return.
1635 */
1636 struct sockaddr saddr;
1637 socklen_t slen = sizeof(saddr);
1638 int acceptfd = accept( get_unix_fd(sock->fd), &saddr, &slen );
1639 if (acceptfd != -1)
1640 fcntl( acceptfd, F_SETFL, O_NONBLOCK );
1641 else
1642 set_error( sock_get_ntstatus( errno ));
1643 return acceptfd;
1644 }
1645
1646 /* accept a socket (creates a new fd) */
1647 static struct sock *accept_socket( struct sock *sock )
1648 {
1649 struct sock *acceptsock;
1650 int acceptfd;
1651
1652 if (get_unix_fd( sock->fd ) == -1) return NULL;
1653
1654 if ( sock->deferred )
1655 {
1656 acceptsock = sock->deferred;
1657 sock->deferred = NULL;
1658 }
1659 else
1660 {
1661 union unix_sockaddr unix_addr;
1662 socklen_t unix_len;
1663
1664 if ((acceptfd = accept_new_fd( sock )) == -1) return NULL;
1665 if (!(acceptsock = create_socket()))
1666 {
1667 close( acceptfd );
1668 return NULL;
1669 }
1670
1671 /* newly created socket gets the same properties of the listening socket */
1672 acceptsock->state = SOCK_CONNECTED;
1673 acceptsock->bound = 1;
1674 acceptsock->nonblocking = sock->nonblocking;
1675 acceptsock->mask = sock->mask;
1676 acceptsock->proto = sock->proto;
1677 acceptsock->type = sock->type;
1678 acceptsock->family = sock->family;
1679 acceptsock->window = sock->window;
1680 acceptsock->message = sock->message;
1681 acceptsock->connect_time = current_time;
1682 if (sock->event) acceptsock->event = (struct event *)grab_object( sock->event );
1683 acceptsock->flags = sock->flags;
1684 if (!(acceptsock->fd = create_anonymous_fd( &sock_fd_ops, acceptfd, &acceptsock->obj,
1685 get_fd_options( sock->fd ) )))
1686 {
1687 release_object( acceptsock );
1688 return NULL;
1689 }
1690 unix_len = sizeof(unix_addr);
1691 if (!getsockname( acceptfd, &unix_addr.addr, &unix_len ))
1692 acceptsock->addr_len = sockaddr_from_unix( &unix_addr, &acceptsock->addr.addr, sizeof(acceptsock->addr) );
1693 }
1694 clear_error();
1695 sock->pending_events &= ~AFD_POLL_ACCEPT;
1696 sock->reported_events &= ~AFD_POLL_ACCEPT;
1697 sock_reselect( sock );
1698 return acceptsock;
1699 }
1700
1701 static int accept_into_socket( struct sock *sock, struct sock *acceptsock )
1702 {
1703 union unix_sockaddr unix_addr;
1704 socklen_t unix_len;
1705 int acceptfd;
1706 struct fd *newfd;
1707
1708 if (get_unix_fd( sock->fd ) == -1) return FALSE;
1709
1710 if ( sock->deferred )
1711 {
1712 newfd = dup_fd_object( sock->deferred->fd, 0, 0,
1713 get_fd_options( acceptsock->fd ) );
1714 if ( !newfd )
1715 return FALSE;
1716
1717 set_fd_user( newfd, &sock_fd_ops, &acceptsock->obj );
1718
1719 release_object( sock->deferred );
1720 sock->deferred = NULL;
1721 }
1722 else
1723 {
1724 if ((acceptfd = accept_new_fd( sock )) == -1)
1725 return FALSE;
1726
1727 if (!(newfd = create_anonymous_fd( &sock_fd_ops, acceptfd, &acceptsock->obj,
1728 get_fd_options( acceptsock->fd ) )))
1729 return FALSE;
1730 }
1731
1732 acceptsock->state = SOCK_CONNECTED;
1733 acceptsock->pending_events = 0;
1734 acceptsock->reported_events = 0;
1735 acceptsock->proto = sock->proto;
1736 acceptsock->type = sock->type;
1737 acceptsock->family = sock->family;
1738 acceptsock->wparam = 0;
1739 acceptsock->deferred = NULL;
1740 acceptsock->connect_time = current_time;
1741 fd_copy_completion( acceptsock->fd, newfd );
1742 release_object( acceptsock->fd );
1743 acceptsock->fd = newfd;
1744
1745 unix_len = sizeof(unix_addr);
1746 if (!getsockname( get_unix_fd( newfd ), &unix_addr.addr, &unix_len ))
1747 acceptsock->addr_len = sockaddr_from_unix( &unix_addr, &acceptsock->addr.addr, sizeof(acceptsock->addr) );
1748
1749 clear_error();
1750 sock->pending_events &= ~AFD_POLL_ACCEPT;
1751 sock->reported_events &= ~AFD_POLL_ACCEPT;
1752 sock_reselect( sock );
1753
1754 return TRUE;
1755 }
1756
1757 #ifdef IP_BOUND_IF
1758
1759 static int bind_to_index( int fd, in_addr_t bind_addr, unsigned int index )
1760 {
1761 return setsockopt( fd, IPPROTO_IP, IP_BOUND_IF, &index, sizeof(index) );
1762 }
1763
1764 #elif defined(IP_UNICAST_IF) && defined(SO_ATTACH_FILTER)
1765
1766 struct interface_filter
1767 {
1768 struct sock_filter iface_memaddr;
1769 struct sock_filter iface_rule;
1770 struct sock_filter ip_memaddr;
1771 struct sock_filter ip_rule;
1772 struct sock_filter return_keep;
1773 struct sock_filter return_dump;
1774 };
1775 # define FILTER_JUMP_DUMP(here) (u_char)(offsetof(struct interface_filter, return_dump) \
1776 -offsetof(struct interface_filter, here)-sizeof(struct sock_filter)) \
1777 /sizeof(struct sock_filter)
1778 # define FILTER_JUMP_KEEP(here) (u_char)(offsetof(struct interface_filter, return_keep) \
1779 -offsetof(struct interface_filter, here)-sizeof(struct sock_filter)) \
1780 /sizeof(struct sock_filter)
1781 # define FILTER_JUMP_NEXT() (u_char)(0)
1782 # define SKF_NET_DESTIP 16 /* offset in the network header to the destination IP */
1783 static struct interface_filter generic_interface_filter =
1784 {
1785 /* This filter rule allows incoming packets on the specified interface, which works for all
1786 * remotely generated packets and for locally generated broadcast packets. */
1787 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, SKF_AD_OFF+SKF_AD_IFINDEX),
1788 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0xdeadbeef, FILTER_JUMP_KEEP(iface_rule), FILTER_JUMP_NEXT()),
1789 /* This rule allows locally generated packets targeted at the specific IP address of the chosen
1790 * adapter (local packets not destined for the broadcast address do not have IFINDEX set) */
1791 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, SKF_NET_OFF+SKF_NET_DESTIP),
1792 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0xdeadbeef, FILTER_JUMP_KEEP(ip_rule), FILTER_JUMP_DUMP(ip_rule)),
1793 BPF_STMT(BPF_RET+BPF_K, (u_int)-1), /* keep packet */
1794 BPF_STMT(BPF_RET+BPF_K, 0) /* dump packet */
1795 };
1796
1797 static int bind_to_index( int fd, in_addr_t bind_addr, unsigned int index )
1798 {
1799 in_addr_t ifindex = htonl( index );
1800 struct interface_filter specific_interface_filter;
1801 struct sock_fprog filter_prog;
1802 int ret;
1803
1804 if ((ret = setsockopt( fd, IPPROTO_IP, IP_UNICAST_IF, &ifindex, sizeof(ifindex) )) < 0)
1805 return ret;
1806
1807 specific_interface_filter = generic_interface_filter;
1808 specific_interface_filter.iface_rule.k = index;
1809 specific_interface_filter.ip_rule.k = htonl( bind_addr );
1810 filter_prog.len = sizeof(generic_interface_filter) / sizeof(struct sock_filter);
1811 filter_prog.filter = (struct sock_filter *)&specific_interface_filter;
1812 return setsockopt( fd, SOL_SOCKET, SO_ATTACH_FILTER, &filter_prog, sizeof(filter_prog) );
1813 }
1814
1815 #else
1816
1817 static int bind_to_index( int fd, in_addr_t bind_addr, unsigned int index )
1818 {
1819 errno = EOPNOTSUPP;
1820 return -1;
1821 }
1822
1823 #endif /* LINUX_BOUND_IF */
1824
1825 /* Take bind() calls on any name corresponding to a local network adapter and
1826 * restrict the given socket to operating only on the specified interface. This
1827 * restriction consists of two components:
1828 * 1) An outgoing packet restriction suggesting the egress interface for all
1829 * packets.
1830 * 2) An incoming packet restriction dropping packets not meant for the
1831 * interface.
1832 * If the function succeeds in placing these restrictions, then the name for the
1833 * bind() may safely be changed to INADDR_ANY, permitting the transmission and
1834 * receipt of broadcast packets on the socket. This behavior is only relevant to
1835 * UDP sockets and is needed for applications that expect to be able to receive
1836 * broadcast packets on a socket that is bound to a specific network interface.
1837 */
1838 static int bind_to_interface( struct sock *sock, const struct sockaddr_in *addr )
1839 {
1840 in_addr_t bind_addr = addr->sin_addr.s_addr;
1841 struct ifaddrs *ifaddrs, *ifaddr;
1842 int fd = get_unix_fd( sock->fd );
1843 static const int enable = 1;
1844 unsigned int index;
1845
1846 if (bind_addr == htonl( INADDR_ANY ) || bind_addr == htonl( INADDR_LOOPBACK ))
1847 return 0;
1848 if (sock->type != WS_SOCK_DGRAM)
1849 return 0;
1850
1851 if (getifaddrs( &ifaddrs ) < 0) return 0;
1852
1853 for (ifaddr = ifaddrs; ifaddr != NULL; ifaddr = ifaddr->ifa_next)
1854 {
1855 if (ifaddr->ifa_addr && ifaddr->ifa_addr->sa_family == AF_INET
1856 && ((struct sockaddr_in *)ifaddr->ifa_addr)->sin_addr.s_addr == bind_addr)
1857 {
1858 index = if_nametoindex( ifaddr->ifa_name );
1859 if (!index)
1860 {
1861 if (debug_level)
1862 fprintf( stderr, "Unable to look up interface index for %s: %s\n",
1863 ifaddr->ifa_name, strerror( errno ) );
1864 continue;
1865 }
1866
1867 freeifaddrs( ifaddrs );
1868
1869 if (bind_to_index( fd, bind_addr, index ) < 0)
1870 {
1871 if (debug_level)
1872 fprintf( stderr, "failed to bind to interface: %s\n", strerror( errno ) );
1873 return 0;
1874 }
1875
1876 if (setsockopt( fd, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable) ) < 0)
1877 {
1878 if (debug_level)
1879 fprintf( stderr, "failed to reuse address: %s\n", strerror( errno ) );
1880 return 0;
1881 }
1882 return 1;
1883 }
1884 }
1885
1886 freeifaddrs( ifaddrs );
1887 return 0;
1888 }
1889
1890 #ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID
1891 static unsigned int get_ipv6_interface_index( const struct in6_addr *addr )
1892 {
1893 struct ifaddrs *ifaddrs, *ifaddr;
1894
1895 if (getifaddrs( &ifaddrs ) < 0) return 0;
1896
1897 for (ifaddr = ifaddrs; ifaddr != NULL; ifaddr = ifaddr->ifa_next)
1898 {
1899 if (ifaddr->ifa_addr && ifaddr->ifa_addr->sa_family == AF_INET6
1900 && !memcmp( &((struct sockaddr_in6 *)ifaddr->ifa_addr)->sin6_addr, addr, sizeof(*addr) ))
1901 {
1902 unsigned int index = if_nametoindex( ifaddr->ifa_name );
1903
1904 if (!index)
1905 {
1906 if (debug_level)
1907 fprintf( stderr, "Unable to look up interface index for %s: %s\n",
1908 ifaddr->ifa_name, strerror( errno ) );
1909 continue;
1910 }
1911
1912 freeifaddrs( ifaddrs );
1913 return index;
1914 }
1915 }
1916
1917 freeifaddrs( ifaddrs );
1918 return 0;
1919 }
1920 #endif
1921
1922 /* return an errno value mapped to a WSA error */
1923 static unsigned int sock_get_error( int err )
1924 {
1925 switch (err)
1926 {
1927 case EINTR: return WSAEINTR;
1928 case EBADF: return WSAEBADF;
1929 case EPERM:
1930 case EACCES: return WSAEACCES;
1931 case EFAULT: return WSAEFAULT;
1932 case EINVAL: return WSAEINVAL;
1933 case EMFILE: return WSAEMFILE;
1934 case EINPROGRESS:
1935 case EWOULDBLOCK: return WSAEWOULDBLOCK;
1936 case EALREADY: return WSAEALREADY;
1937 case ENOTSOCK: return WSAENOTSOCK;
1938 case EDESTADDRREQ: return WSAEDESTADDRREQ;
1939 case EMSGSIZE: return WSAEMSGSIZE;
1940 case EPROTOTYPE: return WSAEPROTOTYPE;
1941 case ENOPROTOOPT: return WSAENOPROTOOPT;
1942 case EPROTONOSUPPORT: return WSAEPROTONOSUPPORT;
1943 case ESOCKTNOSUPPORT: return WSAESOCKTNOSUPPORT;
1944 case EOPNOTSUPP: return WSAEOPNOTSUPP;
1945 case EPFNOSUPPORT: return WSAEPFNOSUPPORT;
1946 case EAFNOSUPPORT: return WSAEAFNOSUPPORT;
1947 case EADDRINUSE: return WSAEADDRINUSE;
1948 case EADDRNOTAVAIL: return WSAEADDRNOTAVAIL;
1949 case ENETDOWN: return WSAENETDOWN;
1950 case ENETUNREACH: return WSAENETUNREACH;
1951 case ENETRESET: return WSAENETRESET;
1952 case ECONNABORTED: return WSAECONNABORTED;
1953 case EPIPE:
1954 case ECONNRESET: return WSAECONNRESET;
1955 case ENOBUFS: return WSAENOBUFS;
1956 case EISCONN: return WSAEISCONN;
1957 case ENOTCONN: return WSAENOTCONN;
1958 case ESHUTDOWN: return WSAESHUTDOWN;
1959 case ETOOMANYREFS: return WSAETOOMANYREFS;
1960 case ETIMEDOUT: return WSAETIMEDOUT;
1961 case ECONNREFUSED: return WSAECONNREFUSED;
1962 case ELOOP: return WSAELOOP;
1963 case ENAMETOOLONG: return WSAENAMETOOLONG;
1964 case EHOSTDOWN: return WSAEHOSTDOWN;
1965 case EHOSTUNREACH: return WSAEHOSTUNREACH;
1966 case ENOTEMPTY: return WSAENOTEMPTY;
1967 #ifdef EPROCLIM
1968 case EPROCLIM: return WSAEPROCLIM;
1969 #endif
1970 #ifdef EUSERS
1971 case EUSERS: return WSAEUSERS;
1972 #endif
1973 #ifdef EDQUOT
1974 case EDQUOT: return WSAEDQUOT;
1975 #endif
1976 #ifdef ESTALE
1977 case ESTALE: return WSAESTALE;
1978 #endif
1979 #ifdef EREMOTE
1980 case EREMOTE: return WSAEREMOTE;
1981 #endif
1982
1983 case 0: return 0;
1984 default:
1985 errno = err;
1986 perror("wineserver: sock_get_error() can't map error");
1987 return WSAEFAULT;
1988 }
1989 }
1990
1991 static int sock_get_ntstatus( int err )
1992 {
1993 switch ( err )
1994 {
1995 case EBADF: return STATUS_INVALID_HANDLE;
1996 case EBUSY: return STATUS_DEVICE_BUSY;
1997 case EPERM:
1998 case EACCES: return STATUS_ACCESS_DENIED;
1999 case EFAULT: return STATUS_ACCESS_VIOLATION;
2000 case EINVAL: return STATUS_INVALID_PARAMETER;
2001 case ENFILE:
2002 case EMFILE: return STATUS_TOO_MANY_OPENED_FILES;
2003 case EINPROGRESS:
2004 case EWOULDBLOCK: return STATUS_DEVICE_NOT_READY;
2005 case EALREADY: return STATUS_NETWORK_BUSY;
2006 case ENOTSOCK: return STATUS_OBJECT_TYPE_MISMATCH;
2007 case EDESTADDRREQ: return STATUS_INVALID_PARAMETER;
2008 case EMSGSIZE: return STATUS_BUFFER_OVERFLOW;
2009 case EPROTONOSUPPORT:
2010 case ESOCKTNOSUPPORT:
2011 case EPFNOSUPPORT:
2012 case EAFNOSUPPORT:
2013 case EPROTOTYPE: return STATUS_NOT_SUPPORTED;
2014 case ENOPROTOOPT: return STATUS_INVALID_PARAMETER;
2015 case EOPNOTSUPP: return STATUS_NOT_SUPPORTED;
2016 case EADDRINUSE: return STATUS_SHARING_VIOLATION;
2017 /* Linux returns ENODEV when specifying an invalid sin6_scope_id;
2018 * Windows returns STATUS_INVALID_ADDRESS_COMPONENT */
2019 case ENODEV:
2020 case EADDRNOTAVAIL: return STATUS_INVALID_ADDRESS_COMPONENT;
2021 case ECONNREFUSED: return STATUS_CONNECTION_REFUSED;
2022 case ESHUTDOWN: return STATUS_PIPE_DISCONNECTED;
2023 case ENOTCONN: return STATUS_INVALID_CONNECTION;
2024 case ETIMEDOUT: return STATUS_IO_TIMEOUT;
2025 case ENETUNREACH: return STATUS_NETWORK_UNREACHABLE;
2026 case EHOSTUNREACH: return STATUS_HOST_UNREACHABLE;
2027 case ENETDOWN: return STATUS_NETWORK_BUSY;
2028 case EPIPE:
2029 case ECONNRESET: return STATUS_CONNECTION_RESET;
2030 case ECONNABORTED: return STATUS_CONNECTION_ABORTED;
2031 case EISCONN: return STATUS_CONNECTION_ACTIVE;
2032
2033 case 0: return STATUS_SUCCESS;
2034 default:
2035 errno = err;
2036 perror("wineserver: sock_get_ntstatus() can't map error");
2037 return STATUS_UNSUCCESSFUL;
2038 }
2039 }
2040
2041 static struct accept_req *alloc_accept_req( struct sock *sock, struct sock *acceptsock, struct async *async,
2042 const struct afd_accept_into_params *params )
2043 {
2044 struct accept_req *req = mem_alloc( sizeof(*req) );
2045
2046 if (req)
2047 {
2048 req->async = (struct async *)grab_object( async );
2049 req->iosb = async_get_iosb( async );
2050 req->sock = (struct sock *)grab_object( sock );
2051 req->acceptsock = acceptsock;
2052 if (acceptsock) grab_object( acceptsock );
2053 req->accepted = 0;
2054 req->recv_len = 0;
2055 req->local_len = 0;
2056 if (params)
2057 {
2058 req->recv_len = params->recv_len;
2059 req->local_len = params->local_len;
2060 }
2061 }
2062 return req;
2063 }
2064
2065 static void sock_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
2066 {
2067 struct sock *sock = get_fd_user( fd );
2068 int unix_fd;
2069
2070 assert( sock->obj.ops == &sock_ops );
2071
2072 if (code != IOCTL_AFD_WINE_CREATE && (unix_fd = get_unix_fd( fd )) < 0) return;
2073
2074 switch(code)
2075 {
2076 case IOCTL_AFD_WINE_CREATE:
2077 {
2078 const struct afd_create_params *params = get_req_data();
2079
2080 if (get_req_data_size() != sizeof(*params))
2081 {
2082 set_error( STATUS_INVALID_PARAMETER );
2083 return;
2084 }
2085 init_socket( sock, params->family, params->type, params->protocol, params->flags );
2086 return;
2087 }
2088
2089 case IOCTL_AFD_WINE_ACCEPT:
2090 {
2091 struct sock *acceptsock;
2092 obj_handle_t handle;
2093
2094 if (get_reply_max_size() != sizeof(handle))
2095 {
2096 set_error( STATUS_BUFFER_TOO_SMALL );
2097 return;
2098 }
2099
2100 if (!(acceptsock = accept_socket( sock )))
2101 {
2102 struct accept_req *req;
2103
2104 if (sock->nonblocking) return;
2105 if (get_error() != STATUS_DEVICE_NOT_READY) return;
2106
2107 if (!(req = alloc_accept_req( sock, NULL, async, NULL ))) return;
2108 list_add_tail( &sock->accept_list, &req->entry );
2109
2110 async_set_completion_callback( async, free_accept_req, req );
2111 queue_async( &sock->accept_q, async );
2112 sock_reselect( sock );
2113 set_error( STATUS_PENDING );
2114 return;
2115 }
2116 handle = alloc_handle( current->process, &acceptsock->obj,
2117 GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE, OBJ_INHERIT );
2118 acceptsock->wparam = handle;
2119 release_object( acceptsock );
2120 set_reply_data( &handle, sizeof(handle) );
2121 return;
2122 }
2123
2124 case IOCTL_AFD_WINE_ACCEPT_INTO:
2125 {
2126 static const int access = FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES | FILE_READ_DATA;
2127 const struct afd_accept_into_params *params = get_req_data();
2128 struct sock *acceptsock;
2129 unsigned int remote_len;
2130 struct accept_req *req;
2131
2132 if (get_req_data_size() != sizeof(*params) ||
2133 get_reply_max_size() < params->recv_len ||
2134 get_reply_max_size() - params->recv_len < params->local_len)
2135 {
2136 set_error( STATUS_BUFFER_TOO_SMALL );
2137 return;
2138 }
2139
2140 remote_len = get_reply_max_size() - params->recv_len - params->local_len;
2141 if (remote_len < sizeof(int))
2142 {
2143 set_error( STATUS_INVALID_PARAMETER );
2144 return;
2145 }
2146
2147 if (!(acceptsock = (struct sock *)get_handle_obj( current->process, params->accept_handle, access, &sock_ops )))
2148 return;
2149
2150 if (acceptsock->accept_recv_req)
2151 {
2152 release_object( acceptsock );
2153 set_error( STATUS_INVALID_PARAMETER );
2154 return;
2155 }
2156
2157 if (!(req = alloc_accept_req( sock, acceptsock, async, params )))
2158 {
2159 release_object( acceptsock );
2160 return;
2161 }
2162 list_add_tail( &sock->accept_list, &req->entry );
2163 acceptsock->accept_recv_req = req;
2164 release_object( acceptsock );
2165
2166 acceptsock->wparam = params->accept_handle;
2167 async_set_completion_callback( async, free_accept_req, req );
2168 queue_async( &sock->accept_q, async );
2169 sock_reselect( sock );
2170 set_error( STATUS_PENDING );
2171 return;
2172 }
2173
2174 case IOCTL_AFD_LISTEN:
2175 {
2176 const struct afd_listen_params *params = get_req_data();
2177
2178 if (get_req_data_size() < sizeof(*params))
2179 {
2180 set_error( STATUS_INVALID_PARAMETER );
2181 return;
2182 }
2183
2184 if (!sock->bound)
2185 {
2186 set_error( STATUS_INVALID_PARAMETER );
2187 return;
2188 }
2189
2190 if (listen( unix_fd, params->backlog ) < 0)
2191 {
2192 set_error( sock_get_ntstatus( errno ) );
2193 return;
2194 }
2195
2196 sock->state = SOCK_LISTENING;
2197
2198 /* a listening socket can no longer be accepted into */
2199 allow_fd_caching( sock->fd );
2200
2201 /* we may already be selecting for AFD_POLL_ACCEPT */
2202 sock_reselect( sock );
2203 return;
2204 }
2205
2206 case IOCTL_AFD_WINE_CONNECT:
2207 {
2208 const struct afd_connect_params *params = get_req_data();
2209 const struct WS_sockaddr *addr;
2210 union unix_sockaddr unix_addr;
2211 struct connect_req *req;
2212 socklen_t unix_len;
2213 int send_len, ret;
2214
2215 if (get_req_data_size() < sizeof(*params) ||
2216 get_req_data_size() - sizeof(*params) < params->addr_len)
2217 {
2218 set_error( STATUS_BUFFER_TOO_SMALL );
2219 return;
2220 }
2221 send_len = get_req_data_size() - sizeof(*params) - params->addr_len;
2222 addr = (const struct WS_sockaddr *)(params + 1);
2223
2224 if (!params->synchronous && !sock->bound)
2225 {
2226 set_error( STATUS_INVALID_PARAMETER );
2227 return;
2228 }
2229
2230 if (sock->accept_recv_req)
2231 {
2232 set_error( STATUS_INVALID_PARAMETER );
2233 return;
2234 }
2235
2236 if (sock->connect_req)
2237 {
2238 set_error( STATUS_INVALID_PARAMETER );
2239 return;
2240 }
2241
2242 switch (sock->state)
2243 {
2244 case SOCK_LISTENING:
2245 set_error( STATUS_INVALID_PARAMETER );
2246 return;
2247
2248 case SOCK_CONNECTING:
2249 /* FIXME: STATUS_ADDRESS_ALREADY_ASSOCIATED probably isn't right,
2250 * but there's no status code that maps to WSAEALREADY... */
2251 set_error( params->synchronous ? STATUS_ADDRESS_ALREADY_ASSOCIATED : STATUS_INVALID_PARAMETER );
2252 return;
2253
2254 case SOCK_CONNECTED:
2255 set_error( STATUS_CONNECTION_ACTIVE );
2256 return;
2257
2258 case SOCK_UNCONNECTED:
2259 case SOCK_CONNECTIONLESS:
2260 break;
2261 }
2262
2263 unix_len = sockaddr_to_unix( addr, params->addr_len, &unix_addr );
2264 if (!unix_len)
2265 {
2266 set_error( STATUS_INVALID_ADDRESS );
2267 return;
2268 }
2269 if (unix_addr.addr.sa_family == AF_INET && !memcmp( &unix_addr.in.sin_addr, magic_loopback_addr, 4 ))
2270 unix_addr.in.sin_addr.s_addr = htonl( INADDR_LOOPBACK );
2271
2272 ret = connect( unix_fd, &unix_addr.addr, unix_len );
2273 if (ret < 0 && errno != EINPROGRESS)
2274 {
2275 set_error( sock_get_ntstatus( errno ) );
2276 return;
2277 }
2278
2279 /* a connected or connecting socket can no longer be accepted into */
2280 allow_fd_caching( sock->fd );
2281
2282 unix_len = sizeof(unix_addr);
2283 if (!sock->bound && !getsockname( unix_fd, &unix_addr.addr, &unix_len ))
2284 sock->addr_len = sockaddr_from_unix( &unix_addr, &sock->addr.addr, sizeof(sock->addr) );
2285 sock->bound = 1;
2286
2287 if (!ret)
2288 {
2289 sock->state = SOCK_CONNECTED;
2290
2291 if (!send_len) return;
2292 }
2293
2294 sock->state = SOCK_CONNECTING;
2295
2296 if (params->synchronous && sock->nonblocking)
2297 {
2298 sock_reselect( sock );
2299 set_error( STATUS_DEVICE_NOT_READY );
2300 return;
2301 }
2302
2303 if (!(req = mem_alloc( sizeof(*req) )))
2304 return;
2305
2306 req->async = (struct async *)grab_object( async );
2307 req->iosb = async_get_iosb( async );
2308 req->sock = (struct sock *)grab_object( sock );
2309 req->addr_len = params->addr_len;
2310 req->send_len = send_len;
2311 req->send_cursor = 0;
2312
2313 async_set_completion_callback( async, free_connect_req, req );
2314 sock->connect_req = req;
2315 queue_async( &sock->connect_q, async );
2316 sock_reselect( sock );
2317 set_error( STATUS_PENDING );
2318 return;
2319 }
2320
2321 case IOCTL_AFD_WINE_SHUTDOWN:
2322 {
2323 unsigned int how;
2324
2325 if (get_req_data_size() < sizeof(int))
2326 {
2327 set_error( STATUS_BUFFER_TOO_SMALL );
2328 return;
2329 }
2330 how = *(int *)get_req_data();
2331
2332 if (how > SD_BOTH)
2333 {
2334 set_error( STATUS_INVALID_PARAMETER );
2335 return;
2336 }
2337
2338 if (sock->state != SOCK_CONNECTED && sock->state != SOCK_CONNECTIONLESS)
2339 {
2340 set_error( STATUS_INVALID_CONNECTION );
2341 return;
2342 }
2343
2344 if (how != SD_SEND)
2345 {
2346 sock->rd_shutdown = 1;
2347 }
2348 if (how != SD_RECEIVE)
2349 {
2350 sock->wr_shutdown = 1;
2351 if (list_empty( &sock->write_q.queue ))
2352 shutdown( unix_fd, SHUT_WR );
2353 else
2354 sock->wr_shutdown_pending = 1;
2355 }
2356
2357 if (how == SD_BOTH)
2358 {
2359 if (sock->event) release_object( sock->event );
2360 sock->event = NULL;
2361 sock->window = 0;
2362 sock->mask = 0;
2363 sock->nonblocking = 1;
2364 }
2365
2366 sock_reselect( sock );
2367 return;
2368 }
2369
2370 case IOCTL_AFD_WINE_ADDRESS_LIST_CHANGE:
2371 {
2372 int force_async;
2373
2374 if (get_req_data_size() < sizeof(int))
2375 {
2376 set_error( STATUS_BUFFER_TOO_SMALL );
2377 return;
2378 }
2379 force_async = *(int *)get_req_data();
2380
2381 if (sock->nonblocking && !force_async)
2382 {
2383 set_error( STATUS_DEVICE_NOT_READY );
2384 return;
2385 }
2386 if (!sock_get_ifchange( sock )) return;
2387 queue_async( &sock->ifchange_q, async );
2388 set_error( STATUS_PENDING );
2389 return;
2390 }
2391
2392 case IOCTL_AFD_WINE_FIONBIO:
2393 if (get_req_data_size() < sizeof(int))
2394 {
2395 set_error( STATUS_BUFFER_TOO_SMALL );
2396 return;
2397 }
2398 if (*(int *)get_req_data())
2399 {
2400 sock->nonblocking = 1;
2401 }
2402 else
2403 {
2404 if (sock->mask)
2405 {
2406 set_error( STATUS_INVALID_PARAMETER );
2407 return;
2408 }
2409 sock->nonblocking = 0;
2410 }
2411 return;
2412
2413 case IOCTL_AFD_GET_EVENTS:
2414 {
2415 struct afd_get_events_params params = {0};
2416 unsigned int i;
2417
2418 if (get_reply_max_size() < sizeof(params))
2419 {
2420 set_error( STATUS_INVALID_PARAMETER );
2421 return;
2422 }
2423
2424 params.flags = sock->pending_events & sock->mask;
2425 for (i = 0; i < ARRAY_SIZE( params.status ); ++i)
2426 params.status[i] = sock_get_ntstatus( sock->errors[i] );
2427
2428 sock->pending_events = 0;
2429 sock_reselect( sock );
2430
2431 set_reply_data( &params, sizeof(params) );
2432 return;
2433 }
2434
2435 case IOCTL_AFD_EVENT_SELECT:
2436 {
2437 struct event *event = NULL;
2438 obj_handle_t event_handle;
2439 int mask;
2440
2441 set_async_pending( async );
2442
2443 if (is_machine_64bit( current->process->machine ))
2444 {
2445 const struct afd_event_select_params_64 *params = get_req_data();
2446
2447 if (get_req_data_size() < sizeof(*params))
2448 {
2449 set_error( STATUS_INVALID_PARAMETER );
2450 return;
2451 }
2452
2453 event_handle = params->event;
2454 mask = params->mask;
2455 }
2456 else
2457 {
2458 const struct afd_event_select_params_32 *params = get_req_data();
2459
2460 if (get_req_data_size() < sizeof(*params))
2461 {
2462 set_error( STATUS_INVALID_PARAMETER );
2463 return;
2464 }
2465
2466 event_handle = params->event;
2467 mask = params->mask;
2468 }
2469
2470 if ((event_handle || mask) &&
2471 !(event = get_event_obj( current->process, event_handle, EVENT_MODIFY_STATE )))
2472 {
2473 set_error( STATUS_INVALID_PARAMETER );
2474 return;
2475 }
2476
2477 if (sock->event) release_object( sock->event );
2478 sock->event = event;
2479 sock->mask = mask;
2480 sock->window = 0;
2481 sock->message = 0;
2482 sock->wparam = 0;
2483 sock->nonblocking = 1;
2484
2485 sock_reselect( sock );
2486
2487 return;
2488 }
2489
2490 case IOCTL_AFD_WINE_MESSAGE_SELECT:
2491 {
2492 const struct afd_message_select_params *params = get_req_data();
2493
2494 if (get_req_data_size() < sizeof(params))
2495 {
2496 set_error( STATUS_BUFFER_TOO_SMALL );
2497 return;
2498 }
2499
2500 if (sock->event) release_object( sock->event );
2501
2502 if (params->window)
2503 {
2504 sock->pending_events = 0;
2505 sock->reported_events = 0;
2506 }
2507 sock->event = NULL;
2508 sock->mask = params->mask;
2509 sock->window = params->window;
2510 sock->message = params->message;
2511 sock->wparam = params->handle;
2512 sock->nonblocking = 1;
2513
2514 sock_reselect( sock );
2515
2516 return;
2517 }
2518
2519 case IOCTL_AFD_BIND:
2520 {
2521 const struct afd_bind_params *params = get_req_data();
2522 union unix_sockaddr unix_addr, bind_addr;
2523 data_size_t in_size;
2524 socklen_t unix_len;
2525
2526 /* the ioctl is METHOD_NEITHER, so ntdll gives us the output buffer as
2527 * input */
2528 if (get_req_data_size() < get_reply_max_size())
2529 {
2530 set_error( STATUS_BUFFER_TOO_SMALL );
2531 return;
2532 }
2533 in_size = get_req_data_size() - get_reply_max_size();
2534 if (in_size < offsetof(struct afd_bind_params, addr.sa_data)
2535 || get_reply_max_size() < in_size - sizeof(int))
2536 {
2537 set_error( STATUS_INVALID_PARAMETER );
2538 return;
2539 }
2540
2541 if (sock->bound)
2542 {
2543 set_error( STATUS_ADDRESS_ALREADY_ASSOCIATED );
2544 return;
2545 }
2546
2547 unix_len = sockaddr_to_unix( &params->addr, in_size - sizeof(int), &unix_addr );
2548 if (!unix_len)
2549 {
2550 set_error( STATUS_INVALID_ADDRESS );
2551 return;
2552 }
2553 bind_addr = unix_addr;
2554
2555 if (unix_addr.addr.sa_family == AF_INET)
2556 {
2557 if (!memcmp( &unix_addr.in.sin_addr, magic_loopback_addr, 4 )
2558 || bind_to_interface( sock, &unix_addr.in ))
2559 bind_addr.in.sin_addr.s_addr = htonl( INADDR_ANY );
2560 }
2561 else if (unix_addr.addr.sa_family == AF_INET6)
2562 {
2563 #ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID
2564 /* Windows allows specifying zero to use the default scope. Linux
2565 * interprets it as an interface index and requires that it be
2566 * nonzero. */
2567 if (!unix_addr.in6.sin6_scope_id)
2568 bind_addr.in6.sin6_scope_id = get_ipv6_interface_index( &unix_addr.in6.sin6_addr );
2569 #endif
2570 }
2571
2572 set_async_pending( async );
2573
2574 if (bind( unix_fd, &bind_addr.addr, unix_len ) < 0)
2575 {
2576 if (errno == EADDRINUSE)
2577 {
2578 int reuse;
2579 socklen_t len = sizeof(reuse);
2580
2581 if (!getsockopt( unix_fd, SOL_SOCKET, SO_REUSEADDR, (char *)&reuse, &len ) && reuse)
2582 errno = EACCES;
2583 }
2584
2585 set_error( sock_get_ntstatus( errno ) );
2586 return;
2587 }
2588
2589 sock->bound = 1;
2590
2591 unix_len = sizeof(bind_addr);
2592 if (!getsockname( unix_fd, &bind_addr.addr, &unix_len ))
2593 {
2594 /* store the interface or magic loopback address instead of the
2595 * actual unix address */
2596 if (bind_addr.addr.sa_family == AF_INET)
2597 bind_addr.in.sin_addr = unix_addr.in.sin_addr;
2598 sock->addr_len = sockaddr_from_unix( &bind_addr, &sock->addr.addr, sizeof(sock->addr) );
2599 }
2600
2601 if (get_reply_max_size() >= sock->addr_len)
2602 set_reply_data( &sock->addr, sock->addr_len );
2603 return;
2604 }
2605
2606 case IOCTL_AFD_GETSOCKNAME:
2607 if (!sock->bound)
2608 {
2609 set_error( STATUS_INVALID_PARAMETER );
2610 return;
2611 }
2612
2613 if (get_reply_max_size() < sock->addr_len)
2614 {
2615 set_error( STATUS_BUFFER_TOO_SMALL );
2616 return;
2617 }
2618
2619 set_reply_data( &sock->addr, sock->addr_len );
2620 return;
2621
2622 case IOCTL_AFD_WINE_DEFER:
2623 {
2624 const obj_handle_t *handle = get_req_data();
2625 struct sock *acceptsock;
2626
2627 if (get_req_data_size() < sizeof(*handle))
2628 {
2629 set_error( STATUS_BUFFER_TOO_SMALL );
2630 return;
2631 }
2632
2633 acceptsock = (struct sock *)get_handle_obj( current->process, *handle, 0, &sock_ops );
2634 if (!acceptsock) return;
2635
2636 sock->deferred = acceptsock;
2637 return;
2638 }
2639
2640 case IOCTL_AFD_WINE_GET_INFO:
2641 {
2642 struct afd_get_info_params params;
2643
2644 if (get_reply_max_size() < sizeof(params))
2645 {
2646 set_error( STATUS_BUFFER_TOO_SMALL );
2647 return;
2648 }
2649
2650 params.family = sock->family;
2651 params.type = sock->type;
2652 params.protocol = sock->proto;
2653 set_reply_data( &params, sizeof(params) );
2654 return;
2655 }
2656
2657 case IOCTL_AFD_WINE_GET_SO_ACCEPTCONN:
2658 {
2659 int listening = (sock->state == SOCK_LISTENING);
2660
2661 if (get_reply_max_size() < sizeof(listening))
2662 {
2663 set_error( STATUS_BUFFER_TOO_SMALL );
2664 return;
2665 }
2666
2667 set_reply_data( &listening, sizeof(listening) );
2668 return;
2669 }
2670
2671 case IOCTL_AFD_WINE_GET_SO_ERROR:
2672 {
2673 int error;
2674 socklen_t len = sizeof(error);
2675 unsigned int i;
2676
2677 if (get_reply_max_size() < sizeof(error))
2678 {
2679 set_error( STATUS_BUFFER_TOO_SMALL );
2680 return;
2681 }
2682
2683 if (getsockopt( unix_fd, SOL_SOCKET, SO_ERROR, (char *)&error, &len ) < 0)
2684 {
2685 set_error( sock_get_ntstatus( errno ) );
2686 return;
2687 }
2688
2689 if (!error)
2690 {
2691 for (i = 0; i < ARRAY_SIZE( sock->errors ); ++i)
2692 {
2693 if (sock->errors[i])
2694 {
2695 error = sock_get_error( sock->errors[i] );
2696 break;
2697 }
2698 }
2699 }
2700
2701 set_reply_data( &error, sizeof(error) );
2702 return;
2703 }
2704
2705 case IOCTL_AFD_WINE_GET_SO_RCVBUF:
2706 {
2707 int rcvbuf = sock->rcvbuf;
2708
2709 if (get_reply_max_size() < sizeof(rcvbuf))
2710 {
2711 set_error( STATUS_BUFFER_TOO_SMALL );
2712 return;
2713 }
2714
2715 set_reply_data( &rcvbuf, sizeof(rcvbuf) );
2716 return;
2717 }
2718
2719 case IOCTL_AFD_WINE_SET_SO_RCVBUF:
2720 {
2721 DWORD rcvbuf;
2722
2723 if (get_req_data_size() < sizeof(rcvbuf))
2724 {
2725 set_error( STATUS_BUFFER_TOO_SMALL );
2726 return;
2727 }
2728 rcvbuf = *(DWORD *)get_req_data();
2729
2730 if (!setsockopt( unix_fd, SOL_SOCKET, SO_RCVBUF, (char *)&rcvbuf, sizeof(rcvbuf) ))
2731 sock->rcvbuf = rcvbuf;
2732 else
2733 set_error( sock_get_ntstatus( errno ) );
2734 return;
2735 }
2736
2737 case IOCTL_AFD_WINE_GET_SO_RCVTIMEO:
2738 {
2739 DWORD rcvtimeo = sock->rcvtimeo;
2740
2741 if (get_reply_max_size() < sizeof(rcvtimeo))
2742 {
2743 set_error( STATUS_BUFFER_TOO_SMALL );
2744 return;
2745 }
2746
2747 set_reply_data( &rcvtimeo, sizeof(rcvtimeo) );
2748 return;
2749 }
2750
2751 case IOCTL_AFD_WINE_SET_SO_RCVTIMEO:
2752 {
2753 DWORD rcvtimeo;
2754
2755 if (get_req_data_size() < sizeof(rcvtimeo))
2756 {
2757 set_error( STATUS_BUFFER_TOO_SMALL );
2758 return;
2759 }
2760 rcvtimeo = *(DWORD *)get_req_data();
2761
2762 sock->rcvtimeo = rcvtimeo;
2763 return;
2764 }
2765
2766 case IOCTL_AFD_WINE_GET_SO_SNDBUF:
2767 {
2768 int sndbuf = sock->sndbuf;
2769
2770 if (get_reply_max_size() < sizeof(sndbuf))
2771 {
2772 set_error( STATUS_BUFFER_TOO_SMALL );
2773 return;
2774 }
2775
2776 set_reply_data( &sndbuf, sizeof(sndbuf) );
2777 return;
2778 }
2779
2780 case IOCTL_AFD_WINE_SET_SO_SNDBUF:
2781 {
2782 DWORD sndbuf;
2783
2784 if (get_req_data_size() < sizeof(sndbuf))
2785 {
2786 set_error( STATUS_BUFFER_TOO_SMALL );
2787 return;
2788 }
2789 sndbuf = *(DWORD *)get_req_data();
2790
2791 #ifdef __APPLE__
2792 if (!sndbuf)
2793 {
2794 /* setsockopt fails if a zero value is passed */
2795 sock->sndbuf = sndbuf;
2796 return;
2797 }
2798 #endif
2799
2800 if (!setsockopt( unix_fd, SOL_SOCKET, SO_SNDBUF, (char *)&sndbuf, sizeof(sndbuf) ))
2801 sock->sndbuf = sndbuf;
2802 else
2803 set_error( sock_get_ntstatus( errno ) );
2804 return;
2805 }
2806
2807 case IOCTL_AFD_WINE_GET_SO_SNDTIMEO:
2808 {
2809 DWORD sndtimeo = sock->sndtimeo;
2810
2811 if (get_reply_max_size() < sizeof(sndtimeo))
2812 {
2813 set_error( STATUS_BUFFER_TOO_SMALL );
2814 return;
2815 }
2816
2817 set_reply_data( &sndtimeo, sizeof(sndtimeo) );
2818 return;
2819 }
2820
2821 case IOCTL_AFD_WINE_SET_SO_SNDTIMEO:
2822 {
2823 DWORD sndtimeo;
2824
2825 if (get_req_data_size() < sizeof(sndtimeo))
2826 {
2827 set_error( STATUS_BUFFER_TOO_SMALL );
2828 return;
2829 }
2830 sndtimeo = *(DWORD *)get_req_data();
2831
2832 sock->sndtimeo = sndtimeo;
2833 return;
2834 }
2835
2836 case IOCTL_AFD_WINE_GET_SO_CONNECT_TIME:
2837 {
2838 DWORD time = ~0u;
2839
2840 if (get_reply_max_size() < sizeof(time))
2841 {
2842 set_error( STATUS_BUFFER_TOO_SMALL );
2843 return;
2844 }
2845
2846 if (sock->state == SOCK_CONNECTED)
2847 time = (current_time - sock->connect_time) / 10000000;
2848
2849 set_reply_data( &time, sizeof(time) );
2850 return;
2851 }
2852
2853 default:
2854 set_error( STATUS_NOT_SUPPORTED );
2855 return;
2856 }
2857 }
2858
2859 static int poll_single_socket( struct sock *sock, int mask )
2860 {
2861 struct pollfd pollfd;
2862
2863 pollfd.fd = get_unix_fd( sock->fd );
2864 pollfd.events = poll_flags_from_afd( sock, mask );
2865 if (pollfd.events < 0 || poll( &pollfd, 1, 0 ) < 0)
2866 return 0;
2867
2868 if ((mask & AFD_POLL_HUP) && (pollfd.revents & POLLIN) && sock->type == WS_SOCK_STREAM)
2869 {
2870 char dummy;
2871
2872 if (!recv( get_unix_fd( sock->fd ), &dummy, 1, MSG_PEEK ))
2873 {
2874 pollfd.revents &= ~POLLIN;
2875 pollfd.revents |= POLLHUP;
2876 }
2877 }
2878
2879 return get_poll_flags( sock, pollfd.revents ) & mask;
2880 }
2881
2882 static void handle_exclusive_poll(struct poll_req *req)
2883 {
2884 unsigned int i;
2885
2886 for (i = 0; i < req->count; ++i)
2887 {
2888 struct sock *sock = req->sockets[i].sock;
2889 struct poll_req *main_poll = sock->main_poll;
2890
2891 if (main_poll && main_poll->exclusive && req->exclusive)
2892 {
2893 complete_async_poll( main_poll, STATUS_SUCCESS );
2894 main_poll = NULL;
2895 }
2896
2897 if (!main_poll)
2898 sock->main_poll = req;
2899 }
2900 }
2901
2902 static void poll_socket( struct sock *poll_sock, struct async *async, int exclusive, timeout_t timeout,
2903 unsigned int count, const struct poll_socket_input *input )
2904 {
2905 struct poll_socket_output *output;
2906 BOOL signaled = FALSE;
2907 struct poll_req *req;
2908 unsigned int i, j;
2909
2910 if (!(output = mem_alloc( count * sizeof(*output) )))
2911 return;
2912 memset( output, 0, count * sizeof(*output) );
2913
2914 if (!(req = mem_alloc( offsetof( struct poll_req, sockets[count] ) )))
2915 {
2916 free( output );
2917 return;
2918 }
2919
2920 req->timeout = NULL;
2921 if (timeout && timeout != TIMEOUT_INFINITE &&
2922 !(req->timeout = add_timeout_user( timeout, async_poll_timeout, req )))
2923 {
2924 free( req );
2925 free( output );
2926 return;
2927 }
2928
2929 for (i = 0; i < count; ++i)
2930 {
2931 req->sockets[i].sock = (struct sock *)get_handle_obj( current->process, input[i].socket, 0, &sock_ops );
2932 if (!req->sockets[i].sock)
2933 {
2934 for (j = 0; j < i; ++j) release_object( req->sockets[i].sock );
2935 if (req->timeout) remove_timeout_user( req->timeout );
2936 free( req );
2937 free( output );
2938 return;
2939 }
2940 req->sockets[i].flags = input[i].flags;
2941 }
2942
2943 req->exclusive = exclusive;
2944 req->count = count;
2945 req->async = (struct async *)grab_object( async );
2946 req->iosb = async_get_iosb( async );
2947 req->output = output;
2948
2949 handle_exclusive_poll(req);
2950
2951 list_add_tail( &poll_list, &req->entry );
2952 async_set_completion_callback( async, free_poll_req, req );
2953 queue_async( &poll_sock->poll_q, async );
2954
2955 for (i = 0; i < count; ++i)
2956 {
2957 struct sock *sock = req->sockets[i].sock;
2958 int mask = req->sockets[i].flags;
2959 int flags = poll_single_socket( sock, mask );
2960
2961 if (flags)
2962 {
2963 signaled = TRUE;
2964 output[i].flags = flags;
2965 output[i].status = sock_get_ntstatus( sock_error( sock->fd ) );
2966 }
2967
2968 /* FIXME: do other error conditions deserve a similar treatment? */
2969 if (sock->state != SOCK_CONNECTING && sock->errors[AFD_POLL_BIT_CONNECT_ERR] && (mask & AFD_POLL_CONNECT_ERR))
2970 {
2971 signaled = TRUE;
2972 output[i].flags |= AFD_POLL_CONNECT_ERR;
2973 output[i].status = sock_get_ntstatus( sock->errors[AFD_POLL_BIT_CONNECT_ERR] );
2974 }
2975 }
2976
2977 if (!timeout || signaled)
2978 complete_async_poll( req, STATUS_SUCCESS );
2979
2980 for (i = 0; i < req->count; ++i)
2981 sock_reselect( req->sockets[i].sock );
2982 set_error( STATUS_PENDING );
2983 }
2984
2985 #ifdef HAVE_LINUX_RTNETLINK_H
2986
2987 /* only keep one ifchange object around, all sockets waiting for wakeups will look to it */
2988 static struct object *ifchange_object;
2989
2990 static void ifchange_dump( struct object *obj, int verbose );
2991 static struct fd *ifchange_get_fd( struct object *obj );
2992 static void ifchange_destroy( struct object *obj );
2993
2994 static int ifchange_get_poll_events( struct fd *fd );
2995 static void ifchange_poll_event( struct fd *fd, int event );
2996
2997 struct ifchange
2998 {
2999 struct object obj; /* object header */
3000 struct fd *fd; /* interface change file descriptor */
3001 struct list sockets; /* list of sockets to send interface change notifications */
3002 };
3003
3004 static const struct object_ops ifchange_ops =
3005 {
3006 sizeof(struct ifchange), /* size */
3007 &no_type, /* type */
3008 ifchange_dump, /* dump */
3009 no_add_queue, /* add_queue */
3010 NULL, /* remove_queue */
3011 NULL, /* signaled */
3012 no_satisfied, /* satisfied */
3013 no_signal, /* signal */
3014 ifchange_get_fd, /* get_fd */
3015 default_map_access, /* map_access */
3016 default_get_sd, /* get_sd */
3017 default_set_sd, /* set_sd */
3018 no_get_full_name, /* get_full_name */
3019 no_lookup_name, /* lookup_name */
3020 no_link_name, /* link_name */
3021 NULL, /* unlink_name */
3022 no_open_file, /* open_file */
3023 no_kernel_obj_list, /* get_kernel_obj_list */
3024 no_close_handle, /* close_handle */
3025 ifchange_destroy /* destroy */
3026 };
3027
3028 static const struct fd_ops ifchange_fd_ops =
3029 {
3030 ifchange_get_poll_events, /* get_poll_events */
3031 ifchange_poll_event, /* poll_event */
3032 NULL, /* get_fd_type */
3033 no_fd_read, /* read */
3034 no_fd_write, /* write */
3035 no_fd_flush, /* flush */
3036 no_fd_get_file_info, /* get_file_info */
3037 no_fd_get_volume_info, /* get_volume_info */
3038 no_fd_ioctl, /* ioctl */
3039 NULL, /* cancel_async */
3040 NULL, /* queue_async */
3041 NULL /* reselect_async */
3042 };
3043
3044 static void ifchange_dump( struct object *obj, int verbose )
3045 {
3046 assert( obj->ops == &ifchange_ops );
3047 fprintf( stderr, "Interface change\n" );
3048 }
3049
3050 static struct fd *ifchange_get_fd( struct object *obj )
3051 {
3052 struct ifchange *ifchange = (struct ifchange *)obj;
3053 return (struct fd *)grab_object( ifchange->fd );
3054 }
3055
3056 static void ifchange_destroy( struct object *obj )
3057 {
3058 struct ifchange *ifchange = (struct ifchange *)obj;
3059 assert( obj->ops == &ifchange_ops );
3060
3061 release_object( ifchange->fd );
3062
3063 /* reset the global ifchange object so that it will be recreated if it is needed again */
3064 assert( obj == ifchange_object );
3065 ifchange_object = NULL;
3066 }
3067
3068 static int ifchange_get_poll_events( struct fd *fd )
3069 {
3070 return POLLIN;
3071 }
3072
3073 /* wake up all the sockets waiting for a change notification event */
3074 static void ifchange_wake_up( struct object *obj, unsigned int status )
3075 {
3076 struct ifchange *ifchange = (struct ifchange *)obj;
3077 struct list *ptr, *next;
3078 assert( obj->ops == &ifchange_ops );
3079 assert( obj == ifchange_object );
3080
3081 LIST_FOR_EACH_SAFE( ptr, next, &ifchange->sockets )
3082 {
3083 struct sock *sock = LIST_ENTRY( ptr, struct sock, ifchange_entry );
3084
3085 assert( sock->ifchange_obj );
3086 async_wake_up( &sock->ifchange_q, status ); /* issue ifchange notification for the socket */
3087 sock_release_ifchange( sock ); /* remove socket from list and decrement ifchange refcount */
3088 }
3089 }
3090
3091 static void ifchange_poll_event( struct fd *fd, int event )
3092 {
3093 struct object *ifchange = get_fd_user( fd );
3094 unsigned int status = STATUS_PENDING;
3095 char buffer[PIPE_BUF];
3096 int r;
3097
3098 r = recv( get_unix_fd(fd), buffer, sizeof(buffer), MSG_DONTWAIT );
3099 if (r < 0)
3100 {
3101 if (errno == EWOULDBLOCK || (EWOULDBLOCK != EAGAIN && errno == EAGAIN))
3102 return; /* retry when poll() says the socket is ready */
3103 status = sock_get_ntstatus( errno );
3104 }
3105 else if (r > 0)
3106 {
3107 struct nlmsghdr *nlh;
3108
3109 for (nlh = (struct nlmsghdr *)buffer; NLMSG_OK(nlh, r); nlh = NLMSG_NEXT(nlh, r))
3110 {
3111 if (nlh->nlmsg_type == NLMSG_DONE)
3112 break;
3113 if (nlh->nlmsg_type == RTM_NEWADDR || nlh->nlmsg_type == RTM_DELADDR)
3114 status = STATUS_SUCCESS;
3115 }
3116 }
3117 else status = STATUS_CANCELLED;
3118
3119 if (status != STATUS_PENDING) ifchange_wake_up( ifchange, status );
3120 }
3121
3122 #endif
3123
3124 /* we only need one of these interface notification objects, all of the sockets dependent upon
3125 * it will wake up when a notification event occurs */
3126 static struct object *get_ifchange( void )
3127 {
3128 #ifdef HAVE_LINUX_RTNETLINK_H
3129 struct ifchange *ifchange;
3130 struct sockaddr_nl addr;
3131 int unix_fd;
3132
3133 if (ifchange_object)
3134 {
3135 /* increment the refcount for each socket that uses the ifchange object */
3136 return grab_object( ifchange_object );
3137 }
3138
3139 /* create the socket we need for processing interface change notifications */
3140 unix_fd = socket( PF_NETLINK, SOCK_RAW, NETLINK_ROUTE );
3141 if (unix_fd == -1)
3142 {
3143 set_error( sock_get_ntstatus( errno ));
3144 return NULL;
3145 }
3146 fcntl( unix_fd, F_SETFL, O_NONBLOCK ); /* make socket nonblocking */
3147 memset( &addr, 0, sizeof(addr) );
3148 addr.nl_family = AF_NETLINK;
3149 addr.nl_groups = RTMGRP_IPV4_IFADDR;
3150 /* bind the socket to the special netlink kernel interface */
3151 if (bind( unix_fd, (struct sockaddr *)&addr, sizeof(addr) ) == -1)
3152 {
3153 close( unix_fd );
3154 set_error( sock_get_ntstatus( errno ));
3155 return NULL;
3156 }
3157 if (!(ifchange = alloc_object( &ifchange_ops )))
3158 {
3159 close( unix_fd );
3160 set_error( STATUS_NO_MEMORY );
3161 return NULL;
3162 }
3163 list_init( &ifchange->sockets );
3164 if (!(ifchange->fd = create_anonymous_fd( &ifchange_fd_ops, unix_fd, &ifchange->obj, 0 )))
3165 {
3166 release_object( ifchange );
3167 set_error( STATUS_NO_MEMORY );
3168 return NULL;
3169 }
3170 set_fd_events( ifchange->fd, POLLIN ); /* enable read wakeup on the file descriptor */
3171
3172 /* the ifchange object is now successfully configured */
3173 ifchange_object = &ifchange->obj;
3174 return &ifchange->obj;
3175 #else
3176 set_error( STATUS_NOT_SUPPORTED );
3177 return NULL;
3178 #endif
3179 }
3180
3181 /* add the socket to the interface change notification list */
3182 static void ifchange_add_sock( struct object *obj, struct sock *sock )
3183 {
3184 #ifdef HAVE_LINUX_RTNETLINK_H
3185 struct ifchange *ifchange = (struct ifchange *)obj;
3186
3187 list_add_tail( &ifchange->sockets, &sock->ifchange_entry );
3188 #endif
3189 }
3190
3191 /* create a new ifchange queue for a specific socket or, if one already exists, reuse the existing one */
3192 static struct object *sock_get_ifchange( struct sock *sock )
3193 {
3194 struct object *ifchange;
3195
3196 if (sock->ifchange_obj) /* reuse existing ifchange_obj for this socket */
3197 return sock->ifchange_obj;
3198
3199 if (!(ifchange = get_ifchange()))
3200 return NULL;
3201
3202 /* add the socket to the ifchange notification list */
3203 ifchange_add_sock( ifchange, sock );
3204 sock->ifchange_obj = ifchange;
3205 return ifchange;
3206 }
3207
3208 /* destroy an existing ifchange queue for a specific socket */
3209 static void sock_release_ifchange( struct sock *sock )
3210 {
3211 if (sock->ifchange_obj)
3212 {
3213 list_remove( &sock->ifchange_entry );
3214 release_object( sock->ifchange_obj );
3215 sock->ifchange_obj = NULL;
3216 }
3217 }
3218
3219 static void socket_device_dump( struct object *obj, int verbose );
3220 static struct object *socket_device_lookup_name( struct object *obj, struct unicode_str *name,
3221 unsigned int attr, struct object *root );
3222 static struct object *socket_device_open_file( struct object *obj, unsigned int access,
3223 unsigned int sharing, unsigned int options );
3224
3225 static const struct object_ops socket_device_ops =
3226 {
3227 sizeof(struct object), /* size */
3228 &device_type, /* type */
3229 socket_device_dump, /* dump */
3230 no_add_queue, /* add_queue */
3231 NULL, /* remove_queue */
3232 NULL, /* signaled */
3233 no_satisfied, /* satisfied */
3234 no_signal, /* signal */
3235 no_get_fd, /* get_fd */
3236 default_map_access, /* map_access */
3237 default_get_sd, /* get_sd */
3238 default_set_sd, /* set_sd */
3239 default_get_full_name, /* get_full_name */
3240 socket_device_lookup_name, /* lookup_name */
3241 directory_link_name, /* link_name */
3242 default_unlink_name, /* unlink_name */
3243 socket_device_open_file, /* open_file */
3244 no_kernel_obj_list, /* get_kernel_obj_list */
3245 no_close_handle, /* close_handle */
3246 no_destroy /* destroy */
3247 };
3248
3249 static void socket_device_dump( struct object *obj, int verbose )
3250 {
3251 fputs( "Socket device\n", stderr );
3252 }
3253
3254 static struct object *socket_device_lookup_name( struct object *obj, struct unicode_str *name,
3255 unsigned int attr, struct object *root )
3256 {
3257 if (name) name->len = 0;
3258 return NULL;
3259 }
3260
3261 static struct object *socket_device_open_file( struct object *obj, unsigned int access,
3262 unsigned int sharing, unsigned int options )
3263 {
3264 struct sock *sock;
3265
3266 if (!(sock = create_socket())) return NULL;
3267 if (!(sock->fd = alloc_pseudo_fd( &sock_fd_ops, &sock->obj, options )))
3268 {
3269 release_object( sock );
3270 return NULL;
3271 }
3272 return &sock->obj;
3273 }
3274
3275 struct object *create_socket_device( struct object *root, const struct unicode_str *name,
3276 unsigned int attr, const struct security_descriptor *sd )
3277 {
3278 return create_named_object( root, &socket_device_ops, name, attr, sd );
3279 }
3280
3281 DECL_HANDLER(recv_socket)
3282 {
3283 struct sock *sock = (struct sock *)get_handle_obj( current->process, req->async.handle, 0, &sock_ops );
3284 unsigned int status = req->status;
3285 timeout_t timeout = 0;
3286 struct async *async;
3287 struct fd *fd;
3288
3289 if (!sock) return;
3290 fd = sock->fd;
3291
3292 /* recv() returned EWOULDBLOCK, i.e. no data available yet */
3293 if (status == STATUS_DEVICE_NOT_READY && !sock->nonblocking)
3294 {
3295 /* Set a timeout on the async if necessary.
3296 *
3297 * We want to do this *only* if the client gave us STATUS_DEVICE_NOT_READY.
3298 * If the client gave us STATUS_PENDING, it expects the async to always
3299 * block (it was triggered by WSARecv*() with a valid OVERLAPPED
3300 * structure) and for the timeout not to be respected. */
3301 if (is_fd_overlapped( fd ))
3302 timeout = (timeout_t)sock->rcvtimeo * -10000;
3303
3304 status = STATUS_PENDING;
3305 }
3306
3307 if ((status == STATUS_PENDING || status == STATUS_DEVICE_NOT_READY) && sock->rd_shutdown)
3308 status = STATUS_PIPE_DISCONNECTED;
3309
3310 sock->pending_events &= ~(req->oob ? AFD_POLL_OOB : AFD_POLL_READ);
3311 sock->reported_events &= ~(req->oob ? AFD_POLL_OOB : AFD_POLL_READ);
3312
3313 if ((async = create_request_async( fd, get_fd_comp_flags( fd ), &req->async )))
3314 {
3315 if (status == STATUS_SUCCESS)
3316 {
3317 struct iosb *iosb = async_get_iosb( async );
3318 iosb->result = req->total;
3319 release_object( iosb );
3320 }
3321 set_error( status );
3322
3323 if (timeout)
3324 async_set_timeout( async, timeout, STATUS_IO_TIMEOUT );
3325
3326 if (status == STATUS_PENDING)
3327 queue_async( &sock->read_q, async );
3328
3329 /* always reselect; we changed reported_events above */
3330 sock_reselect( sock );
3331
3332 reply->wait = async_handoff( async, NULL, 0 );
3333 reply->options = get_fd_options( fd );
3334 release_object( async );
3335 }
3336 release_object( sock );
3337 }
3338
3339 DECL_HANDLER(poll_socket)
3340 {
3341 struct sock *sock = (struct sock *)get_handle_obj( current->process, req->async.handle, 0, &sock_ops );
3342 const struct poll_socket_input *input = get_req_data();
3343 struct async *async;
3344 unsigned int count;
3345
3346 if (!sock) return;
3347
3348 count = get_req_data_size() / sizeof(*input);
3349
3350 if ((async = create_request_async( sock->fd, get_fd_comp_flags( sock->fd ), &req->async )))
3351 {
3352 poll_socket( sock, async, req->exclusive, req->timeout, count, input );
3353 reply->wait = async_handoff( async, NULL, 0 );
3354 reply->options = get_fd_options( sock->fd );
3355 release_object( async );
3356 }
3357
3358 release_object( sock );
3359 }
3360
3361 DECL_HANDLER(send_socket)
3362 {
3363 struct sock *sock = (struct sock *)get_handle_obj( current->process, req->async.handle, 0, &sock_ops );
3364 unsigned int status = req->status;
3365 timeout_t timeout = 0;
3366 struct async *async;
3367 struct fd *fd;
3368
3369 if (!sock) return;
3370 fd = sock->fd;
3371
3372 if (sock->type == WS_SOCK_DGRAM)
3373 {
3374 /* sendto() and sendmsg() implicitly binds a socket */
3375 union unix_sockaddr unix_addr;
3376 socklen_t unix_len = sizeof(unix_addr);
3377
3378 if (!sock->bound && !getsockname( get_unix_fd( fd ), &unix_addr.addr, &unix_len ))
3379 sock->addr_len = sockaddr_from_unix( &unix_addr, &sock->addr.addr, sizeof(sock->addr) );
3380 sock->bound = 1;
3381 }
3382
3383 if (status != STATUS_SUCCESS)
3384 {
3385 /* send() calls only clear and reselect events if unsuccessful. */
3386 sock->pending_events &= ~AFD_POLL_WRITE;
3387 sock->reported_events &= ~AFD_POLL_WRITE;
3388 }
3389
3390 /* If we had a short write and the socket is nonblocking (and the client is
3391 * not trying to force the operation to be asynchronous), return success.
3392 * Windows actually refuses to send any data in this case, and returns
3393 * EWOULDBLOCK, but we have no way of doing that. */
3394 if (status == STATUS_DEVICE_NOT_READY && req->total && sock->nonblocking)
3395 status = STATUS_SUCCESS;
3396
3397 /* send() returned EWOULDBLOCK or a short write, i.e. cannot send all data yet */
3398 if (status == STATUS_DEVICE_NOT_READY && !sock->nonblocking)
3399 {
3400 /* Set a timeout on the async if necessary.
3401 *
3402 * We want to do this *only* if the client gave us STATUS_DEVICE_NOT_READY.
3403 * If the client gave us STATUS_PENDING, it expects the async to always
3404 * block (it was triggered by WSASend*() with a valid OVERLAPPED
3405 * structure) and for the timeout not to be respected. */
3406 if (is_fd_overlapped( fd ))
3407 timeout = (timeout_t)sock->sndtimeo * -10000;
3408
3409 status = STATUS_PENDING;
3410 }
3411
3412 if ((status == STATUS_PENDING || status == STATUS_DEVICE_NOT_READY) && sock->wr_shutdown)
3413 status = STATUS_PIPE_DISCONNECTED;
3414
3415 if ((async = create_request_async( fd, get_fd_comp_flags( fd ), &req->async )))
3416 {
3417 if (status == STATUS_SUCCESS)
3418 {
3419 struct iosb *iosb = async_get_iosb( async );
3420 iosb->result = req->total;
3421 release_object( iosb );
3422 }
3423 set_error( status );
3424
3425 if (timeout)
3426 async_set_timeout( async, timeout, STATUS_IO_TIMEOUT );
3427
3428 if (status == STATUS_PENDING)
3429 queue_async( &sock->write_q, async );
3430
3431 /* always reselect; we changed reported_events above */
3432 sock_reselect( sock );
3433
3434 reply->wait = async_handoff( async, NULL, 0 );
3435 reply->options = get_fd_options( fd );
3436 release_object( async );
3437 }
3438 release_object( sock );
3439 }
Windows API implementation