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