winex11.drv: GetAsyncKeyState must check mouse buttons, too.
[wine.git] / server / sock.c
blob817c6bd2c3b2f77105c797ecaf43cb5e5abc42d4
1 /*
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?
24 #include "config.h"
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_SYS_ERRNO_H
34 # include <sys/errno.h>
35 #endif
36 #include <sys/time.h>
37 #include <sys/types.h>
38 #ifdef HAVE_SYS_SOCKET_H
39 # include <sys/socket.h>
40 #endif
41 #ifdef HAVE_SYS_IOCTL_H
42 #include <sys/ioctl.h>
43 #endif
44 #ifdef HAVE_SYS_FILIO_H
45 # include <sys/filio.h>
46 #endif
47 #include <time.h>
48 #include <unistd.h>
50 #include "ntstatus.h"
51 #define WIN32_NO_STATUS
52 #include "windef.h"
53 #include "winternl.h"
55 #include "process.h"
56 #include "file.h"
57 #include "handle.h"
58 #include "thread.h"
59 #include "request.h"
60 #include "user.h"
62 /* To avoid conflicts with the Unix socket headers. Plus we only need a few
63 * macros anyway.
65 #define USE_WS_PREFIX
66 #include "winsock2.h"
68 struct sock
70 struct object obj; /* object header */
71 struct fd *fd; /* socket file descriptor */
72 unsigned int state; /* status bits */
73 unsigned int mask; /* event mask */
74 unsigned int hmask; /* held (blocked) events */
75 unsigned int pmask; /* pending events */
76 unsigned int flags; /* socket flags */
77 int polling; /* is socket being polled? */
78 unsigned short type; /* socket type */
79 unsigned short family; /* socket family */
80 struct event *event; /* event object */
81 user_handle_t window; /* window to send the message to */
82 unsigned int message; /* message to send */
83 obj_handle_t wparam; /* message wparam (socket handle) */
84 int errors[FD_MAX_EVENTS]; /* event errors */
85 struct sock *deferred; /* socket that waits for a deferred accept */
86 struct async_queue *read_q; /* queue for asynchronous reads */
87 struct async_queue *write_q; /* queue for asynchronous writes */
90 static void sock_dump( struct object *obj, int verbose );
91 static int sock_signaled( struct object *obj, struct thread *thread );
92 static struct fd *sock_get_fd( struct object *obj );
93 static unsigned int sock_map_access( struct object *obj, unsigned int access );
94 static void sock_destroy( struct object *obj );
96 static int sock_get_poll_events( struct fd *fd );
97 static void sock_poll_event( struct fd *fd, int event );
98 static enum server_fd_type sock_get_fd_type( struct fd *fd );
99 static void sock_queue_async( struct fd *fd, const async_data_t *data, int type, int count );
100 static void sock_reselect_async( struct fd *fd, struct async_queue *queue );
101 static void sock_cancel_async( struct fd *fd );
103 static int sock_get_error( int err );
104 static void sock_set_error(void);
106 static const struct object_ops sock_ops =
108 sizeof(struct sock), /* size */
109 sock_dump, /* dump */
110 add_queue, /* add_queue */
111 remove_queue, /* remove_queue */
112 sock_signaled, /* signaled */
113 no_satisfied, /* satisfied */
114 no_signal, /* signal */
115 sock_get_fd, /* get_fd */
116 sock_map_access, /* map_access */
117 no_lookup_name, /* lookup_name */
118 no_open_file, /* open_file */
119 fd_close_handle, /* close_handle */
120 sock_destroy /* destroy */
123 static const struct fd_ops sock_fd_ops =
125 sock_get_poll_events, /* get_poll_events */
126 sock_poll_event, /* poll_event */
127 no_flush, /* flush */
128 sock_get_fd_type, /* get_file_info */
129 sock_queue_async, /* queue_async */
130 sock_reselect_async, /* reselect_async */
131 sock_cancel_async /* cancel_async */
135 /* Permutation of 0..FD_MAX_EVENTS - 1 representing the order in which
136 * we post messages if there are multiple events. Used to send
137 * messages. The problem is if there is both a FD_CONNECT event and,
138 * say, an FD_READ event available on the same socket, we want to
139 * notify the app of the connect event first. Otherwise it may
140 * discard the read event because it thinks it hasn't connected yet.
142 static const int event_bitorder[FD_MAX_EVENTS] =
144 FD_CONNECT_BIT,
145 FD_ACCEPT_BIT,
146 FD_OOB_BIT,
147 FD_WRITE_BIT,
148 FD_READ_BIT,
149 FD_CLOSE_BIT,
150 6, 7, 8, 9 /* leftovers */
153 /* Flags that make sense only for SOCK_STREAM sockets */
154 #define STREAM_FLAG_MASK ((unsigned int) (FD_CONNECT | FD_ACCEPT | FD_WINE_LISTENING | FD_WINE_CONNECTED))
156 typedef enum {
157 SOCK_SHUTDOWN_ERROR = -1,
158 SOCK_SHUTDOWN_EOF = 0,
159 SOCK_SHUTDOWN_POLLHUP = 1
160 } sock_shutdown_t;
162 static sock_shutdown_t sock_shutdown_type = SOCK_SHUTDOWN_ERROR;
164 static sock_shutdown_t sock_check_pollhup(void)
166 sock_shutdown_t ret = SOCK_SHUTDOWN_ERROR;
167 int fd[2], n;
168 struct pollfd pfd;
169 char dummy;
171 if ( socketpair( AF_UNIX, SOCK_STREAM, 0, fd ) ) goto out;
172 if ( shutdown( fd[0], 1 ) ) goto out;
174 pfd.fd = fd[1];
175 pfd.events = POLLIN;
176 pfd.revents = 0;
178 n = poll( &pfd, 1, 0 );
179 if ( n != 1 ) goto out; /* error or timeout */
180 if ( pfd.revents & POLLHUP )
181 ret = SOCK_SHUTDOWN_POLLHUP;
182 else if ( pfd.revents & POLLIN &&
183 read( fd[1], &dummy, 1 ) == 0 )
184 ret = SOCK_SHUTDOWN_EOF;
186 out:
187 close( fd[0] );
188 close( fd[1] );
189 return ret;
192 void sock_init(void)
194 sock_shutdown_type = sock_check_pollhup();
196 switch ( sock_shutdown_type )
198 case SOCK_SHUTDOWN_EOF:
199 if (debug_level) fprintf( stderr, "sock_init: shutdown() causes EOF\n" );
200 break;
201 case SOCK_SHUTDOWN_POLLHUP:
202 if (debug_level) fprintf( stderr, "sock_init: shutdown() causes POLLHUP\n" );
203 break;
204 default:
205 fprintf( stderr, "sock_init: ERROR in sock_check_pollhup()\n" );
206 sock_shutdown_type = SOCK_SHUTDOWN_EOF;
210 static int sock_reselect( struct sock *sock )
212 int ev = sock_get_poll_events( sock->fd );
214 if (debug_level)
215 fprintf(stderr,"sock_reselect(%p): new mask %x\n", sock, ev);
217 if (!sock->polling) /* FIXME: should find a better way to do this */
219 /* previously unconnected socket, is this reselect supposed to connect it? */
220 if (!(sock->state & ~FD_WINE_NONBLOCKING)) return 0;
221 /* ok, it is, attach it to the wineserver's main poll loop */
222 sock->polling = 1;
224 /* update condition mask */
225 set_fd_events( sock->fd, ev );
226 return ev;
229 /* After POLLHUP is received, the socket will no longer be in the main select loop.
230 This function is used to signal pending events nevertheless */
231 static void sock_try_event( struct sock *sock, int event )
233 event = check_fd_events( sock->fd, event );
234 if (event)
236 if ( debug_level ) fprintf( stderr, "sock_try_event: %x\n", event );
237 sock_poll_event( sock->fd, event );
241 /* wake anybody waiting on the socket event or send the associated message */
242 static void sock_wake_up( struct sock *sock, int pollev )
244 unsigned int events = sock->pmask & sock->mask;
245 int i;
246 int async_active = 0;
248 if ( pollev & (POLLIN|POLLPRI) && async_waiting( sock->read_q ))
250 if (debug_level) fprintf( stderr, "activating read queue for socket %p\n", sock );
251 async_wake_up( sock->read_q, STATUS_ALERTED );
252 async_active = 1;
254 if ( pollev & POLLOUT && async_waiting( sock->write_q ))
256 if (debug_level) fprintf( stderr, "activating write queue for socket %p\n", sock );
257 async_wake_up( sock->write_q, STATUS_ALERTED );
258 async_active = 1;
261 /* Do not signal events if there are still pending asynchronous IO requests */
262 /* We need this to delay FD_CLOSE events until all pending overlapped requests are processed */
263 if ( !events || async_active ) return;
265 if (sock->event)
267 if (debug_level) fprintf(stderr, "signalling events %x ptr %p\n", events, sock->event );
268 set_event( sock->event );
270 if (sock->window)
272 if (debug_level) fprintf(stderr, "signalling events %x win %p\n", events, sock->window );
273 for (i = 0; i < FD_MAX_EVENTS; i++)
275 int event = event_bitorder[i];
276 if (sock->pmask & (1 << event))
278 unsigned int lparam = (1 << event) | (sock->errors[event] << 16);
279 post_message( sock->window, sock->message, (unsigned long)sock->wparam, lparam );
282 sock->pmask = 0;
283 sock_reselect( sock );
287 static inline int sock_error( struct fd *fd )
289 unsigned int optval = 0, optlen;
291 optlen = sizeof(optval);
292 getsockopt( get_unix_fd(fd), SOL_SOCKET, SO_ERROR, (void *) &optval, &optlen);
293 return optval ? sock_get_error(optval) : 0;
296 static void sock_poll_event( struct fd *fd, int event )
298 struct sock *sock = get_fd_user( fd );
299 int hangup_seen = 0;
301 assert( sock->obj.ops == &sock_ops );
302 if (debug_level)
303 fprintf(stderr, "socket %p select event: %x\n", sock, event);
304 if (sock->state & FD_CONNECT)
306 /* connecting */
307 if (event & POLLOUT)
309 /* we got connected */
310 sock->state |= FD_WINE_CONNECTED|FD_READ|FD_WRITE;
311 sock->state &= ~FD_CONNECT;
312 sock->pmask |= FD_CONNECT;
313 sock->errors[FD_CONNECT_BIT] = 0;
314 if (debug_level)
315 fprintf(stderr, "socket %p connection success\n", sock);
317 else if (event & (POLLERR|POLLHUP))
319 /* we didn't get connected? */
320 sock->state &= ~FD_CONNECT;
321 sock->pmask |= FD_CONNECT;
322 sock->errors[FD_CONNECT_BIT] = sock_error( fd );
323 if (debug_level)
324 fprintf(stderr, "socket %p connection failure\n", sock);
327 else if (sock->state & FD_WINE_LISTENING)
329 /* listening */
330 if (event & POLLIN)
332 /* incoming connection */
333 sock->pmask |= FD_ACCEPT;
334 sock->errors[FD_ACCEPT_BIT] = 0;
335 sock->hmask |= FD_ACCEPT;
337 else if (event & (POLLERR|POLLHUP))
339 /* failed incoming connection? */
340 sock->pmask |= FD_ACCEPT;
341 sock->errors[FD_ACCEPT_BIT] = sock_error( fd );
342 sock->hmask |= FD_ACCEPT;
345 else
347 /* normal data flow */
348 if ( sock->type == SOCK_STREAM && ( event & POLLIN ) )
350 char dummy;
351 int nr;
353 /* Linux 2.4 doesn't report POLLHUP if only one side of the socket
354 * has been closed, so we need to check for it explicitly here */
355 nr = recv( get_unix_fd( fd ), &dummy, 1, MSG_PEEK );
356 if ( nr > 0 )
358 /* incoming data */
359 sock->pmask |= FD_READ;
360 sock->hmask |= (FD_READ|FD_CLOSE);
361 sock->errors[FD_READ_BIT] = 0;
362 if (debug_level)
363 fprintf(stderr, "socket %p is readable\n", sock );
365 else if ( nr == 0 )
366 hangup_seen = 1;
367 else
369 /* EAGAIN can happen if an async recv() falls between the server's poll()
370 call and the invocation of this routine */
371 if ( errno == EAGAIN )
372 event &= ~POLLIN;
373 else
375 if ( debug_level )
376 fprintf( stderr, "recv error on socket %p: %d\n", sock, errno );
377 event = POLLERR;
382 else if ( sock_shutdown_type == SOCK_SHUTDOWN_POLLHUP && (event & POLLHUP) )
384 hangup_seen = 1;
386 else if ( event & POLLIN ) /* POLLIN for non-stream socket */
388 sock->pmask |= FD_READ;
389 sock->hmask |= (FD_READ|FD_CLOSE);
390 sock->errors[FD_READ_BIT] = 0;
391 if (debug_level)
392 fprintf(stderr, "socket %p is readable\n", sock );
396 if (event & POLLOUT)
398 sock->pmask |= FD_WRITE;
399 sock->hmask |= FD_WRITE;
400 sock->errors[FD_WRITE_BIT] = 0;
401 if (debug_level)
402 fprintf(stderr, "socket %p is writable\n", sock);
404 if (event & POLLPRI)
406 sock->pmask |= FD_OOB;
407 sock->hmask |= FD_OOB;
408 sock->errors[FD_OOB_BIT] = 0;
409 if (debug_level)
410 fprintf(stderr, "socket %p got OOB data\n", sock);
412 /* According to WS2 specs, FD_CLOSE is only delivered when there is
413 no more data to be read (i.e. hangup_seen = 1) */
414 else if ( hangup_seen && (sock->state & (FD_READ|FD_WRITE) ))
416 sock->errors[FD_CLOSE_BIT] = sock_error( fd );
417 if ( (event & POLLERR) || ( sock_shutdown_type == SOCK_SHUTDOWN_EOF && (event & POLLHUP) ))
418 sock->state &= ~FD_WRITE;
419 sock->pmask |= FD_CLOSE;
420 sock->hmask |= FD_CLOSE;
421 if (debug_level)
422 fprintf(stderr, "socket %p aborted by error %d, event: %x - removing from select loop\n",
423 sock, sock->errors[FD_CLOSE_BIT], event);
427 if ( sock->pmask & FD_CLOSE || event & (POLLERR|POLLHUP) )
429 if ( debug_level )
430 fprintf( stderr, "removing socket %p from select loop\n", sock );
431 set_fd_events( sock->fd, -1 );
433 else
434 sock_reselect( sock );
436 /* wake up anyone waiting for whatever just happened */
437 if ( sock->pmask & sock->mask || sock->flags & WSA_FLAG_OVERLAPPED ) sock_wake_up( sock, event );
439 /* if anyone is stupid enough to wait on the socket object itself,
440 * maybe we should wake them up too, just in case? */
441 wake_up( &sock->obj, 0 );
444 static void sock_dump( struct object *obj, int verbose )
446 struct sock *sock = (struct sock *)obj;
447 assert( obj->ops == &sock_ops );
448 printf( "Socket fd=%p, state=%x, mask=%x, pending=%x, held=%x\n",
449 sock->fd, sock->state,
450 sock->mask, sock->pmask, sock->hmask );
453 static int sock_signaled( struct object *obj, struct thread *thread )
455 struct sock *sock = (struct sock *)obj;
456 assert( obj->ops == &sock_ops );
458 return check_fd_events( sock->fd, sock_get_poll_events( sock->fd ) ) != 0;
461 static unsigned int sock_map_access( struct object *obj, unsigned int access )
463 if (access & GENERIC_READ) access |= FILE_GENERIC_READ;
464 if (access & GENERIC_WRITE) access |= FILE_GENERIC_WRITE;
465 if (access & GENERIC_EXECUTE) access |= FILE_GENERIC_EXECUTE;
466 if (access & GENERIC_ALL) access |= FILE_ALL_ACCESS;
467 return access & ~(GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | GENERIC_ALL);
470 static int sock_get_poll_events( struct fd *fd )
472 struct sock *sock = get_fd_user( fd );
473 unsigned int mask = sock->mask & sock->state & ~sock->hmask;
474 int ev = 0;
476 assert( sock->obj.ops == &sock_ops );
478 if (sock->state & FD_CONNECT)
479 /* connecting, wait for writable */
480 return POLLOUT;
481 if (sock->state & FD_WINE_LISTENING)
482 /* listening, wait for readable */
483 return (sock->hmask & FD_ACCEPT) ? 0 : POLLIN;
485 if (mask & FD_READ || async_waiting( sock->read_q )) ev |= POLLIN | POLLPRI;
486 if (mask & FD_WRITE || async_waiting( sock->write_q )) ev |= POLLOUT;
487 /* We use POLLIN with 0 bytes recv() as FD_CLOSE indication for stream sockets. */
488 if ( sock->type == SOCK_STREAM && ( sock->mask & ~sock->hmask & FD_CLOSE) )
489 ev |= POLLIN;
491 return ev;
494 static enum server_fd_type sock_get_fd_type( struct fd *fd )
496 return FD_TYPE_SOCKET;
499 static void sock_queue_async( struct fd *fd, const async_data_t *data, int type, int count )
501 struct sock *sock = get_fd_user( fd );
502 struct async_queue *queue;
503 int pollev;
505 assert( sock->obj.ops == &sock_ops );
507 switch (type)
509 case ASYNC_TYPE_READ:
510 if (!sock->read_q && !(sock->read_q = create_async_queue( sock->fd ))) return;
511 queue = sock->read_q;
512 sock->hmask &= ~FD_CLOSE;
513 break;
514 case ASYNC_TYPE_WRITE:
515 if (!sock->write_q && !(sock->write_q = create_async_queue( sock->fd ))) return;
516 queue = sock->write_q;
517 break;
518 default:
519 set_error( STATUS_INVALID_PARAMETER );
520 return;
523 if ( ( !( sock->state & FD_READ ) && type == ASYNC_TYPE_READ ) ||
524 ( !( sock->state & FD_WRITE ) && type == ASYNC_TYPE_WRITE ) )
526 set_error( STATUS_PIPE_DISCONNECTED );
528 else
530 struct async *async;
531 if (!(async = create_async( current, queue, data ))) return;
532 release_object( async );
533 set_error( STATUS_PENDING );
536 pollev = sock_reselect( sock );
537 if ( pollev ) sock_try_event( sock, pollev );
540 static void sock_reselect_async( struct fd *fd, struct async_queue *queue )
542 struct sock *sock = get_fd_user( fd );
543 int events = sock_reselect( sock );
544 if (events) sock_try_event( sock, events );
547 static void sock_cancel_async( struct fd *fd )
549 struct sock *sock = get_fd_user( fd );
550 assert( sock->obj.ops == &sock_ops );
552 async_wake_up( sock->read_q, STATUS_CANCELLED );
553 async_wake_up( sock->write_q, STATUS_CANCELLED );
556 static struct fd *sock_get_fd( struct object *obj )
558 struct sock *sock = (struct sock *)obj;
559 return (struct fd *)grab_object( sock->fd );
562 static void sock_destroy( struct object *obj )
564 struct sock *sock = (struct sock *)obj;
565 assert( obj->ops == &sock_ops );
567 /* FIXME: special socket shutdown stuff? */
569 if ( sock->deferred )
570 release_object( sock->deferred );
572 free_async_queue( sock->read_q );
573 free_async_queue( sock->write_q );
574 if (sock->event) release_object( sock->event );
575 if (sock->fd)
577 /* shut the socket down to force pending poll() calls in the client to return */
578 shutdown( get_unix_fd(sock->fd), SHUT_RDWR );
579 release_object( sock->fd );
583 /* create a new and unconnected socket */
584 static struct object *create_socket( int family, int type, int protocol, unsigned int flags )
586 struct sock *sock;
587 int sockfd;
589 sockfd = socket( family, type, protocol );
590 if (debug_level)
591 fprintf(stderr,"socket(%d,%d,%d)=%d\n",family,type,protocol,sockfd);
592 if (sockfd == -1)
594 sock_set_error();
595 return NULL;
597 fcntl(sockfd, F_SETFL, O_NONBLOCK); /* make socket nonblocking */
598 if (!(sock = alloc_object( &sock_ops )))
600 close( sockfd );
601 return NULL;
603 sock->state = (type != SOCK_STREAM) ? (FD_READ|FD_WRITE) : 0;
604 sock->mask = 0;
605 sock->hmask = 0;
606 sock->pmask = 0;
607 sock->polling = 0;
608 sock->flags = flags;
609 sock->type = type;
610 sock->family = family;
611 sock->event = NULL;
612 sock->window = 0;
613 sock->message = 0;
614 sock->wparam = 0;
615 sock->deferred = NULL;
616 sock->read_q = NULL;
617 sock->write_q = NULL;
618 if (!(sock->fd = create_anonymous_fd( &sock_fd_ops, sockfd, &sock->obj,
619 (flags & WSA_FLAG_OVERLAPPED) ? 0 : FILE_SYNCHRONOUS_IO_NONALERT )))
621 release_object( sock );
622 return NULL;
624 sock_reselect( sock );
625 clear_error();
626 return &sock->obj;
629 /* accept a socket (creates a new fd) */
630 static struct sock *accept_socket( obj_handle_t handle )
632 struct sock *acceptsock;
633 struct sock *sock;
634 int acceptfd;
635 struct sockaddr saddr;
637 sock = (struct sock *)get_handle_obj( current->process, handle, FILE_READ_DATA, &sock_ops );
638 if (!sock)
639 return NULL;
641 if ( sock->deferred )
643 acceptsock = sock->deferred;
644 sock->deferred = NULL;
646 else
649 /* Try to accept(2). We can't be safe that this an already connected socket
650 * or that accept() is allowed on it. In those cases we will get -1/errno
651 * return.
653 unsigned int slen = sizeof(saddr);
654 acceptfd = accept( get_unix_fd(sock->fd), &saddr, &slen);
655 if (acceptfd==-1)
657 sock_set_error();
658 release_object( sock );
659 return NULL;
661 if (!(acceptsock = alloc_object( &sock_ops )))
663 close( acceptfd );
664 release_object( sock );
665 return NULL;
668 /* newly created socket gets the same properties of the listening socket */
669 fcntl(acceptfd, F_SETFL, O_NONBLOCK); /* make socket nonblocking */
670 acceptsock->state = FD_WINE_CONNECTED|FD_READ|FD_WRITE;
671 if (sock->state & FD_WINE_NONBLOCKING)
672 acceptsock->state |= FD_WINE_NONBLOCKING;
673 acceptsock->mask = sock->mask;
674 acceptsock->hmask = 0;
675 acceptsock->pmask = 0;
676 acceptsock->polling = 0;
677 acceptsock->type = sock->type;
678 acceptsock->family = sock->family;
679 acceptsock->event = NULL;
680 acceptsock->window = sock->window;
681 acceptsock->message = sock->message;
682 acceptsock->wparam = 0;
683 if (sock->event) acceptsock->event = (struct event *)grab_object( sock->event );
684 acceptsock->flags = sock->flags;
685 acceptsock->deferred = NULL;
686 acceptsock->read_q = NULL;
687 acceptsock->write_q = NULL;
688 if (!(acceptsock->fd = create_anonymous_fd( &sock_fd_ops, acceptfd, &acceptsock->obj,
689 get_fd_options( sock->fd ) )))
691 release_object( acceptsock );
692 release_object( sock );
693 return NULL;
696 clear_error();
697 sock->pmask &= ~FD_ACCEPT;
698 sock->hmask &= ~FD_ACCEPT;
699 sock_reselect( sock );
700 release_object( sock );
701 return acceptsock;
704 /* set the last error depending on errno */
705 static int sock_get_error( int err )
707 switch (err)
709 case EINTR: return WSAEINTR;
710 case EBADF: return WSAEBADF;
711 case EPERM:
712 case EACCES: return WSAEACCES;
713 case EFAULT: return WSAEFAULT;
714 case EINVAL: return WSAEINVAL;
715 case EMFILE: return WSAEMFILE;
716 case EWOULDBLOCK: return WSAEWOULDBLOCK;
717 case EINPROGRESS: return WSAEINPROGRESS;
718 case EALREADY: return WSAEALREADY;
719 case ENOTSOCK: return WSAENOTSOCK;
720 case EDESTADDRREQ: return WSAEDESTADDRREQ;
721 case EMSGSIZE: return WSAEMSGSIZE;
722 case EPROTOTYPE: return WSAEPROTOTYPE;
723 case ENOPROTOOPT: return WSAENOPROTOOPT;
724 case EPROTONOSUPPORT: return WSAEPROTONOSUPPORT;
725 case ESOCKTNOSUPPORT: return WSAESOCKTNOSUPPORT;
726 case EOPNOTSUPP: return WSAEOPNOTSUPP;
727 case EPFNOSUPPORT: return WSAEPFNOSUPPORT;
728 case EAFNOSUPPORT: return WSAEAFNOSUPPORT;
729 case EADDRINUSE: return WSAEADDRINUSE;
730 case EADDRNOTAVAIL: return WSAEADDRNOTAVAIL;
731 case ENETDOWN: return WSAENETDOWN;
732 case ENETUNREACH: return WSAENETUNREACH;
733 case ENETRESET: return WSAENETRESET;
734 case ECONNABORTED: return WSAECONNABORTED;
735 case EPIPE:
736 case ECONNRESET: return WSAECONNRESET;
737 case ENOBUFS: return WSAENOBUFS;
738 case EISCONN: return WSAEISCONN;
739 case ENOTCONN: return WSAENOTCONN;
740 case ESHUTDOWN: return WSAESHUTDOWN;
741 case ETOOMANYREFS: return WSAETOOMANYREFS;
742 case ETIMEDOUT: return WSAETIMEDOUT;
743 case ECONNREFUSED: return WSAECONNREFUSED;
744 case ELOOP: return WSAELOOP;
745 case ENAMETOOLONG: return WSAENAMETOOLONG;
746 case EHOSTDOWN: return WSAEHOSTDOWN;
747 case EHOSTUNREACH: return WSAEHOSTUNREACH;
748 case ENOTEMPTY: return WSAENOTEMPTY;
749 #ifdef EPROCLIM
750 case EPROCLIM: return WSAEPROCLIM;
751 #endif
752 #ifdef EUSERS
753 case EUSERS: return WSAEUSERS;
754 #endif
755 #ifdef EDQUOT
756 case EDQUOT: return WSAEDQUOT;
757 #endif
758 #ifdef ESTALE
759 case ESTALE: return WSAESTALE;
760 #endif
761 #ifdef EREMOTE
762 case EREMOTE: return WSAEREMOTE;
763 #endif
764 default: errno=err; perror("sock_set_error"); return WSAEFAULT;
768 /* set the last error depending on errno */
769 static void sock_set_error(void)
771 set_error( sock_get_error( errno ) );
774 /* create a socket */
775 DECL_HANDLER(create_socket)
777 struct object *obj;
779 reply->handle = 0;
780 if ((obj = create_socket( req->family, req->type, req->protocol, req->flags )) != NULL)
782 reply->handle = alloc_handle( current->process, obj, req->access, req->attributes );
783 release_object( obj );
787 /* accept a socket */
788 DECL_HANDLER(accept_socket)
790 struct sock *sock;
792 reply->handle = 0;
793 if ((sock = accept_socket( req->lhandle )) != NULL)
795 reply->handle = alloc_handle( current->process, &sock->obj, req->access, req->attributes );
796 sock->wparam = reply->handle; /* wparam for message is the socket handle */
797 sock_reselect( sock );
798 release_object( &sock->obj );
802 /* set socket event parameters */
803 DECL_HANDLER(set_socket_event)
805 struct sock *sock;
806 struct event *old_event;
807 int pollev;
809 if (!(sock = (struct sock *)get_handle_obj( current->process, req->handle,
810 FILE_WRITE_ATTRIBUTES, &sock_ops))) return;
811 old_event = sock->event;
812 sock->mask = req->mask;
813 sock->hmask &= ~req->mask; /* re-enable held events */
814 sock->event = NULL;
815 sock->window = req->window;
816 sock->message = req->msg;
817 sock->wparam = req->handle; /* wparam is the socket handle */
818 if (req->event) sock->event = get_event_obj( current->process, req->event, EVENT_MODIFY_STATE );
820 if (debug_level && sock->event) fprintf(stderr, "event ptr: %p\n", sock->event);
822 pollev = sock_reselect( sock );
823 if ( pollev ) sock_try_event( sock, pollev );
825 if (sock->mask)
826 sock->state |= FD_WINE_NONBLOCKING;
828 /* if a network event is pending, signal the event object
829 it is possible that FD_CONNECT or FD_ACCEPT network events has happened
830 before a WSAEventSelect() was done on it.
831 (when dealing with Asynchronous socket) */
832 if (sock->pmask & sock->mask) sock_wake_up( sock, pollev );
834 if (old_event) release_object( old_event ); /* we're through with it */
835 release_object( &sock->obj );
838 /* get socket event parameters */
839 DECL_HANDLER(get_socket_event)
841 struct sock *sock;
843 sock = (struct sock *)get_handle_obj( current->process, req->handle, FILE_READ_ATTRIBUTES, &sock_ops );
844 if (!sock)
846 reply->mask = 0;
847 reply->pmask = 0;
848 reply->state = 0;
849 set_error( WSAENOTSOCK );
850 return;
852 reply->mask = sock->mask;
853 reply->pmask = sock->pmask;
854 reply->state = sock->state;
855 set_reply_data( sock->errors, min( get_reply_max_size(), sizeof(sock->errors) ));
857 if (req->service)
859 if (req->c_event)
861 struct event *cevent = get_event_obj( current->process, req->c_event,
862 EVENT_MODIFY_STATE );
863 if (cevent)
865 reset_event( cevent );
866 release_object( cevent );
869 sock->pmask = 0;
870 sock_reselect( sock );
872 release_object( &sock->obj );
875 /* re-enable pending socket events */
876 DECL_HANDLER(enable_socket_event)
878 struct sock *sock;
879 int pollev;
881 if (!(sock = (struct sock*)get_handle_obj( current->process, req->handle,
882 FILE_WRITE_ATTRIBUTES, &sock_ops)))
883 return;
885 sock->pmask &= ~req->mask; /* is this safe? */
886 sock->hmask &= ~req->mask;
887 if ( req->mask & FD_READ )
888 sock->hmask &= ~FD_CLOSE;
889 sock->state |= req->sstate;
890 sock->state &= ~req->cstate;
891 if ( sock->type != SOCK_STREAM ) sock->state &= ~STREAM_FLAG_MASK;
893 pollev = sock_reselect( sock );
894 if ( pollev ) sock_try_event( sock, pollev );
896 release_object( &sock->obj );
899 DECL_HANDLER(set_socket_deferred)
901 struct sock *sock, *acceptsock;
903 sock=(struct sock *)get_handle_obj( current->process, req->handle, FILE_WRITE_ATTRIBUTES, &sock_ops );
904 if ( !sock )
906 set_error( WSAENOTSOCK );
907 return;
909 acceptsock = (struct sock *)get_handle_obj( current->process, req->deferred, 0, &sock_ops );
910 if ( !acceptsock )
912 release_object( sock );
913 set_error( WSAENOTSOCK );
914 return;
916 sock->deferred = acceptsock;
917 release_object( sock );