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