?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
include: Add RTL_CONSTANT_STRING.
[wine.git] / server / sock.c
bloba64cb22404e241a085502923c682c04ee420bc5e
1 /*
2 * Server-side socket management
3 *
4 * Copyright (C) 1999 Marcus Meissner, Ove Kåven
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 *
20 * FIXME: we use read|write access in all cases. Shouldn't we depend that
21 * on the access of the current handle?
22 */
23
24 #include "config.h"
25
26 #include <assert.h>
27 #include <fcntl.h>
28 #include <stdarg.h>
29 #include <stdio.h>
30 #include <string.h>
31 #include <stdlib.h>
32 #include <errno.h>
33 #ifdef HAVE_IFADDRS_H
34 # include <ifaddrs.h>
35 #endif
36 #ifdef HAVE_NET_IF_H
37 # include <net/if.h>
38 #endif
39 #ifdef HAVE_NETINET_IN_H
40 # include <netinet/in.h>
41 #endif
42 #include <poll.h>
43 #include <sys/time.h>
44 #include <sys/types.h>
45 #include <sys/socket.h>
46 #include <sys/ioctl.h>
47 #ifdef HAVE_SYS_FILIO_H
48 # include <sys/filio.h>
49 #endif
50 #include <time.h>
51 #include <unistd.h>
52 #include <limits.h>
53 #ifdef HAVE_LINUX_FILTER_H
54 # include <linux/filter.h>
55 #endif
56 #ifdef HAVE_LINUX_RTNETLINK_H
57 # include <linux/rtnetlink.h>
58 #endif
59
60 #ifdef HAVE_NETIPX_IPX_H
61 # include <netipx/ipx.h>
62 #elif defined(HAVE_LINUX_IPX_H)
63 # ifdef HAVE_ASM_TYPES_H
64 # include <asm/types.h>
65 # endif
66 # ifdef HAVE_LINUX_TYPES_H
67 # include <linux/types.h>
68 # endif
69 # include <linux/ipx.h>
70 #endif
71 #if defined(SOL_IPX) || defined(SO_DEFAULT_HEADERS)
72 # define HAS_IPX
73 #endif
74
75 #ifdef HAVE_LINUX_IRDA_H
76 # ifdef HAVE_LINUX_TYPES_H
77 # include <linux/types.h>
78 # endif
79 # include <linux/irda.h>
80 # define HAS_IRDA
81 #endif
82
83 #include "ntstatus.h"
84 #define WIN32_NO_STATUS
85 #include "windef.h"
86 #include "winternl.h"
87 #include "winerror.h"
88 #define USE_WS_PREFIX
89 #include "winsock2.h"
90 #include "ws2tcpip.h"
91 #include "wsipx.h"
92 #include "af_irda.h"
93 #include "wine/afd.h"
94 #include "wine/rbtree.h"
95
96 #include "process.h"
97 #include "file.h"
98 #include "handle.h"
99 #include "thread.h"
100 #include "request.h"
101 #include "user.h"
102
103 #if defined(linux) && !defined(IP_UNICAST_IF)
104 #define IP_UNICAST_IF 50
105 #endif
106
107 static const char magic_loopback_addr[] = {127, 12, 34, 56};
108
109 union win_sockaddr
110 {
111 struct WS_sockaddr addr;
112 struct WS_sockaddr_in in;
113 struct WS_sockaddr_in6 in6;
114 struct WS_sockaddr_ipx ipx;
115 SOCKADDR_IRDA irda;
116 };
117
118 union unix_sockaddr
119 {
120 struct sockaddr addr;
121 struct sockaddr_in in;
122 struct sockaddr_in6 in6;
123 #ifdef HAS_IPX
124 struct sockaddr_ipx ipx;
125 #endif
126 #ifdef HAS_IRDA
127 struct sockaddr_irda irda;
128 #endif
129 };
130
131 static struct list poll_list = LIST_INIT( poll_list );
132
133 struct poll_req
134 {
135 struct list entry;
136 struct async *async;
137 struct iosb *iosb;
138 struct timeout_user *timeout;
139 timeout_t orig_timeout;
140 int exclusive;
141 int pending;
142 unsigned int count;
143 struct
144 {
145 struct sock *sock;
146 int mask;
147 obj_handle_t handle;
148 int flags;
149 unsigned int status;
150 } sockets[1];
151 };
152
153 struct accept_req
154 {
155 struct list entry;
156 struct async *async;
157 struct iosb *iosb;
158 struct sock *sock, *acceptsock;
159 int accepted;
160 unsigned int recv_len, local_len;
161 };
162
163 struct connect_req
164 {
165 struct async *async;
166 struct iosb *iosb;
167 struct sock *sock;
168 unsigned int addr_len, send_len, send_cursor;
169 };
170
171 struct send_req
172 {
173 struct iosb *iosb;
174 struct sock *sock;
175 };
176
177 enum connection_state
178 {
179 SOCK_LISTENING,
180 SOCK_UNCONNECTED,
181 SOCK_CONNECTING,
182 SOCK_CONNECTED,
183 SOCK_CONNECTIONLESS,
184 };
185
186 struct bound_addr
187 {
188 struct rb_entry entry;
189 union unix_sockaddr addr;
190 int match_any_addr;
191 int reuse_count;
192 };
193
194 #define MAX_ICMP_HISTORY_LENGTH 8
195
196 struct sock
197 {
198 struct object obj; /* object header */
199 struct fd *fd; /* socket file descriptor */
200 enum connection_state state; /* connection state */
201 unsigned int mask; /* event mask */
202 /* pending AFD_POLL_* events which have not yet been reported to the application */
203 unsigned int pending_events;
204 /* AFD_POLL_* events which have already been reported and should not be
205 * selected for again until reset by a relevant call.
206 *
207 * For example, if AFD_POLL_READ is set here and not in pending_events, it
208 * has already been reported and consumed, and we should not report it
209 * again, even if POLLIN is signaled, until it is reset by e.g recv().
210 *
211 * If an event has been signaled and not consumed yet, it will be set in
212 * both pending_events and reported_events (as we should only ever report
213 * any event once until it is reset.) */
214 unsigned int reported_events;
215 unsigned short proto; /* socket protocol */
216 unsigned short type; /* socket type */
217 unsigned short family; /* socket family */
218 struct event *event; /* event object */
219 user_handle_t window; /* window to send the message to */
220 unsigned int message; /* message to send */
221 obj_handle_t wparam; /* message wparam (socket handle) */
222 int errors[AFD_POLL_BIT_COUNT]; /* event errors */
223 timeout_t connect_time;/* time the socket was connected */
224 struct sock *deferred; /* socket that waits for a deferred accept */
225 struct async_queue read_q; /* queue for asynchronous reads */
226 struct async_queue write_q; /* queue for asynchronous writes */
227 struct async_queue ifchange_q; /* queue for interface change notifications */
228 struct async_queue accept_q; /* queue for asynchronous accepts */
229 struct async_queue connect_q; /* queue for asynchronous connects */
230 struct async_queue poll_q; /* queue for asynchronous polls */
231 struct object *ifchange_obj; /* the interface change notification object */
232 struct list ifchange_entry; /* entry in ifchange notification list */
233 struct list accept_list; /* list of pending accept requests */
234 struct accept_req *accept_recv_req; /* pending accept-into request which will recv on this socket */
235 struct connect_req *connect_req; /* pending connection request */
236 struct poll_req *main_poll; /* main poll */
237 union win_sockaddr addr; /* socket name */
238 int addr_len; /* socket name length */
239 unsigned int rcvbuf; /* advisory recv buffer size */
240 unsigned int sndbuf; /* advisory send buffer size */
241 unsigned int rcvtimeo; /* receive timeout in ms */
242 unsigned int sndtimeo; /* send timeout in ms */
243 struct
244 {
245 unsigned short icmp_id;
246 unsigned short icmp_seq;
247 }
248 icmp_fixup_data[MAX_ICMP_HISTORY_LENGTH]; /* Sent ICMP packets history used to fixup reply id. */
249 struct bound_addr *bound_addr[2]; /* Links to the entries in bound addresses tree. */
250 unsigned int icmp_fixup_data_len; /* Sent ICMP packets history length. */
251 unsigned int rd_shutdown : 1; /* is the read end shut down? */
252 unsigned int wr_shutdown : 1; /* is the write end shut down? */
253 unsigned int wr_shutdown_pending : 1; /* is a write shutdown pending? */
254 unsigned int hangup : 1; /* has the read end received a hangup? */
255 unsigned int aborted : 1; /* did we get a POLLERR or irregular POLLHUP? */
256 unsigned int nonblocking : 1; /* is the socket nonblocking? */
257 unsigned int bound : 1; /* is the socket bound? */
258 unsigned int reset : 1; /* did we get a TCP reset? */
259 unsigned int reuseaddr : 1; /* winsock SO_REUSEADDR option value */
260 unsigned int exclusiveaddruse : 1; /* winsock SO_EXCLUSIVEADDRUSE option value */
261 };
262
263 static int is_tcp_socket( struct sock *sock )
264 {
265 return sock->type == WS_SOCK_STREAM && (sock->family == WS_AF_INET || sock->family == WS_AF_INET6);
266 }
267
268 static int addr_compare( const void *key, const struct wine_rb_entry *entry )
269 {
270 const struct bound_addr *bound_addr = RB_ENTRY_VALUE(entry, struct bound_addr, entry);
271 const struct bound_addr *addr = key;
272
273 if (addr->addr.addr.sa_family != bound_addr->addr.addr.sa_family)
274 return addr->addr.addr.sa_family < bound_addr->addr.addr.sa_family ? -1 : 1;
275
276 if (addr->addr.addr.sa_family == AF_INET)
277 {
278 if (addr->addr.in.sin_port != bound_addr->addr.in.sin_port)
279 return addr->addr.in.sin_port < bound_addr->addr.in.sin_port ? -1 : 1;
280 if (bound_addr->match_any_addr || addr->match_any_addr
281 || addr->addr.in.sin_addr.s_addr == bound_addr->addr.in.sin_addr.s_addr)
282 return 0;
283 return addr->addr.in.sin_addr.s_addr < bound_addr->addr.in.sin_addr.s_addr ? -1 : 1;
284 }
285
286 assert( addr->addr.addr.sa_family == AF_INET6 );
287 if (addr->addr.in6.sin6_port != bound_addr->addr.in6.sin6_port)
288 return addr->addr.in6.sin6_port < bound_addr->addr.in6.sin6_port ? -1 : 1;
289 if (bound_addr->match_any_addr || addr->match_any_addr) return 0;
290 return memcmp( &addr->addr.in6.sin6_addr, &bound_addr->addr.in6.sin6_addr, sizeof(addr->addr.in6.sin6_addr) );
291 }
292
293 static int ipv4addr_from_v6( union unix_sockaddr *v4addr, const struct sockaddr_in6 *in6, int map_unspecified )
294 {
295 v4addr->in.sin_family = AF_INET;
296 v4addr->in.sin_port = in6->sin6_port;
297
298 if (map_unspecified && IN6_IS_ADDR_UNSPECIFIED(&in6->sin6_addr))
299 {
300 v4addr->in.sin_addr.s_addr = htonl( INADDR_ANY );
301 return 1;
302 }
303 if (IN6_IS_ADDR_V4COMPAT(&in6->sin6_addr) || IN6_IS_ADDR_V4MAPPED(&in6->sin6_addr))
304 {
305 memcpy( &v4addr->in.sin_addr.s_addr, &in6->sin6_addr.s6_addr[12], sizeof(v4addr->in.sin_addr.s_addr) );
306 return 1;
307 }
308 return 0;
309 }
310
311 static struct rb_tree bound_addresses_tree = { addr_compare };
312
313 static int should_track_conflicts_for_addr( struct sock *sock, const union unix_sockaddr *addr )
314 {
315 if (!is_tcp_socket( sock )) return 0;
316
317 if (sock->family == WS_AF_INET && addr->addr.sa_family == AF_INET && addr->in.sin_port)
318 return 1;
319 else if (sock->family == WS_AF_INET6 && addr->addr.sa_family == AF_INET6 && addr->in6.sin6_port)
320 return 1;
321
322 return 0;
323 }
324
325 static int is_any_addr( const union unix_sockaddr *addr )
326 {
327 if (addr->addr.sa_family == AF_INET && addr->in.sin_addr.s_addr == htonl( INADDR_ANY ))
328 return 1;
329 if (addr->addr.sa_family == AF_INET6 && IN6_IS_ADDR_UNSPECIFIED(&addr->in6.sin6_addr))
330 return 1;
331 return 0;
332 }
333
334 static int check_addr_usage( struct sock *sock, const union unix_sockaddr *addr, int v6only )
335 {
336 struct bound_addr *bound_addr, search_addr;
337 struct rb_entry *entry;
338
339 if (!should_track_conflicts_for_addr( sock, addr )) return 0;
340
341 search_addr.addr = *addr;
342 search_addr.match_any_addr = sock->exclusiveaddruse && is_any_addr( addr );
343
344 if ((entry = rb_get( &bound_addresses_tree, &search_addr )))
345 {
346 bound_addr = WINE_RB_ENTRY_VALUE(entry, struct bound_addr, entry);
347 if (bound_addr->reuse_count == -1 || !sock->reuseaddr)
348 {
349 set_error( sock->reuseaddr || bound_addr->match_any_addr
350 ? STATUS_ACCESS_DENIED : STATUS_SHARING_VIOLATION );
351 return 1;
352 }
353 }
354
355 if (sock->family != WS_AF_INET6 || v6only) return 0;
356 if (!ipv4addr_from_v6( &search_addr.addr, &addr->in6, sock->exclusiveaddruse )) return 0;
357
358 search_addr.match_any_addr = sock->exclusiveaddruse && is_any_addr( &search_addr.addr );
359 if ((entry = rb_get( &bound_addresses_tree, &search_addr )))
360 {
361 bound_addr = WINE_RB_ENTRY_VALUE(entry, struct bound_addr, entry);
362 if (bound_addr->reuse_count == -1 || !sock->reuseaddr)
363 {
364 set_error( sock->reuseaddr || bound_addr->match_any_addr
365 ? STATUS_ACCESS_DENIED : STATUS_SHARING_VIOLATION );
366 return 1;
367 }
368 }
369 return 0;
370 }
371
372 static struct bound_addr *register_bound_address( struct sock *sock, const union unix_sockaddr *addr )
373 {
374 struct bound_addr *bound_addr, *temp;
375
376 if (!(bound_addr = mem_alloc( sizeof(*bound_addr) )))
377 return NULL;
378
379 bound_addr->addr = *addr;
380 bound_addr->match_any_addr = sock->exclusiveaddruse && is_any_addr( addr );
381
382 if (rb_put( &bound_addresses_tree, bound_addr, &bound_addr->entry ))
383 {
384 temp = bound_addr;
385 bound_addr = WINE_RB_ENTRY_VALUE(rb_get( &bound_addresses_tree, temp ), struct bound_addr, entry);
386 free( temp );
387 if (bound_addr->reuse_count == -1)
388 {
389 if (debug_level)
390 fprintf( stderr, "register_bound_address: address being updated is already exclusively bound\n" );
391 return NULL;
392 }
393 ++bound_addr->reuse_count;
394 }
395 else
396 {
397 bound_addr->reuse_count = sock->reuseaddr ? 1 : -1;
398 }
399 return bound_addr;
400 }
401
402 static void update_addr_usage( struct sock *sock, const union unix_sockaddr *addr, int v6only )
403 {
404 union unix_sockaddr v4addr;
405
406 assert( !sock->bound_addr[0] && !sock->bound_addr[1] );
407
408 if (!should_track_conflicts_for_addr( sock, addr )) return;
409
410 sock->bound_addr[0] = register_bound_address( sock, addr );
411
412 if (sock->family != WS_AF_INET6 || v6only) return;
413
414 if (!ipv4addr_from_v6( &v4addr, &addr->in6, sock->exclusiveaddruse )) return;
415
416 sock->bound_addr[1] = register_bound_address( sock, &v4addr );
417 }
418
419 static void sock_dump( struct object *obj, int verbose );
420 static struct fd *sock_get_fd( struct object *obj );
421 static int sock_close_handle( struct object *obj, struct process *process, obj_handle_t handle );
422 static void sock_destroy( struct object *obj );
423 static struct object *sock_get_ifchange( struct sock *sock );
424 static void sock_release_ifchange( struct sock *sock );
425
426 static int sock_get_poll_events( struct fd *fd );
427 static void sock_poll_event( struct fd *fd, int event );
428 static enum server_fd_type sock_get_fd_type( struct fd *fd );
429 static void sock_ioctl( struct fd *fd, ioctl_code_t code, struct async *async );
430 static void sock_cancel_async( struct fd *fd, struct async *async );
431 static void sock_reselect_async( struct fd *fd, struct async_queue *queue );
432
433 static int accept_into_socket( struct sock *sock, struct sock *acceptsock );
434 static struct sock *accept_socket( struct sock *sock );
435 static int sock_get_ntstatus( int err );
436 static unsigned int sock_get_error( int err );
437 static void poll_socket( struct sock *poll_sock, struct async *async, int exclusive, timeout_t timeout,
438 unsigned int count, const struct afd_poll_socket_64 *sockets );
439
440 static const struct object_ops sock_ops =
441 {
442 sizeof(struct sock), /* size */
443 &file_type, /* type */
444 sock_dump, /* dump */
445 add_queue, /* add_queue */
446 remove_queue, /* remove_queue */
447 default_fd_signaled, /* signaled */
448 no_satisfied, /* satisfied */
449 no_signal, /* signal */
450 sock_get_fd, /* get_fd */
451 default_map_access, /* map_access */
452 default_get_sd, /* get_sd */
453 default_set_sd, /* set_sd */
454 no_get_full_name, /* get_full_name */
455 no_lookup_name, /* lookup_name */
456 no_link_name, /* link_name */
457 NULL, /* unlink_name */
458 no_open_file, /* open_file */
459 no_kernel_obj_list, /* get_kernel_obj_list */
460 sock_close_handle, /* close_handle */
461 sock_destroy /* destroy */
462 };
463
464 static const struct fd_ops sock_fd_ops =
465 {
466 sock_get_poll_events, /* get_poll_events */
467 sock_poll_event, /* poll_event */
468 sock_get_fd_type, /* get_fd_type */
469 no_fd_read, /* read */
470 no_fd_write, /* write */
471 no_fd_flush, /* flush */
472 default_fd_get_file_info, /* get_file_info */
473 no_fd_get_volume_info, /* get_volume_info */
474 sock_ioctl, /* ioctl */
475 sock_cancel_async, /* cancel_async */
476 no_fd_queue_async, /* queue_async */
477 sock_reselect_async /* reselect_async */
478 };
479
480 static int sockaddr_from_unix( const union unix_sockaddr *uaddr, struct WS_sockaddr *wsaddr, socklen_t wsaddrlen )
481 {
482 memset( wsaddr, 0, wsaddrlen );
483
484 switch (uaddr->addr.sa_family)
485 {
486 case AF_INET:
487 {
488 struct WS_sockaddr_in win = {0};
489
490 if (wsaddrlen < sizeof(win)) return -1;
491 win.sin_family = WS_AF_INET;
492 win.sin_port = uaddr->in.sin_port;
493 memcpy( &win.sin_addr, &uaddr->in.sin_addr, sizeof(win.sin_addr) );
494 memcpy( wsaddr, &win, sizeof(win) );
495 return sizeof(win);
496 }
497
498 case AF_INET6:
499 {
500 struct WS_sockaddr_in6 win = {0};
501
502 if (wsaddrlen < sizeof(win)) return -1;
503 win.sin6_family = WS_AF_INET6;
504 win.sin6_port = uaddr->in6.sin6_port;
505 win.sin6_flowinfo = uaddr->in6.sin6_flowinfo;
506 memcpy( &win.sin6_addr, &uaddr->in6.sin6_addr, sizeof(win.sin6_addr) );
507 #ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID
508 win.sin6_scope_id = uaddr->in6.sin6_scope_id;
509 #endif
510 memcpy( wsaddr, &win, sizeof(win) );
511 return sizeof(win);
512 }
513
514 #ifdef HAS_IPX
515 case AF_IPX:
516 {
517 struct WS_sockaddr_ipx win = {0};
518
519 if (wsaddrlen < sizeof(win)) return -1;
520 win.sa_family = WS_AF_IPX;
521 memcpy( win.sa_netnum, &uaddr->ipx.sipx_network, sizeof(win.sa_netnum) );
522 memcpy( win.sa_nodenum, &uaddr->ipx.sipx_node, sizeof(win.sa_nodenum) );
523 win.sa_socket = uaddr->ipx.sipx_port;
524 memcpy( wsaddr, &win, sizeof(win) );
525 return sizeof(win);
526 }
527 #endif
528
529 #ifdef HAS_IRDA
530 case AF_IRDA:
531 {
532 SOCKADDR_IRDA win;
533
534 if (wsaddrlen < sizeof(win)) return -1;
535 win.irdaAddressFamily = WS_AF_IRDA;
536 memcpy( win.irdaDeviceID, &uaddr->irda.sir_addr, sizeof(win.irdaDeviceID) );
537 if (uaddr->irda.sir_lsap_sel != LSAP_ANY)
538 snprintf( win.irdaServiceName, sizeof(win.irdaServiceName), "LSAP-SEL%u", uaddr->irda.sir_lsap_sel );
539 else
540 memcpy( win.irdaServiceName, uaddr->irda.sir_name, sizeof(win.irdaServiceName) );
541 memcpy( wsaddr, &win, sizeof(win) );
542 return sizeof(win);
543 }
544 #endif
545
546 case AF_UNSPEC:
547 return 0;
548
549 default:
550 return -1;
551
552 }
553 }
554
555 static socklen_t sockaddr_to_unix( const struct WS_sockaddr *wsaddr, int wsaddrlen, union unix_sockaddr *uaddr )
556 {
557 memset( uaddr, 0, sizeof(*uaddr) );
558
559 switch (wsaddr->sa_family)
560 {
561 case WS_AF_INET:
562 {
563 struct WS_sockaddr_in win = {0};
564
565 if (wsaddrlen < sizeof(win)) return 0;
566 memcpy( &win, wsaddr, sizeof(win) );
567 uaddr->in.sin_family = AF_INET;
568 uaddr->in.sin_port = win.sin_port;
569 memcpy( &uaddr->in.sin_addr, &win.sin_addr, sizeof(win.sin_addr) );
570 return sizeof(uaddr->in);
571 }
572
573 case WS_AF_INET6:
574 {
575 struct WS_sockaddr_in6 win = {0};
576
577 if (wsaddrlen < sizeof(win)) return 0;
578 memcpy( &win, wsaddr, sizeof(win) );
579 uaddr->in6.sin6_family = AF_INET6;
580 uaddr->in6.sin6_port = win.sin6_port;
581 uaddr->in6.sin6_flowinfo = win.sin6_flowinfo;
582 memcpy( &uaddr->in6.sin6_addr, &win.sin6_addr, sizeof(win.sin6_addr) );
583 #ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID
584 uaddr->in6.sin6_scope_id = win.sin6_scope_id;
585 #endif
586 return sizeof(uaddr->in6);
587 }
588
589 #ifdef HAS_IPX
590 case WS_AF_IPX:
591 {
592 struct WS_sockaddr_ipx win = {0};
593
594 if (wsaddrlen < sizeof(win)) return 0;
595 memcpy( &win, wsaddr, sizeof(win) );
596 uaddr->ipx.sipx_family = AF_IPX;
597 memcpy( &uaddr->ipx.sipx_network, win.sa_netnum, sizeof(win.sa_netnum) );
598 memcpy( &uaddr->ipx.sipx_node, win.sa_nodenum, sizeof(win.sa_nodenum) );
599 uaddr->ipx.sipx_port = win.sa_socket;
600 return sizeof(uaddr->ipx);
601 }
602 #endif
603
604 #ifdef HAS_IRDA
605 case WS_AF_IRDA:
606 {
607 SOCKADDR_IRDA win = {0};
608 unsigned int lsap_sel;
609
610 if (wsaddrlen < sizeof(win)) return 0;
611 memcpy( &win, wsaddr, sizeof(win) );
612 uaddr->irda.sir_family = AF_IRDA;
613 if (sscanf( win.irdaServiceName, "LSAP-SEL%u", &lsap_sel ) == 1)
614 uaddr->irda.sir_lsap_sel = lsap_sel;
615 else
616 {
617 uaddr->irda.sir_lsap_sel = LSAP_ANY;
618 memcpy( uaddr->irda.sir_name, win.irdaServiceName, sizeof(win.irdaServiceName) );
619 }
620 memcpy( &uaddr->irda.sir_addr, win.irdaDeviceID, sizeof(win.irdaDeviceID) );
621 return sizeof(uaddr->irda);
622 }
623 #endif
624
625 case WS_AF_UNSPEC:
626 switch (wsaddrlen)
627 {
628 default: /* likely an ipv4 address */
629 case sizeof(struct WS_sockaddr_in):
630 return sizeof(uaddr->in);
631
632 #ifdef HAS_IPX
633 case sizeof(struct WS_sockaddr_ipx):
634 return sizeof(uaddr->ipx);
635 #endif
636
637 #ifdef HAS_IRDA
638 case sizeof(SOCKADDR_IRDA):
639 return sizeof(uaddr->irda);
640 #endif
641
642 case sizeof(struct WS_sockaddr_in6):
643 return sizeof(uaddr->in6);
644 }
645
646 default:
647 return 0;
648 }
649 }
650
651 static socklen_t get_unix_sockaddr_any( union unix_sockaddr *uaddr, int ws_family )
652 {
653 memset( uaddr, 0, sizeof(*uaddr) );
654 switch (ws_family)
655 {
656 case WS_AF_INET:
657 uaddr->in.sin_family = AF_INET;
658 return sizeof(uaddr->in);
659 case WS_AF_INET6:
660 uaddr->in6.sin6_family = AF_INET6;
661 return sizeof(uaddr->in6);
662 #ifdef HAS_IPX
663 case WS_AF_IPX:
664 uaddr->ipx.sipx_family = AF_IPX;
665 return sizeof(uaddr->ipx);
666 #endif
667 #ifdef HAS_IRDA
668 case WS_AF_IRDA:
669 uaddr->irda.sir_family = AF_IRDA;
670 return sizeof(uaddr->irda);
671 #endif
672 default:
673 return 0;
674 }
675 }
676
677 /* some events are generated at the same time but must be sent in a particular
678 * order (e.g. CONNECT must be sent before READ) */
679 static const enum afd_poll_bit event_bitorder[] =
680 {
681 AFD_POLL_BIT_CONNECT,
682 AFD_POLL_BIT_CONNECT_ERR,
683 AFD_POLL_BIT_ACCEPT,
684 AFD_POLL_BIT_OOB,
685 AFD_POLL_BIT_READ,
686 AFD_POLL_BIT_WRITE,
687 AFD_POLL_BIT_RESET,
688 AFD_POLL_BIT_HUP,
689 AFD_POLL_BIT_CLOSE,
690 };
691
692 typedef enum {
693 SOCK_SHUTDOWN_ERROR = -1,
694 SOCK_SHUTDOWN_EOF = 0,
695 SOCK_SHUTDOWN_POLLHUP = 1
696 } sock_shutdown_t;
697
698 static sock_shutdown_t sock_shutdown_type = SOCK_SHUTDOWN_ERROR;
699
700 static sock_shutdown_t sock_check_pollhup(void)
701 {
702 sock_shutdown_t ret = SOCK_SHUTDOWN_ERROR;
703 int fd[2], n;
704 struct pollfd pfd;
705 char dummy;
706
707 if ( socketpair( AF_UNIX, SOCK_STREAM, 0, fd ) ) return ret;
708 if ( shutdown( fd[0], 1 ) ) goto out;
709
710 pfd.fd = fd[1];
711 pfd.events = POLLIN;
712 pfd.revents = 0;
713
714 /* Solaris' poll() sometimes returns nothing if given a 0ms timeout here */
715 n = poll( &pfd, 1, 1 );
716 if ( n != 1 ) goto out; /* error or timeout */
717 if ( pfd.revents & POLLHUP )
718 ret = SOCK_SHUTDOWN_POLLHUP;
719 else if ( pfd.revents & POLLIN &&
720 read( fd[1], &dummy, 1 ) == 0 )
721 ret = SOCK_SHUTDOWN_EOF;
722
723 out:
724 close( fd[0] );
725 close( fd[1] );
726 return ret;
727 }
728
729 void sock_init(void)
730 {
731 sock_shutdown_type = sock_check_pollhup();
732
733 switch ( sock_shutdown_type )
734 {
735 case SOCK_SHUTDOWN_EOF:
736 if (debug_level) fprintf( stderr, "sock_init: shutdown() causes EOF\n" );
737 break;
738 case SOCK_SHUTDOWN_POLLHUP:
739 if (debug_level) fprintf( stderr, "sock_init: shutdown() causes POLLHUP\n" );
740 break;
741 default:
742 fprintf( stderr, "sock_init: ERROR in sock_check_pollhup()\n" );
743 sock_shutdown_type = SOCK_SHUTDOWN_EOF;
744 }
745 }
746
747 static void sock_reselect( struct sock *sock )
748 {
749 int ev = sock_get_poll_events( sock->fd );
750
751 if (debug_level)
752 fprintf(stderr,"sock_reselect(%p): new mask %x\n", sock, ev);
753
754 set_fd_events( sock->fd, ev );
755 }
756
757 static unsigned int afd_poll_flag_to_win32( unsigned int flags )
758 {
759 static const unsigned int map[] =
760 {
761 FD_READ, /* READ */
762 FD_OOB, /* OOB */
763 FD_WRITE, /* WRITE */
764 FD_CLOSE, /* HUP */
765 FD_CLOSE, /* RESET */
766 0, /* CLOSE */
767 FD_CONNECT, /* CONNECT */
768 FD_ACCEPT, /* ACCEPT */
769 FD_CONNECT, /* CONNECT_ERR */
770 };
771
772 unsigned int i, ret = 0;
773
774 for (i = 0; i < ARRAY_SIZE(map); ++i)
775 {
776 if (flags & (1 << i)) ret |= map[i];
777 }
778
779 return ret;
780 }
781
782 /* wake anybody waiting on the socket event or send the associated message */
783 static void sock_wake_up( struct sock *sock )
784 {
785 unsigned int events = sock->pending_events & sock->mask;
786 int i;
787
788 if (sock->event)
789 {
790 if (debug_level) fprintf(stderr, "signalling events %x ptr %p\n", events, sock->event );
791 if (events)
792 set_event( sock->event );
793 }
794 if (sock->window)
795 {
796 if (debug_level) fprintf(stderr, "signalling events %x win %08x\n", events, sock->window );
797 for (i = 0; i < ARRAY_SIZE(event_bitorder); i++)
798 {
799 enum afd_poll_bit event = event_bitorder[i];
800 if (events & (1 << event))
801 {
802 lparam_t lparam = afd_poll_flag_to_win32(1 << event) | (sock_get_error( sock->errors[event] ) << 16);
803 post_message( sock->window, sock->message, sock->wparam, lparam );
804 }
805 }
806 sock->pending_events = 0;
807 sock_reselect( sock );
808 }
809 }
810
811 static inline int sock_error( struct sock *sock )
812 {
813 int error = 0;
814 socklen_t len = sizeof(error);
815
816 getsockopt( get_unix_fd(sock->fd), SOL_SOCKET, SO_ERROR, (void *)&error, &len);
817
818 switch (sock->state)
819 {
820 case SOCK_UNCONNECTED:
821 break;
822
823 case SOCK_CONNECTING:
824 if (error)
825 sock->errors[AFD_POLL_BIT_CONNECT_ERR] = error;
826 else
827 error = sock->errors[AFD_POLL_BIT_CONNECT_ERR];
828 break;
829
830 case SOCK_LISTENING:
831 if (error)
832 sock->errors[AFD_POLL_BIT_ACCEPT] = error;
833 else
834 error = sock->errors[AFD_POLL_BIT_ACCEPT];
835 break;
836
837 case SOCK_CONNECTED:
838 case SOCK_CONNECTIONLESS:
839 if (error == ECONNRESET || error == EPIPE)
840 {
841 sock->reset = 1;
842 error = 0;
843 }
844 else if (error)
845 sock->errors[AFD_POLL_BIT_HUP] = error;
846 else
847 error = sock->errors[AFD_POLL_BIT_HUP];
848 break;
849 }
850
851 return error;
852 }
853
854 static void free_accept_req( void *private )
855 {
856 struct accept_req *req = private;
857 list_remove( &req->entry );
858 if (req->acceptsock)
859 {
860 req->acceptsock->accept_recv_req = NULL;
861 release_object( req->acceptsock );
862 }
863 release_object( req->async );
864 release_object( req->iosb );
865 release_object( req->sock );
866 free( req );
867 }
868
869 static void fill_accept_output( struct accept_req *req )
870 {
871 const data_size_t out_size = req->iosb->out_size;
872 struct async *async = req->async;
873 union unix_sockaddr unix_addr;
874 struct WS_sockaddr *win_addr;
875 unsigned int remote_len;
876 socklen_t unix_len;
877 int fd, size = 0;
878 char *out_data;
879 int win_len;
880
881 if (!(out_data = mem_alloc( out_size )))
882 {
883 async_terminate( async, get_error() );
884 return;
885 }
886
887 fd = get_unix_fd( req->acceptsock->fd );
888
889 if (req->recv_len && (size = recv( fd, out_data, req->recv_len, 0 )) < 0)
890 {
891 if (!req->accepted && errno == EWOULDBLOCK)
892 {
893 req->accepted = 1;
894 sock_reselect( req->acceptsock );
895 return;
896 }
897
898 async_terminate( async, sock_get_ntstatus( errno ) );
899 free( out_data );
900 return;
901 }
902
903 if (req->local_len)
904 {
905 if (req->local_len < sizeof(int))
906 {
907 async_terminate( async, STATUS_BUFFER_TOO_SMALL );
908 free( out_data );
909 return;
910 }
911
912 unix_len = sizeof(unix_addr);
913 win_addr = (struct WS_sockaddr *)(out_data + req->recv_len + sizeof(int));
914 if (getsockname( fd, &unix_addr.addr, &unix_len ) < 0 ||
915 (win_len = sockaddr_from_unix( &unix_addr, win_addr, req->local_len - sizeof(int) )) < 0)
916 {
917 async_terminate( async, sock_get_ntstatus( errno ) );
918 free( out_data );
919 return;
920 }
921 memcpy( out_data + req->recv_len, &win_len, sizeof(int) );
922 }
923
924 unix_len = sizeof(unix_addr);
925 win_addr = (struct WS_sockaddr *)(out_data + req->recv_len + req->local_len + sizeof(int));
926 remote_len = out_size - req->recv_len - req->local_len;
927 if (getpeername( fd, &unix_addr.addr, &unix_len ) < 0 ||
928 (win_len = sockaddr_from_unix( &unix_addr, win_addr, remote_len - sizeof(int) )) < 0)
929 {
930 async_terminate( async, sock_get_ntstatus( errno ) );
931 free( out_data );
932 return;
933 }
934 memcpy( out_data + req->recv_len + req->local_len, &win_len, sizeof(int) );
935
936 async_request_complete( req->async, STATUS_SUCCESS, size, out_size, out_data );
937 }
938
939 static void complete_async_accept( struct sock *sock, struct accept_req *req )
940 {
941 struct sock *acceptsock = req->acceptsock;
942 struct async *async = req->async;
943
944 if (debug_level) fprintf( stderr, "completing accept request for socket %p\n", sock );
945
946 if (acceptsock)
947 {
948 if (!accept_into_socket( sock, acceptsock ))
949 {
950 async_terminate( async, get_error() );
951 return;
952 }
953 fill_accept_output( req );
954 }
955 else
956 {
957 obj_handle_t handle;
958
959 if (!(acceptsock = accept_socket( sock )))
960 {
961 async_terminate( async, get_error() );
962 return;
963 }
964 handle = alloc_handle_no_access_check( async_get_thread( async )->process, &acceptsock->obj,
965 GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE, OBJ_INHERIT );
966 acceptsock->wparam = handle;
967 sock_reselect( acceptsock );
968 release_object( acceptsock );
969 if (!handle)
970 {
971 async_terminate( async, get_error() );
972 return;
973 }
974
975 async_request_complete_alloc( req->async, STATUS_SUCCESS, 0, sizeof(handle), &handle );
976 }
977 }
978
979 static void complete_async_accept_recv( struct accept_req *req )
980 {
981 if (debug_level) fprintf( stderr, "completing accept recv request for socket %p\n", req->acceptsock );
982
983 assert( req->recv_len );
984
985 fill_accept_output( req );
986 }
987
988 static void free_connect_req( void *private )
989 {
990 struct connect_req *req = private;
991
992 req->sock->connect_req = NULL;
993 release_object( req->async );
994 release_object( req->iosb );
995 release_object( req->sock );
996 free( req );
997 }
998
999 static void complete_async_connect( struct sock *sock )
1000 {
1001 struct connect_req *req = sock->connect_req;
1002 const char *in_buffer;
1003 size_t len;
1004 int ret;
1005
1006 if (debug_level) fprintf( stderr, "completing connect request for socket %p\n", sock );
1007
1008 if (!req->send_len)
1009 {
1010 async_terminate( req->async, STATUS_SUCCESS );
1011 return;
1012 }
1013
1014 in_buffer = (const char *)req->iosb->in_data + sizeof(struct afd_connect_params) + req->addr_len;
1015 len = req->send_len - req->send_cursor;
1016
1017 ret = send( get_unix_fd( sock->fd ), in_buffer + req->send_cursor, len, 0 );
1018 if (ret < 0 && errno != EWOULDBLOCK)
1019 async_terminate( req->async, sock_get_ntstatus( errno ) );
1020 else if (ret == len)
1021 async_request_complete( req->async, STATUS_SUCCESS, req->send_len, 0, NULL );
1022 else
1023 req->send_cursor += ret;
1024 }
1025
1026 static void free_poll_req( void *private )
1027 {
1028 struct poll_req *req = private;
1029 unsigned int i;
1030
1031 if (req->timeout) remove_timeout_user( req->timeout );
1032
1033 for (i = 0; i < req->count; ++i)
1034 release_object( req->sockets[i].sock );
1035 release_object( req->async );
1036 release_object( req->iosb );
1037 list_remove( &req->entry );
1038 free( req );
1039 }
1040
1041 static int is_oobinline( struct sock *sock )
1042 {
1043 int oobinline;
1044 socklen_t len = sizeof(oobinline);
1045 return !getsockopt( get_unix_fd( sock->fd ), SOL_SOCKET, SO_OOBINLINE, (char *)&oobinline, &len ) && oobinline;
1046 }
1047
1048 static int get_poll_flags( struct sock *sock, int event )
1049 {
1050 int flags = 0;
1051
1052 /* A connection-mode socket which has never been connected does not return
1053 * write or hangup events, but Linux reports POLLOUT | POLLHUP. */
1054 if (sock->state == SOCK_UNCONNECTED)
1055 event &= ~(POLLOUT | POLLHUP);
1056
1057 if (event & POLLIN)
1058 {
1059 if (sock->state == SOCK_LISTENING)
1060 flags |= AFD_POLL_ACCEPT;
1061 else
1062 flags |= AFD_POLL_READ;
1063 }
1064 if (event & POLLPRI)
1065 flags |= is_oobinline( sock ) ? AFD_POLL_READ : AFD_POLL_OOB;
1066 if (event & POLLOUT)
1067 flags |= AFD_POLL_WRITE;
1068 if (sock->state == SOCK_CONNECTED)
1069 flags |= AFD_POLL_CONNECT;
1070 if (event & POLLHUP)
1071 flags |= AFD_POLL_HUP;
1072 if (event & POLLERR)
1073 flags |= AFD_POLL_CONNECT_ERR;
1074 if (sock->reset)
1075 flags |= AFD_POLL_RESET;
1076
1077 return flags;
1078 }
1079
1080 static void complete_async_poll( struct poll_req *req, unsigned int status )
1081 {
1082 unsigned int i, signaled_count = 0;
1083
1084 for (i = 0; i < req->count; ++i)
1085 {
1086 struct sock *sock = req->sockets[i].sock;
1087
1088 if (sock->main_poll == req)
1089 sock->main_poll = NULL;
1090 }
1091
1092 if (!status)
1093 {
1094 for (i = 0; i < req->count; ++i)
1095 {
1096 if (req->sockets[i].flags)
1097 ++signaled_count;
1098 }
1099 }
1100
1101 if (is_machine_64bit( async_get_thread( req->async )->process->machine ))
1102 {
1103 size_t output_size = offsetof( struct afd_poll_params_64, sockets[signaled_count] );
1104 struct afd_poll_params_64 *output;
1105
1106 if (!(output = mem_alloc( output_size )))
1107 {
1108 async_terminate( req->async, get_error() );
1109 return;
1110 }
1111 memset( output, 0, output_size );
1112 output->timeout = req->orig_timeout;
1113 output->exclusive = req->exclusive;
1114 for (i = 0; i < req->count; ++i)
1115 {
1116 if (!req->sockets[i].flags) continue;
1117 output->sockets[output->count].socket = req->sockets[i].handle;
1118 output->sockets[output->count].flags = req->sockets[i].flags;
1119 output->sockets[output->count].status = req->sockets[i].status;
1120 ++output->count;
1121 }
1122 assert( output->count == signaled_count );
1123
1124 async_request_complete( req->async, status, output_size, output_size, output );
1125 }
1126 else
1127 {
1128 size_t output_size = offsetof( struct afd_poll_params_32, sockets[signaled_count] );
1129 struct afd_poll_params_32 *output;
1130
1131 if (!(output = mem_alloc( output_size )))
1132 {
1133 async_terminate( req->async, get_error() );
1134 return;
1135 }
1136 memset( output, 0, output_size );
1137 output->timeout = req->orig_timeout;
1138 output->exclusive = req->exclusive;
1139 for (i = 0; i < req->count; ++i)
1140 {
1141 if (!req->sockets[i].flags) continue;
1142 output->sockets[output->count].socket = req->sockets[i].handle;
1143 output->sockets[output->count].flags = req->sockets[i].flags;
1144 output->sockets[output->count].status = req->sockets[i].status;
1145 ++output->count;
1146 }
1147 assert( output->count == signaled_count );
1148
1149 async_request_complete( req->async, status, output_size, output_size, output );
1150 }
1151 }
1152
1153 static void complete_async_polls( struct sock *sock, int event, int error )
1154 {
1155 int flags = get_poll_flags( sock, event );
1156 struct poll_req *req, *next;
1157
1158 LIST_FOR_EACH_ENTRY_SAFE( req, next, &poll_list, struct poll_req, entry )
1159 {
1160 unsigned int i;
1161
1162 if (req->iosb->status != STATUS_PENDING) continue;
1163
1164 for (i = 0; i < req->count; ++i)
1165 {
1166 if (req->sockets[i].sock != sock) continue;
1167 if (!(req->sockets[i].mask & flags)) continue;
1168
1169 if (debug_level)
1170 fprintf( stderr, "completing poll for socket %p, wanted %#x got %#x\n",
1171 sock, req->sockets[i].mask, flags );
1172
1173 req->sockets[i].flags = req->sockets[i].mask & flags;
1174 req->sockets[i].status = sock_get_ntstatus( error );
1175
1176 if (req->pending)
1177 {
1178 complete_async_poll( req, STATUS_SUCCESS );
1179 break;
1180 }
1181 }
1182 }
1183 }
1184
1185 static void async_poll_timeout( void *private )
1186 {
1187 struct poll_req *req = private;
1188
1189 req->timeout = NULL;
1190
1191 if (req->iosb->status != STATUS_PENDING) return;
1192
1193 complete_async_poll( req, STATUS_TIMEOUT );
1194 }
1195
1196 static int sock_dispatch_asyncs( struct sock *sock, int event, int error )
1197 {
1198 if (event & (POLLIN | POLLPRI))
1199 {
1200 struct accept_req *req;
1201
1202 LIST_FOR_EACH_ENTRY( req, &sock->accept_list, struct accept_req, entry )
1203 {
1204 if (req->iosb->status == STATUS_PENDING && !req->accepted)
1205 {
1206 complete_async_accept( sock, req );
1207 event &= ~POLLIN;
1208 break;
1209 }
1210 }
1211
1212 if (sock->accept_recv_req && sock->accept_recv_req->iosb->status == STATUS_PENDING)
1213 complete_async_accept_recv( sock->accept_recv_req );
1214 }
1215
1216 if ((event & POLLOUT) && sock->connect_req && sock->connect_req->iosb->status == STATUS_PENDING)
1217 complete_async_connect( sock );
1218
1219 if ((event & (POLLIN | POLLPRI)) && async_queued( &sock->read_q ))
1220 {
1221 if (async_waiting( &sock->read_q ))
1222 {
1223 if (debug_level) fprintf( stderr, "activating read queue for socket %p\n", sock );
1224 async_wake_up( &sock->read_q, STATUS_ALERTED );
1225 }
1226 event &= ~(POLLIN | POLLPRI);
1227 }
1228
1229 if ((event & POLLOUT) && async_queued( &sock->write_q ))
1230 {
1231 if (async_waiting( &sock->write_q ))
1232 {
1233 if (debug_level) fprintf( stderr, "activating write queue for socket %p\n", sock );
1234 async_wake_up( &sock->write_q, STATUS_ALERTED );
1235 }
1236 event &= ~POLLOUT;
1237 }
1238
1239 if (event & (POLLERR | POLLHUP))
1240 {
1241 int status = sock_get_ntstatus( error );
1242 struct accept_req *req, *next;
1243
1244 async_wake_up( &sock->read_q, status );
1245 async_wake_up( &sock->write_q, status );
1246
1247 LIST_FOR_EACH_ENTRY_SAFE( req, next, &sock->accept_list, struct accept_req, entry )
1248 {
1249 if (req->iosb->status == STATUS_PENDING)
1250 async_terminate( req->async, status );
1251 }
1252
1253 if (sock->accept_recv_req && sock->accept_recv_req->iosb->status == STATUS_PENDING)
1254 async_terminate( sock->accept_recv_req->async, status );
1255
1256 if (sock->connect_req)
1257 async_terminate( sock->connect_req->async, status );
1258 }
1259
1260 if (sock->reset)
1261 {
1262 async_wake_up( &sock->read_q, STATUS_CONNECTION_RESET );
1263 async_wake_up( &sock->write_q, STATUS_CONNECTION_RESET );
1264
1265 if (sock->accept_recv_req && sock->accept_recv_req->iosb->status == STATUS_PENDING)
1266 async_terminate( sock->accept_recv_req->async, STATUS_CONNECTION_RESET );
1267 }
1268
1269 return event;
1270 }
1271
1272 static void post_socket_event( struct sock *sock, enum afd_poll_bit event_bit )
1273 {
1274 unsigned int event = (1 << event_bit);
1275
1276 if (!(sock->reported_events & event))
1277 {
1278 sock->pending_events |= event;
1279 sock->reported_events |= event;
1280 }
1281 }
1282
1283 static void sock_dispatch_events( struct sock *sock, enum connection_state prevstate, int event )
1284 {
1285 switch (prevstate)
1286 {
1287 case SOCK_UNCONNECTED:
1288 break;
1289
1290 case SOCK_CONNECTING:
1291 if (event & POLLOUT)
1292 post_socket_event( sock, AFD_POLL_BIT_CONNECT );
1293 if (event & (POLLERR | POLLHUP))
1294 post_socket_event( sock, AFD_POLL_BIT_CONNECT_ERR );
1295 break;
1296
1297 case SOCK_LISTENING:
1298 if (event & (POLLIN | POLLERR | POLLHUP))
1299 post_socket_event( sock, AFD_POLL_BIT_ACCEPT );
1300 break;
1301
1302 case SOCK_CONNECTED:
1303 case SOCK_CONNECTIONLESS:
1304 if (sock->reset)
1305 post_socket_event( sock, AFD_POLL_BIT_RESET );
1306
1307 if (event & POLLIN)
1308 post_socket_event( sock, AFD_POLL_BIT_READ );
1309
1310 if (event & POLLOUT)
1311 post_socket_event( sock, AFD_POLL_BIT_WRITE );
1312
1313 if (event & POLLPRI)
1314 post_socket_event( sock, AFD_POLL_BIT_OOB );
1315
1316 if (event & (POLLERR | POLLHUP))
1317 post_socket_event( sock, AFD_POLL_BIT_HUP );
1318 break;
1319 }
1320
1321 sock_wake_up( sock );
1322 }
1323
1324 static void sock_poll_event( struct fd *fd, int event )
1325 {
1326 struct sock *sock = get_fd_user( fd );
1327 int hangup_seen = 0;
1328 enum connection_state prevstate = sock->state;
1329 int error = 0;
1330
1331 assert( sock->obj.ops == &sock_ops );
1332 if (debug_level)
1333 fprintf(stderr, "socket %p select event: %x\n", sock, event);
1334
1335 if (event & (POLLERR | POLLHUP))
1336 error = sock_error( sock );
1337
1338 switch (sock->state)
1339 {
1340 case SOCK_UNCONNECTED:
1341 break;
1342
1343 case SOCK_CONNECTING:
1344 if (event & (POLLERR|POLLHUP))
1345 {
1346 sock->state = SOCK_UNCONNECTED;
1347 event &= ~POLLOUT;
1348 }
1349 else if (event & POLLOUT)
1350 {
1351 sock->state = SOCK_CONNECTED;
1352 sock->connect_time = current_time;
1353 sock->errors[AFD_POLL_BIT_CONNECT_ERR] = 0;
1354 }
1355 break;
1356
1357 case SOCK_LISTENING:
1358 break;
1359
1360 case SOCK_CONNECTED:
1361 case SOCK_CONNECTIONLESS:
1362 if (sock->reset)
1363 event &= ~(POLLIN | POLLERR | POLLHUP);
1364
1365 if (sock->type == WS_SOCK_STREAM && (event & POLLIN))
1366 {
1367 char dummy;
1368 int nr;
1369
1370 /* Linux 2.4 doesn't report POLLHUP if only one side of the socket
1371 * has been closed, so we need to check for it explicitly here */
1372 nr = recv( get_unix_fd( fd ), &dummy, 1, MSG_PEEK );
1373 if ( nr == 0 )
1374 {
1375 hangup_seen = 1;
1376 event &= ~POLLIN;
1377 }
1378 else if ( nr < 0 )
1379 {
1380 event &= ~POLLIN;
1381 /* EAGAIN can happen if an async recv() falls between the server's poll()
1382 call and the invocation of this routine */
1383 if (errno == ECONNRESET || errno == EPIPE)
1384 {
1385 sock->reset = 1;
1386 }
1387 else if (errno != EAGAIN)
1388 {
1389 error = errno;
1390 event |= POLLERR;
1391 sock->errors[AFD_POLL_BIT_HUP] = error;
1392 if ( debug_level )
1393 fprintf( stderr, "recv error on socket %p: %d\n", sock, errno );
1394 }
1395 }
1396 }
1397
1398 if (hangup_seen || (sock_shutdown_type == SOCK_SHUTDOWN_POLLHUP && (event & POLLHUP)))
1399 {
1400 sock->hangup = 1;
1401 }
1402 else if (event & (POLLHUP | POLLERR))
1403 {
1404 sock->aborted = 1;
1405
1406 if (debug_level)
1407 fprintf( stderr, "socket %p aborted by error %d, event %#x\n", sock, error, event );
1408 }
1409
1410 if (hangup_seen)
1411 event |= POLLHUP;
1412 break;
1413 }
1414
1415 event = sock_dispatch_asyncs( sock, event, error );
1416 sock_dispatch_events( sock, prevstate, event );
1417 complete_async_polls( sock, event, error );
1418
1419 sock_reselect( sock );
1420 }
1421
1422 static void sock_dump( struct object *obj, int verbose )
1423 {
1424 struct sock *sock = (struct sock *)obj;
1425 assert( obj->ops == &sock_ops );
1426 fprintf( stderr, "Socket fd=%p, state=%x, mask=%x, pending=%x, reported=%x\n",
1427 sock->fd, sock->state,
1428 sock->mask, sock->pending_events, sock->reported_events );
1429 }
1430
1431 static int poll_flags_from_afd( struct sock *sock, int flags )
1432 {
1433 int ev = 0;
1434
1435 /* A connection-mode socket which has never been connected does
1436 * not return write or hangup events, but Linux returns
1437 * POLLOUT | POLLHUP. */
1438 if (sock->state == SOCK_UNCONNECTED)
1439 return -1;
1440
1441 if (flags & (AFD_POLL_READ | AFD_POLL_ACCEPT))
1442 ev |= POLLIN;
1443 if ((flags & AFD_POLL_HUP) && sock->type == WS_SOCK_STREAM)
1444 ev |= POLLIN;
1445 if (flags & AFD_POLL_OOB)
1446 ev |= is_oobinline( sock ) ? POLLIN : POLLPRI;
1447 if (flags & AFD_POLL_WRITE)
1448 ev |= POLLOUT;
1449
1450 return ev;
1451 }
1452
1453 static int sock_get_poll_events( struct fd *fd )
1454 {
1455 struct sock *sock = get_fd_user( fd );
1456 unsigned int mask = sock->mask & ~sock->reported_events;
1457 struct poll_req *req;
1458 int ev = 0;
1459
1460 assert( sock->obj.ops == &sock_ops );
1461
1462 if (!sock->type) /* not initialized yet */
1463 return -1;
1464
1465 LIST_FOR_EACH_ENTRY( req, &poll_list, struct poll_req, entry )
1466 {
1467 unsigned int i;
1468
1469 for (i = 0; i < req->count; ++i)
1470 {
1471 if (req->sockets[i].sock != sock) continue;
1472
1473 ev |= poll_flags_from_afd( sock, req->sockets[i].mask );
1474 }
1475 }
1476
1477 switch (sock->state)
1478 {
1479 case SOCK_UNCONNECTED:
1480 /* A connection-mode Windows socket which has never been connected does
1481 * not return any events, but Linux returns POLLOUT | POLLHUP. Hence we
1482 * need to return -1 here, to prevent the socket from being polled on at
1483 * all. */
1484 return -1;
1485
1486 case SOCK_CONNECTING:
1487 return POLLOUT;
1488
1489 case SOCK_LISTENING:
1490 if (!list_empty( &sock->accept_list ) || (mask & AFD_POLL_ACCEPT))
1491 ev |= POLLIN;
1492 break;
1493
1494 case SOCK_CONNECTED:
1495 case SOCK_CONNECTIONLESS:
1496 if (sock->hangup && sock->wr_shutdown && !sock->wr_shutdown_pending)
1497 {
1498 /* Linux returns POLLHUP if a socket is both SHUT_RD and SHUT_WR, or
1499 * if both the socket and its peer are SHUT_WR.
1500 *
1501 * We don't use SHUT_RD, so we can only encounter this in the latter
1502 * case. In that case there can't be any pending read requests (they
1503 * would have already been completed with a length of zero), the
1504 * above condition ensures that we don't have any pending write
1505 * requests, and nothing that can change about the socket state that
1506 * would complete a pending poll request. */
1507 return -1;
1508 }
1509
1510 if (sock->aborted || sock->reset)
1511 return -1;
1512
1513 if (sock->accept_recv_req)
1514 {
1515 ev |= POLLIN;
1516 }
1517 else if (async_queued( &sock->read_q ))
1518 {
1519 /* Clear POLLIN and POLLPRI if we have an alerted async, even if
1520 * we're polling this socket for READ or OOB. We can't signal the
1521 * poll if the pending async will read all of the data [cf. the
1522 * matching logic in sock_dispatch_asyncs()], but we also don't
1523 * want to spin polling for POLLIN if we're not going to use it. */
1524 if (async_waiting( &sock->read_q ))
1525 ev |= POLLIN | POLLPRI;
1526 else
1527 ev &= ~(POLLIN | POLLPRI);
1528 }
1529 else
1530 {
1531 /* Don't ask for POLLIN if we got a hangup. We won't receive more
1532 * data anyway, but we will get POLLIN if SOCK_SHUTDOWN_EOF. */
1533 if (!sock->hangup)
1534 {
1535 if (mask & AFD_POLL_READ)
1536 ev |= POLLIN;
1537 if (mask & AFD_POLL_OOB)
1538 ev |= POLLPRI;
1539 }
1540
1541 /* We use POLLIN with 0 bytes recv() as hangup indication for stream sockets. */
1542 if (sock->state == SOCK_CONNECTED && (mask & AFD_POLL_HUP) && !(sock->reported_events & AFD_POLL_READ))
1543 ev |= POLLIN;
1544 }
1545
1546 if (async_queued( &sock->write_q ))
1547 {
1548 /* As with read asyncs above, clear POLLOUT if we have an alerted
1549 * async. */
1550 if (async_waiting( &sock->write_q ))
1551 ev |= POLLOUT;
1552 else
1553 ev &= ~POLLOUT;
1554 }
1555 else if (!sock->wr_shutdown && (mask & AFD_POLL_WRITE))
1556 {
1557 ev |= POLLOUT;
1558 }
1559
1560 break;
1561 }
1562
1563 return ev;
1564 }
1565
1566 static enum server_fd_type sock_get_fd_type( struct fd *fd )
1567 {
1568 return FD_TYPE_SOCKET;
1569 }
1570
1571 static void sock_cancel_async( struct fd *fd, struct async *async )
1572 {
1573 struct poll_req *req;
1574
1575 LIST_FOR_EACH_ENTRY( req, &poll_list, struct poll_req, entry )
1576 {
1577 unsigned int i;
1578
1579 if (req->async != async)
1580 continue;
1581
1582 for (i = 0; i < req->count; i++)
1583 {
1584 struct sock *sock = req->sockets[i].sock;
1585
1586 if (sock->main_poll == req)
1587 sock->main_poll = NULL;
1588 }
1589 }
1590
1591 async_terminate( async, STATUS_CANCELLED );
1592 }
1593
1594 static void sock_reselect_async( struct fd *fd, struct async_queue *queue )
1595 {
1596 struct sock *sock = get_fd_user( fd );
1597
1598 if (sock->wr_shutdown_pending && list_empty( &sock->write_q.queue ))
1599 {
1600 shutdown( get_unix_fd( sock->fd ), SHUT_WR );
1601 sock->wr_shutdown_pending = 0;
1602 }
1603
1604 /* Don't reselect the ifchange queue; we always ask for POLLIN.
1605 * Don't reselect an uninitialized socket; we can't call set_fd_events() on
1606 * a pseudo-fd. */
1607 if (queue != &sock->ifchange_q && sock->type)
1608 sock_reselect( sock );
1609 }
1610
1611 static struct fd *sock_get_fd( struct object *obj )
1612 {
1613 struct sock *sock = (struct sock *)obj;
1614 return (struct fd *)grab_object( sock->fd );
1615 }
1616
1617 static int sock_close_handle( struct object *obj, struct process *process, obj_handle_t handle )
1618 {
1619 struct sock *sock = (struct sock *)obj;
1620
1621 if (sock->obj.handle_count == 1) /* last handle */
1622 {
1623 struct accept_req *accept_req, *accept_next;
1624 struct poll_req *poll_req, *poll_next;
1625
1626 if (sock->accept_recv_req)
1627 async_terminate( sock->accept_recv_req->async, STATUS_CANCELLED );
1628
1629 LIST_FOR_EACH_ENTRY_SAFE( accept_req, accept_next, &sock->accept_list, struct accept_req, entry )
1630 async_terminate( accept_req->async, STATUS_CANCELLED );
1631
1632 if (sock->connect_req)
1633 async_terminate( sock->connect_req->async, STATUS_CANCELLED );
1634
1635 LIST_FOR_EACH_ENTRY_SAFE( poll_req, poll_next, &poll_list, struct poll_req, entry )
1636 {
1637 struct iosb *iosb = poll_req->iosb;
1638 BOOL signaled = FALSE;
1639 unsigned int i;
1640
1641 if (iosb->status != STATUS_PENDING) continue;
1642
1643 for (i = 0; i < poll_req->count; ++i)
1644 {
1645 if (poll_req->sockets[i].sock == sock)
1646 {
1647 signaled = TRUE;
1648 poll_req->sockets[i].flags = AFD_POLL_CLOSE;
1649 poll_req->sockets[i].status = 0;
1650 }
1651 }
1652
1653 if (signaled) complete_async_poll( poll_req, STATUS_SUCCESS );
1654 }
1655 }
1656
1657 return 1;
1658 }
1659
1660 static void sock_destroy( struct object *obj )
1661 {
1662 struct sock *sock = (struct sock *)obj;
1663 unsigned int i;
1664
1665 assert( obj->ops == &sock_ops );
1666
1667 /* FIXME: special socket shutdown stuff? */
1668
1669 for (i = 0; i < 2; ++i)
1670 {
1671 if (sock->bound_addr[i] && --sock->bound_addr[i]->reuse_count <= 0)
1672 {
1673 rb_remove( &bound_addresses_tree, &sock->bound_addr[i]->entry );
1674 free( sock->bound_addr[i] );
1675 }
1676 }
1677
1678 if ( sock->deferred )
1679 release_object( sock->deferred );
1680
1681 async_wake_up( &sock->ifchange_q, STATUS_CANCELLED );
1682 sock_release_ifchange( sock );
1683 free_async_queue( &sock->read_q );
1684 free_async_queue( &sock->write_q );
1685 free_async_queue( &sock->ifchange_q );
1686 free_async_queue( &sock->accept_q );
1687 free_async_queue( &sock->connect_q );
1688 free_async_queue( &sock->poll_q );
1689 if (sock->event) release_object( sock->event );
1690 if (sock->fd) release_object( sock->fd );
1691 }
1692
1693 static struct sock *create_socket(void)
1694 {
1695 struct sock *sock;
1696
1697 if (!(sock = alloc_object( &sock_ops ))) return NULL;
1698 sock->fd = NULL;
1699 sock->state = SOCK_UNCONNECTED;
1700 sock->mask = 0;
1701 sock->pending_events = 0;
1702 sock->reported_events = 0;
1703 sock->proto = 0;
1704 sock->type = 0;
1705 sock->family = 0;
1706 sock->event = NULL;
1707 sock->window = 0;
1708 sock->message = 0;
1709 sock->wparam = 0;
1710 sock->connect_time = 0;
1711 sock->deferred = NULL;
1712 sock->ifchange_obj = NULL;
1713 sock->accept_recv_req = NULL;
1714 sock->connect_req = NULL;
1715 sock->main_poll = NULL;
1716 memset( &sock->addr, 0, sizeof(sock->addr) );
1717 sock->addr_len = 0;
1718 sock->rd_shutdown = 0;
1719 sock->wr_shutdown = 0;
1720 sock->wr_shutdown_pending = 0;
1721 sock->hangup = 0;
1722 sock->aborted = 0;
1723 sock->nonblocking = 0;
1724 sock->bound = 0;
1725 sock->reset = 0;
1726 sock->reuseaddr = 0;
1727 sock->exclusiveaddruse = 0;
1728 sock->rcvbuf = 0;
1729 sock->sndbuf = 0;
1730 sock->rcvtimeo = 0;
1731 sock->sndtimeo = 0;
1732 sock->icmp_fixup_data_len = 0;
1733 sock->bound_addr[0] = sock->bound_addr[1] = NULL;
1734 init_async_queue( &sock->read_q );
1735 init_async_queue( &sock->write_q );
1736 init_async_queue( &sock->ifchange_q );
1737 init_async_queue( &sock->accept_q );
1738 init_async_queue( &sock->connect_q );
1739 init_async_queue( &sock->poll_q );
1740 memset( sock->errors, 0, sizeof(sock->errors) );
1741 list_init( &sock->accept_list );
1742 return sock;
1743 }
1744
1745 static int get_unix_family( int family )
1746 {
1747 switch (family)
1748 {
1749 case WS_AF_INET: return AF_INET;
1750 case WS_AF_INET6: return AF_INET6;
1751 #ifdef HAS_IPX
1752 case WS_AF_IPX: return AF_IPX;
1753 #endif
1754 #ifdef AF_IRDA
1755 case WS_AF_IRDA: return AF_IRDA;
1756 #endif
1757 case WS_AF_UNSPEC: return AF_UNSPEC;
1758 default: return -1;
1759 }
1760 }
1761
1762 static int get_unix_type( int type )
1763 {
1764 switch (type)
1765 {
1766 case WS_SOCK_DGRAM: return SOCK_DGRAM;
1767 case WS_SOCK_RAW: return SOCK_RAW;
1768 case WS_SOCK_STREAM: return SOCK_STREAM;
1769 default: return -1;
1770 }
1771 }
1772
1773 static int get_unix_protocol( int protocol )
1774 {
1775 if (protocol >= WS_NSPROTO_IPX && protocol <= WS_NSPROTO_IPX + 255)
1776 return protocol;
1777
1778 switch (protocol)
1779 {
1780 case WS_IPPROTO_ICMP: return IPPROTO_ICMP;
1781 case WS_IPPROTO_IGMP: return IPPROTO_IGMP;
1782 case WS_IPPROTO_IP: return IPPROTO_IP;
1783 case WS_IPPROTO_IPV4: return IPPROTO_IPIP;
1784 case WS_IPPROTO_IPV6: return IPPROTO_IPV6;
1785 case WS_IPPROTO_RAW: return IPPROTO_RAW;
1786 case WS_IPPROTO_TCP: return IPPROTO_TCP;
1787 case WS_IPPROTO_UDP: return IPPROTO_UDP;
1788 default: return -1;
1789 }
1790 }
1791
1792 static void set_dont_fragment( int fd, int level, int value )
1793 {
1794 int optname;
1795
1796 if (level == IPPROTO_IP)
1797 {
1798 #ifdef IP_DONTFRAG
1799 optname = IP_DONTFRAG;
1800 #elif defined(IP_MTU_DISCOVER) && defined(IP_PMTUDISC_DO) && defined(IP_PMTUDISC_DONT)
1801 optname = IP_MTU_DISCOVER;
1802 value = value ? IP_PMTUDISC_DO : IP_PMTUDISC_DONT;
1803 #else
1804 return;
1805 #endif
1806 }
1807 else
1808 {
1809 #ifdef IPV6_DONTFRAG
1810 optname = IPV6_DONTFRAG;
1811 #elif defined(IPV6_MTU_DISCOVER) && defined(IPV6_PMTUDISC_DO) && defined(IPV6_PMTUDISC_DONT)
1812 optname = IPV6_MTU_DISCOVER;
1813 value = value ? IPV6_PMTUDISC_DO : IPV6_PMTUDISC_DONT;
1814 #else
1815 return;
1816 #endif
1817 }
1818
1819 setsockopt( fd, level, optname, &value, sizeof(value) );
1820 }
1821
1822 static int init_socket( struct sock *sock, int family, int type, int protocol )
1823 {
1824 unsigned int options = 0;
1825 int sockfd, unix_type, unix_family, unix_protocol, value;
1826 socklen_t len;
1827
1828 unix_family = get_unix_family( family );
1829 unix_type = get_unix_type( type );
1830 unix_protocol = get_unix_protocol( protocol );
1831
1832 if (unix_protocol < 0)
1833 {
1834 if (type && unix_type < 0)
1835 set_win32_error( WSAESOCKTNOSUPPORT );
1836 else
1837 set_win32_error( WSAEPROTONOSUPPORT );
1838 return -1;
1839 }
1840 if (unix_family < 0)
1841 {
1842 if (family >= 0 && unix_type < 0)
1843 set_win32_error( WSAESOCKTNOSUPPORT );
1844 else
1845 set_win32_error( WSAEAFNOSUPPORT );
1846 return -1;
1847 }
1848
1849 sockfd = socket( unix_family, unix_type, unix_protocol );
1850
1851 #ifdef linux
1852 if (sockfd == -1 && errno == EPERM && unix_family == AF_INET
1853 && unix_type == SOCK_RAW && unix_protocol == IPPROTO_ICMP)
1854 {
1855 sockfd = socket( unix_family, SOCK_DGRAM, unix_protocol );
1856 if (sockfd != -1)
1857 {
1858 const int val = 1;
1859
1860 setsockopt( sockfd, IPPROTO_IP, IP_RECVTTL, (const char *)&val, sizeof(val) );
1861 setsockopt( sockfd, IPPROTO_IP, IP_RECVTOS, (const char *)&val, sizeof(val) );
1862 setsockopt( sockfd, IPPROTO_IP, IP_PKTINFO, (const char *)&val, sizeof(val) );
1863 }
1864 }
1865 #endif
1866
1867 if (sockfd == -1)
1868 {
1869 if (errno == EINVAL) set_win32_error( WSAESOCKTNOSUPPORT );
1870 else set_win32_error( sock_get_error( errno ));
1871 return -1;
1872 }
1873 fcntl(sockfd, F_SETFL, O_NONBLOCK); /* make socket nonblocking */
1874
1875 if (family == WS_AF_IPX && protocol >= WS_NSPROTO_IPX && protocol <= WS_NSPROTO_IPX + 255)
1876 {
1877 #ifdef HAS_IPX
1878 int ipx_type = protocol - WS_NSPROTO_IPX;
1879
1880 #ifdef SOL_IPX
1881 setsockopt( sockfd, SOL_IPX, IPX_TYPE, &ipx_type, sizeof(ipx_type) );
1882 #else
1883 struct ipx val;
1884 /* Should we retrieve val using a getsockopt call and then
1885 * set the modified one? */
1886 val.ipx_pt = ipx_type;
1887 setsockopt( sockfd, 0, SO_DEFAULT_HEADERS, &val, sizeof(val) );
1888 #endif
1889 #endif
1890 }
1891
1892 if (unix_family == AF_INET || unix_family == AF_INET6)
1893 {
1894 /* ensure IP_DONTFRAGMENT is disabled for SOCK_DGRAM and SOCK_RAW, enabled for SOCK_STREAM */
1895 if (unix_type == SOCK_DGRAM || unix_type == SOCK_RAW) /* in Linux the global default can be enabled */
1896 set_dont_fragment( sockfd, unix_family == AF_INET6 ? IPPROTO_IPV6 : IPPROTO_IP, FALSE );
1897 else if (unix_type == SOCK_STREAM)
1898 set_dont_fragment( sockfd, unix_family == AF_INET6 ? IPPROTO_IPV6 : IPPROTO_IP, TRUE );
1899 }
1900
1901 #ifdef IPV6_V6ONLY
1902 if (unix_family == AF_INET6)
1903 {
1904 static const int enable = 1;
1905 setsockopt( sockfd, IPPROTO_IPV6, IPV6_V6ONLY, &enable, sizeof(enable) );
1906 }
1907 #endif
1908
1909 len = sizeof(value);
1910 if (!getsockopt( sockfd, SOL_SOCKET, SO_RCVBUF, &value, &len ))
1911 sock->rcvbuf = value;
1912
1913 len = sizeof(value);
1914 if (!getsockopt( sockfd, SOL_SOCKET, SO_SNDBUF, &value, &len ))
1915 sock->sndbuf = value;
1916
1917 sock->state = (type == WS_SOCK_STREAM ? SOCK_UNCONNECTED : SOCK_CONNECTIONLESS);
1918 sock->proto = protocol;
1919 sock->type = type;
1920 sock->family = family;
1921
1922 if (is_tcp_socket( sock ))
1923 {
1924 int reuse = 1;
1925
1926 setsockopt( sockfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse) );
1927 }
1928
1929 if (sock->fd)
1930 {
1931 options = get_fd_options( sock->fd );
1932 release_object( sock->fd );
1933 }
1934
1935 if (!(sock->fd = create_anonymous_fd( &sock_fd_ops, sockfd, &sock->obj, options )))
1936 {
1937 return -1;
1938 }
1939
1940 /* We can't immediately allow caching for a connection-mode socket, since it
1941 * might be accepted into (changing the underlying fd object.) */
1942 if (sock->type != WS_SOCK_STREAM) allow_fd_caching( sock->fd );
1943
1944 return 0;
1945 }
1946
1947 /* accepts a socket and inits it */
1948 static int accept_new_fd( struct sock *sock )
1949 {
1950
1951 /* Try to accept(2). We can't be safe that this an already connected socket
1952 * or that accept() is allowed on it. In those cases we will get -1/errno
1953 * return.
1954 */
1955 struct sockaddr saddr;
1956 socklen_t slen = sizeof(saddr);
1957 int acceptfd = accept( get_unix_fd(sock->fd), &saddr, &slen );
1958 if (acceptfd != -1)
1959 fcntl( acceptfd, F_SETFL, O_NONBLOCK );
1960 else
1961 set_error( sock_get_ntstatus( errno ));
1962 return acceptfd;
1963 }
1964
1965 /* accept a socket (creates a new fd) */
1966 static struct sock *accept_socket( struct sock *sock )
1967 {
1968 struct sock *acceptsock;
1969 int acceptfd;
1970
1971 if (get_unix_fd( sock->fd ) == -1) return NULL;
1972
1973 if ( sock->deferred )
1974 {
1975 acceptsock = sock->deferred;
1976 sock->deferred = NULL;
1977 }
1978 else
1979 {
1980 union unix_sockaddr unix_addr;
1981 socklen_t unix_len;
1982
1983 if ((acceptfd = accept_new_fd( sock )) == -1) return NULL;
1984 if (!(acceptsock = create_socket()))
1985 {
1986 close( acceptfd );
1987 return NULL;
1988 }
1989
1990 /* newly created socket gets the same properties of the listening socket */
1991 acceptsock->state = SOCK_CONNECTED;
1992 acceptsock->bound = 1;
1993 acceptsock->nonblocking = sock->nonblocking;
1994 acceptsock->mask = sock->mask;
1995 acceptsock->proto = sock->proto;
1996 acceptsock->type = sock->type;
1997 acceptsock->family = sock->family;
1998 acceptsock->window = sock->window;
1999 acceptsock->message = sock->message;
2000 acceptsock->reuseaddr = sock->reuseaddr;
2001 acceptsock->exclusiveaddruse = sock->exclusiveaddruse;
2002 acceptsock->sndbuf = sock->sndbuf;
2003 acceptsock->rcvbuf = sock->rcvbuf;
2004 acceptsock->sndtimeo = sock->sndtimeo;
2005 acceptsock->rcvtimeo = sock->rcvtimeo;
2006 acceptsock->connect_time = current_time;
2007
2008 if (sock->event) acceptsock->event = (struct event *)grab_object( sock->event );
2009 if (!(acceptsock->fd = create_anonymous_fd( &sock_fd_ops, acceptfd, &acceptsock->obj,
2010 get_fd_options( sock->fd ) )))
2011 {
2012 release_object( acceptsock );
2013 return NULL;
2014 }
2015 unix_len = sizeof(unix_addr);
2016 if (!getsockname( acceptfd, &unix_addr.addr, &unix_len ))
2017 acceptsock->addr_len = sockaddr_from_unix( &unix_addr, &acceptsock->addr.addr, sizeof(acceptsock->addr) );
2018 }
2019 clear_error();
2020 sock->pending_events &= ~AFD_POLL_ACCEPT;
2021 sock->reported_events &= ~AFD_POLL_ACCEPT;
2022 sock_reselect( sock );
2023 return acceptsock;
2024 }
2025
2026 static int accept_into_socket( struct sock *sock, struct sock *acceptsock )
2027 {
2028 union unix_sockaddr unix_addr;
2029 socklen_t unix_len;
2030 int acceptfd;
2031 struct fd *newfd;
2032
2033 if (get_unix_fd( sock->fd ) == -1) return FALSE;
2034
2035 if ( sock->deferred )
2036 {
2037 newfd = dup_fd_object( sock->deferred->fd, 0, 0,
2038 get_fd_options( acceptsock->fd ) );
2039 if ( !newfd )
2040 return FALSE;
2041
2042 set_fd_user( newfd, &sock_fd_ops, &acceptsock->obj );
2043
2044 release_object( sock->deferred );
2045 sock->deferred = NULL;
2046 }
2047 else
2048 {
2049 if ((acceptfd = accept_new_fd( sock )) == -1)
2050 return FALSE;
2051
2052 if (!(newfd = create_anonymous_fd( &sock_fd_ops, acceptfd, &acceptsock->obj,
2053 get_fd_options( acceptsock->fd ) )))
2054 return FALSE;
2055 }
2056
2057 acceptsock->state = SOCK_CONNECTED;
2058 acceptsock->bound = 1;
2059 acceptsock->pending_events = 0;
2060 acceptsock->reported_events = 0;
2061 acceptsock->proto = sock->proto;
2062 acceptsock->type = sock->type;
2063 acceptsock->family = sock->family;
2064 acceptsock->wparam = 0;
2065 acceptsock->deferred = NULL;
2066 acceptsock->connect_time = current_time;
2067 fd_copy_completion( acceptsock->fd, newfd );
2068 release_object( acceptsock->fd );
2069 acceptsock->fd = newfd;
2070
2071 unix_len = sizeof(unix_addr);
2072 if (!getsockname( get_unix_fd( newfd ), &unix_addr.addr, &unix_len ))
2073 acceptsock->addr_len = sockaddr_from_unix( &unix_addr, &acceptsock->addr.addr, sizeof(acceptsock->addr) );
2074
2075 clear_error();
2076 sock->pending_events &= ~AFD_POLL_ACCEPT;
2077 sock->reported_events &= ~AFD_POLL_ACCEPT;
2078 sock_reselect( sock );
2079
2080 return TRUE;
2081 }
2082
2083 #ifdef IP_BOUND_IF
2084
2085 static int bind_to_iface_name( int fd, in_addr_t bind_addr, const char *name )
2086 {
2087 static const int enable = 1;
2088 unsigned int index;
2089
2090 if (!(index = if_nametoindex( name )))
2091 return -1;
2092
2093 if (setsockopt( fd, IPPROTO_IP, IP_BOUND_IF, &index, sizeof(index) ))
2094 return -1;
2095
2096 return setsockopt( fd, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable) );
2097 }
2098
2099 #elif defined(IP_UNICAST_IF) && defined(SO_ATTACH_FILTER) && defined(SO_BINDTODEVICE)
2100
2101 struct interface_filter
2102 {
2103 struct sock_filter iface_memaddr;
2104 struct sock_filter iface_rule;
2105 struct sock_filter ip_memaddr;
2106 struct sock_filter ip_rule;
2107 struct sock_filter return_keep;
2108 struct sock_filter return_dump;
2109 };
2110 # define FILTER_JUMP_DUMP(here) (u_char)(offsetof(struct interface_filter, return_dump) \
2111 -offsetof(struct interface_filter, here)-sizeof(struct sock_filter)) \
2112 /sizeof(struct sock_filter)
2113 # define FILTER_JUMP_KEEP(here) (u_char)(offsetof(struct interface_filter, return_keep) \
2114 -offsetof(struct interface_filter, here)-sizeof(struct sock_filter)) \
2115 /sizeof(struct sock_filter)
2116 # define FILTER_JUMP_NEXT() (u_char)(0)
2117 # define SKF_NET_DESTIP 16 /* offset in the network header to the destination IP */
2118 static struct interface_filter generic_interface_filter =
2119 {
2120 /* This filter rule allows incoming packets on the specified interface, which works for all
2121 * remotely generated packets and for locally generated broadcast packets. */
2122 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, SKF_AD_OFF+SKF_AD_IFINDEX),
2123 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0xdeadbeef, FILTER_JUMP_KEEP(iface_rule), FILTER_JUMP_NEXT()),
2124 /* This rule allows locally generated packets targeted at the specific IP address of the chosen
2125 * adapter (local packets not destined for the broadcast address do not have IFINDEX set) */
2126 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, SKF_NET_OFF+SKF_NET_DESTIP),
2127 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0xdeadbeef, FILTER_JUMP_KEEP(ip_rule), FILTER_JUMP_DUMP(ip_rule)),
2128 BPF_STMT(BPF_RET+BPF_K, (u_int)-1), /* keep packet */
2129 BPF_STMT(BPF_RET+BPF_K, 0) /* dump packet */
2130 };
2131
2132 static int bind_to_iface_name( int fd, in_addr_t bind_addr, const char *name )
2133 {
2134 struct interface_filter specific_interface_filter;
2135 struct sock_fprog filter_prog;
2136 static const int enable = 1;
2137 unsigned int index;
2138 in_addr_t ifindex;
2139
2140 if (!setsockopt( fd, SOL_SOCKET, SO_BINDTODEVICE, name, strlen( name ) + 1 ))
2141 return 0;
2142
2143 /* SO_BINDTODEVICE requires NET_CAP_RAW until Linux 5.7. */
2144 if (debug_level)
2145 fprintf( stderr, "setsockopt SO_BINDTODEVICE fd %d, name %s failed: %s, falling back to SO_REUSE_ADDR\n",
2146 fd, name, strerror( errno ));
2147
2148 if (!(index = if_nametoindex( name )))
2149 return -1;
2150
2151 ifindex = htonl( index );
2152 if (setsockopt( fd, IPPROTO_IP, IP_UNICAST_IF, &ifindex, sizeof(ifindex) ) < 0)
2153 return -1;
2154
2155 specific_interface_filter = generic_interface_filter;
2156 specific_interface_filter.iface_rule.k = index;
2157 specific_interface_filter.ip_rule.k = htonl( bind_addr );
2158 filter_prog.len = sizeof(generic_interface_filter) / sizeof(struct sock_filter);
2159 filter_prog.filter = (struct sock_filter *)&specific_interface_filter;
2160 if (setsockopt( fd, SOL_SOCKET, SO_ATTACH_FILTER, &filter_prog, sizeof(filter_prog) ))
2161 return -1;
2162
2163 return setsockopt( fd, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable) );
2164 }
2165
2166 #else
2167
2168 static int bind_to_iface_name( int fd, in_addr_t bind_addr, const char *name )
2169 {
2170 errno = EOPNOTSUPP;
2171 return -1;
2172 }
2173
2174 #endif /* LINUX_BOUND_IF */
2175
2176 /* Take bind() calls on any name corresponding to a local network adapter and
2177 * restrict the given socket to operating only on the specified interface. This
2178 * restriction consists of two components:
2179 * 1) An outgoing packet restriction suggesting the egress interface for all
2180 * packets.
2181 * 2) An incoming packet restriction dropping packets not meant for the
2182 * interface.
2183 * If the function succeeds in placing these restrictions, then the name for the
2184 * bind() may safely be changed to INADDR_ANY, permitting the transmission and
2185 * receipt of broadcast packets on the socket. This behavior is only relevant to
2186 * UDP sockets and is needed for applications that expect to be able to receive
2187 * broadcast packets on a socket that is bound to a specific network interface.
2188 */
2189 static int bind_to_interface( struct sock *sock, const struct sockaddr_in *addr )
2190 {
2191 in_addr_t bind_addr = addr->sin_addr.s_addr;
2192 struct ifaddrs *ifaddrs, *ifaddr;
2193 int fd = get_unix_fd( sock->fd );
2194 int err = 0;
2195
2196 if (bind_addr == htonl( INADDR_ANY ) || bind_addr == htonl( INADDR_LOOPBACK ))
2197 return 0;
2198 if (sock->type != WS_SOCK_DGRAM)
2199 return 0;
2200
2201 if (getifaddrs( &ifaddrs ) < 0) return 0;
2202
2203 for (ifaddr = ifaddrs; ifaddr != NULL; ifaddr = ifaddr->ifa_next)
2204 {
2205 if (ifaddr->ifa_addr && ifaddr->ifa_addr->sa_family == AF_INET
2206 && ((struct sockaddr_in *)ifaddr->ifa_addr)->sin_addr.s_addr == bind_addr)
2207 {
2208 if ((err = bind_to_iface_name( fd, bind_addr, ifaddr->ifa_name )) < 0)
2209 {
2210 if (debug_level)
2211 fprintf( stderr, "failed to bind to interface: %s\n", strerror( errno ) );
2212 }
2213 break;
2214 }
2215 }
2216 freeifaddrs( ifaddrs );
2217 return !err;
2218 }
2219
2220 #ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID
2221 static unsigned int get_ipv6_interface_index( const struct in6_addr *addr )
2222 {
2223 struct ifaddrs *ifaddrs, *ifaddr;
2224
2225 if (getifaddrs( &ifaddrs ) < 0) return 0;
2226
2227 for (ifaddr = ifaddrs; ifaddr != NULL; ifaddr = ifaddr->ifa_next)
2228 {
2229 if (ifaddr->ifa_addr && ifaddr->ifa_addr->sa_family == AF_INET6
2230 && !memcmp( &((struct sockaddr_in6 *)ifaddr->ifa_addr)->sin6_addr, addr, sizeof(*addr) ))
2231 {
2232 unsigned int index = if_nametoindex( ifaddr->ifa_name );
2233
2234 if (!index)
2235 {
2236 if (debug_level)
2237 fprintf( stderr, "Unable to look up interface index for %s: %s\n",
2238 ifaddr->ifa_name, strerror( errno ) );
2239 continue;
2240 }
2241
2242 freeifaddrs( ifaddrs );
2243 return index;
2244 }
2245 }
2246
2247 freeifaddrs( ifaddrs );
2248 return 0;
2249 }
2250 #endif
2251
2252 /* return an errno value mapped to a WSA error */
2253 static unsigned int sock_get_error( int err )
2254 {
2255 switch (err)
2256 {
2257 case EINTR: return WSAEINTR;
2258 case EBADF: return WSAEBADF;
2259 case EPERM:
2260 case EACCES: return WSAEACCES;
2261 case EFAULT: return WSAEFAULT;
2262 case EINVAL: return WSAEINVAL;
2263 case EMFILE: return WSAEMFILE;
2264 case EINPROGRESS:
2265 case EWOULDBLOCK: return WSAEWOULDBLOCK;
2266 case EALREADY: return WSAEALREADY;
2267 case ENOTSOCK: return WSAENOTSOCK;
2268 case EDESTADDRREQ: return WSAEDESTADDRREQ;
2269 case EMSGSIZE: return WSAEMSGSIZE;
2270 case EPROTOTYPE: return WSAEPROTOTYPE;
2271 case ENOPROTOOPT: return WSAENOPROTOOPT;
2272 case EPROTONOSUPPORT: return WSAEPROTONOSUPPORT;
2273 case ESOCKTNOSUPPORT: return WSAESOCKTNOSUPPORT;
2274 case EOPNOTSUPP: return WSAEOPNOTSUPP;
2275 case EPFNOSUPPORT: return WSAEPFNOSUPPORT;
2276 case EAFNOSUPPORT: return WSAEAFNOSUPPORT;
2277 case EADDRINUSE: return WSAEADDRINUSE;
2278 case EADDRNOTAVAIL: return WSAEADDRNOTAVAIL;
2279 case ENETDOWN: return WSAENETDOWN;
2280 case ENETUNREACH: return WSAENETUNREACH;
2281 case ENETRESET: return WSAENETRESET;
2282 case ECONNABORTED: return WSAECONNABORTED;
2283 case EPIPE:
2284 case ECONNRESET: return WSAECONNRESET;
2285 case ENOBUFS: return WSAENOBUFS;
2286 case EISCONN: return WSAEISCONN;
2287 case ENOTCONN: return WSAENOTCONN;
2288 case ESHUTDOWN: return WSAESHUTDOWN;
2289 case ETOOMANYREFS: return WSAETOOMANYREFS;
2290 case ETIMEDOUT: return WSAETIMEDOUT;
2291 case ECONNREFUSED: return WSAECONNREFUSED;
2292 case ELOOP: return WSAELOOP;
2293 case ENAMETOOLONG: return WSAENAMETOOLONG;
2294 case EHOSTDOWN: return WSAEHOSTDOWN;
2295 case EHOSTUNREACH: return WSAEHOSTUNREACH;
2296 case ENOTEMPTY: return WSAENOTEMPTY;
2297 #ifdef EPROCLIM
2298 case EPROCLIM: return WSAEPROCLIM;
2299 #endif
2300 #ifdef EUSERS
2301 case EUSERS: return WSAEUSERS;
2302 #endif
2303 #ifdef EDQUOT
2304 case EDQUOT: return WSAEDQUOT;
2305 #endif
2306 #ifdef ESTALE
2307 case ESTALE: return WSAESTALE;
2308 #endif
2309 #ifdef EREMOTE
2310 case EREMOTE: return WSAEREMOTE;
2311 #endif
2312
2313 case 0: return 0;
2314 default:
2315 errno = err;
2316 perror("wineserver: sock_get_error() can't map error");
2317 return WSAEFAULT;
2318 }
2319 }
2320
2321 static int sock_get_ntstatus( int err )
2322 {
2323 switch ( err )
2324 {
2325 case EBADF: return STATUS_INVALID_HANDLE;
2326 case EBUSY: return STATUS_DEVICE_BUSY;
2327 case EPERM:
2328 case EACCES: return STATUS_ACCESS_DENIED;
2329 case EFAULT: return STATUS_ACCESS_VIOLATION;
2330 case EINVAL: return STATUS_INVALID_PARAMETER;
2331 case ENFILE:
2332 case EMFILE: return STATUS_TOO_MANY_OPENED_FILES;
2333 case EINPROGRESS:
2334 case EWOULDBLOCK: return STATUS_DEVICE_NOT_READY;
2335 case EALREADY: return STATUS_NETWORK_BUSY;
2336 case ENOTSOCK: return STATUS_OBJECT_TYPE_MISMATCH;
2337 case EDESTADDRREQ: return STATUS_INVALID_PARAMETER;
2338 case EMSGSIZE: return STATUS_BUFFER_OVERFLOW;
2339 case EPROTONOSUPPORT:
2340 case ESOCKTNOSUPPORT:
2341 case EPFNOSUPPORT:
2342 case EAFNOSUPPORT:
2343 case EPROTOTYPE: return STATUS_NOT_SUPPORTED;
2344 case ENOPROTOOPT: return STATUS_INVALID_PARAMETER;
2345 case EOPNOTSUPP: return STATUS_NOT_SUPPORTED;
2346 case EADDRINUSE: return STATUS_SHARING_VIOLATION;
2347 /* Linux returns ENODEV when specifying an invalid sin6_scope_id;
2348 * Windows returns STATUS_INVALID_ADDRESS_COMPONENT */
2349 case ENODEV:
2350 case EADDRNOTAVAIL: return STATUS_INVALID_ADDRESS_COMPONENT;
2351 case ECONNREFUSED: return STATUS_CONNECTION_REFUSED;
2352 case ESHUTDOWN: return STATUS_PIPE_DISCONNECTED;
2353 case ENOTCONN: return STATUS_INVALID_CONNECTION;
2354 case ETIMEDOUT: return STATUS_IO_TIMEOUT;
2355 case ENETUNREACH: return STATUS_NETWORK_UNREACHABLE;
2356 case EHOSTUNREACH: return STATUS_HOST_UNREACHABLE;
2357 case ENETDOWN: return STATUS_NETWORK_BUSY;
2358 case EPIPE:
2359 case ECONNRESET: return STATUS_CONNECTION_RESET;
2360 case ECONNABORTED: return STATUS_CONNECTION_ABORTED;
2361 case EISCONN: return STATUS_CONNECTION_ACTIVE;
2362
2363 case 0: return STATUS_SUCCESS;
2364 default:
2365 errno = err;
2366 perror("wineserver: sock_get_ntstatus() can't map error");
2367 return STATUS_UNSUCCESSFUL;
2368 }
2369 }
2370
2371 static struct accept_req *alloc_accept_req( struct sock *sock, struct sock *acceptsock, struct async *async,
2372 const struct afd_accept_into_params *params )
2373 {
2374 struct accept_req *req = mem_alloc( sizeof(*req) );
2375
2376 if (req)
2377 {
2378 req->async = (struct async *)grab_object( async );
2379 req->iosb = async_get_iosb( async );
2380 req->sock = (struct sock *)grab_object( sock );
2381 req->acceptsock = acceptsock;
2382 if (acceptsock) grab_object( acceptsock );
2383 req->accepted = 0;
2384 req->recv_len = 0;
2385 req->local_len = 0;
2386 if (params)
2387 {
2388 req->recv_len = params->recv_len;
2389 req->local_len = params->local_len;
2390 }
2391 }
2392 return req;
2393 }
2394
2395 static void sock_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
2396 {
2397 struct sock *sock = get_fd_user( fd );
2398 int unix_fd = -1;
2399
2400 assert( sock->obj.ops == &sock_ops );
2401
2402 if (code != IOCTL_AFD_WINE_CREATE && code != IOCTL_AFD_POLL && (unix_fd = get_unix_fd( fd )) < 0)
2403 return;
2404
2405 switch(code)
2406 {
2407 case IOCTL_AFD_WINE_CREATE:
2408 {
2409 const struct afd_create_params *params = get_req_data();
2410
2411 if (get_req_data_size() != sizeof(*params))
2412 {
2413 set_error( STATUS_INVALID_PARAMETER );
2414 return;
2415 }
2416 init_socket( sock, params->family, params->type, params->protocol );
2417 return;
2418 }
2419
2420 case IOCTL_AFD_WINE_ACCEPT:
2421 {
2422 struct sock *acceptsock;
2423 obj_handle_t handle;
2424
2425 if (get_reply_max_size() != sizeof(handle))
2426 {
2427 set_error( STATUS_BUFFER_TOO_SMALL );
2428 return;
2429 }
2430
2431 if (!(acceptsock = accept_socket( sock )))
2432 {
2433 struct accept_req *req;
2434
2435 if (sock->nonblocking) return;
2436 if (get_error() != STATUS_DEVICE_NOT_READY) return;
2437
2438 if (!(req = alloc_accept_req( sock, NULL, async, NULL ))) return;
2439 list_add_tail( &sock->accept_list, &req->entry );
2440
2441 async_set_completion_callback( async, free_accept_req, req );
2442 queue_async( &sock->accept_q, async );
2443 sock_reselect( sock );
2444 set_error( STATUS_PENDING );
2445 return;
2446 }
2447 handle = alloc_handle( current->process, &acceptsock->obj,
2448 GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE, OBJ_INHERIT );
2449 acceptsock->wparam = handle;
2450 sock_reselect( acceptsock );
2451 release_object( acceptsock );
2452 set_reply_data( &handle, sizeof(handle) );
2453 return;
2454 }
2455
2456 case IOCTL_AFD_WINE_ACCEPT_INTO:
2457 {
2458 static const int access = FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES | FILE_READ_DATA;
2459 const struct afd_accept_into_params *params = get_req_data();
2460 struct sock *acceptsock;
2461 unsigned int remote_len;
2462 struct accept_req *req;
2463
2464 if (get_req_data_size() != sizeof(*params) ||
2465 get_reply_max_size() < params->recv_len ||
2466 get_reply_max_size() - params->recv_len < params->local_len)
2467 {
2468 set_error( STATUS_BUFFER_TOO_SMALL );
2469 return;
2470 }
2471
2472 remote_len = get_reply_max_size() - params->recv_len - params->local_len;
2473 if (remote_len < sizeof(int))
2474 {
2475 set_error( STATUS_INVALID_PARAMETER );
2476 return;
2477 }
2478
2479 if (!(acceptsock = (struct sock *)get_handle_obj( current->process, params->accept_handle, access, &sock_ops )))
2480 return;
2481
2482 if (acceptsock->accept_recv_req)
2483 {
2484 release_object( acceptsock );
2485 set_error( STATUS_INVALID_PARAMETER );
2486 return;
2487 }
2488
2489 if (!(req = alloc_accept_req( sock, acceptsock, async, params )))
2490 {
2491 release_object( acceptsock );
2492 return;
2493 }
2494 list_add_tail( &sock->accept_list, &req->entry );
2495 acceptsock->accept_recv_req = req;
2496 release_object( acceptsock );
2497
2498 acceptsock->wparam = params->accept_handle;
2499 async_set_completion_callback( async, free_accept_req, req );
2500 queue_async( &sock->accept_q, async );
2501 sock_reselect( sock );
2502 set_error( STATUS_PENDING );
2503 return;
2504 }
2505
2506 case IOCTL_AFD_LISTEN:
2507 {
2508 const struct afd_listen_params *params = get_req_data();
2509
2510 if (get_req_data_size() < sizeof(*params))
2511 {
2512 set_error( STATUS_INVALID_PARAMETER );
2513 return;
2514 }
2515
2516 if (!sock->bound)
2517 {
2518 set_error( STATUS_INVALID_PARAMETER );
2519 return;
2520 }
2521
2522 if (listen( unix_fd, params->backlog ) < 0)
2523 {
2524 set_error( sock_get_ntstatus( errno ) );
2525 return;
2526 }
2527
2528 sock->state = SOCK_LISTENING;
2529
2530 /* a listening socket can no longer be accepted into */
2531 allow_fd_caching( sock->fd );
2532
2533 /* we may already be selecting for AFD_POLL_ACCEPT */
2534 sock_reselect( sock );
2535 return;
2536 }
2537
2538 case IOCTL_AFD_WINE_CONNECT:
2539 {
2540 const struct afd_connect_params *params = get_req_data();
2541 const struct WS_sockaddr *addr;
2542 union unix_sockaddr unix_addr;
2543 struct connect_req *req;
2544 socklen_t unix_len;
2545 int send_len, ret;
2546
2547 if (get_req_data_size() < sizeof(*params) ||
2548 get_req_data_size() - sizeof(*params) < params->addr_len)
2549 {
2550 set_error( STATUS_BUFFER_TOO_SMALL );
2551 return;
2552 }
2553 send_len = get_req_data_size() - sizeof(*params) - params->addr_len;
2554 addr = (const struct WS_sockaddr *)(params + 1);
2555
2556 if (!params->synchronous && !sock->bound)
2557 {
2558 set_error( STATUS_INVALID_PARAMETER );
2559 return;
2560 }
2561
2562 if (sock->accept_recv_req)
2563 {
2564 set_error( STATUS_INVALID_PARAMETER );
2565 return;
2566 }
2567
2568 if (sock->connect_req)
2569 {
2570 set_error( STATUS_INVALID_PARAMETER );
2571 return;
2572 }
2573
2574 switch (sock->state)
2575 {
2576 case SOCK_LISTENING:
2577 set_error( STATUS_INVALID_PARAMETER );
2578 return;
2579
2580 case SOCK_CONNECTING:
2581 /* FIXME: STATUS_ADDRESS_ALREADY_ASSOCIATED probably isn't right,
2582 * but there's no status code that maps to WSAEALREADY... */
2583 set_error( params->synchronous ? STATUS_ADDRESS_ALREADY_ASSOCIATED : STATUS_INVALID_PARAMETER );
2584 return;
2585
2586 case SOCK_CONNECTED:
2587 set_error( STATUS_CONNECTION_ACTIVE );
2588 return;
2589
2590 case SOCK_UNCONNECTED:
2591 case SOCK_CONNECTIONLESS:
2592 break;
2593 }
2594
2595 unix_len = sockaddr_to_unix( addr, params->addr_len, &unix_addr );
2596 if (!unix_len)
2597 {
2598 set_error( STATUS_INVALID_ADDRESS );
2599 return;
2600 }
2601 if (unix_addr.addr.sa_family == AF_INET && !memcmp( &unix_addr.in.sin_addr, magic_loopback_addr, 4 ))
2602 unix_addr.in.sin_addr.s_addr = htonl( INADDR_LOOPBACK );
2603
2604 ret = connect( unix_fd, &unix_addr.addr, unix_len );
2605 if (ret < 0 && errno != EINPROGRESS)
2606 {
2607 set_error( sock_get_ntstatus( errno ) );
2608 return;
2609 }
2610
2611 /* a connected or connecting socket can no longer be accepted into */
2612 allow_fd_caching( sock->fd );
2613
2614 unix_len = sizeof(unix_addr);
2615 if (!getsockname( unix_fd, &unix_addr.addr, &unix_len ))
2616 sock->addr_len = sockaddr_from_unix( &unix_addr, &sock->addr.addr, sizeof(sock->addr) );
2617 sock->bound = 1;
2618
2619 if (!ret)
2620 {
2621 if (sock->type != WS_SOCK_DGRAM)
2622 {
2623 sock->state = SOCK_CONNECTED;
2624 sock->connect_time = current_time;
2625 }
2626
2627 if (!send_len) return;
2628 }
2629
2630 if (sock->type != WS_SOCK_DGRAM)
2631 sock->state = SOCK_CONNECTING;
2632
2633 if (params->synchronous && sock->nonblocking)
2634 {
2635 sock_reselect( sock );
2636 set_error( STATUS_DEVICE_NOT_READY );
2637 return;
2638 }
2639
2640 if (!(req = mem_alloc( sizeof(*req) )))
2641 return;
2642
2643 req->async = (struct async *)grab_object( async );
2644 req->iosb = async_get_iosb( async );
2645 req->sock = (struct sock *)grab_object( sock );
2646 req->addr_len = params->addr_len;
2647 req->send_len = send_len;
2648 req->send_cursor = 0;
2649
2650 async_set_completion_callback( async, free_connect_req, req );
2651 sock->connect_req = req;
2652 queue_async( &sock->connect_q, async );
2653 sock_reselect( sock );
2654 set_error( STATUS_PENDING );
2655 return;
2656 }
2657
2658 case IOCTL_AFD_WINE_SHUTDOWN:
2659 {
2660 unsigned int how;
2661
2662 if (get_req_data_size() < sizeof(int))
2663 {
2664 set_error( STATUS_BUFFER_TOO_SMALL );
2665 return;
2666 }
2667 how = *(int *)get_req_data();
2668
2669 if (how > SD_BOTH)
2670 {
2671 set_error( STATUS_INVALID_PARAMETER );
2672 return;
2673 }
2674
2675 if (sock->state != SOCK_CONNECTED && sock->state != SOCK_CONNECTIONLESS)
2676 {
2677 set_error( STATUS_INVALID_CONNECTION );
2678 return;
2679 }
2680
2681 if (how != SD_SEND)
2682 {
2683 sock->rd_shutdown = 1;
2684 }
2685 if (how != SD_RECEIVE)
2686 {
2687 sock->wr_shutdown = 1;
2688 if (list_empty( &sock->write_q.queue ))
2689 shutdown( unix_fd, SHUT_WR );
2690 else
2691 sock->wr_shutdown_pending = 1;
2692 }
2693
2694 if (how == SD_BOTH)
2695 {
2696 if (sock->event) release_object( sock->event );
2697 sock->event = NULL;
2698 sock->window = 0;
2699 sock->mask = 0;
2700 sock->nonblocking = 1;
2701 }
2702
2703 sock_reselect( sock );
2704 return;
2705 }
2706
2707 case IOCTL_AFD_WINE_ADDRESS_LIST_CHANGE:
2708 {
2709 int force_async;
2710
2711 if (get_req_data_size() < sizeof(int))
2712 {
2713 set_error( STATUS_BUFFER_TOO_SMALL );
2714 return;
2715 }
2716 force_async = *(int *)get_req_data();
2717
2718 if (sock->nonblocking && !force_async)
2719 {
2720 set_error( STATUS_DEVICE_NOT_READY );
2721 return;
2722 }
2723 if (!sock_get_ifchange( sock )) return;
2724 queue_async( &sock->ifchange_q, async );
2725 set_error( STATUS_PENDING );
2726 return;
2727 }
2728
2729 case IOCTL_AFD_WINE_FIONBIO:
2730 if (get_req_data_size() < sizeof(int))
2731 {
2732 set_error( STATUS_BUFFER_TOO_SMALL );
2733 return;
2734 }
2735 if (*(int *)get_req_data())
2736 {
2737 sock->nonblocking = 1;
2738 }
2739 else
2740 {
2741 if (sock->mask)
2742 {
2743 set_error( STATUS_INVALID_PARAMETER );
2744 return;
2745 }
2746 sock->nonblocking = 0;
2747 }
2748 return;
2749
2750 case IOCTL_AFD_GET_EVENTS:
2751 {
2752 struct afd_get_events_params params = {0};
2753 unsigned int i;
2754
2755 if (get_reply_max_size() < sizeof(params))
2756 {
2757 set_error( STATUS_INVALID_PARAMETER );
2758 return;
2759 }
2760
2761 params.flags = sock->pending_events & sock->mask;
2762 for (i = 0; i < ARRAY_SIZE( params.status ); ++i)
2763 params.status[i] = sock_get_ntstatus( sock->errors[i] );
2764
2765 sock->pending_events &= ~sock->mask;
2766 sock_reselect( sock );
2767
2768 set_reply_data( &params, sizeof(params) );
2769 return;
2770 }
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_send_icmp_id)
3926 {
3927 struct sock *sock = (struct sock *)get_handle_obj( current->process, req->handle, 0, &sock_ops );
3928
3929 if (!sock) return;
3930
3931 if (sock->icmp_fixup_data_len == MAX_ICMP_HISTORY_LENGTH)
3932 {
3933 memmove( sock->icmp_fixup_data, sock->icmp_fixup_data + 1,
3934 sizeof(*sock->icmp_fixup_data) * (MAX_ICMP_HISTORY_LENGTH - 1) );
3935 --sock->icmp_fixup_data_len;
3936 }
3937
3938 sock->icmp_fixup_data[sock->icmp_fixup_data_len].icmp_id = req->icmp_id;
3939 sock->icmp_fixup_data[sock->icmp_fixup_data_len].icmp_seq = req->icmp_seq;
3940 ++sock->icmp_fixup_data_len;
3941
3942 release_object( sock );
3943 }
3944
3945 DECL_HANDLER(socket_get_icmp_id)
3946 {
3947 struct sock *sock = (struct sock *)get_handle_obj( current->process, req->handle, 0, &sock_ops );
3948 unsigned int i;
3949
3950 if (!sock) return;
3951
3952 for (i = 0; i < sock->icmp_fixup_data_len; ++i)
3953 {
3954 if (sock->icmp_fixup_data[i].icmp_seq == req->icmp_seq)
3955 {
3956 reply->icmp_id = sock->icmp_fixup_data[i].icmp_id;
3957 --sock->icmp_fixup_data_len;
3958 memmove( &sock->icmp_fixup_data[i], &sock->icmp_fixup_data[i + 1],
3959 (sock->icmp_fixup_data_len - i) * sizeof(*sock->icmp_fixup_data) );
3960 release_object( sock );
3961 return;
3962 }
3963 }
3964
3965 set_error( STATUS_NOT_FOUND );
3966 release_object( sock );
3967 }
Windows API implementation