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