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