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