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