?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
oledb32: Return INT_PTR instead of LRESULT in dialog procedures.
[wine.git] / server / sock.c
blob4cb5503ad25f67ef67db8b1f83c0fb7f026f5064
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 struct poll_socket_output *output = req->output;
842 unsigned int i;
843
844 for (i = 0; i < req->count; ++i)
845 {
846 struct sock *sock = req->sockets[i].sock;
847
848 if (sock->main_poll == req)
849 sock->main_poll = NULL;
850 }
851
852 /* pass 0 as result; client will set actual result size */
853 req->output = NULL;
854 async_request_complete( req->async, status, 0, req->count * sizeof(*output), output );
855 }
856
857 static void complete_async_polls( struct sock *sock, int event, int error )
858 {
859 int flags = get_poll_flags( sock, event );
860 struct poll_req *req, *next;
861
862 LIST_FOR_EACH_ENTRY_SAFE( req, next, &poll_list, struct poll_req, entry )
863 {
864 unsigned int i;
865
866 if (req->iosb->status != STATUS_PENDING) continue;
867
868 for (i = 0; i < req->count; ++i)
869 {
870 if (req->sockets[i].sock != sock) continue;
871 if (!(req->sockets[i].flags & flags)) continue;
872
873 if (debug_level)
874 fprintf( stderr, "completing poll for socket %p, wanted %#x got %#x\n",
875 sock, req->sockets[i].flags, flags );
876
877 req->output[i].flags = req->sockets[i].flags & flags;
878 req->output[i].status = sock_get_ntstatus( error );
879
880 complete_async_poll( req, STATUS_SUCCESS );
881 break;
882 }
883 }
884 }
885
886 static void async_poll_timeout( void *private )
887 {
888 struct poll_req *req = private;
889
890 req->timeout = NULL;
891
892 if (req->iosb->status != STATUS_PENDING) return;
893
894 complete_async_poll( req, STATUS_TIMEOUT );
895 }
896
897 static int sock_dispatch_asyncs( struct sock *sock, int event, int error )
898 {
899 if (event & (POLLIN | POLLPRI))
900 {
901 struct accept_req *req;
902
903 LIST_FOR_EACH_ENTRY( req, &sock->accept_list, struct accept_req, entry )
904 {
905 if (req->iosb->status == STATUS_PENDING && !req->accepted)
906 {
907 complete_async_accept( sock, req );
908 break;
909 }
910 }
911
912 if (sock->accept_recv_req && sock->accept_recv_req->iosb->status == STATUS_PENDING)
913 complete_async_accept_recv( sock->accept_recv_req );
914 }
915
916 if ((event & POLLOUT) && sock->connect_req && sock->connect_req->iosb->status == STATUS_PENDING)
917 complete_async_connect( sock );
918
919 if (event & (POLLIN | POLLPRI) && async_waiting( &sock->read_q ))
920 {
921 if (debug_level) fprintf( stderr, "activating read queue for socket %p\n", sock );
922 async_wake_up( &sock->read_q, STATUS_ALERTED );
923 event &= ~(POLLIN | POLLPRI);
924 }
925
926 if (event & POLLOUT && async_waiting( &sock->write_q ))
927 {
928 if (debug_level) fprintf( stderr, "activating write queue for socket %p\n", sock );
929 async_wake_up( &sock->write_q, STATUS_ALERTED );
930 event &= ~POLLOUT;
931 }
932
933 if (event & (POLLERR | POLLHUP))
934 {
935 int status = sock_get_ntstatus( error );
936 struct accept_req *req, *next;
937
938 if (sock->rd_shutdown || sock->hangup)
939 async_wake_up( &sock->read_q, status );
940 if (sock->wr_shutdown)
941 async_wake_up( &sock->write_q, status );
942
943 LIST_FOR_EACH_ENTRY_SAFE( req, next, &sock->accept_list, struct accept_req, entry )
944 {
945 if (req->iosb->status == STATUS_PENDING)
946 async_terminate( req->async, status );
947 }
948
949 if (sock->accept_recv_req && sock->accept_recv_req->iosb->status == STATUS_PENDING)
950 async_terminate( sock->accept_recv_req->async, status );
951
952 if (sock->connect_req)
953 async_terminate( sock->connect_req->async, status );
954 }
955
956 return event;
957 }
958
959 static void post_socket_event( struct sock *sock, enum afd_poll_bit event_bit, int error )
960 {
961 unsigned int event = (1 << event_bit);
962
963 if (!(sock->reported_events & event))
964 {
965 sock->pending_events |= event;
966 sock->reported_events |= event;
967 sock->errors[event_bit] = error;
968 }
969 }
970
971 static void sock_dispatch_events( struct sock *sock, enum connection_state prevstate, int event, int error )
972 {
973 switch (prevstate)
974 {
975 case SOCK_UNCONNECTED:
976 break;
977
978 case SOCK_CONNECTING:
979 if (event & POLLOUT)
980 {
981 post_socket_event( sock, AFD_POLL_BIT_CONNECT, 0 );
982 sock->errors[AFD_POLL_BIT_CONNECT_ERR] = 0;
983 }
984 if (event & (POLLERR | POLLHUP))
985 post_socket_event( sock, AFD_POLL_BIT_CONNECT_ERR, error );
986 break;
987
988 case SOCK_LISTENING:
989 if (event & (POLLIN | POLLERR | POLLHUP))
990 post_socket_event( sock, AFD_POLL_BIT_ACCEPT, error );
991 break;
992
993 case SOCK_CONNECTED:
994 case SOCK_CONNECTIONLESS:
995 if (event & POLLIN)
996 post_socket_event( sock, AFD_POLL_BIT_READ, 0 );
997
998 if (event & POLLOUT)
999 post_socket_event( sock, AFD_POLL_BIT_WRITE, 0 );
1000
1001 if (event & POLLPRI)
1002 post_socket_event( sock, AFD_POLL_BIT_OOB, 0 );
1003
1004 if (event & (POLLERR | POLLHUP))
1005 post_socket_event( sock, AFD_POLL_BIT_HUP, error );
1006 break;
1007 }
1008
1009 sock_wake_up( sock );
1010 }
1011
1012 static void sock_poll_event( struct fd *fd, int event )
1013 {
1014 struct sock *sock = get_fd_user( fd );
1015 int hangup_seen = 0;
1016 enum connection_state prevstate = sock->state;
1017 int error = 0;
1018
1019 assert( sock->obj.ops == &sock_ops );
1020 if (debug_level)
1021 fprintf(stderr, "socket %p select event: %x\n", sock, event);
1022
1023 /* we may change event later, remove from loop here */
1024 if (event & (POLLERR|POLLHUP)) set_fd_events( sock->fd, -1 );
1025
1026 switch (sock->state)
1027 {
1028 case SOCK_UNCONNECTED:
1029 break;
1030
1031 case SOCK_CONNECTING:
1032 if (event & (POLLERR|POLLHUP))
1033 {
1034 sock->state = SOCK_UNCONNECTED;
1035 event &= ~POLLOUT;
1036 error = sock_error( fd );
1037 }
1038 else if (event & POLLOUT)
1039 {
1040 sock->state = SOCK_CONNECTED;
1041 sock->connect_time = current_time;
1042 }
1043 break;
1044
1045 case SOCK_LISTENING:
1046 if (event & (POLLERR|POLLHUP))
1047 error = sock_error( fd );
1048 break;
1049
1050 case SOCK_CONNECTED:
1051 case SOCK_CONNECTIONLESS:
1052 if (sock->type == WS_SOCK_STREAM && (event & POLLIN))
1053 {
1054 char dummy;
1055 int nr;
1056
1057 /* Linux 2.4 doesn't report POLLHUP if only one side of the socket
1058 * has been closed, so we need to check for it explicitly here */
1059 nr = recv( get_unix_fd( fd ), &dummy, 1, MSG_PEEK );
1060 if ( nr == 0 )
1061 {
1062 hangup_seen = 1;
1063 event &= ~POLLIN;
1064 }
1065 else if ( nr < 0 )
1066 {
1067 event &= ~POLLIN;
1068 /* EAGAIN can happen if an async recv() falls between the server's poll()
1069 call and the invocation of this routine */
1070 if ( errno != EAGAIN )
1071 {
1072 error = errno;
1073 event |= POLLERR;
1074 if ( debug_level )
1075 fprintf( stderr, "recv error on socket %p: %d\n", sock, errno );
1076 }
1077 }
1078 }
1079
1080 if (hangup_seen || (sock_shutdown_type == SOCK_SHUTDOWN_POLLHUP && (event & POLLHUP)))
1081 {
1082 sock->hangup = 1;
1083 }
1084 else if (event & (POLLHUP | POLLERR))
1085 {
1086 sock->aborted = 1;
1087
1088 if (debug_level)
1089 fprintf( stderr, "socket %p aborted by error %d, event %#x\n", sock, error, event );
1090 }
1091
1092 if (hangup_seen)
1093 event |= POLLHUP;
1094 break;
1095 }
1096
1097 complete_async_polls( sock, event, error );
1098
1099 event = sock_dispatch_asyncs( sock, event, error );
1100 sock_dispatch_events( sock, prevstate, event, error );
1101
1102 sock_reselect( sock );
1103 }
1104
1105 static void sock_dump( struct object *obj, int verbose )
1106 {
1107 struct sock *sock = (struct sock *)obj;
1108 assert( obj->ops == &sock_ops );
1109 fprintf( stderr, "Socket fd=%p, state=%x, mask=%x, pending=%x, reported=%x\n",
1110 sock->fd, sock->state,
1111 sock->mask, sock->pending_events, sock->reported_events );
1112 }
1113
1114 static int poll_flags_from_afd( struct sock *sock, int flags )
1115 {
1116 int ev = 0;
1117
1118 /* A connection-mode socket which has never been connected does
1119 * not return write or hangup events, but Linux returns
1120 * POLLOUT | POLLHUP. */
1121 if (sock->state == SOCK_UNCONNECTED)
1122 return -1;
1123
1124 if (flags & (AFD_POLL_READ | AFD_POLL_ACCEPT))
1125 ev |= POLLIN;
1126 if ((flags & AFD_POLL_HUP) && sock->type == WS_SOCK_STREAM)
1127 ev |= POLLIN;
1128 if (flags & AFD_POLL_OOB)
1129 ev |= is_oobinline( sock ) ? POLLIN : POLLPRI;
1130 if (flags & AFD_POLL_WRITE)
1131 ev |= POLLOUT;
1132
1133 return ev;
1134 }
1135
1136 static int sock_get_poll_events( struct fd *fd )
1137 {
1138 struct sock *sock = get_fd_user( fd );
1139 unsigned int mask = sock->mask & ~sock->reported_events;
1140 struct poll_req *req;
1141 int ev = 0;
1142
1143 assert( sock->obj.ops == &sock_ops );
1144
1145 if (!sock->type) /* not initialized yet */
1146 return -1;
1147
1148 switch (sock->state)
1149 {
1150 case SOCK_UNCONNECTED:
1151 /* A connection-mode Windows socket which has never been connected does
1152 * not return any events, but Linux returns POLLOUT | POLLHUP. Hence we
1153 * need to return -1 here, to prevent the socket from being polled on at
1154 * all. */
1155 return -1;
1156
1157 case SOCK_CONNECTING:
1158 return POLLOUT;
1159
1160 case SOCK_LISTENING:
1161 if (!list_empty( &sock->accept_list ) || (mask & AFD_POLL_ACCEPT))
1162 ev |= POLLIN;
1163 break;
1164
1165 case SOCK_CONNECTED:
1166 case SOCK_CONNECTIONLESS:
1167 if (sock->hangup && sock->wr_shutdown && !sock->wr_shutdown_pending)
1168 {
1169 /* Linux returns POLLHUP if a socket is both SHUT_RD and SHUT_WR, or
1170 * if both the socket and its peer are SHUT_WR.
1171 *
1172 * We don't use SHUT_RD, so we can only encounter this in the latter
1173 * case. In that case there can't be any pending read requests (they
1174 * would have already been completed with a length of zero), the
1175 * above condition ensures that we don't have any pending write
1176 * requests, and nothing that can change about the socket state that
1177 * would complete a pending poll request. */
1178 return -1;
1179 }
1180
1181 if (sock->aborted)
1182 return -1;
1183
1184 if (sock->accept_recv_req)
1185 {
1186 ev |= POLLIN;
1187 }
1188 else if (async_queued( &sock->read_q ))
1189 {
1190 if (async_waiting( &sock->read_q )) ev |= POLLIN | POLLPRI;
1191 }
1192 else
1193 {
1194 /* Don't ask for POLLIN if we got a hangup. We won't receive more
1195 * data anyway, but we will get POLLIN if SOCK_SHUTDOWN_EOF. */
1196 if (!sock->hangup)
1197 {
1198 if (mask & AFD_POLL_READ)
1199 ev |= POLLIN;
1200 if (mask & AFD_POLL_OOB)
1201 ev |= POLLPRI;
1202 }
1203
1204 /* We use POLLIN with 0 bytes recv() as hangup indication for stream sockets. */
1205 if (sock->state == SOCK_CONNECTED && (mask & AFD_POLL_HUP) && !(sock->reported_events & AFD_POLL_READ))
1206 ev |= POLLIN;
1207 }
1208
1209 if (async_queued( &sock->write_q ))
1210 {
1211 if (async_waiting( &sock->write_q )) ev |= POLLOUT;
1212 }
1213 else if (!sock->wr_shutdown && (mask & AFD_POLL_WRITE))
1214 {
1215 ev |= POLLOUT;
1216 }
1217
1218 break;
1219 }
1220
1221 LIST_FOR_EACH_ENTRY( req, &poll_list, struct poll_req, entry )
1222 {
1223 unsigned int i;
1224
1225 for (i = 0; i < req->count; ++i)
1226 {
1227 if (req->sockets[i].sock != sock) continue;
1228
1229 ev |= poll_flags_from_afd( sock, req->sockets[i].flags );
1230 }
1231 }
1232
1233 return ev;
1234 }
1235
1236 static enum server_fd_type sock_get_fd_type( struct fd *fd )
1237 {
1238 return FD_TYPE_SOCKET;
1239 }
1240
1241 static void sock_cancel_async( struct fd *fd, struct async *async )
1242 {
1243 struct poll_req *req;
1244
1245 LIST_FOR_EACH_ENTRY( req, &poll_list, struct poll_req, entry )
1246 {
1247 unsigned int i;
1248
1249 if (req->async != async)
1250 continue;
1251
1252 for (i = 0; i < req->count; i++)
1253 {
1254 struct sock *sock = req->sockets[i].sock;
1255
1256 if (sock->main_poll == req)
1257 sock->main_poll = NULL;
1258 }
1259 }
1260
1261 async_terminate( async, STATUS_CANCELLED );
1262 }
1263
1264 static void sock_queue_async( struct fd *fd, struct async *async, int type, int count )
1265 {
1266 struct sock *sock = get_fd_user( fd );
1267 struct async_queue *queue;
1268
1269 assert( sock->obj.ops == &sock_ops );
1270
1271 switch (type)
1272 {
1273 case ASYNC_TYPE_READ:
1274 if (sock->rd_shutdown)
1275 {
1276 set_error( STATUS_PIPE_DISCONNECTED );
1277 return;
1278 }
1279 queue = &sock->read_q;
1280 break;
1281
1282 case ASYNC_TYPE_WRITE:
1283 if (sock->wr_shutdown)
1284 {
1285 set_error( STATUS_PIPE_DISCONNECTED );
1286 return;
1287 }
1288 queue = &sock->write_q;
1289 break;
1290
1291 default:
1292 set_error( STATUS_INVALID_PARAMETER );
1293 return;
1294 }
1295
1296 if (sock->state != SOCK_CONNECTED)
1297 {
1298 set_error( STATUS_PIPE_DISCONNECTED );
1299 return;
1300 }
1301
1302 queue_async( queue, async );
1303 sock_reselect( sock );
1304
1305 set_error( STATUS_PENDING );
1306 }
1307
1308 static void sock_reselect_async( struct fd *fd, struct async_queue *queue )
1309 {
1310 struct sock *sock = get_fd_user( fd );
1311
1312 if (sock->wr_shutdown_pending && list_empty( &sock->write_q.queue ))
1313 {
1314 shutdown( get_unix_fd( sock->fd ), SHUT_WR );
1315 sock->wr_shutdown_pending = 0;
1316 }
1317
1318 /* Don't reselect the ifchange queue; we always ask for POLLIN.
1319 * Don't reselect an uninitialized socket; we can't call set_fd_events() on
1320 * a pseudo-fd. */
1321 if (queue != &sock->ifchange_q && sock->type)
1322 sock_reselect( sock );
1323 }
1324
1325 static struct fd *sock_get_fd( struct object *obj )
1326 {
1327 struct sock *sock = (struct sock *)obj;
1328 return (struct fd *)grab_object( sock->fd );
1329 }
1330
1331 static int sock_close_handle( struct object *obj, struct process *process, obj_handle_t handle )
1332 {
1333 struct sock *sock = (struct sock *)obj;
1334
1335 if (sock->obj.handle_count == 1) /* last handle */
1336 {
1337 struct accept_req *accept_req, *accept_next;
1338 struct poll_req *poll_req, *poll_next;
1339
1340 if (sock->accept_recv_req)
1341 async_terminate( sock->accept_recv_req->async, STATUS_CANCELLED );
1342
1343 LIST_FOR_EACH_ENTRY_SAFE( accept_req, accept_next, &sock->accept_list, struct accept_req, entry )
1344 async_terminate( accept_req->async, STATUS_CANCELLED );
1345
1346 if (sock->connect_req)
1347 async_terminate( sock->connect_req->async, STATUS_CANCELLED );
1348
1349 LIST_FOR_EACH_ENTRY_SAFE( poll_req, poll_next, &poll_list, struct poll_req, entry )
1350 {
1351 struct iosb *iosb = poll_req->iosb;
1352 BOOL signaled = FALSE;
1353 unsigned int i;
1354
1355 if (iosb->status != STATUS_PENDING) continue;
1356
1357 for (i = 0; i < poll_req->count; ++i)
1358 {
1359 if (poll_req->sockets[i].sock == sock)
1360 {
1361 signaled = TRUE;
1362 poll_req->output[i].flags = AFD_POLL_CLOSE;
1363 poll_req->output[i].status = 0;
1364 }
1365 }
1366
1367 if (signaled) complete_async_poll( poll_req, STATUS_SUCCESS );
1368 }
1369 }
1370
1371 return 1;
1372 }
1373
1374 static void sock_destroy( struct object *obj )
1375 {
1376 struct sock *sock = (struct sock *)obj;
1377
1378 assert( obj->ops == &sock_ops );
1379
1380 /* FIXME: special socket shutdown stuff? */
1381
1382 if ( sock->deferred )
1383 release_object( sock->deferred );
1384
1385 async_wake_up( &sock->ifchange_q, STATUS_CANCELLED );
1386 sock_release_ifchange( sock );
1387 free_async_queue( &sock->read_q );
1388 free_async_queue( &sock->write_q );
1389 free_async_queue( &sock->ifchange_q );
1390 free_async_queue( &sock->accept_q );
1391 free_async_queue( &sock->connect_q );
1392 free_async_queue( &sock->poll_q );
1393 if (sock->event) release_object( sock->event );
1394 if (sock->fd)
1395 {
1396 /* shut the socket down to force pending poll() calls in the client to return */
1397 shutdown( get_unix_fd(sock->fd), SHUT_RDWR );
1398 release_object( sock->fd );
1399 }
1400 }
1401
1402 static struct sock *create_socket(void)
1403 {
1404 struct sock *sock;
1405
1406 if (!(sock = alloc_object( &sock_ops ))) return NULL;
1407 sock->fd = NULL;
1408 sock->state = SOCK_UNCONNECTED;
1409 sock->mask = 0;
1410 sock->pending_events = 0;
1411 sock->reported_events = 0;
1412 sock->flags = 0;
1413 sock->proto = 0;
1414 sock->type = 0;
1415 sock->family = 0;
1416 sock->event = NULL;
1417 sock->window = 0;
1418 sock->message = 0;
1419 sock->wparam = 0;
1420 sock->connect_time = 0;
1421 sock->deferred = NULL;
1422 sock->ifchange_obj = NULL;
1423 sock->accept_recv_req = NULL;
1424 sock->connect_req = NULL;
1425 sock->main_poll = NULL;
1426 memset( &sock->addr, 0, sizeof(sock->addr) );
1427 sock->addr_len = 0;
1428 sock->rd_shutdown = 0;
1429 sock->wr_shutdown = 0;
1430 sock->wr_shutdown_pending = 0;
1431 sock->hangup = 0;
1432 sock->aborted = 0;
1433 sock->nonblocking = 0;
1434 sock->bound = 0;
1435 sock->rcvbuf = 0;
1436 sock->sndbuf = 0;
1437 sock->rcvtimeo = 0;
1438 sock->sndtimeo = 0;
1439 init_async_queue( &sock->read_q );
1440 init_async_queue( &sock->write_q );
1441 init_async_queue( &sock->ifchange_q );
1442 init_async_queue( &sock->accept_q );
1443 init_async_queue( &sock->connect_q );
1444 init_async_queue( &sock->poll_q );
1445 memset( sock->errors, 0, sizeof(sock->errors) );
1446 list_init( &sock->accept_list );
1447 return sock;
1448 }
1449
1450 static int get_unix_family( int family )
1451 {
1452 switch (family)
1453 {
1454 case WS_AF_INET: return AF_INET;
1455 case WS_AF_INET6: return AF_INET6;
1456 #ifdef HAS_IPX
1457 case WS_AF_IPX: return AF_IPX;
1458 #endif
1459 #ifdef AF_IRDA
1460 case WS_AF_IRDA: return AF_IRDA;
1461 #endif
1462 case WS_AF_UNSPEC: return AF_UNSPEC;
1463 default: return -1;
1464 }
1465 }
1466
1467 static int get_unix_type( int type )
1468 {
1469 switch (type)
1470 {
1471 case WS_SOCK_DGRAM: return SOCK_DGRAM;
1472 case WS_SOCK_RAW: return SOCK_RAW;
1473 case WS_SOCK_STREAM: return SOCK_STREAM;
1474 default: return -1;
1475 }
1476 }
1477
1478 static int get_unix_protocol( int protocol )
1479 {
1480 if (protocol >= WS_NSPROTO_IPX && protocol <= WS_NSPROTO_IPX + 255)
1481 return protocol;
1482
1483 switch (protocol)
1484 {
1485 case WS_IPPROTO_ICMP: return IPPROTO_ICMP;
1486 case WS_IPPROTO_IGMP: return IPPROTO_IGMP;
1487 case WS_IPPROTO_IP: return IPPROTO_IP;
1488 case WS_IPPROTO_IPV4: return IPPROTO_IPIP;
1489 case WS_IPPROTO_IPV6: return IPPROTO_IPV6;
1490 case WS_IPPROTO_RAW: return IPPROTO_RAW;
1491 case WS_IPPROTO_TCP: return IPPROTO_TCP;
1492 case WS_IPPROTO_UDP: return IPPROTO_UDP;
1493 default: return -1;
1494 }
1495 }
1496
1497 static void set_dont_fragment( int fd, int level, int value )
1498 {
1499 int optname;
1500
1501 if (level == IPPROTO_IP)
1502 {
1503 #ifdef IP_DONTFRAG
1504 optname = IP_DONTFRAG;
1505 #elif defined(IP_MTU_DISCOVER) && defined(IP_PMTUDISC_DO) && defined(IP_PMTUDISC_DONT)
1506 optname = IP_MTU_DISCOVER;
1507 value = value ? IP_PMTUDISC_DO : IP_PMTUDISC_DONT;
1508 #else
1509 return;
1510 #endif
1511 }
1512 else
1513 {
1514 #ifdef IPV6_DONTFRAG
1515 optname = IPV6_DONTFRAG;
1516 #elif defined(IPV6_MTU_DISCOVER) && defined(IPV6_PMTUDISC_DO) && defined(IPV6_PMTUDISC_DONT)
1517 optname = IPV6_MTU_DISCOVER;
1518 value = value ? IPV6_PMTUDISC_DO : IPV6_PMTUDISC_DONT;
1519 #else
1520 return;
1521 #endif
1522 }
1523
1524 setsockopt( fd, level, optname, &value, sizeof(value) );
1525 }
1526
1527 static int init_socket( struct sock *sock, int family, int type, int protocol, unsigned int flags )
1528 {
1529 unsigned int options = 0;
1530 int sockfd, unix_type, unix_family, unix_protocol, value;
1531 socklen_t len;
1532
1533 unix_family = get_unix_family( family );
1534 unix_type = get_unix_type( type );
1535 unix_protocol = get_unix_protocol( protocol );
1536
1537 if (unix_protocol < 0)
1538 {
1539 if (type && unix_type < 0)
1540 set_win32_error( WSAESOCKTNOSUPPORT );
1541 else
1542 set_win32_error( WSAEPROTONOSUPPORT );
1543 return -1;
1544 }
1545 if (unix_family < 0)
1546 {
1547 if (family >= 0 && unix_type < 0)
1548 set_win32_error( WSAESOCKTNOSUPPORT );
1549 else
1550 set_win32_error( WSAEAFNOSUPPORT );
1551 return -1;
1552 }
1553
1554 sockfd = socket( unix_family, unix_type, unix_protocol );
1555 if (sockfd == -1)
1556 {
1557 if (errno == EINVAL) set_win32_error( WSAESOCKTNOSUPPORT );
1558 else set_win32_error( sock_get_error( errno ));
1559 return -1;
1560 }
1561 fcntl(sockfd, F_SETFL, O_NONBLOCK); /* make socket nonblocking */
1562
1563 if (family == WS_AF_IPX && protocol >= WS_NSPROTO_IPX && protocol <= WS_NSPROTO_IPX + 255)
1564 {
1565 #ifdef HAS_IPX
1566 int ipx_type = protocol - WS_NSPROTO_IPX;
1567
1568 #ifdef SOL_IPX
1569 setsockopt( sockfd, SOL_IPX, IPX_TYPE, &ipx_type, sizeof(ipx_type) );
1570 #else
1571 struct ipx val;
1572 /* Should we retrieve val using a getsockopt call and then
1573 * set the modified one? */
1574 val.ipx_pt = ipx_type;
1575 setsockopt( sockfd, 0, SO_DEFAULT_HEADERS, &val, sizeof(val) );
1576 #endif
1577 #endif
1578 }
1579
1580 if (unix_family == AF_INET || unix_family == AF_INET6)
1581 {
1582 /* ensure IP_DONTFRAGMENT is disabled for SOCK_DGRAM and SOCK_RAW, enabled for SOCK_STREAM */
1583 if (unix_type == SOCK_DGRAM || unix_type == SOCK_RAW) /* in Linux the global default can be enabled */
1584 set_dont_fragment( sockfd, unix_family == AF_INET6 ? IPPROTO_IPV6 : IPPROTO_IP, FALSE );
1585 else if (unix_type == SOCK_STREAM)
1586 set_dont_fragment( sockfd, unix_family == AF_INET6 ? IPPROTO_IPV6 : IPPROTO_IP, TRUE );
1587 }
1588
1589 #ifdef IPV6_V6ONLY
1590 if (unix_family == AF_INET6)
1591 {
1592 static const int enable = 1;
1593 setsockopt( sockfd, IPPROTO_IPV6, IPV6_V6ONLY, &enable, sizeof(enable) );
1594 }
1595 #endif
1596
1597 len = sizeof(value);
1598 if (!getsockopt( sockfd, SOL_SOCKET, SO_RCVBUF, &value, &len ))
1599 sock->rcvbuf = value;
1600
1601 len = sizeof(value);
1602 if (!getsockopt( sockfd, SOL_SOCKET, SO_SNDBUF, &value, &len ))
1603 sock->sndbuf = value;
1604
1605 sock->state = (type == WS_SOCK_STREAM ? SOCK_UNCONNECTED : SOCK_CONNECTIONLESS);
1606 sock->flags = flags;
1607 sock->proto = protocol;
1608 sock->type = type;
1609 sock->family = family;
1610
1611 if (sock->fd)
1612 {
1613 options = get_fd_options( sock->fd );
1614 release_object( sock->fd );
1615 }
1616
1617 if (!(sock->fd = create_anonymous_fd( &sock_fd_ops, sockfd, &sock->obj, options )))
1618 {
1619 return -1;
1620 }
1621
1622 /* We can't immediately allow caching for a connection-mode socket, since it
1623 * might be accepted into (changing the underlying fd object.) */
1624 if (sock->type != WS_SOCK_STREAM) allow_fd_caching( sock->fd );
1625
1626 return 0;
1627 }
1628
1629 /* accepts a socket and inits it */
1630 static int accept_new_fd( struct sock *sock )
1631 {
1632
1633 /* Try to accept(2). We can't be safe that this an already connected socket
1634 * or that accept() is allowed on it. In those cases we will get -1/errno
1635 * return.
1636 */
1637 struct sockaddr saddr;
1638 socklen_t slen = sizeof(saddr);
1639 int acceptfd = accept( get_unix_fd(sock->fd), &saddr, &slen );
1640 if (acceptfd != -1)
1641 fcntl( acceptfd, F_SETFL, O_NONBLOCK );
1642 else
1643 set_error( sock_get_ntstatus( errno ));
1644 return acceptfd;
1645 }
1646
1647 /* accept a socket (creates a new fd) */
1648 static struct sock *accept_socket( struct sock *sock )
1649 {
1650 struct sock *acceptsock;
1651 int acceptfd;
1652
1653 if (get_unix_fd( sock->fd ) == -1) return NULL;
1654
1655 if ( sock->deferred )
1656 {
1657 acceptsock = sock->deferred;
1658 sock->deferred = NULL;
1659 }
1660 else
1661 {
1662 union unix_sockaddr unix_addr;
1663 socklen_t unix_len;
1664
1665 if ((acceptfd = accept_new_fd( sock )) == -1) return NULL;
1666 if (!(acceptsock = create_socket()))
1667 {
1668 close( acceptfd );
1669 return NULL;
1670 }
1671
1672 /* newly created socket gets the same properties of the listening socket */
1673 acceptsock->state = SOCK_CONNECTED;
1674 acceptsock->bound = 1;
1675 acceptsock->nonblocking = sock->nonblocking;
1676 acceptsock->mask = sock->mask;
1677 acceptsock->proto = sock->proto;
1678 acceptsock->type = sock->type;
1679 acceptsock->family = sock->family;
1680 acceptsock->window = sock->window;
1681 acceptsock->message = sock->message;
1682 acceptsock->connect_time = current_time;
1683 if (sock->event) acceptsock->event = (struct event *)grab_object( sock->event );
1684 acceptsock->flags = sock->flags;
1685 if (!(acceptsock->fd = create_anonymous_fd( &sock_fd_ops, acceptfd, &acceptsock->obj,
1686 get_fd_options( sock->fd ) )))
1687 {
1688 release_object( acceptsock );
1689 return NULL;
1690 }
1691 unix_len = sizeof(unix_addr);
1692 if (!getsockname( acceptfd, &unix_addr.addr, &unix_len ))
1693 acceptsock->addr_len = sockaddr_from_unix( &unix_addr, &acceptsock->addr.addr, sizeof(acceptsock->addr) );
1694 }
1695 clear_error();
1696 sock->pending_events &= ~AFD_POLL_ACCEPT;
1697 sock->reported_events &= ~AFD_POLL_ACCEPT;
1698 sock_reselect( sock );
1699 return acceptsock;
1700 }
1701
1702 static int accept_into_socket( struct sock *sock, struct sock *acceptsock )
1703 {
1704 union unix_sockaddr unix_addr;
1705 socklen_t unix_len;
1706 int acceptfd;
1707 struct fd *newfd;
1708
1709 if (get_unix_fd( sock->fd ) == -1) return FALSE;
1710
1711 if ( sock->deferred )
1712 {
1713 newfd = dup_fd_object( sock->deferred->fd, 0, 0,
1714 get_fd_options( acceptsock->fd ) );
1715 if ( !newfd )
1716 return FALSE;
1717
1718 set_fd_user( newfd, &sock_fd_ops, &acceptsock->obj );
1719
1720 release_object( sock->deferred );
1721 sock->deferred = NULL;
1722 }
1723 else
1724 {
1725 if ((acceptfd = accept_new_fd( sock )) == -1)
1726 return FALSE;
1727
1728 if (!(newfd = create_anonymous_fd( &sock_fd_ops, acceptfd, &acceptsock->obj,
1729 get_fd_options( acceptsock->fd ) )))
1730 return FALSE;
1731 }
1732
1733 acceptsock->state = SOCK_CONNECTED;
1734 acceptsock->pending_events = 0;
1735 acceptsock->reported_events = 0;
1736 acceptsock->proto = sock->proto;
1737 acceptsock->type = sock->type;
1738 acceptsock->family = sock->family;
1739 acceptsock->wparam = 0;
1740 acceptsock->deferred = NULL;
1741 acceptsock->connect_time = current_time;
1742 fd_copy_completion( acceptsock->fd, newfd );
1743 release_object( acceptsock->fd );
1744 acceptsock->fd = newfd;
1745
1746 unix_len = sizeof(unix_addr);
1747 if (!getsockname( get_unix_fd( newfd ), &unix_addr.addr, &unix_len ))
1748 acceptsock->addr_len = sockaddr_from_unix( &unix_addr, &acceptsock->addr.addr, sizeof(acceptsock->addr) );
1749
1750 clear_error();
1751 sock->pending_events &= ~AFD_POLL_ACCEPT;
1752 sock->reported_events &= ~AFD_POLL_ACCEPT;
1753 sock_reselect( sock );
1754
1755 return TRUE;
1756 }
1757
1758 #ifdef IP_BOUND_IF
1759
1760 static int bind_to_iface_name( int fd, in_addr_t bind_addr, const char *name )
1761 {
1762 static const int enable = 1;
1763 unsigned int index;
1764
1765 if (!(index = if_nametoindex( name )))
1766 return -1;
1767
1768 if (setsockopt( fd, IPPROTO_IP, IP_BOUND_IF, &index, sizeof(index) ))
1769 return -1;
1770
1771 return setsockopt( fd, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable) );
1772 }
1773
1774 #elif defined(IP_UNICAST_IF) && defined(SO_ATTACH_FILTER) && defined(SO_BINDTODEVICE)
1775
1776 struct interface_filter
1777 {
1778 struct sock_filter iface_memaddr;
1779 struct sock_filter iface_rule;
1780 struct sock_filter ip_memaddr;
1781 struct sock_filter ip_rule;
1782 struct sock_filter return_keep;
1783 struct sock_filter return_dump;
1784 };
1785 # define FILTER_JUMP_DUMP(here) (u_char)(offsetof(struct interface_filter, return_dump) \
1786 -offsetof(struct interface_filter, here)-sizeof(struct sock_filter)) \
1787 /sizeof(struct sock_filter)
1788 # define FILTER_JUMP_KEEP(here) (u_char)(offsetof(struct interface_filter, return_keep) \
1789 -offsetof(struct interface_filter, here)-sizeof(struct sock_filter)) \
1790 /sizeof(struct sock_filter)
1791 # define FILTER_JUMP_NEXT() (u_char)(0)
1792 # define SKF_NET_DESTIP 16 /* offset in the network header to the destination IP */
1793 static struct interface_filter generic_interface_filter =
1794 {
1795 /* This filter rule allows incoming packets on the specified interface, which works for all
1796 * remotely generated packets and for locally generated broadcast packets. */
1797 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, SKF_AD_OFF+SKF_AD_IFINDEX),
1798 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0xdeadbeef, FILTER_JUMP_KEEP(iface_rule), FILTER_JUMP_NEXT()),
1799 /* This rule allows locally generated packets targeted at the specific IP address of the chosen
1800 * adapter (local packets not destined for the broadcast address do not have IFINDEX set) */
1801 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, SKF_NET_OFF+SKF_NET_DESTIP),
1802 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0xdeadbeef, FILTER_JUMP_KEEP(ip_rule), FILTER_JUMP_DUMP(ip_rule)),
1803 BPF_STMT(BPF_RET+BPF_K, (u_int)-1), /* keep packet */
1804 BPF_STMT(BPF_RET+BPF_K, 0) /* dump packet */
1805 };
1806
1807 static int bind_to_iface_name( int fd, in_addr_t bind_addr, const char *name )
1808 {
1809 struct interface_filter specific_interface_filter;
1810 struct sock_fprog filter_prog;
1811 static const int enable = 1;
1812 unsigned int index;
1813 in_addr_t ifindex;
1814
1815 if (!setsockopt( fd, SOL_SOCKET, SO_BINDTODEVICE, name, strlen( name ) + 1 ))
1816 return 0;
1817
1818 /* SO_BINDTODEVICE requires NET_CAP_RAW until Linux 5.7. */
1819 if (debug_level)
1820 fprintf( stderr, "setsockopt SO_BINDTODEVICE fd %d, name %s failed: %s, falling back to SO_REUSE_ADDR\n",
1821 fd, name, strerror( errno ));
1822
1823 if (!(index = if_nametoindex( name )))
1824 return -1;
1825
1826 ifindex = htonl( index );
1827 if (setsockopt( fd, IPPROTO_IP, IP_UNICAST_IF, &ifindex, sizeof(ifindex) ) < 0)
1828 return -1;
1829
1830 specific_interface_filter = generic_interface_filter;
1831 specific_interface_filter.iface_rule.k = index;
1832 specific_interface_filter.ip_rule.k = htonl( bind_addr );
1833 filter_prog.len = sizeof(generic_interface_filter) / sizeof(struct sock_filter);
1834 filter_prog.filter = (struct sock_filter *)&specific_interface_filter;
1835 if (setsockopt( fd, SOL_SOCKET, SO_ATTACH_FILTER, &filter_prog, sizeof(filter_prog) ))
1836 return -1;
1837
1838 return setsockopt( fd, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable) );
1839 }
1840
1841 #else
1842
1843 static int bind_to_iface_name( int fd, in_addr_t bind_addr, const char *name )
1844 {
1845 errno = EOPNOTSUPP;
1846 return -1;
1847 }
1848
1849 #endif /* LINUX_BOUND_IF */
1850
1851 /* Take bind() calls on any name corresponding to a local network adapter and
1852 * restrict the given socket to operating only on the specified interface. This
1853 * restriction consists of two components:
1854 * 1) An outgoing packet restriction suggesting the egress interface for all
1855 * packets.
1856 * 2) An incoming packet restriction dropping packets not meant for the
1857 * interface.
1858 * If the function succeeds in placing these restrictions, then the name for the
1859 * bind() may safely be changed to INADDR_ANY, permitting the transmission and
1860 * receipt of broadcast packets on the socket. This behavior is only relevant to
1861 * UDP sockets and is needed for applications that expect to be able to receive
1862 * broadcast packets on a socket that is bound to a specific network interface.
1863 */
1864 static int bind_to_interface( struct sock *sock, const struct sockaddr_in *addr )
1865 {
1866 in_addr_t bind_addr = addr->sin_addr.s_addr;
1867 struct ifaddrs *ifaddrs, *ifaddr;
1868 int fd = get_unix_fd( sock->fd );
1869 int err = 0;
1870
1871 if (bind_addr == htonl( INADDR_ANY ) || bind_addr == htonl( INADDR_LOOPBACK ))
1872 return 0;
1873 if (sock->type != WS_SOCK_DGRAM)
1874 return 0;
1875
1876 if (getifaddrs( &ifaddrs ) < 0) return 0;
1877
1878 for (ifaddr = ifaddrs; ifaddr != NULL; ifaddr = ifaddr->ifa_next)
1879 {
1880 if (ifaddr->ifa_addr && ifaddr->ifa_addr->sa_family == AF_INET
1881 && ((struct sockaddr_in *)ifaddr->ifa_addr)->sin_addr.s_addr == bind_addr)
1882 {
1883 if ((err = bind_to_iface_name( fd, bind_addr, ifaddr->ifa_name )) < 0)
1884 {
1885 if (debug_level)
1886 fprintf( stderr, "failed to bind to interface: %s\n", strerror( errno ) );
1887 }
1888 break;
1889 }
1890 }
1891 freeifaddrs( ifaddrs );
1892 return !err;
1893 }
1894
1895 #ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID
1896 static unsigned int get_ipv6_interface_index( const struct in6_addr *addr )
1897 {
1898 struct ifaddrs *ifaddrs, *ifaddr;
1899
1900 if (getifaddrs( &ifaddrs ) < 0) return 0;
1901
1902 for (ifaddr = ifaddrs; ifaddr != NULL; ifaddr = ifaddr->ifa_next)
1903 {
1904 if (ifaddr->ifa_addr && ifaddr->ifa_addr->sa_family == AF_INET6
1905 && !memcmp( &((struct sockaddr_in6 *)ifaddr->ifa_addr)->sin6_addr, addr, sizeof(*addr) ))
1906 {
1907 unsigned int index = if_nametoindex( ifaddr->ifa_name );
1908
1909 if (!index)
1910 {
1911 if (debug_level)
1912 fprintf( stderr, "Unable to look up interface index for %s: %s\n",
1913 ifaddr->ifa_name, strerror( errno ) );
1914 continue;
1915 }
1916
1917 freeifaddrs( ifaddrs );
1918 return index;
1919 }
1920 }
1921
1922 freeifaddrs( ifaddrs );
1923 return 0;
1924 }
1925 #endif
1926
1927 /* return an errno value mapped to a WSA error */
1928 static unsigned int sock_get_error( int err )
1929 {
1930 switch (err)
1931 {
1932 case EINTR: return WSAEINTR;
1933 case EBADF: return WSAEBADF;
1934 case EPERM:
1935 case EACCES: return WSAEACCES;
1936 case EFAULT: return WSAEFAULT;
1937 case EINVAL: return WSAEINVAL;
1938 case EMFILE: return WSAEMFILE;
1939 case EINPROGRESS:
1940 case EWOULDBLOCK: return WSAEWOULDBLOCK;
1941 case EALREADY: return WSAEALREADY;
1942 case ENOTSOCK: return WSAENOTSOCK;
1943 case EDESTADDRREQ: return WSAEDESTADDRREQ;
1944 case EMSGSIZE: return WSAEMSGSIZE;
1945 case EPROTOTYPE: return WSAEPROTOTYPE;
1946 case ENOPROTOOPT: return WSAENOPROTOOPT;
1947 case EPROTONOSUPPORT: return WSAEPROTONOSUPPORT;
1948 case ESOCKTNOSUPPORT: return WSAESOCKTNOSUPPORT;
1949 case EOPNOTSUPP: return WSAEOPNOTSUPP;
1950 case EPFNOSUPPORT: return WSAEPFNOSUPPORT;
1951 case EAFNOSUPPORT: return WSAEAFNOSUPPORT;
1952 case EADDRINUSE: return WSAEADDRINUSE;
1953 case EADDRNOTAVAIL: return WSAEADDRNOTAVAIL;
1954 case ENETDOWN: return WSAENETDOWN;
1955 case ENETUNREACH: return WSAENETUNREACH;
1956 case ENETRESET: return WSAENETRESET;
1957 case ECONNABORTED: return WSAECONNABORTED;
1958 case EPIPE:
1959 case ECONNRESET: return WSAECONNRESET;
1960 case ENOBUFS: return WSAENOBUFS;
1961 case EISCONN: return WSAEISCONN;
1962 case ENOTCONN: return WSAENOTCONN;
1963 case ESHUTDOWN: return WSAESHUTDOWN;
1964 case ETOOMANYREFS: return WSAETOOMANYREFS;
1965 case ETIMEDOUT: return WSAETIMEDOUT;
1966 case ECONNREFUSED: return WSAECONNREFUSED;
1967 case ELOOP: return WSAELOOP;
1968 case ENAMETOOLONG: return WSAENAMETOOLONG;
1969 case EHOSTDOWN: return WSAEHOSTDOWN;
1970 case EHOSTUNREACH: return WSAEHOSTUNREACH;
1971 case ENOTEMPTY: return WSAENOTEMPTY;
1972 #ifdef EPROCLIM
1973 case EPROCLIM: return WSAEPROCLIM;
1974 #endif
1975 #ifdef EUSERS
1976 case EUSERS: return WSAEUSERS;
1977 #endif
1978 #ifdef EDQUOT
1979 case EDQUOT: return WSAEDQUOT;
1980 #endif
1981 #ifdef ESTALE
1982 case ESTALE: return WSAESTALE;
1983 #endif
1984 #ifdef EREMOTE
1985 case EREMOTE: return WSAEREMOTE;
1986 #endif
1987
1988 case 0: return 0;
1989 default:
1990 errno = err;
1991 perror("wineserver: sock_get_error() can't map error");
1992 return WSAEFAULT;
1993 }
1994 }
1995
1996 static int sock_get_ntstatus( int err )
1997 {
1998 switch ( err )
1999 {
2000 case EBADF: return STATUS_INVALID_HANDLE;
2001 case EBUSY: return STATUS_DEVICE_BUSY;
2002 case EPERM:
2003 case EACCES: return STATUS_ACCESS_DENIED;
2004 case EFAULT: return STATUS_ACCESS_VIOLATION;
2005 case EINVAL: return STATUS_INVALID_PARAMETER;
2006 case ENFILE:
2007 case EMFILE: return STATUS_TOO_MANY_OPENED_FILES;
2008 case EINPROGRESS:
2009 case EWOULDBLOCK: return STATUS_DEVICE_NOT_READY;
2010 case EALREADY: return STATUS_NETWORK_BUSY;
2011 case ENOTSOCK: return STATUS_OBJECT_TYPE_MISMATCH;
2012 case EDESTADDRREQ: return STATUS_INVALID_PARAMETER;
2013 case EMSGSIZE: return STATUS_BUFFER_OVERFLOW;
2014 case EPROTONOSUPPORT:
2015 case ESOCKTNOSUPPORT:
2016 case EPFNOSUPPORT:
2017 case EAFNOSUPPORT:
2018 case EPROTOTYPE: return STATUS_NOT_SUPPORTED;
2019 case ENOPROTOOPT: return STATUS_INVALID_PARAMETER;
2020 case EOPNOTSUPP: return STATUS_NOT_SUPPORTED;
2021 case EADDRINUSE: return STATUS_SHARING_VIOLATION;
2022 /* Linux returns ENODEV when specifying an invalid sin6_scope_id;
2023 * Windows returns STATUS_INVALID_ADDRESS_COMPONENT */
2024 case ENODEV:
2025 case EADDRNOTAVAIL: return STATUS_INVALID_ADDRESS_COMPONENT;
2026 case ECONNREFUSED: return STATUS_CONNECTION_REFUSED;
2027 case ESHUTDOWN: return STATUS_PIPE_DISCONNECTED;
2028 case ENOTCONN: return STATUS_INVALID_CONNECTION;
2029 case ETIMEDOUT: return STATUS_IO_TIMEOUT;
2030 case ENETUNREACH: return STATUS_NETWORK_UNREACHABLE;
2031 case EHOSTUNREACH: return STATUS_HOST_UNREACHABLE;
2032 case ENETDOWN: return STATUS_NETWORK_BUSY;
2033 case EPIPE:
2034 case ECONNRESET: return STATUS_CONNECTION_RESET;
2035 case ECONNABORTED: return STATUS_CONNECTION_ABORTED;
2036 case EISCONN: return STATUS_CONNECTION_ACTIVE;
2037
2038 case 0: return STATUS_SUCCESS;
2039 default:
2040 errno = err;
2041 perror("wineserver: sock_get_ntstatus() can't map error");
2042 return STATUS_UNSUCCESSFUL;
2043 }
2044 }
2045
2046 static struct accept_req *alloc_accept_req( struct sock *sock, struct sock *acceptsock, struct async *async,
2047 const struct afd_accept_into_params *params )
2048 {
2049 struct accept_req *req = mem_alloc( sizeof(*req) );
2050
2051 if (req)
2052 {
2053 req->async = (struct async *)grab_object( async );
2054 req->iosb = async_get_iosb( async );
2055 req->sock = (struct sock *)grab_object( sock );
2056 req->acceptsock = acceptsock;
2057 if (acceptsock) grab_object( acceptsock );
2058 req->accepted = 0;
2059 req->recv_len = 0;
2060 req->local_len = 0;
2061 if (params)
2062 {
2063 req->recv_len = params->recv_len;
2064 req->local_len = params->local_len;
2065 }
2066 }
2067 return req;
2068 }
2069
2070 static void sock_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
2071 {
2072 struct sock *sock = get_fd_user( fd );
2073 int unix_fd;
2074
2075 assert( sock->obj.ops == &sock_ops );
2076
2077 if (code != IOCTL_AFD_WINE_CREATE && (unix_fd = get_unix_fd( fd )) < 0) return;
2078
2079 switch(code)
2080 {
2081 case IOCTL_AFD_WINE_CREATE:
2082 {
2083 const struct afd_create_params *params = get_req_data();
2084
2085 if (get_req_data_size() != sizeof(*params))
2086 {
2087 set_error( STATUS_INVALID_PARAMETER );
2088 return;
2089 }
2090 init_socket( sock, params->family, params->type, params->protocol, params->flags );
2091 return;
2092 }
2093
2094 case IOCTL_AFD_WINE_ACCEPT:
2095 {
2096 struct sock *acceptsock;
2097 obj_handle_t handle;
2098
2099 if (get_reply_max_size() != sizeof(handle))
2100 {
2101 set_error( STATUS_BUFFER_TOO_SMALL );
2102 return;
2103 }
2104
2105 if (!(acceptsock = accept_socket( sock )))
2106 {
2107 struct accept_req *req;
2108
2109 if (sock->nonblocking) return;
2110 if (get_error() != STATUS_DEVICE_NOT_READY) return;
2111
2112 if (!(req = alloc_accept_req( sock, NULL, async, NULL ))) return;
2113 list_add_tail( &sock->accept_list, &req->entry );
2114
2115 async_set_completion_callback( async, free_accept_req, req );
2116 queue_async( &sock->accept_q, async );
2117 sock_reselect( sock );
2118 set_error( STATUS_PENDING );
2119 return;
2120 }
2121 handle = alloc_handle( current->process, &acceptsock->obj,
2122 GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE, OBJ_INHERIT );
2123 acceptsock->wparam = handle;
2124 release_object( acceptsock );
2125 set_reply_data( &handle, sizeof(handle) );
2126 return;
2127 }
2128
2129 case IOCTL_AFD_WINE_ACCEPT_INTO:
2130 {
2131 static const int access = FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES | FILE_READ_DATA;
2132 const struct afd_accept_into_params *params = get_req_data();
2133 struct sock *acceptsock;
2134 unsigned int remote_len;
2135 struct accept_req *req;
2136
2137 if (get_req_data_size() != sizeof(*params) ||
2138 get_reply_max_size() < params->recv_len ||
2139 get_reply_max_size() - params->recv_len < params->local_len)
2140 {
2141 set_error( STATUS_BUFFER_TOO_SMALL );
2142 return;
2143 }
2144
2145 remote_len = get_reply_max_size() - params->recv_len - params->local_len;
2146 if (remote_len < sizeof(int))
2147 {
2148 set_error( STATUS_INVALID_PARAMETER );
2149 return;
2150 }
2151
2152 if (!(acceptsock = (struct sock *)get_handle_obj( current->process, params->accept_handle, access, &sock_ops )))
2153 return;
2154
2155 if (acceptsock->accept_recv_req)
2156 {
2157 release_object( acceptsock );
2158 set_error( STATUS_INVALID_PARAMETER );
2159 return;
2160 }
2161
2162 if (!(req = alloc_accept_req( sock, acceptsock, async, params )))
2163 {
2164 release_object( acceptsock );
2165 return;
2166 }
2167 list_add_tail( &sock->accept_list, &req->entry );
2168 acceptsock->accept_recv_req = req;
2169 release_object( acceptsock );
2170
2171 acceptsock->wparam = params->accept_handle;
2172 async_set_completion_callback( async, free_accept_req, req );
2173 queue_async( &sock->accept_q, async );
2174 sock_reselect( sock );
2175 set_error( STATUS_PENDING );
2176 return;
2177 }
2178
2179 case IOCTL_AFD_LISTEN:
2180 {
2181 const struct afd_listen_params *params = get_req_data();
2182
2183 if (get_req_data_size() < sizeof(*params))
2184 {
2185 set_error( STATUS_INVALID_PARAMETER );
2186 return;
2187 }
2188
2189 if (!sock->bound)
2190 {
2191 set_error( STATUS_INVALID_PARAMETER );
2192 return;
2193 }
2194
2195 if (listen( unix_fd, params->backlog ) < 0)
2196 {
2197 set_error( sock_get_ntstatus( errno ) );
2198 return;
2199 }
2200
2201 sock->state = SOCK_LISTENING;
2202
2203 /* a listening socket can no longer be accepted into */
2204 allow_fd_caching( sock->fd );
2205
2206 /* we may already be selecting for AFD_POLL_ACCEPT */
2207 sock_reselect( sock );
2208 return;
2209 }
2210
2211 case IOCTL_AFD_WINE_CONNECT:
2212 {
2213 const struct afd_connect_params *params = get_req_data();
2214 const struct WS_sockaddr *addr;
2215 union unix_sockaddr unix_addr;
2216 struct connect_req *req;
2217 socklen_t unix_len;
2218 int send_len, ret;
2219
2220 if (get_req_data_size() < sizeof(*params) ||
2221 get_req_data_size() - sizeof(*params) < params->addr_len)
2222 {
2223 set_error( STATUS_BUFFER_TOO_SMALL );
2224 return;
2225 }
2226 send_len = get_req_data_size() - sizeof(*params) - params->addr_len;
2227 addr = (const struct WS_sockaddr *)(params + 1);
2228
2229 if (!params->synchronous && !sock->bound)
2230 {
2231 set_error( STATUS_INVALID_PARAMETER );
2232 return;
2233 }
2234
2235 if (sock->accept_recv_req)
2236 {
2237 set_error( STATUS_INVALID_PARAMETER );
2238 return;
2239 }
2240
2241 if (sock->connect_req)
2242 {
2243 set_error( STATUS_INVALID_PARAMETER );
2244 return;
2245 }
2246
2247 switch (sock->state)
2248 {
2249 case SOCK_LISTENING:
2250 set_error( STATUS_INVALID_PARAMETER );
2251 return;
2252
2253 case SOCK_CONNECTING:
2254 /* FIXME: STATUS_ADDRESS_ALREADY_ASSOCIATED probably isn't right,
2255 * but there's no status code that maps to WSAEALREADY... */
2256 set_error( params->synchronous ? STATUS_ADDRESS_ALREADY_ASSOCIATED : STATUS_INVALID_PARAMETER );
2257 return;
2258
2259 case SOCK_CONNECTED:
2260 set_error( STATUS_CONNECTION_ACTIVE );
2261 return;
2262
2263 case SOCK_UNCONNECTED:
2264 case SOCK_CONNECTIONLESS:
2265 break;
2266 }
2267
2268 unix_len = sockaddr_to_unix( addr, params->addr_len, &unix_addr );
2269 if (!unix_len)
2270 {
2271 set_error( STATUS_INVALID_ADDRESS );
2272 return;
2273 }
2274 if (unix_addr.addr.sa_family == AF_INET && !memcmp( &unix_addr.in.sin_addr, magic_loopback_addr, 4 ))
2275 unix_addr.in.sin_addr.s_addr = htonl( INADDR_LOOPBACK );
2276
2277 ret = connect( unix_fd, &unix_addr.addr, unix_len );
2278 if (ret < 0 && errno != EINPROGRESS)
2279 {
2280 set_error( sock_get_ntstatus( errno ) );
2281 return;
2282 }
2283
2284 /* a connected or connecting socket can no longer be accepted into */
2285 allow_fd_caching( sock->fd );
2286
2287 unix_len = sizeof(unix_addr);
2288 if (!sock->bound && !getsockname( unix_fd, &unix_addr.addr, &unix_len ))
2289 sock->addr_len = sockaddr_from_unix( &unix_addr, &sock->addr.addr, sizeof(sock->addr) );
2290 sock->bound = 1;
2291
2292 if (!ret)
2293 {
2294 sock->state = SOCK_CONNECTED;
2295
2296 if (!send_len) return;
2297 }
2298
2299 sock->state = SOCK_CONNECTING;
2300
2301 if (params->synchronous && sock->nonblocking)
2302 {
2303 sock_reselect( sock );
2304 set_error( STATUS_DEVICE_NOT_READY );
2305 return;
2306 }
2307
2308 if (!(req = mem_alloc( sizeof(*req) )))
2309 return;
2310
2311 req->async = (struct async *)grab_object( async );
2312 req->iosb = async_get_iosb( async );
2313 req->sock = (struct sock *)grab_object( sock );
2314 req->addr_len = params->addr_len;
2315 req->send_len = send_len;
2316 req->send_cursor = 0;
2317
2318 async_set_completion_callback( async, free_connect_req, req );
2319 sock->connect_req = req;
2320 queue_async( &sock->connect_q, async );
2321 sock_reselect( sock );
2322 set_error( STATUS_PENDING );
2323 return;
2324 }
2325
2326 case IOCTL_AFD_WINE_SHUTDOWN:
2327 {
2328 unsigned int how;
2329
2330 if (get_req_data_size() < sizeof(int))
2331 {
2332 set_error( STATUS_BUFFER_TOO_SMALL );
2333 return;
2334 }
2335 how = *(int *)get_req_data();
2336
2337 if (how > SD_BOTH)
2338 {
2339 set_error( STATUS_INVALID_PARAMETER );
2340 return;
2341 }
2342
2343 if (sock->state != SOCK_CONNECTED && sock->state != SOCK_CONNECTIONLESS)
2344 {
2345 set_error( STATUS_INVALID_CONNECTION );
2346 return;
2347 }
2348
2349 if (how != SD_SEND)
2350 {
2351 sock->rd_shutdown = 1;
2352 }
2353 if (how != SD_RECEIVE)
2354 {
2355 sock->wr_shutdown = 1;
2356 if (list_empty( &sock->write_q.queue ))
2357 shutdown( unix_fd, SHUT_WR );
2358 else
2359 sock->wr_shutdown_pending = 1;
2360 }
2361
2362 if (how == SD_BOTH)
2363 {
2364 if (sock->event) release_object( sock->event );
2365 sock->event = NULL;
2366 sock->window = 0;
2367 sock->mask = 0;
2368 sock->nonblocking = 1;
2369 }
2370
2371 sock_reselect( sock );
2372 return;
2373 }
2374
2375 case IOCTL_AFD_WINE_ADDRESS_LIST_CHANGE:
2376 {
2377 int force_async;
2378
2379 if (get_req_data_size() < sizeof(int))
2380 {
2381 set_error( STATUS_BUFFER_TOO_SMALL );
2382 return;
2383 }
2384 force_async = *(int *)get_req_data();
2385
2386 if (sock->nonblocking && !force_async)
2387 {
2388 set_error( STATUS_DEVICE_NOT_READY );
2389 return;
2390 }
2391 if (!sock_get_ifchange( sock )) return;
2392 queue_async( &sock->ifchange_q, async );
2393 set_error( STATUS_PENDING );
2394 return;
2395 }
2396
2397 case IOCTL_AFD_WINE_FIONBIO:
2398 if (get_req_data_size() < sizeof(int))
2399 {
2400 set_error( STATUS_BUFFER_TOO_SMALL );
2401 return;
2402 }
2403 if (*(int *)get_req_data())
2404 {
2405 sock->nonblocking = 1;
2406 }
2407 else
2408 {
2409 if (sock->mask)
2410 {
2411 set_error( STATUS_INVALID_PARAMETER );
2412 return;
2413 }
2414 sock->nonblocking = 0;
2415 }
2416 return;
2417
2418 case IOCTL_AFD_GET_EVENTS:
2419 {
2420 struct afd_get_events_params params = {0};
2421 unsigned int i;
2422
2423 if (get_reply_max_size() < sizeof(params))
2424 {
2425 set_error( STATUS_INVALID_PARAMETER );
2426 return;
2427 }
2428
2429 params.flags = sock->pending_events & sock->mask;
2430 for (i = 0; i < ARRAY_SIZE( params.status ); ++i)
2431 params.status[i] = sock_get_ntstatus( sock->errors[i] );
2432
2433 sock->pending_events = 0;
2434 sock_reselect( sock );
2435
2436 set_reply_data( &params, sizeof(params) );
2437 return;
2438 }
2439
2440 case IOCTL_AFD_EVENT_SELECT:
2441 {
2442 struct event *event = NULL;
2443 obj_handle_t event_handle;
2444 int mask;
2445
2446 set_async_pending( async );
2447
2448 if (is_machine_64bit( current->process->machine ))
2449 {
2450 const struct afd_event_select_params_64 *params = get_req_data();
2451
2452 if (get_req_data_size() < sizeof(*params))
2453 {
2454 set_error( STATUS_INVALID_PARAMETER );
2455 return;
2456 }
2457
2458 event_handle = params->event;
2459 mask = params->mask;
2460 }
2461 else
2462 {
2463 const struct afd_event_select_params_32 *params = get_req_data();
2464
2465 if (get_req_data_size() < sizeof(*params))
2466 {
2467 set_error( STATUS_INVALID_PARAMETER );
2468 return;
2469 }
2470
2471 event_handle = params->event;
2472 mask = params->mask;
2473 }
2474
2475 if ((event_handle || mask) &&
2476 !(event = get_event_obj( current->process, event_handle, EVENT_MODIFY_STATE )))
2477 {
2478 set_error( STATUS_INVALID_PARAMETER );
2479 return;
2480 }
2481
2482 if (sock->event) release_object( sock->event );
2483 sock->event = event;
2484 sock->mask = mask;
2485 sock->window = 0;
2486 sock->message = 0;
2487 sock->wparam = 0;
2488 sock->nonblocking = 1;
2489
2490 sock_reselect( sock );
2491
2492 return;
2493 }
2494
2495 case IOCTL_AFD_WINE_MESSAGE_SELECT:
2496 {
2497 const struct afd_message_select_params *params = get_req_data();
2498
2499 if (get_req_data_size() < sizeof(params))
2500 {
2501 set_error( STATUS_BUFFER_TOO_SMALL );
2502 return;
2503 }
2504
2505 if (sock->event) release_object( sock->event );
2506
2507 if (params->window)
2508 {
2509 sock->pending_events = 0;
2510 sock->reported_events = 0;
2511 }
2512 sock->event = NULL;
2513 sock->mask = params->mask;
2514 sock->window = params->window;
2515 sock->message = params->message;
2516 sock->wparam = params->handle;
2517 sock->nonblocking = 1;
2518
2519 sock_reselect( sock );
2520
2521 return;
2522 }
2523
2524 case IOCTL_AFD_BIND:
2525 {
2526 const struct afd_bind_params *params = get_req_data();
2527 union unix_sockaddr unix_addr, bind_addr;
2528 data_size_t in_size;
2529 socklen_t unix_len;
2530
2531 /* the ioctl is METHOD_NEITHER, so ntdll gives us the output buffer as
2532 * input */
2533 if (get_req_data_size() < get_reply_max_size())
2534 {
2535 set_error( STATUS_BUFFER_TOO_SMALL );
2536 return;
2537 }
2538 in_size = get_req_data_size() - get_reply_max_size();
2539 if (in_size < offsetof(struct afd_bind_params, addr.sa_data)
2540 || get_reply_max_size() < in_size - sizeof(int))
2541 {
2542 set_error( STATUS_INVALID_PARAMETER );
2543 return;
2544 }
2545
2546 if (sock->bound)
2547 {
2548 set_error( STATUS_ADDRESS_ALREADY_ASSOCIATED );
2549 return;
2550 }
2551
2552 unix_len = sockaddr_to_unix( &params->addr, in_size - sizeof(int), &unix_addr );
2553 if (!unix_len)
2554 {
2555 set_error( STATUS_INVALID_ADDRESS );
2556 return;
2557 }
2558 bind_addr = unix_addr;
2559
2560 if (unix_addr.addr.sa_family == AF_INET)
2561 {
2562 if (!memcmp( &unix_addr.in.sin_addr, magic_loopback_addr, 4 )
2563 || bind_to_interface( sock, &unix_addr.in ))
2564 bind_addr.in.sin_addr.s_addr = htonl( INADDR_ANY );
2565 }
2566 else if (unix_addr.addr.sa_family == AF_INET6)
2567 {
2568 #ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID
2569 /* Windows allows specifying zero to use the default scope. Linux
2570 * interprets it as an interface index and requires that it be
2571 * nonzero. */
2572 if (!unix_addr.in6.sin6_scope_id)
2573 bind_addr.in6.sin6_scope_id = get_ipv6_interface_index( &unix_addr.in6.sin6_addr );
2574 #endif
2575 }
2576
2577 set_async_pending( async );
2578
2579 if (bind( unix_fd, &bind_addr.addr, unix_len ) < 0)
2580 {
2581 if (errno == EADDRINUSE)
2582 {
2583 int reuse;
2584 socklen_t len = sizeof(reuse);
2585
2586 if (!getsockopt( unix_fd, SOL_SOCKET, SO_REUSEADDR, (char *)&reuse, &len ) && reuse)
2587 errno = EACCES;
2588 }
2589
2590 set_error( sock_get_ntstatus( errno ) );
2591 return;
2592 }
2593
2594 sock->bound = 1;
2595
2596 unix_len = sizeof(bind_addr);
2597 if (!getsockname( unix_fd, &bind_addr.addr, &unix_len ))
2598 {
2599 /* store the interface or magic loopback address instead of the
2600 * actual unix address */
2601 if (bind_addr.addr.sa_family == AF_INET)
2602 bind_addr.in.sin_addr = unix_addr.in.sin_addr;
2603 sock->addr_len = sockaddr_from_unix( &bind_addr, &sock->addr.addr, sizeof(sock->addr) );
2604 }
2605
2606 if (get_reply_max_size() >= sock->addr_len)
2607 set_reply_data( &sock->addr, sock->addr_len );
2608 return;
2609 }
2610
2611 case IOCTL_AFD_GETSOCKNAME:
2612 if (!sock->bound)
2613 {
2614 set_error( STATUS_INVALID_PARAMETER );
2615 return;
2616 }
2617
2618 if (get_reply_max_size() < sock->addr_len)
2619 {
2620 set_error( STATUS_BUFFER_TOO_SMALL );
2621 return;
2622 }
2623
2624 set_reply_data( &sock->addr, sock->addr_len );
2625 return;
2626
2627 case IOCTL_AFD_WINE_DEFER:
2628 {
2629 const obj_handle_t *handle = get_req_data();
2630 struct sock *acceptsock;
2631
2632 if (get_req_data_size() < sizeof(*handle))
2633 {
2634 set_error( STATUS_BUFFER_TOO_SMALL );
2635 return;
2636 }
2637
2638 acceptsock = (struct sock *)get_handle_obj( current->process, *handle, 0, &sock_ops );
2639 if (!acceptsock) return;
2640
2641 sock->deferred = acceptsock;
2642 return;
2643 }
2644
2645 case IOCTL_AFD_WINE_GET_INFO:
2646 {
2647 struct afd_get_info_params params;
2648
2649 if (get_reply_max_size() < sizeof(params))
2650 {
2651 set_error( STATUS_BUFFER_TOO_SMALL );
2652 return;
2653 }
2654
2655 params.family = sock->family;
2656 params.type = sock->type;
2657 params.protocol = sock->proto;
2658 set_reply_data( &params, sizeof(params) );
2659 return;
2660 }
2661
2662 case IOCTL_AFD_WINE_GET_SO_ACCEPTCONN:
2663 {
2664 int listening = (sock->state == SOCK_LISTENING);
2665
2666 if (get_reply_max_size() < sizeof(listening))
2667 {
2668 set_error( STATUS_BUFFER_TOO_SMALL );
2669 return;
2670 }
2671
2672 set_reply_data( &listening, sizeof(listening) );
2673 return;
2674 }
2675
2676 case IOCTL_AFD_WINE_GET_SO_ERROR:
2677 {
2678 int error;
2679 socklen_t len = sizeof(error);
2680 unsigned int i;
2681
2682 if (get_reply_max_size() < sizeof(error))
2683 {
2684 set_error( STATUS_BUFFER_TOO_SMALL );
2685 return;
2686 }
2687
2688 if (getsockopt( unix_fd, SOL_SOCKET, SO_ERROR, (char *)&error, &len ) < 0)
2689 {
2690 set_error( sock_get_ntstatus( errno ) );
2691 return;
2692 }
2693
2694 if (!error)
2695 {
2696 for (i = 0; i < ARRAY_SIZE( sock->errors ); ++i)
2697 {
2698 if (sock->errors[i])
2699 {
2700 error = sock_get_error( sock->errors[i] );
2701 break;
2702 }
2703 }
2704 }
2705
2706 set_reply_data( &error, sizeof(error) );
2707 return;
2708 }
2709
2710 case IOCTL_AFD_WINE_GET_SO_RCVBUF:
2711 {
2712 int rcvbuf = sock->rcvbuf;
2713
2714 if (get_reply_max_size() < sizeof(rcvbuf))
2715 {
2716 set_error( STATUS_BUFFER_TOO_SMALL );
2717 return;
2718 }
2719
2720 set_reply_data( &rcvbuf, sizeof(rcvbuf) );
2721 return;
2722 }
2723
2724 case IOCTL_AFD_WINE_SET_SO_RCVBUF:
2725 {
2726 DWORD rcvbuf;
2727
2728 if (get_req_data_size() < sizeof(rcvbuf))
2729 {
2730 set_error( STATUS_BUFFER_TOO_SMALL );
2731 return;
2732 }
2733 rcvbuf = *(DWORD *)get_req_data();
2734
2735 if (!setsockopt( unix_fd, SOL_SOCKET, SO_RCVBUF, (char *)&rcvbuf, sizeof(rcvbuf) ))
2736 sock->rcvbuf = rcvbuf;
2737 else
2738 set_error( sock_get_ntstatus( errno ) );
2739 return;
2740 }
2741
2742 case IOCTL_AFD_WINE_GET_SO_RCVTIMEO:
2743 {
2744 DWORD rcvtimeo = sock->rcvtimeo;
2745
2746 if (get_reply_max_size() < sizeof(rcvtimeo))
2747 {
2748 set_error( STATUS_BUFFER_TOO_SMALL );
2749 return;
2750 }
2751
2752 set_reply_data( &rcvtimeo, sizeof(rcvtimeo) );
2753 return;
2754 }
2755
2756 case IOCTL_AFD_WINE_SET_SO_RCVTIMEO:
2757 {
2758 DWORD rcvtimeo;
2759
2760 if (get_req_data_size() < sizeof(rcvtimeo))
2761 {
2762 set_error( STATUS_BUFFER_TOO_SMALL );
2763 return;
2764 }
2765 rcvtimeo = *(DWORD *)get_req_data();
2766
2767 sock->rcvtimeo = rcvtimeo;
2768 return;
2769 }
2770
2771 case IOCTL_AFD_WINE_GET_SO_SNDBUF:
2772 {
2773 int sndbuf = sock->sndbuf;
2774
2775 if (get_reply_max_size() < sizeof(sndbuf))
2776 {
2777 set_error( STATUS_BUFFER_TOO_SMALL );
2778 return;
2779 }
2780
2781 set_reply_data( &sndbuf, sizeof(sndbuf) );
2782 return;
2783 }
2784
2785 case IOCTL_AFD_WINE_SET_SO_SNDBUF:
2786 {
2787 DWORD sndbuf;
2788
2789 if (get_req_data_size() < sizeof(sndbuf))
2790 {
2791 set_error( STATUS_BUFFER_TOO_SMALL );
2792 return;
2793 }
2794 sndbuf = *(DWORD *)get_req_data();
2795
2796 #ifdef __APPLE__
2797 if (!sndbuf)
2798 {
2799 /* setsockopt fails if a zero value is passed */
2800 sock->sndbuf = sndbuf;
2801 return;
2802 }
2803 #endif
2804
2805 if (!setsockopt( unix_fd, SOL_SOCKET, SO_SNDBUF, (char *)&sndbuf, sizeof(sndbuf) ))
2806 sock->sndbuf = sndbuf;
2807 else
2808 set_error( sock_get_ntstatus( errno ) );
2809 return;
2810 }
2811
2812 case IOCTL_AFD_WINE_GET_SO_SNDTIMEO:
2813 {
2814 DWORD sndtimeo = sock->sndtimeo;
2815
2816 if (get_reply_max_size() < sizeof(sndtimeo))
2817 {
2818 set_error( STATUS_BUFFER_TOO_SMALL );
2819 return;
2820 }
2821
2822 set_reply_data( &sndtimeo, sizeof(sndtimeo) );
2823 return;
2824 }
2825
2826 case IOCTL_AFD_WINE_SET_SO_SNDTIMEO:
2827 {
2828 DWORD sndtimeo;
2829
2830 if (get_req_data_size() < sizeof(sndtimeo))
2831 {
2832 set_error( STATUS_BUFFER_TOO_SMALL );
2833 return;
2834 }
2835 sndtimeo = *(DWORD *)get_req_data();
2836
2837 sock->sndtimeo = sndtimeo;
2838 return;
2839 }
2840
2841 case IOCTL_AFD_WINE_GET_SO_CONNECT_TIME:
2842 {
2843 DWORD time = ~0u;
2844
2845 if (get_reply_max_size() < sizeof(time))
2846 {
2847 set_error( STATUS_BUFFER_TOO_SMALL );
2848 return;
2849 }
2850
2851 if (sock->state == SOCK_CONNECTED)
2852 time = (current_time - sock->connect_time) / 10000000;
2853
2854 set_reply_data( &time, sizeof(time) );
2855 return;
2856 }
2857
2858 default:
2859 set_error( STATUS_NOT_SUPPORTED );
2860 return;
2861 }
2862 }
2863
2864 static int poll_single_socket( struct sock *sock, int mask )
2865 {
2866 struct pollfd pollfd;
2867
2868 pollfd.fd = get_unix_fd( sock->fd );
2869 pollfd.events = poll_flags_from_afd( sock, mask );
2870 if (pollfd.events < 0 || poll( &pollfd, 1, 0 ) < 0)
2871 return 0;
2872
2873 if ((mask & AFD_POLL_HUP) && (pollfd.revents & POLLIN) && sock->type == WS_SOCK_STREAM)
2874 {
2875 char dummy;
2876
2877 if (!recv( get_unix_fd( sock->fd ), &dummy, 1, MSG_PEEK ))
2878 {
2879 pollfd.revents &= ~POLLIN;
2880 pollfd.revents |= POLLHUP;
2881 }
2882 }
2883
2884 return get_poll_flags( sock, pollfd.revents ) & mask;
2885 }
2886
2887 static void handle_exclusive_poll(struct poll_req *req)
2888 {
2889 unsigned int i;
2890
2891 for (i = 0; i < req->count; ++i)
2892 {
2893 struct sock *sock = req->sockets[i].sock;
2894 struct poll_req *main_poll = sock->main_poll;
2895
2896 if (main_poll && main_poll->exclusive && req->exclusive)
2897 {
2898 complete_async_poll( main_poll, STATUS_SUCCESS );
2899 main_poll = NULL;
2900 }
2901
2902 if (!main_poll)
2903 sock->main_poll = req;
2904 }
2905 }
2906
2907 static void poll_socket( struct sock *poll_sock, struct async *async, int exclusive, timeout_t timeout,
2908 unsigned int count, const struct poll_socket_input *input )
2909 {
2910 struct poll_socket_output *output;
2911 BOOL signaled = FALSE;
2912 struct poll_req *req;
2913 unsigned int i, j;
2914
2915 if (!(output = mem_alloc( count * sizeof(*output) )))
2916 return;
2917 memset( output, 0, count * sizeof(*output) );
2918
2919 if (!(req = mem_alloc( offsetof( struct poll_req, sockets[count] ) )))
2920 {
2921 free( output );
2922 return;
2923 }
2924
2925 req->timeout = NULL;
2926 if (timeout && timeout != TIMEOUT_INFINITE &&
2927 !(req->timeout = add_timeout_user( timeout, async_poll_timeout, req )))
2928 {
2929 free( req );
2930 free( output );
2931 return;
2932 }
2933
2934 for (i = 0; i < count; ++i)
2935 {
2936 req->sockets[i].sock = (struct sock *)get_handle_obj( current->process, input[i].socket, 0, &sock_ops );
2937 if (!req->sockets[i].sock)
2938 {
2939 for (j = 0; j < i; ++j) release_object( req->sockets[i].sock );
2940 if (req->timeout) remove_timeout_user( req->timeout );
2941 free( req );
2942 free( output );
2943 return;
2944 }
2945 req->sockets[i].flags = input[i].flags;
2946 }
2947
2948 req->exclusive = exclusive;
2949 req->count = count;
2950 req->async = (struct async *)grab_object( async );
2951 req->iosb = async_get_iosb( async );
2952 req->output = output;
2953
2954 handle_exclusive_poll(req);
2955
2956 list_add_tail( &poll_list, &req->entry );
2957 async_set_completion_callback( async, free_poll_req, req );
2958 queue_async( &poll_sock->poll_q, async );
2959
2960 for (i = 0; i < count; ++i)
2961 {
2962 struct sock *sock = req->sockets[i].sock;
2963 int mask = req->sockets[i].flags;
2964 int flags = poll_single_socket( sock, mask );
2965
2966 if (flags)
2967 {
2968 signaled = TRUE;
2969 output[i].flags = flags;
2970 output[i].status = sock_get_ntstatus( sock_error( sock->fd ) );
2971 }
2972
2973 /* FIXME: do other error conditions deserve a similar treatment? */
2974 if (sock->state != SOCK_CONNECTING && sock->errors[AFD_POLL_BIT_CONNECT_ERR] && (mask & AFD_POLL_CONNECT_ERR))
2975 {
2976 signaled = TRUE;
2977 output[i].flags |= AFD_POLL_CONNECT_ERR;
2978 output[i].status = sock_get_ntstatus( sock->errors[AFD_POLL_BIT_CONNECT_ERR] );
2979 }
2980 }
2981
2982 if (!timeout || signaled)
2983 complete_async_poll( req, STATUS_SUCCESS );
2984
2985 for (i = 0; i < req->count; ++i)
2986 sock_reselect( req->sockets[i].sock );
2987 set_error( STATUS_PENDING );
2988 }
2989
2990 #ifdef HAVE_LINUX_RTNETLINK_H
2991
2992 /* only keep one ifchange object around, all sockets waiting for wakeups will look to it */
2993 static struct object *ifchange_object;
2994
2995 static void ifchange_dump( struct object *obj, int verbose );
2996 static struct fd *ifchange_get_fd( struct object *obj );
2997 static void ifchange_destroy( struct object *obj );
2998
2999 static int ifchange_get_poll_events( struct fd *fd );
3000 static void ifchange_poll_event( struct fd *fd, int event );
3001
3002 struct ifchange
3003 {
3004 struct object obj; /* object header */
3005 struct fd *fd; /* interface change file descriptor */
3006 struct list sockets; /* list of sockets to send interface change notifications */
3007 };
3008
3009 static const struct object_ops ifchange_ops =
3010 {
3011 sizeof(struct ifchange), /* size */
3012 &no_type, /* type */
3013 ifchange_dump, /* dump */
3014 no_add_queue, /* add_queue */
3015 NULL, /* remove_queue */
3016 NULL, /* signaled */
3017 no_satisfied, /* satisfied */
3018 no_signal, /* signal */
3019 ifchange_get_fd, /* get_fd */
3020 default_map_access, /* map_access */
3021 default_get_sd, /* get_sd */
3022 default_set_sd, /* set_sd */
3023 no_get_full_name, /* get_full_name */
3024 no_lookup_name, /* lookup_name */
3025 no_link_name, /* link_name */
3026 NULL, /* unlink_name */
3027 no_open_file, /* open_file */
3028 no_kernel_obj_list, /* get_kernel_obj_list */
3029 no_close_handle, /* close_handle */
3030 ifchange_destroy /* destroy */
3031 };
3032
3033 static const struct fd_ops ifchange_fd_ops =
3034 {
3035 ifchange_get_poll_events, /* get_poll_events */
3036 ifchange_poll_event, /* poll_event */
3037 NULL, /* get_fd_type */
3038 no_fd_read, /* read */
3039 no_fd_write, /* write */
3040 no_fd_flush, /* flush */
3041 no_fd_get_file_info, /* get_file_info */
3042 no_fd_get_volume_info, /* get_volume_info */
3043 no_fd_ioctl, /* ioctl */
3044 NULL, /* cancel_async */
3045 NULL, /* queue_async */
3046 NULL /* reselect_async */
3047 };
3048
3049 static void ifchange_dump( struct object *obj, int verbose )
3050 {
3051 assert( obj->ops == &ifchange_ops );
3052 fprintf( stderr, "Interface change\n" );
3053 }
3054
3055 static struct fd *ifchange_get_fd( struct object *obj )
3056 {
3057 struct ifchange *ifchange = (struct ifchange *)obj;
3058 return (struct fd *)grab_object( ifchange->fd );
3059 }
3060
3061 static void ifchange_destroy( struct object *obj )
3062 {
3063 struct ifchange *ifchange = (struct ifchange *)obj;
3064 assert( obj->ops == &ifchange_ops );
3065
3066 release_object( ifchange->fd );
3067
3068 /* reset the global ifchange object so that it will be recreated if it is needed again */
3069 assert( obj == ifchange_object );
3070 ifchange_object = NULL;
3071 }
3072
3073 static int ifchange_get_poll_events( struct fd *fd )
3074 {
3075 return POLLIN;
3076 }
3077
3078 /* wake up all the sockets waiting for a change notification event */
3079 static void ifchange_wake_up( struct object *obj, unsigned int status )
3080 {
3081 struct ifchange *ifchange = (struct ifchange *)obj;
3082 struct list *ptr, *next;
3083 assert( obj->ops == &ifchange_ops );
3084 assert( obj == ifchange_object );
3085
3086 LIST_FOR_EACH_SAFE( ptr, next, &ifchange->sockets )
3087 {
3088 struct sock *sock = LIST_ENTRY( ptr, struct sock, ifchange_entry );
3089
3090 assert( sock->ifchange_obj );
3091 async_wake_up( &sock->ifchange_q, status ); /* issue ifchange notification for the socket */
3092 sock_release_ifchange( sock ); /* remove socket from list and decrement ifchange refcount */
3093 }
3094 }
3095
3096 static void ifchange_poll_event( struct fd *fd, int event )
3097 {
3098 struct object *ifchange = get_fd_user( fd );
3099 unsigned int status = STATUS_PENDING;
3100 char buffer[PIPE_BUF];
3101 int r;
3102
3103 r = recv( get_unix_fd(fd), buffer, sizeof(buffer), MSG_DONTWAIT );
3104 if (r < 0)
3105 {
3106 if (errno == EWOULDBLOCK || (EWOULDBLOCK != EAGAIN && errno == EAGAIN))
3107 return; /* retry when poll() says the socket is ready */
3108 status = sock_get_ntstatus( errno );
3109 }
3110 else if (r > 0)
3111 {
3112 struct nlmsghdr *nlh;
3113
3114 for (nlh = (struct nlmsghdr *)buffer; NLMSG_OK(nlh, r); nlh = NLMSG_NEXT(nlh, r))
3115 {
3116 if (nlh->nlmsg_type == NLMSG_DONE)
3117 break;
3118 if (nlh->nlmsg_type == RTM_NEWADDR || nlh->nlmsg_type == RTM_DELADDR)
3119 status = STATUS_SUCCESS;
3120 }
3121 }
3122 else status = STATUS_CANCELLED;
3123
3124 if (status != STATUS_PENDING) ifchange_wake_up( ifchange, status );
3125 }
3126
3127 #endif
3128
3129 /* we only need one of these interface notification objects, all of the sockets dependent upon
3130 * it will wake up when a notification event occurs */
3131 static struct object *get_ifchange( void )
3132 {
3133 #ifdef HAVE_LINUX_RTNETLINK_H
3134 struct ifchange *ifchange;
3135 struct sockaddr_nl addr;
3136 int unix_fd;
3137
3138 if (ifchange_object)
3139 {
3140 /* increment the refcount for each socket that uses the ifchange object */
3141 return grab_object( ifchange_object );
3142 }
3143
3144 /* create the socket we need for processing interface change notifications */
3145 unix_fd = socket( PF_NETLINK, SOCK_RAW, NETLINK_ROUTE );
3146 if (unix_fd == -1)
3147 {
3148 set_error( sock_get_ntstatus( errno ));
3149 return NULL;
3150 }
3151 fcntl( unix_fd, F_SETFL, O_NONBLOCK ); /* make socket nonblocking */
3152 memset( &addr, 0, sizeof(addr) );
3153 addr.nl_family = AF_NETLINK;
3154 addr.nl_groups = RTMGRP_IPV4_IFADDR;
3155 /* bind the socket to the special netlink kernel interface */
3156 if (bind( unix_fd, (struct sockaddr *)&addr, sizeof(addr) ) == -1)
3157 {
3158 close( unix_fd );
3159 set_error( sock_get_ntstatus( errno ));
3160 return NULL;
3161 }
3162 if (!(ifchange = alloc_object( &ifchange_ops )))
3163 {
3164 close( unix_fd );
3165 set_error( STATUS_NO_MEMORY );
3166 return NULL;
3167 }
3168 list_init( &ifchange->sockets );
3169 if (!(ifchange->fd = create_anonymous_fd( &ifchange_fd_ops, unix_fd, &ifchange->obj, 0 )))
3170 {
3171 release_object( ifchange );
3172 set_error( STATUS_NO_MEMORY );
3173 return NULL;
3174 }
3175 set_fd_events( ifchange->fd, POLLIN ); /* enable read wakeup on the file descriptor */
3176
3177 /* the ifchange object is now successfully configured */
3178 ifchange_object = &ifchange->obj;
3179 return &ifchange->obj;
3180 #else
3181 set_error( STATUS_NOT_SUPPORTED );
3182 return NULL;
3183 #endif
3184 }
3185
3186 /* add the socket to the interface change notification list */
3187 static void ifchange_add_sock( struct object *obj, struct sock *sock )
3188 {
3189 #ifdef HAVE_LINUX_RTNETLINK_H
3190 struct ifchange *ifchange = (struct ifchange *)obj;
3191
3192 list_add_tail( &ifchange->sockets, &sock->ifchange_entry );
3193 #endif
3194 }
3195
3196 /* create a new ifchange queue for a specific socket or, if one already exists, reuse the existing one */
3197 static struct object *sock_get_ifchange( struct sock *sock )
3198 {
3199 struct object *ifchange;
3200
3201 if (sock->ifchange_obj) /* reuse existing ifchange_obj for this socket */
3202 return sock->ifchange_obj;
3203
3204 if (!(ifchange = get_ifchange()))
3205 return NULL;
3206
3207 /* add the socket to the ifchange notification list */
3208 ifchange_add_sock( ifchange, sock );
3209 sock->ifchange_obj = ifchange;
3210 return ifchange;
3211 }
3212
3213 /* destroy an existing ifchange queue for a specific socket */
3214 static void sock_release_ifchange( struct sock *sock )
3215 {
3216 if (sock->ifchange_obj)
3217 {
3218 list_remove( &sock->ifchange_entry );
3219 release_object( sock->ifchange_obj );
3220 sock->ifchange_obj = NULL;
3221 }
3222 }
3223
3224 static void socket_device_dump( struct object *obj, int verbose );
3225 static struct object *socket_device_lookup_name( struct object *obj, struct unicode_str *name,
3226 unsigned int attr, struct object *root );
3227 static struct object *socket_device_open_file( struct object *obj, unsigned int access,
3228 unsigned int sharing, unsigned int options );
3229
3230 static const struct object_ops socket_device_ops =
3231 {
3232 sizeof(struct object), /* size */
3233 &device_type, /* type */
3234 socket_device_dump, /* dump */
3235 no_add_queue, /* add_queue */
3236 NULL, /* remove_queue */
3237 NULL, /* signaled */
3238 no_satisfied, /* satisfied */
3239 no_signal, /* signal */
3240 no_get_fd, /* get_fd */
3241 default_map_access, /* map_access */
3242 default_get_sd, /* get_sd */
3243 default_set_sd, /* set_sd */
3244 default_get_full_name, /* get_full_name */
3245 socket_device_lookup_name, /* lookup_name */
3246 directory_link_name, /* link_name */
3247 default_unlink_name, /* unlink_name */
3248 socket_device_open_file, /* open_file */
3249 no_kernel_obj_list, /* get_kernel_obj_list */
3250 no_close_handle, /* close_handle */
3251 no_destroy /* destroy */
3252 };
3253
3254 static void socket_device_dump( struct object *obj, int verbose )
3255 {
3256 fputs( "Socket device\n", stderr );
3257 }
3258
3259 static struct object *socket_device_lookup_name( struct object *obj, struct unicode_str *name,
3260 unsigned int attr, struct object *root )
3261 {
3262 if (name) name->len = 0;
3263 return NULL;
3264 }
3265
3266 static struct object *socket_device_open_file( struct object *obj, unsigned int access,
3267 unsigned int sharing, unsigned int options )
3268 {
3269 struct sock *sock;
3270
3271 if (!(sock = create_socket())) return NULL;
3272 if (!(sock->fd = alloc_pseudo_fd( &sock_fd_ops, &sock->obj, options )))
3273 {
3274 release_object( sock );
3275 return NULL;
3276 }
3277 return &sock->obj;
3278 }
3279
3280 struct object *create_socket_device( struct object *root, const struct unicode_str *name,
3281 unsigned int attr, const struct security_descriptor *sd )
3282 {
3283 return create_named_object( root, &socket_device_ops, name, attr, sd );
3284 }
3285
3286 DECL_HANDLER(recv_socket)
3287 {
3288 struct sock *sock = (struct sock *)get_handle_obj( current->process, req->async.handle, 0, &sock_ops );
3289 unsigned int status = req->status;
3290 timeout_t timeout = 0;
3291 struct async *async;
3292 struct fd *fd;
3293
3294 if (!sock) return;
3295 fd = sock->fd;
3296
3297 /* recv() returned EWOULDBLOCK, i.e. no data available yet */
3298 if (status == STATUS_DEVICE_NOT_READY && !sock->nonblocking)
3299 {
3300 /* Set a timeout on the async if necessary.
3301 *
3302 * We want to do this *only* if the client gave us STATUS_DEVICE_NOT_READY.
3303 * If the client gave us STATUS_PENDING, it expects the async to always
3304 * block (it was triggered by WSARecv*() with a valid OVERLAPPED
3305 * structure) and for the timeout not to be respected. */
3306 if (is_fd_overlapped( fd ))
3307 timeout = (timeout_t)sock->rcvtimeo * -10000;
3308
3309 status = STATUS_PENDING;
3310 }
3311
3312 if ((status == STATUS_PENDING || status == STATUS_DEVICE_NOT_READY) && sock->rd_shutdown)
3313 status = STATUS_PIPE_DISCONNECTED;
3314
3315 sock->pending_events &= ~(req->oob ? AFD_POLL_OOB : AFD_POLL_READ);
3316 sock->reported_events &= ~(req->oob ? AFD_POLL_OOB : AFD_POLL_READ);
3317
3318 if ((async = create_request_async( fd, get_fd_comp_flags( fd ), &req->async )))
3319 {
3320 if (status == STATUS_SUCCESS)
3321 {
3322 struct iosb *iosb = async_get_iosb( async );
3323 iosb->result = req->total;
3324 release_object( iosb );
3325 }
3326 set_error( status );
3327
3328 if (timeout)
3329 async_set_timeout( async, timeout, STATUS_IO_TIMEOUT );
3330
3331 if (status == STATUS_PENDING)
3332 queue_async( &sock->read_q, async );
3333
3334 /* always reselect; we changed reported_events above */
3335 sock_reselect( sock );
3336
3337 reply->wait = async_handoff( async, NULL, 0 );
3338 reply->options = get_fd_options( fd );
3339 release_object( async );
3340 }
3341 release_object( sock );
3342 }
3343
3344 DECL_HANDLER(poll_socket)
3345 {
3346 struct sock *sock = (struct sock *)get_handle_obj( current->process, req->async.handle, 0, &sock_ops );
3347 const struct poll_socket_input *input = get_req_data();
3348 struct async *async;
3349 unsigned int count;
3350
3351 if (!sock) return;
3352
3353 count = get_req_data_size() / sizeof(*input);
3354
3355 if ((async = create_request_async( sock->fd, get_fd_comp_flags( sock->fd ), &req->async )))
3356 {
3357 poll_socket( sock, async, req->exclusive, req->timeout, count, input );
3358 reply->wait = async_handoff( async, NULL, 0 );
3359 reply->options = get_fd_options( sock->fd );
3360 release_object( async );
3361 }
3362
3363 release_object( sock );
3364 }
3365
3366 DECL_HANDLER(send_socket)
3367 {
3368 struct sock *sock = (struct sock *)get_handle_obj( current->process, req->async.handle, 0, &sock_ops );
3369 unsigned int status = req->status;
3370 timeout_t timeout = 0;
3371 struct async *async;
3372 struct fd *fd;
3373
3374 if (!sock) return;
3375 fd = sock->fd;
3376
3377 if (sock->type == WS_SOCK_DGRAM)
3378 {
3379 /* sendto() and sendmsg() implicitly binds a socket */
3380 union unix_sockaddr unix_addr;
3381 socklen_t unix_len = sizeof(unix_addr);
3382
3383 if (!sock->bound && !getsockname( get_unix_fd( fd ), &unix_addr.addr, &unix_len ))
3384 sock->addr_len = sockaddr_from_unix( &unix_addr, &sock->addr.addr, sizeof(sock->addr) );
3385 sock->bound = 1;
3386 }
3387
3388 if (status != STATUS_SUCCESS)
3389 {
3390 /* send() calls only clear and reselect events if unsuccessful. */
3391 sock->pending_events &= ~AFD_POLL_WRITE;
3392 sock->reported_events &= ~AFD_POLL_WRITE;
3393 }
3394
3395 /* If we had a short write and the socket is nonblocking (and the client is
3396 * not trying to force the operation to be asynchronous), return success.
3397 * Windows actually refuses to send any data in this case, and returns
3398 * EWOULDBLOCK, but we have no way of doing that. */
3399 if (status == STATUS_DEVICE_NOT_READY && req->total && sock->nonblocking)
3400 status = STATUS_SUCCESS;
3401
3402 /* send() returned EWOULDBLOCK or a short write, i.e. cannot send all data yet */
3403 if (status == STATUS_DEVICE_NOT_READY && !sock->nonblocking)
3404 {
3405 /* Set a timeout on the async if necessary.
3406 *
3407 * We want to do this *only* if the client gave us STATUS_DEVICE_NOT_READY.
3408 * If the client gave us STATUS_PENDING, it expects the async to always
3409 * block (it was triggered by WSASend*() with a valid OVERLAPPED
3410 * structure) and for the timeout not to be respected. */
3411 if (is_fd_overlapped( fd ))
3412 timeout = (timeout_t)sock->sndtimeo * -10000;
3413
3414 status = STATUS_PENDING;
3415 }
3416
3417 if ((status == STATUS_PENDING || status == STATUS_DEVICE_NOT_READY) && sock->wr_shutdown)
3418 status = STATUS_PIPE_DISCONNECTED;
3419
3420 if ((async = create_request_async( fd, get_fd_comp_flags( fd ), &req->async )))
3421 {
3422 if (status == STATUS_SUCCESS)
3423 {
3424 struct iosb *iosb = async_get_iosb( async );
3425 iosb->result = req->total;
3426 release_object( iosb );
3427 }
3428 set_error( status );
3429
3430 if (timeout)
3431 async_set_timeout( async, timeout, STATUS_IO_TIMEOUT );
3432
3433 if (status == STATUS_PENDING)
3434 queue_async( &sock->write_q, async );
3435
3436 /* always reselect; we changed reported_events above */
3437 sock_reselect( sock );
3438
3439 reply->wait = async_handoff( async, NULL, 0 );
3440 reply->options = get_fd_options( fd );
3441 release_object( async );
3442 }
3443 release_object( sock );
3444 }
Windows API implementation