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