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