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