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