2 * Server-side socket management
4 * Copyright (C) 1999 Marcus Meissner, Ove Kåven
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.
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.
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
20 * FIXME: we use read|write access in all cases. Shouldn't we depend that
21 * on the access of the current handle?
33 #ifdef HAVE_SYS_ERRNO_H
34 # include <sys/errno.h>
37 #include <sys/types.h>
38 #ifdef HAVE_SYS_SOCKET_H
39 # include <sys/socket.h>
41 #ifdef HAVE_SYS_IOCTL_H
42 #include <sys/ioctl.h>
44 #ifdef HAVE_SYS_FILIO_H
45 # include <sys/filio.h>
51 #define WIN32_NO_STATUS
64 #define FD_MAX_EVENTS 10
66 #define FD_WRITE_BIT 1
68 #define FD_ACCEPT_BIT 3
69 #define FD_CONNECT_BIT 4
70 #define FD_CLOSE_BIT 5
73 * Define flags to be used with the WSAAsyncSelect() call.
75 #define FD_READ 0x00000001
76 #define FD_WRITE 0x00000002
77 #define FD_OOB 0x00000004
78 #define FD_ACCEPT 0x00000008
79 #define FD_CONNECT 0x00000010
80 #define FD_CLOSE 0x00000020
82 /* internal per-socket flags */
83 #define FD_WINE_ACCEPTING 0x08000000
84 #define FD_WINE_LISTENING 0x10000000
85 #define FD_WINE_NONBLOCKING 0x20000000
86 #define FD_WINE_CONNECTED 0x40000000
87 #define FD_WINE_RAW 0x80000000
88 #define FD_WINE_INTERNAL 0xFFFF0000
90 /* Constants for WSAIoctl() */
91 #define WSA_FLAG_OVERLAPPED 0x01
95 struct object obj
; /* object header */
96 struct fd
*fd
; /* socket file descriptor */
97 unsigned int state
; /* status bits */
98 unsigned int mask
; /* event mask */
99 unsigned int hmask
; /* held (blocked) events */
100 unsigned int pmask
; /* pending events */
101 unsigned int flags
; /* socket flags */
102 int polling
; /* is socket being polled? */
103 unsigned short type
; /* socket type */
104 unsigned short family
; /* socket family */
105 struct event
*event
; /* event object */
106 user_handle_t window
; /* window to send the message to */
107 unsigned int message
; /* message to send */
108 obj_handle_t wparam
; /* message wparam (socket handle) */
109 int errors
[FD_MAX_EVENTS
]; /* event errors */
110 struct sock
*deferred
; /* socket that waits for a deferred accept */
111 struct async
*async
; /* pending accept to this socket */
112 struct list accentry
; /* entry in the list below for the request */
113 struct list paccepts
; /* pending accepts on this socket */
114 struct async_queue
*read_q
; /* queue for asynchronous reads */
115 struct async_queue
*write_q
; /* queue for asynchronous writes */
118 static void sock_dump( struct object
*obj
, int verbose
);
119 static int sock_signaled( struct object
*obj
, struct thread
*thread
);
120 static struct fd
*sock_get_fd( struct object
*obj
);
121 static void sock_destroy( struct object
*obj
);
123 static int sock_get_poll_events( struct fd
*fd
);
124 static void sock_poll_event( struct fd
*fd
, int event
);
125 static enum server_fd_type
sock_get_fd_type( struct fd
*fd
);
126 static int sock_removable( struct fd
*fd
);
127 static void sock_queue_async( struct fd
*fd
, const async_data_t
*data
, int type
, int count
);
128 static void sock_async_event( struct fd
*fd
, struct async_queue
*queue
, struct async
*async
, int status
, int finished
);
129 static int sock_async_terminated( struct fd
*fd
, struct async_queue
*queue
, struct async
*async
, int status
);
130 static void sock_cancel_async( struct fd
*fd
, struct process
*process
, struct thread
*thread
, client_ptr_t iosb
);
132 static int sock_get_ntstatus( int err
);
133 static int sock_get_error( int err
);
134 static void sock_set_error(void);
135 static int accept_into_socket( struct sock
*sock
, struct sock
*acceptsock
);
137 static const struct object_ops sock_ops
=
139 sizeof(struct sock
), /* size */
140 sock_dump
, /* dump */
141 no_get_type
, /* get_type */
142 add_queue
, /* add_queue */
143 remove_queue
, /* remove_queue */
144 sock_signaled
, /* signaled */
145 no_satisfied
, /* satisfied */
146 no_signal
, /* signal */
147 sock_get_fd
, /* get_fd */
148 default_fd_map_access
, /* map_access */
149 default_get_sd
, /* get_sd */
150 default_set_sd
, /* set_sd */
151 no_lookup_name
, /* lookup_name */
152 no_open_file
, /* open_file */
153 fd_close_handle
, /* close_handle */
154 sock_destroy
/* destroy */
157 static const struct fd_ops sock_fd_ops
=
159 sock_get_poll_events
, /* get_poll_events */
160 sock_poll_event
, /* poll_event */
161 no_flush
, /* flush */
162 sock_get_fd_type
, /* get_file_info */
163 sock_removable
, /* removable */
164 default_fd_ioctl
, /* ioctl */
165 sock_queue_async
, /* queue_async */
166 sock_async_event
, /* async_event */
167 sock_async_terminated
, /* async_terminated */
168 sock_cancel_async
/* cancel_async */
172 /* Permutation of 0..FD_MAX_EVENTS - 1 representing the order in which
173 * we post messages if there are multiple events. Used to send
174 * messages. The problem is if there is both a FD_CONNECT event and,
175 * say, an FD_READ event available on the same socket, we want to
176 * notify the app of the connect event first. Otherwise it may
177 * discard the read event because it thinks it hasn't connected yet.
179 static const int event_bitorder
[FD_MAX_EVENTS
] =
187 6, 7, 8, 9 /* leftovers */
190 /* Flags that make sense only for SOCK_STREAM sockets */
191 #define STREAM_FLAG_MASK ((unsigned int) (FD_CONNECT | FD_ACCEPT | FD_WINE_LISTENING | FD_WINE_CONNECTED))
194 SOCK_SHUTDOWN_ERROR
= -1,
195 SOCK_SHUTDOWN_EOF
= 0,
196 SOCK_SHUTDOWN_POLLHUP
= 1
199 static sock_shutdown_t sock_shutdown_type
= SOCK_SHUTDOWN_ERROR
;
201 static sock_shutdown_t
sock_check_pollhup(void)
203 sock_shutdown_t ret
= SOCK_SHUTDOWN_ERROR
;
208 if ( socketpair( AF_UNIX
, SOCK_STREAM
, 0, fd
) ) goto out
;
209 if ( shutdown( fd
[0], 1 ) ) goto out
;
215 n
= poll( &pfd
, 1, 0 );
216 if ( n
!= 1 ) goto out
; /* error or timeout */
217 if ( pfd
.revents
& POLLHUP
)
218 ret
= SOCK_SHUTDOWN_POLLHUP
;
219 else if ( pfd
.revents
& POLLIN
&&
220 read( fd
[1], &dummy
, 1 ) == 0 )
221 ret
= SOCK_SHUTDOWN_EOF
;
231 sock_shutdown_type
= sock_check_pollhup();
233 switch ( sock_shutdown_type
)
235 case SOCK_SHUTDOWN_EOF
:
236 if (debug_level
) fprintf( stderr
, "sock_init: shutdown() causes EOF\n" );
238 case SOCK_SHUTDOWN_POLLHUP
:
239 if (debug_level
) fprintf( stderr
, "sock_init: shutdown() causes POLLHUP\n" );
242 fprintf( stderr
, "sock_init: ERROR in sock_check_pollhup()\n" );
243 sock_shutdown_type
= SOCK_SHUTDOWN_EOF
;
247 static int sock_reselect( struct sock
*sock
)
249 int ev
= sock_get_poll_events( sock
->fd
);
252 fprintf(stderr
,"sock_reselect(%p): new mask %x\n", sock
, ev
);
254 if (!sock
->polling
) /* FIXME: should find a better way to do this */
256 /* previously unconnected socket, is this reselect supposed to connect it? */
257 if (!(sock
->state
& ~(FD_WINE_NONBLOCKING
|FD_WINE_ACCEPTING
))) return 0;
258 /* ok, it is, attach it to the wineserver's main poll loop */
261 /* update condition mask */
262 set_fd_events( sock
->fd
, ev
);
266 /* wake anybody waiting on the socket event or send the associated message */
267 static void sock_wake_up( struct sock
*sock
)
269 unsigned int events
= sock
->pmask
& sock
->mask
;
272 /* Do not signal events if there are still pending asynchronous IO requests */
273 /* We need this to delay FD_CLOSE events until all pending overlapped requests are processed */
274 if ( !events
|| async_queued( sock
->read_q
) || async_queued( sock
->write_q
) ) return;
278 if (debug_level
) fprintf(stderr
, "signalling events %x ptr %p\n", events
, sock
->event
);
279 set_event( sock
->event
);
283 if (debug_level
) fprintf(stderr
, "signalling events %x win %08x\n", events
, sock
->window
);
284 for (i
= 0; i
< FD_MAX_EVENTS
; i
++)
286 int event
= event_bitorder
[i
];
287 if (sock
->pmask
& (1 << event
))
289 lparam_t lparam
= (1 << event
) | (sock_get_error(sock
->errors
[event
]) << 16);
290 post_message( sock
->window
, sock
->message
, sock
->wparam
, lparam
);
294 sock_reselect( sock
);
298 static inline int sock_error( struct fd
*fd
)
300 unsigned int optval
= 0, optlen
;
302 optlen
= sizeof(optval
);
303 getsockopt( get_unix_fd(fd
), SOL_SOCKET
, SO_ERROR
, (void *) &optval
, &optlen
);
307 static void sock_dispatch_asyncs( struct sock
*sock
, int event
)
309 if ( sock
->flags
& WSA_FLAG_OVERLAPPED
)
311 if ( event
& (POLLIN
|POLLPRI
|POLLERR
|POLLHUP
) && async_waiting( sock
->read_q
))
313 if (debug_level
) fprintf( stderr
, "activating read queue for socket %p\n", sock
);
314 async_wake_up( sock
->read_q
, STATUS_ALERTED
);
316 if ( event
& (POLLOUT
|POLLERR
|POLLHUP
) && async_waiting( sock
->write_q
))
318 if (debug_level
) fprintf( stderr
, "activating write queue for socket %p\n", sock
);
319 async_wake_up( sock
->write_q
, STATUS_ALERTED
);
324 static inline void sock_free_accept_async( struct sock
*acceptsock
)
326 list_remove( &acceptsock
->accentry
);
327 acceptsock
->state
&= ~FD_WINE_ACCEPTING
;
328 acceptsock
->async
= NULL
;
331 static void sock_poll_event( struct fd
*fd
, int event
)
333 struct sock
*sock
= get_fd_user( fd
);
336 assert( sock
->obj
.ops
== &sock_ops
);
338 fprintf(stderr
, "socket %p select event: %x\n", sock
, event
);
340 /* we may change event later, remove from loop here */
341 if (event
& (POLLERR
|POLLHUP
)) set_fd_events( sock
->fd
, -1 );
343 if (sock
->state
& FD_CONNECT
)
348 /* we got connected */
349 sock
->state
|= FD_WINE_CONNECTED
|FD_READ
|FD_WRITE
;
350 sock
->state
&= ~FD_CONNECT
;
351 sock
->pmask
|= FD_CONNECT
;
352 sock
->errors
[FD_CONNECT_BIT
] = 0;
354 fprintf(stderr
, "socket %p connection success\n", sock
);
356 else if (event
& (POLLERR
|POLLHUP
))
358 /* we didn't get connected? */
359 sock
->state
&= ~FD_CONNECT
;
360 sock
->pmask
|= FD_CONNECT
;
361 sock
->errors
[FD_CONNECT_BIT
] = sock_error( fd
);
363 fprintf(stderr
, "socket %p connection failure\n", sock
);
366 else if (sock
->state
& FD_WINE_LISTENING
)
371 /* incoming connection */
372 sock
->pmask
|= FD_ACCEPT
;
373 sock
->errors
[FD_ACCEPT_BIT
] = 0;
374 sock
->hmask
|= FD_ACCEPT
;
376 else if (event
& (POLLERR
|POLLHUP
))
378 /* failed incoming connection? */
379 sock
->pmask
|= FD_ACCEPT
;
380 sock
->errors
[FD_ACCEPT_BIT
] = sock_error( fd
);
381 sock
->hmask
|= FD_ACCEPT
;
386 /* normal data flow */
387 if ( sock
->type
== SOCK_STREAM
&& ( event
& POLLIN
) )
392 /* Linux 2.4 doesn't report POLLHUP if only one side of the socket
393 * has been closed, so we need to check for it explicitly here */
394 nr
= recv( get_unix_fd( fd
), &dummy
, 1, MSG_PEEK
);
403 /* EAGAIN can happen if an async recv() falls between the server's poll()
404 call and the invocation of this routine */
405 if ( errno
!= EAGAIN
)
408 fprintf( stderr
, "recv error on socket %p: %d\n", sock
, errno
);
414 if ( event
& POLLIN
)
416 sock
->pmask
|= FD_READ
;
417 sock
->hmask
|= FD_READ
;
418 sock
->errors
[FD_READ_BIT
] = 0;
420 fprintf(stderr
, "socket %p is readable\n", sock
);
425 sock
->pmask
|= FD_WRITE
;
426 sock
->hmask
|= FD_WRITE
;
427 sock
->errors
[FD_WRITE_BIT
] = 0;
429 fprintf(stderr
, "socket %p is writable\n", sock
);
433 sock
->pmask
|= FD_OOB
;
434 sock
->hmask
|= FD_OOB
;
435 sock
->errors
[FD_OOB_BIT
] = 0;
437 fprintf(stderr
, "socket %p got OOB data\n", sock
);
440 if ( (hangup_seen
|| event
& (POLLHUP
|POLLERR
)) && (sock
->state
& (FD_READ
|FD_WRITE
)) )
442 sock
->errors
[FD_CLOSE_BIT
] = sock_error( fd
);
443 if ( (event
& POLLERR
) || ( sock_shutdown_type
== SOCK_SHUTDOWN_EOF
&& (event
& POLLHUP
) ))
444 sock
->state
&= ~FD_WRITE
;
445 sock
->state
&= ~FD_READ
;
447 sock
->pmask
|= FD_CLOSE
;
448 sock
->hmask
|= FD_CLOSE
;
450 fprintf(stderr
, "socket %p aborted by error %d, event: %x - removing from select loop\n",
451 sock
, sock
->errors
[FD_CLOSE_BIT
], event
);
458 sock_dispatch_asyncs( sock
, event
);
460 /* wake up anyone waiting for whatever just happened */
461 sock_wake_up( sock
);
463 /* if anyone is stupid enough to wait on the socket object itself,
464 * maybe we should wake them up too, just in case? */
465 wake_up( &sock
->obj
, 0 );
467 sock_reselect( sock
);
470 static void sock_dump( struct object
*obj
, int verbose
)
472 struct sock
*sock
= (struct sock
*)obj
;
473 assert( obj
->ops
== &sock_ops
);
474 printf( "Socket fd=%p, state=%x, mask=%x, pending=%x, held=%x\n",
475 sock
->fd
, sock
->state
,
476 sock
->mask
, sock
->pmask
, sock
->hmask
);
479 static int sock_signaled( struct object
*obj
, struct thread
*thread
)
481 struct sock
*sock
= (struct sock
*)obj
;
482 assert( obj
->ops
== &sock_ops
);
484 return check_fd_events( sock
->fd
, sock_get_poll_events( sock
->fd
) ) != 0;
487 static int sock_get_poll_events( struct fd
*fd
)
489 struct sock
*sock
= get_fd_user( fd
);
490 unsigned int mask
= sock
->mask
& ~sock
->hmask
;
491 unsigned int smask
= sock
->state
& mask
;
494 assert( sock
->obj
.ops
== &sock_ops
);
496 if (sock
->state
& FD_CONNECT
)
497 /* connecting, wait for writable */
499 if (sock
->state
& FD_WINE_LISTENING
)
500 /* listening, wait for readable */
501 return (mask
& FD_ACCEPT
) ? POLLIN
: 0;
503 if ( async_queued( sock
->read_q
) )
505 if ( async_waiting( sock
->read_q
) ) ev
|= POLLIN
| POLLPRI
;
507 else if (smask
& FD_READ
)
508 ev
|= POLLIN
| POLLPRI
;
509 /* We use POLLIN with 0 bytes recv() as FD_CLOSE indication for stream sockets. */
510 else if ( sock
->type
== SOCK_STREAM
&& sock
->state
& FD_READ
&& mask
& FD_CLOSE
&&
511 !(sock
->hmask
& FD_READ
) )
514 if ( async_queued( sock
->write_q
) )
516 if ( async_waiting( sock
->write_q
) ) ev
|= POLLOUT
;
518 else if (smask
& FD_WRITE
)
524 static enum server_fd_type
sock_get_fd_type( struct fd
*fd
)
526 return FD_TYPE_SOCKET
;
529 static int sock_removable( struct fd
*fd
)
531 struct sock
*sock
= get_fd_user( fd
);
532 assert( sock
->obj
.ops
== &sock_ops
);
534 /* Don't cache SOCK_STREAM sockets until connected (needed for AcceptEx) */
535 return sock
->type
== SOCK_STREAM
&& !sock
->polling
;
538 static void sock_queue_async( struct fd
*fd
, const async_data_t
*data
, int type
, int count
)
540 struct sock
*sock
= get_fd_user( fd
);
541 struct async_queue
*queue
;
543 assert( sock
->obj
.ops
== &sock_ops
);
547 case ASYNC_TYPE_READ
:
548 if (!sock
->read_q
&& !(sock
->read_q
= create_async_queue( sock
->fd
))) return;
549 queue
= sock
->read_q
;
551 case ASYNC_TYPE_WRITE
:
552 if (!sock
->write_q
&& !(sock
->write_q
= create_async_queue( sock
->fd
))) return;
553 queue
= sock
->write_q
;
556 set_error( STATUS_INVALID_PARAMETER
);
560 if ( ( !( sock
->state
& FD_READ
) && type
== ASYNC_TYPE_READ
) ||
561 ( !( sock
->state
& FD_WRITE
) && type
== ASYNC_TYPE_WRITE
) )
563 set_error( STATUS_PIPE_DISCONNECTED
);
568 if (!(async
= create_async( current
, queue
, data
))) return;
569 release_object( async
);
570 set_error( STATUS_PENDING
);
573 sock_reselect( sock
);
576 static void sock_async_event( struct fd
*fd
, struct async_queue
*queue
, struct async
*async
, int status
, int finished
)
578 struct sock
*sock
= get_fd_user( fd
);
579 struct sock
*acceptsock
, *next
;
580 assert( sock
->obj
.ops
== &sock_ops
);
584 /* Clear pending accepts */
585 LIST_FOR_EACH_ENTRY_SAFE( acceptsock
, next
, &sock
->paccepts
, struct sock
, accentry
)
587 if ( acceptsock
->async
== async
)
589 sock_free_accept_async( acceptsock
);
595 sock_reselect( sock
);
598 static int sock_async_terminated( struct fd
*fd
, struct async_queue
*queue
, struct async
*async
, int status
)
600 struct sock
*sock
= get_fd_user( fd
);
601 struct sock
*acceptsock
;
602 assert( sock
->obj
.ops
== &sock_ops
);
604 if (status
== STATUS_ALERTED
)
606 LIST_FOR_EACH_ENTRY( acceptsock
, &sock
->paccepts
, struct sock
, accentry
)
608 if ( acceptsock
->async
== async
)
610 status
= accept_into_socket( sock
, acceptsock
);
612 if (status
!= WSAEWOULDBLOCK
)
613 sock_free_accept_async( acceptsock
);
615 if (status
== STATUS_SUCCESS
)
617 sock_reselect( acceptsock
);
618 status
= STATUS_ALERTED
;
620 else if (status
== WSAEWOULDBLOCK
)
621 status
= STATUS_PENDING
;
630 static void sock_cancel_async( struct fd
*fd
, struct process
*process
, struct thread
*thread
, client_ptr_t iosb
)
632 struct sock
*sock
= get_fd_user( fd
);
634 assert( sock
->obj
.ops
== &sock_ops
);
636 n
+= async_wake_up_by( sock
->read_q
, process
, thread
, iosb
, STATUS_CANCELLED
);
637 n
+= async_wake_up_by( sock
->write_q
, process
, thread
, iosb
, STATUS_CANCELLED
);
639 set_error( STATUS_NOT_FOUND
);
642 static struct fd
*sock_get_fd( struct object
*obj
)
644 struct sock
*sock
= (struct sock
*)obj
;
645 return (struct fd
*)grab_object( sock
->fd
);
648 static void sock_destroy( struct object
*obj
)
650 struct sock
*sock
= (struct sock
*)obj
;
651 struct sock
*acceptsock
, *next
;
652 assert( obj
->ops
== &sock_ops
);
654 /* FIXME: special socket shutdown stuff? */
656 if ( sock
->deferred
)
657 release_object( sock
->deferred
);
660 async_terminate( sock
->async
, STATUS_CANCELLED
);
661 sock_free_accept_async( sock
);
663 LIST_FOR_EACH_ENTRY_SAFE( acceptsock
, next
, &sock
->paccepts
, struct sock
, accentry
)
665 /* No need to cancel, freeing queues does it */
666 sock_free_accept_async( acceptsock
);
669 free_async_queue( sock
->read_q
);
670 free_async_queue( sock
->write_q
);
671 if (sock
->event
) release_object( sock
->event
);
674 /* shut the socket down to force pending poll() calls in the client to return */
675 shutdown( get_unix_fd(sock
->fd
), SHUT_RDWR
);
676 release_object( sock
->fd
);
680 static struct sock
*alloc_sock(void)
683 if (!(sock
= alloc_object( &sock_ops
)))
698 sock
->deferred
= NULL
;
700 list_init( &sock
->paccepts
);
702 sock
->write_q
= NULL
;
707 /* create a new and unconnected socket */
708 static struct object
*create_socket( int family
, int type
, int protocol
, unsigned int flags
)
713 sockfd
= socket( family
, type
, protocol
);
715 fprintf(stderr
,"socket(%d,%d,%d)=%d\n",family
,type
,protocol
,sockfd
);
721 fcntl(sockfd
, F_SETFL
, O_NONBLOCK
); /* make socket nonblocking */
722 if (!(sock
= alloc_sock()))
727 sock
->state
= (type
!= SOCK_STREAM
) ? (FD_READ
|FD_WRITE
) : 0;
730 sock
->family
= family
;
731 memset( sock
->errors
, 0, sizeof(sock
->errors
) );
732 if (!(sock
->fd
= create_anonymous_fd( &sock_fd_ops
, sockfd
, &sock
->obj
,
733 (flags
& WSA_FLAG_OVERLAPPED
) ? 0 : FILE_SYNCHRONOUS_IO_NONALERT
)))
735 release_object( sock
);
738 sock_reselect( sock
);
743 /* accepts a socket and inits it */
744 static int accept_new_fd( struct sock
*sock
)
747 /* Try to accept(2). We can't be safe that this an already connected socket
748 * or that accept() is allowed on it. In those cases we will get -1/errno
752 struct sockaddr saddr
;
753 unsigned int slen
= sizeof(saddr
);
754 acceptfd
= accept( get_unix_fd(sock
->fd
), &saddr
, &slen
);
758 fcntl(acceptfd
, F_SETFL
, O_NONBLOCK
); /* make socket nonblocking */
762 static int accept_into_socket( struct sock
*sock
, struct sock
*acceptsock
)
766 if ( sock
->deferred
)
768 acceptfd
= dup( get_unix_fd(sock
->deferred
->fd
) );
769 if ( acceptfd
== -1 )
770 return sock_get_error(errno
);
772 /* Make sure we destroy fd first, so shutdown() isn't called */
773 oldfd
= sock
->deferred
->fd
;
774 sock
->deferred
->fd
= NULL
;
775 release_object( sock
->deferred
);
776 sock
->deferred
= NULL
;
777 release_object( oldfd
);
781 if ((acceptfd
= accept_new_fd( sock
)) == -1)
782 return sock_get_error(errno
);
785 /* FIXME: need to copy sockopts from the old fd */
786 if ( dup2( acceptfd
, get_unix_fd(acceptsock
->fd
) ) == -1 )
789 return sock_get_error(errno
);
793 /* FIXME: Move these into SO_UPDATE_ACCEPT_CONTEXT + validation */
794 acceptsock
->state
|= FD_WINE_CONNECTED
|FD_READ
|FD_WRITE
;
795 acceptsock
->mask
= sock
->mask
;
796 acceptsock
->hmask
= 0;
797 acceptsock
->pmask
= 0;
798 acceptsock
->polling
= 0;
799 acceptsock
->type
= sock
->type
;
800 acceptsock
->family
= sock
->family
;
801 acceptsock
->window
= sock
->window
;
802 acceptsock
->message
= sock
->message
;
803 acceptsock
->wparam
= 0;
804 if (acceptsock
->event
) release_object(acceptsock
->event
);
805 acceptsock
->event
= NULL
;
806 if (sock
->event
) acceptsock
->event
= (struct event
*)grab_object( sock
->event
);
807 acceptsock
->deferred
= NULL
;
809 sock
->pmask
&= ~FD_ACCEPT
;
810 sock
->hmask
&= ~FD_ACCEPT
;
811 sock_reselect( sock
);
813 return STATUS_SUCCESS
;
816 /* accept a socket (creates a new fd) */
817 static struct sock
*accept_socket( struct sock
*sock
)
819 struct sock
*acceptsock
;
822 if ( sock
->deferred
)
824 acceptsock
= sock
->deferred
;
825 sock
->deferred
= NULL
;
829 if ((acceptfd
= accept_new_fd( sock
)) == -1)
835 if (!(acceptsock
= alloc_sock()))
841 /* newly created socket gets the same properties of the listening socket */
842 acceptsock
->state
= FD_WINE_CONNECTED
|FD_READ
|FD_WRITE
;
843 if (sock
->state
& FD_WINE_NONBLOCKING
)
844 acceptsock
->state
|= FD_WINE_NONBLOCKING
;
845 acceptsock
->mask
= sock
->mask
;
846 acceptsock
->type
= sock
->type
;
847 acceptsock
->family
= sock
->family
;
848 acceptsock
->window
= sock
->window
;
849 acceptsock
->message
= sock
->message
;
850 if (sock
->event
) acceptsock
->event
= (struct event
*)grab_object( sock
->event
);
851 acceptsock
->flags
= sock
->flags
;
852 memset( acceptsock
->errors
, 0, sizeof(acceptsock
->errors
) );
853 if (!(acceptsock
->fd
= create_anonymous_fd( &sock_fd_ops
, acceptfd
, &acceptsock
->obj
,
854 get_fd_options( sock
->fd
) )))
856 release_object( acceptsock
);
861 sock
->pmask
&= ~FD_ACCEPT
;
862 sock
->hmask
&= ~FD_ACCEPT
;
863 sock_reselect( sock
);
867 /* set the last error depending on errno */
868 static int sock_get_error( int err
)
872 case EINTR
: return WSAEINTR
;
873 case EBADF
: return WSAEBADF
;
875 case EACCES
: return WSAEACCES
;
876 case EFAULT
: return WSAEFAULT
;
877 case EINVAL
: return WSAEINVAL
;
878 case EMFILE
: return WSAEMFILE
;
879 case EWOULDBLOCK
: return WSAEWOULDBLOCK
;
880 case EINPROGRESS
: return WSAEINPROGRESS
;
881 case EALREADY
: return WSAEALREADY
;
882 case ENOTSOCK
: return WSAENOTSOCK
;
883 case EDESTADDRREQ
: return WSAEDESTADDRREQ
;
884 case EMSGSIZE
: return WSAEMSGSIZE
;
885 case EPROTOTYPE
: return WSAEPROTOTYPE
;
886 case ENOPROTOOPT
: return WSAENOPROTOOPT
;
887 case EPROTONOSUPPORT
: return WSAEPROTONOSUPPORT
;
888 case ESOCKTNOSUPPORT
: return WSAESOCKTNOSUPPORT
;
889 case EOPNOTSUPP
: return WSAEOPNOTSUPP
;
890 case EPFNOSUPPORT
: return WSAEPFNOSUPPORT
;
891 case EAFNOSUPPORT
: return WSAEAFNOSUPPORT
;
892 case EADDRINUSE
: return WSAEADDRINUSE
;
893 case EADDRNOTAVAIL
: return WSAEADDRNOTAVAIL
;
894 case ENETDOWN
: return WSAENETDOWN
;
895 case ENETUNREACH
: return WSAENETUNREACH
;
896 case ENETRESET
: return WSAENETRESET
;
897 case ECONNABORTED
: return WSAECONNABORTED
;
899 case ECONNRESET
: return WSAECONNRESET
;
900 case ENOBUFS
: return WSAENOBUFS
;
901 case EISCONN
: return WSAEISCONN
;
902 case ENOTCONN
: return WSAENOTCONN
;
903 case ESHUTDOWN
: return WSAESHUTDOWN
;
904 case ETOOMANYREFS
: return WSAETOOMANYREFS
;
905 case ETIMEDOUT
: return WSAETIMEDOUT
;
906 case ECONNREFUSED
: return WSAECONNREFUSED
;
907 case ELOOP
: return WSAELOOP
;
908 case ENAMETOOLONG
: return WSAENAMETOOLONG
;
909 case EHOSTDOWN
: return WSAEHOSTDOWN
;
910 case EHOSTUNREACH
: return WSAEHOSTUNREACH
;
911 case ENOTEMPTY
: return WSAENOTEMPTY
;
913 case EPROCLIM
: return WSAEPROCLIM
;
916 case EUSERS
: return WSAEUSERS
;
919 case EDQUOT
: return WSAEDQUOT
;
922 case ESTALE
: return WSAESTALE
;
925 case EREMOTE
: return WSAEREMOTE
;
931 perror("wineserver: sock_get_error() can't map error");
936 static int sock_get_ntstatus( int err
)
940 case EBADF
: return STATUS_INVALID_HANDLE
;
941 case EBUSY
: return STATUS_DEVICE_BUSY
;
943 case EACCES
: return STATUS_ACCESS_DENIED
;
944 case EFAULT
: return STATUS_NO_MEMORY
;
945 case EINVAL
: return STATUS_INVALID_PARAMETER
;
947 case EMFILE
: return STATUS_TOO_MANY_OPENED_FILES
;
948 case EWOULDBLOCK
: return STATUS_CANT_WAIT
;
949 case EINPROGRESS
: return STATUS_PENDING
;
950 case EALREADY
: return STATUS_NETWORK_BUSY
;
951 case ENOTSOCK
: return STATUS_OBJECT_TYPE_MISMATCH
;
952 case EDESTADDRREQ
: return STATUS_INVALID_PARAMETER
;
953 case EMSGSIZE
: return STATUS_BUFFER_OVERFLOW
;
954 case EPROTONOSUPPORT
:
955 case ESOCKTNOSUPPORT
:
958 case EPROTOTYPE
: return STATUS_NOT_SUPPORTED
;
959 case ENOPROTOOPT
: return STATUS_INVALID_PARAMETER
;
960 case EOPNOTSUPP
: return STATUS_NOT_SUPPORTED
;
961 case EADDRINUSE
: return STATUS_ADDRESS_ALREADY_ASSOCIATED
;
962 case EADDRNOTAVAIL
: return STATUS_INVALID_PARAMETER
;
963 case ECONNREFUSED
: return STATUS_CONNECTION_REFUSED
;
964 case ESHUTDOWN
: return STATUS_PIPE_DISCONNECTED
;
965 case ENOTCONN
: return STATUS_CONNECTION_DISCONNECTED
;
966 case ETIMEDOUT
: return STATUS_IO_TIMEOUT
;
967 case ENETUNREACH
: return STATUS_NETWORK_UNREACHABLE
;
968 case EHOSTUNREACH
: return STATUS_HOST_UNREACHABLE
;
969 case ENETDOWN
: return STATUS_NETWORK_BUSY
;
971 case ECONNRESET
: return STATUS_CONNECTION_RESET
;
972 case ECONNABORTED
: return STATUS_CONNECTION_ABORTED
;
974 case 0: return STATUS_SUCCESS
;
977 perror("wineserver: sock_get_ntstatus() can't map error");
978 return STATUS_UNSUCCESSFUL
;
982 /* set the last error depending on errno */
983 static void sock_set_error(void)
985 set_error( sock_get_ntstatus( errno
) );
988 /* create a socket */
989 DECL_HANDLER(create_socket
)
994 if ((obj
= create_socket( req
->family
, req
->type
, req
->protocol
, req
->flags
)) != NULL
)
996 reply
->handle
= alloc_handle( current
->process
, obj
, req
->access
, req
->attributes
);
997 release_object( obj
);
1001 /* accept a socket */
1002 DECL_HANDLER(accept_socket
)
1004 struct sock
*sock
, *acceptsock
;
1007 if (!(sock
= (struct sock
*)get_handle_obj( current
->process
, req
->lhandle
,
1008 FILE_READ_ATTRIBUTES
|FILE_WRITE_ATTRIBUTES
|FILE_READ_DATA
, &sock_ops
)))
1011 if ((acceptsock
= accept_socket( sock
)) != NULL
)
1013 reply
->handle
= alloc_handle( current
->process
, &acceptsock
->obj
, req
->access
, req
->attributes
);
1014 acceptsock
->wparam
= reply
->handle
; /* wparam for message is the socket handle */
1015 sock_reselect( acceptsock
);
1017 release_object( acceptsock
);
1019 release_object( sock
);
1022 /* set socket event parameters */
1023 DECL_HANDLER(set_socket_event
)
1026 struct event
*old_event
;
1029 if (!(sock
= (struct sock
*)get_handle_obj( current
->process
, req
->handle
,
1030 FILE_WRITE_ATTRIBUTES
, &sock_ops
))) return;
1031 old_event
= sock
->event
;
1032 sock
->mask
= req
->mask
;
1033 sock
->hmask
&= ~req
->mask
; /* re-enable held events */
1035 sock
->window
= req
->window
;
1036 sock
->message
= req
->msg
;
1037 sock
->wparam
= req
->handle
; /* wparam is the socket handle */
1038 if (req
->event
) sock
->event
= get_event_obj( current
->process
, req
->event
, EVENT_MODIFY_STATE
);
1040 if (debug_level
&& sock
->event
) fprintf(stderr
, "event ptr: %p\n", sock
->event
);
1042 pollev
= sock_reselect( sock
);
1045 sock
->state
|= FD_WINE_NONBLOCKING
;
1047 /* if a network event is pending, signal the event object
1048 it is possible that FD_CONNECT or FD_ACCEPT network events has happened
1049 before a WSAEventSelect() was done on it.
1050 (when dealing with Asynchronous socket) */
1051 sock_wake_up( sock
);
1053 if (old_event
) release_object( old_event
); /* we're through with it */
1054 release_object( &sock
->obj
);
1057 /* get socket event parameters */
1058 DECL_HANDLER(get_socket_event
)
1062 int errors
[FD_MAX_EVENTS
];
1064 sock
= (struct sock
*)get_handle_obj( current
->process
, req
->handle
, FILE_READ_ATTRIBUTES
, &sock_ops
);
1072 reply
->mask
= sock
->mask
;
1073 reply
->pmask
= sock
->pmask
;
1074 reply
->state
= sock
->state
;
1075 for (i
= 0; i
< FD_MAX_EVENTS
; i
++)
1076 errors
[i
] = sock_get_ntstatus(sock
->errors
[i
]);
1078 set_reply_data( errors
, min( get_reply_max_size(), sizeof(errors
) ));
1084 struct event
*cevent
= get_event_obj( current
->process
, req
->c_event
,
1085 EVENT_MODIFY_STATE
);
1088 reset_event( cevent
);
1089 release_object( cevent
);
1093 sock_reselect( sock
);
1095 release_object( &sock
->obj
);
1098 /* re-enable pending socket events */
1099 DECL_HANDLER(enable_socket_event
)
1103 if (!(sock
= (struct sock
*)get_handle_obj( current
->process
, req
->handle
,
1104 FILE_WRITE_ATTRIBUTES
, &sock_ops
)))
1107 sock
->pmask
&= ~req
->mask
; /* is this safe? */
1108 sock
->hmask
&= ~req
->mask
;
1109 sock
->state
|= req
->sstate
;
1110 sock
->state
&= ~req
->cstate
;
1111 if ( sock
->type
!= SOCK_STREAM
) sock
->state
&= ~STREAM_FLAG_MASK
;
1113 sock_reselect( sock
);
1115 release_object( &sock
->obj
);
1118 DECL_HANDLER(set_socket_deferred
)
1120 struct sock
*sock
, *acceptsock
;
1122 sock
=(struct sock
*)get_handle_obj( current
->process
, req
->handle
, FILE_WRITE_ATTRIBUTES
, &sock_ops
);
1126 acceptsock
= (struct sock
*)get_handle_obj( current
->process
, req
->deferred
, 0, &sock_ops
);
1129 release_object( sock
);
1132 sock
->deferred
= acceptsock
;
1133 release_object( sock
);
1136 DECL_HANDLER(register_accept_async
)
1138 struct sock
*sock
, *acceptsock
;
1140 sock
= (struct sock
*)get_handle_obj( current
->process
, req
->data
.handle
,
1141 FILE_READ_ATTRIBUTES
, &sock_ops
);
1144 set_error( STATUS_OBJECT_TYPE_MISMATCH
);
1147 if ( !(sock
->state
& FD_WINE_LISTENING
) )
1149 release_object( sock
);
1150 set_error( STATUS_OBJECT_TYPE_MISMATCH
);
1154 acceptsock
= (struct sock
*)get_handle_obj( current
->process
, req
->ahandle
,
1155 FILE_WRITE_ATTRIBUTES
, &sock_ops
);
1158 release_object( sock
);
1159 set_error( STATUS_INVALID_PARAMETER
);
1162 if ( acceptsock
->state
& ~FD_WINE_NONBLOCKING
)
1164 release_object( acceptsock
);
1165 release_object( sock
);
1166 set_error( STATUS_INVALID_PARAMETER
);
1170 if (!sock
->read_q
&& !(sock
->read_q
= create_async_queue( sock
->fd
))) return;
1172 acceptsock
->async
= create_async( current
, sock
->read_q
, &req
->data
);
1173 if ( !acceptsock
->async
)
1175 release_object( acceptsock
);
1176 release_object( sock
);
1180 list_add_tail( &sock
->paccepts
, &acceptsock
->accentry
);
1181 acceptsock
->state
|= FD_WINE_ACCEPTING
;
1182 release_object( acceptsock
->async
);
1184 sock_reselect( sock
);
1186 set_error( STATUS_PENDING
);
1188 release_object( acceptsock
);
1189 release_object( sock
);