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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 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
62 /* To avoid conflicts with the Unix socket headers. Plus we only need a few
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 list read_q; /* queue for asynchronous reads */
87 struct list 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 void sock_destroy( struct object *obj );
95 static int sock_get_poll_events( struct fd *fd );
96 static void sock_poll_event( struct fd *fd, int event );
97 static int sock_get_info( struct fd *fd );
98 static void sock_queue_async( struct fd *fd, void *apc, void *user, void *iosb, int type, int count );
99 static void sock_cancel_async( struct fd *fd );
101 static int sock_get_error( int err );
102 static void sock_set_error(void);
104 static const struct object_ops sock_ops =
106 sizeof(struct sock), /* size */
107 sock_dump, /* dump */
108 add_queue, /* add_queue */
109 remove_queue, /* remove_queue */
110 sock_signaled, /* signaled */
111 no_satisfied, /* satisfied */
112 no_signal, /* signal */
113 sock_get_fd, /* get_fd */
114 no_map_access, /* map_access */
115 no_lookup_name, /* lookup_name */
116 no_close_handle, /* close_handle */
117 sock_destroy /* destroy */
120 static const struct fd_ops sock_fd_ops =
122 sock_get_poll_events, /* get_poll_events */
123 sock_poll_event, /* poll_event */
124 no_flush, /* flush */
125 sock_get_info, /* get_file_info */
126 sock_queue_async, /* queue_async */
127 sock_cancel_async /* cancel_async */
131 /* Permutation of 0..FD_MAX_EVENTS - 1 representing the order in which
132 * we post messages if there are multiple events. Used to send
133 * messages. The problem is if there is both a FD_CONNECT event and,
134 * say, an FD_READ event available on the same socket, we want to
135 * notify the app of the connect event first. Otherwise it may
136 * discard the read event because it thinks it hasn't connected yet.
138 static const int event_bitorder[FD_MAX_EVENTS] =
146 6, 7, 8, 9 /* leftovers */
149 /* Flags that make sense only for SOCK_STREAM sockets */
150 #define STREAM_FLAG_MASK ((unsigned int) (FD_CONNECT | FD_ACCEPT | FD_WINE_LISTENING | FD_WINE_CONNECTED))
153 SOCK_SHUTDOWN_ERROR = -1,
154 SOCK_SHUTDOWN_EOF = 0,
155 SOCK_SHUTDOWN_POLLHUP = 1
158 static sock_shutdown_t sock_shutdown_type = SOCK_SHUTDOWN_ERROR;
160 static sock_shutdown_t sock_check_pollhup(void)
162 sock_shutdown_t ret = SOCK_SHUTDOWN_ERROR;
167 if ( socketpair( AF_UNIX, SOCK_STREAM, 0, fd ) ) goto out;
168 if ( shutdown( fd[0], 1 ) ) goto out;
174 n = poll( &pfd, 1, 0 );
175 if ( n != 1 ) goto out; /* error or timeout */
176 if ( pfd.revents & POLLHUP )
177 ret = SOCK_SHUTDOWN_POLLHUP;
178 else if ( pfd.revents & POLLIN &&
179 read( fd[1], &dummy, 1 ) == 0 )
180 ret = SOCK_SHUTDOWN_EOF;
190 sock_shutdown_type = sock_check_pollhup();
192 switch ( sock_shutdown_type )
194 case SOCK_SHUTDOWN_EOF:
195 if (debug_level) fprintf( stderr, "sock_init: shutdown() causes EOF\n" );
197 case SOCK_SHUTDOWN_POLLHUP:
198 if (debug_level) fprintf( stderr, "sock_init: shutdown() causes POLLHUP\n" );
201 fprintf( stderr, "sock_init: ERROR in sock_check_pollhup()\n" );
202 sock_shutdown_type = SOCK_SHUTDOWN_EOF;
206 static int sock_reselect( struct sock *sock )
208 int ev = sock_get_poll_events( sock->fd );
211 fprintf(stderr,"sock_reselect(%p): new mask %x\n", sock, ev);
213 if (!sock->polling) /* FIXME: should find a better way to do this */
215 /* previously unconnected socket, is this reselect supposed to connect it? */
216 if (!(sock->state & ~FD_WINE_NONBLOCKING)) return 0;
217 /* ok, it is, attach it to the wineserver's main poll loop */
220 /* update condition mask */
221 set_fd_events( sock->fd, ev );
225 /* After POLLHUP is received, the socket will no longer be in the main select loop.
226 This function is used to signal pending events nevertheless */
227 static void sock_try_event( struct sock *sock, int event )
229 event = check_fd_events( sock->fd, event );
232 if ( debug_level ) fprintf( stderr, "sock_try_event: %x\n", event );
233 sock_poll_event( sock->fd, event );
237 /* wake anybody waiting on the socket event or send the associated message */
238 static void sock_wake_up( struct sock *sock, int pollev )
240 unsigned int events = sock->pmask & sock->mask;
242 int async_active = 0;
244 if ( sock->flags & WSA_FLAG_OVERLAPPED )
246 if ( pollev & (POLLIN|POLLPRI) && !list_empty( &sock->read_q ))
248 if (debug_level) fprintf( stderr, "activating read queue for socket %p\n", sock );
249 async_terminate_head( &sock->read_q, STATUS_ALERTED );
252 if ( pollev & POLLOUT && !list_empty( &sock->write_q ))
254 if (debug_level) fprintf( stderr, "activating write queue for socket %p\n", sock );
255 async_terminate_head( &sock->write_q, STATUS_ALERTED );
260 /* Do not signal events if there are still pending asynchronous IO requests */
261 /* We need this to delay FD_CLOSE events until all pending overlapped requests are processed */
262 if ( !events || async_active ) return;
266 if (debug_level) fprintf(stderr, "signalling events %x ptr %p\n", events, sock->event );
267 set_event( sock->event );
271 if (debug_level) fprintf(stderr, "signalling events %x win %p\n", events, sock->window );
272 for (i = 0; i < FD_MAX_EVENTS; i++)
274 int event = event_bitorder[i];
275 if (sock->pmask & (1 << event))
277 unsigned int lparam = (1 << event) | (sock->errors[event] << 16);
278 post_message( sock->window, sock->message, (unsigned int)sock->wparam, lparam );
282 sock_reselect( sock );
286 inline static int sock_error( struct fd *fd )
288 unsigned int optval = 0, optlen;
290 optlen = sizeof(optval);
291 getsockopt( get_unix_fd(fd), SOL_SOCKET, SO_ERROR, (void *) &optval, &optlen);
292 return optval ? sock_get_error(optval) : 0;
295 static void sock_poll_event( struct fd *fd, int event )
297 struct sock *sock = get_fd_user( fd );
300 assert( sock->obj.ops == &sock_ops );
302 fprintf(stderr, "socket %p select event: %x\n", sock, event);
303 if (sock->state & FD_CONNECT)
308 /* we got connected */
309 sock->state |= FD_WINE_CONNECTED|FD_READ|FD_WRITE;
310 sock->state &= ~FD_CONNECT;
311 sock->pmask |= FD_CONNECT;
312 sock->errors[FD_CONNECT_BIT] = 0;
314 fprintf(stderr, "socket %p connection success\n", sock);
316 else if (event & (POLLERR|POLLHUP))
318 /* we didn't get connected? */
319 sock->state &= ~FD_CONNECT;
320 sock->pmask |= FD_CONNECT;
321 sock->errors[FD_CONNECT_BIT] = sock_error( fd );
323 fprintf(stderr, "socket %p connection failure\n", sock);
326 else if (sock->state & FD_WINE_LISTENING)
331 /* incoming connection */
332 sock->pmask |= FD_ACCEPT;
333 sock->errors[FD_ACCEPT_BIT] = 0;
334 sock->hmask |= FD_ACCEPT;
336 else if (event & (POLLERR|POLLHUP))
338 /* failed incoming connection? */
339 sock->pmask |= FD_ACCEPT;
340 sock->errors[FD_ACCEPT_BIT] = sock_error( fd );
341 sock->hmask |= FD_ACCEPT;
346 /* normal data flow */
347 if ( sock->type == SOCK_STREAM && ( event & POLLIN ) )
352 /* Linux 2.4 doesn't report POLLHUP if only one side of the socket
353 * has been closed, so we need to check for it explicitly here */
354 nr = recv( get_unix_fd( fd ), &dummy, 1, MSG_PEEK );
358 sock->pmask |= FD_READ;
359 sock->hmask |= (FD_READ|FD_CLOSE);
360 sock->errors[FD_READ_BIT] = 0;
362 fprintf(stderr, "socket %p is readable\n", sock );
368 /* EAGAIN can happen if an async recv() falls between the server's poll()
369 call and the invocation of this routine */
370 if ( errno == EAGAIN )
375 fprintf( stderr, "recv error on socket %p: %d\n", sock, errno );
381 else if ( sock_shutdown_type == SOCK_SHUTDOWN_POLLHUP && (event & POLLHUP) )
385 else if ( event & POLLIN ) /* POLLIN for non-stream socket */
387 sock->pmask |= FD_READ;
388 sock->hmask |= (FD_READ|FD_CLOSE);
389 sock->errors[FD_READ_BIT] = 0;
391 fprintf(stderr, "socket %p is readable\n", sock );
397 sock->pmask |= FD_WRITE;
398 sock->hmask |= FD_WRITE;
399 sock->errors[FD_WRITE_BIT] = 0;
401 fprintf(stderr, "socket %p is writable\n", sock);
405 sock->pmask |= FD_OOB;
406 sock->hmask |= FD_OOB;
407 sock->errors[FD_OOB_BIT] = 0;
409 fprintf(stderr, "socket %p got OOB data\n", sock);
411 /* According to WS2 specs, FD_CLOSE is only delivered when there is
412 no more data to be read (i.e. hangup_seen = 1) */
413 else if ( hangup_seen && (sock->state & (FD_READ|FD_WRITE) ))
415 sock->errors[FD_CLOSE_BIT] = sock_error( fd );
416 if ( (event & POLLERR) || ( sock_shutdown_type == SOCK_SHUTDOWN_EOF && (event & POLLHUP) ))
417 sock->state &= ~FD_WRITE;
418 sock->pmask |= FD_CLOSE;
419 sock->hmask |= FD_CLOSE;
421 fprintf(stderr, "socket %p aborted by error %d, event: %x - removing from select loop\n",
422 sock, sock->errors[FD_CLOSE_BIT], event);
426 if ( sock->pmask & FD_CLOSE || event & (POLLERR|POLLHUP) )
429 fprintf( stderr, "removing socket %p from select loop\n", sock );
430 set_fd_events( sock->fd, -1 );
433 sock_reselect( sock );
435 /* wake up anyone waiting for whatever just happened */
436 if ( sock->pmask & sock->mask || sock->flags & WSA_FLAG_OVERLAPPED ) sock_wake_up( sock, event );
438 /* if anyone is stupid enough to wait on the socket object itself,
439 * maybe we should wake them up too, just in case? */
440 wake_up( &sock->obj, 0 );
443 static void sock_dump( struct object *obj, int verbose )
445 struct sock *sock = (struct sock *)obj;
446 assert( obj->ops == &sock_ops );
447 printf( "Socket fd=%p, state=%x, mask=%x, pending=%x, held=%x\n",
448 sock->fd, sock->state,
449 sock->mask, sock->pmask, sock->hmask );
452 static int sock_signaled( struct object *obj, struct thread *thread )
454 struct sock *sock = (struct sock *)obj;
455 assert( obj->ops == &sock_ops );
457 return check_fd_events( sock->fd, sock_get_poll_events( sock->fd ) ) != 0;
460 static int sock_get_poll_events( struct fd *fd )
462 struct sock *sock = get_fd_user( fd );
463 unsigned int mask = sock->mask & sock->state & ~sock->hmask;
466 assert( sock->obj.ops == &sock_ops );
468 if (sock->state & FD_CONNECT)
469 /* connecting, wait for writable */
471 if (sock->state & FD_WINE_LISTENING)
472 /* listening, wait for readable */
473 return (sock->hmask & FD_ACCEPT) ? 0 : POLLIN;
475 if (mask & (FD_READ) || (sock->flags & WSA_FLAG_OVERLAPPED && !list_empty( &sock->read_q )))
476 ev |= POLLIN | POLLPRI;
477 if (mask & FD_WRITE || (sock->flags & WSA_FLAG_OVERLAPPED && !list_empty( &sock->write_q )))
479 /* We use POLLIN with 0 bytes recv() as FD_CLOSE indication for stream sockets. */
480 if ( sock->type == SOCK_STREAM && ( sock->mask & ~sock->hmask & FD_CLOSE) )
486 static int sock_get_info( struct fd *fd )
488 int flags = FD_FLAG_AVAILABLE;
489 struct sock *sock = get_fd_user( fd );
490 assert( sock->obj.ops == &sock_ops );
492 if (sock->flags & WSA_FLAG_OVERLAPPED) flags |= FD_FLAG_OVERLAPPED;
493 if ( sock->type != SOCK_STREAM || sock->state & FD_WINE_CONNECTED )
495 if ( !(sock->state & FD_READ ) ) flags |= FD_FLAG_RECV_SHUTDOWN;
496 if ( !(sock->state & FD_WRITE ) ) flags |= FD_FLAG_SEND_SHUTDOWN;
501 static void sock_queue_async( struct fd *fd, void *apc, void *user, void *iosb,
502 int type, int count )
504 struct sock *sock = get_fd_user( fd );
508 assert( sock->obj.ops == &sock_ops );
510 if ( !(sock->flags & WSA_FLAG_OVERLAPPED) )
512 set_error( STATUS_INVALID_HANDLE );
518 case ASYNC_TYPE_READ:
519 queue = &sock->read_q;
520 sock->hmask &= ~FD_CLOSE;
522 case ASYNC_TYPE_WRITE:
523 queue = &sock->write_q;
526 set_error( STATUS_INVALID_PARAMETER );
530 if ( ( !( sock->state & FD_READ ) && type == ASYNC_TYPE_READ ) ||
531 ( !( sock->state & FD_WRITE ) && type == ASYNC_TYPE_WRITE ) )
533 set_error( STATUS_PIPE_DISCONNECTED );
537 if (!create_async( current, NULL, queue, apc, user, iosb ))
541 pollev = sock_reselect( sock );
542 if ( pollev ) sock_try_event( sock, pollev );
545 static void sock_cancel_async( struct fd *fd )
547 struct sock *sock = get_fd_user( fd );
548 assert( sock->obj.ops == &sock_ops );
550 async_terminate_queue( &sock->read_q, STATUS_CANCELLED );
551 async_terminate_queue( &sock->write_q, STATUS_CANCELLED );
554 static struct fd *sock_get_fd( struct object *obj )
556 struct sock *sock = (struct sock *)obj;
557 return (struct fd *)grab_object( sock->fd );
560 static void sock_destroy( struct object *obj )
562 struct sock *sock = (struct sock *)obj;
563 assert( obj->ops == &sock_ops );
565 /* FIXME: special socket shutdown stuff? */
567 if ( sock->deferred )
568 release_object( sock->deferred );
570 if ( sock->flags & WSA_FLAG_OVERLAPPED )
572 async_terminate_queue( &sock->read_q, STATUS_CANCELLED );
573 async_terminate_queue( &sock->write_q, STATUS_CANCELLED );
575 if (sock->event) release_object( sock->event );
576 if (sock->fd) release_object( sock->fd );
579 /* create a new and unconnected socket */
580 static struct object *create_socket( int family, int type, int protocol, unsigned int flags )
585 sockfd = socket( family, type, protocol );
587 fprintf(stderr,"socket(%d,%d,%d)=%d\n",family,type,protocol,sockfd);
593 fcntl(sockfd, F_SETFL, O_NONBLOCK); /* make socket nonblocking */
594 if (!(sock = alloc_object( &sock_ops )))
599 sock->state = (type != SOCK_STREAM) ? (FD_READ|FD_WRITE) : 0;
606 sock->family = family;
611 sock->deferred = NULL;
612 if (!(sock->fd = create_anonymous_fd( &sock_fd_ops, sockfd, &sock->obj )))
614 release_object( sock );
617 list_init( &sock->read_q );
618 list_init( &sock->write_q );
619 sock_reselect( sock );
624 /* accept a socket (creates a new fd) */
625 static struct sock *accept_socket( obj_handle_t handle )
627 struct sock *acceptsock;
630 struct sockaddr saddr;
632 sock=(struct sock*)get_handle_obj(current->process,handle,
633 GENERIC_READ|GENERIC_WRITE|SYNCHRONIZE,&sock_ops);
637 if ( sock->deferred )
639 acceptsock = sock->deferred;
640 sock->deferred = NULL;
645 /* Try to accept(2). We can't be safe that this an already connected socket
646 * or that accept() is allowed on it. In those cases we will get -1/errno
649 unsigned int slen = sizeof(saddr);
650 acceptfd = accept( get_unix_fd(sock->fd), &saddr, &slen);
654 release_object( sock );
657 if (!(acceptsock = alloc_object( &sock_ops )))
660 release_object( sock );
664 /* newly created socket gets the same properties of the listening socket */
665 fcntl(acceptfd, F_SETFL, O_NONBLOCK); /* make socket nonblocking */
666 acceptsock->state = FD_WINE_CONNECTED|FD_READ|FD_WRITE;
667 if (sock->state & FD_WINE_NONBLOCKING)
668 acceptsock->state |= FD_WINE_NONBLOCKING;
669 acceptsock->mask = sock->mask;
670 acceptsock->hmask = 0;
671 acceptsock->pmask = 0;
672 acceptsock->polling = 0;
673 acceptsock->type = sock->type;
674 acceptsock->family = sock->family;
675 acceptsock->event = NULL;
676 acceptsock->window = sock->window;
677 acceptsock->message = sock->message;
678 acceptsock->wparam = 0;
679 if (sock->event) acceptsock->event = (struct event *)grab_object( sock->event );
680 acceptsock->flags = sock->flags;
681 acceptsock->deferred = NULL;
682 if (!(acceptsock->fd = create_anonymous_fd( &sock_fd_ops, acceptfd, &acceptsock->obj )))
684 release_object( acceptsock );
685 release_object( sock );
688 list_init( &acceptsock->read_q );
689 list_init( &acceptsock->write_q );
692 sock->pmask &= ~FD_ACCEPT;
693 sock->hmask &= ~FD_ACCEPT;
694 sock_reselect( sock );
695 release_object( sock );
699 /* set the last error depending on errno */
700 static int sock_get_error( int err )
704 case EINTR: return WSAEINTR;
705 case EBADF: return WSAEBADF;
707 case EACCES: return WSAEACCES;
708 case EFAULT: return WSAEFAULT;
709 case EINVAL: return WSAEINVAL;
710 case EMFILE: return WSAEMFILE;
711 case EWOULDBLOCK: return WSAEWOULDBLOCK;
712 case EINPROGRESS: return WSAEINPROGRESS;
713 case EALREADY: return WSAEALREADY;
714 case ENOTSOCK: return WSAENOTSOCK;
715 case EDESTADDRREQ: return WSAEDESTADDRREQ;
716 case EMSGSIZE: return WSAEMSGSIZE;
717 case EPROTOTYPE: return WSAEPROTOTYPE;
718 case ENOPROTOOPT: return WSAENOPROTOOPT;
719 case EPROTONOSUPPORT: return WSAEPROTONOSUPPORT;
720 case ESOCKTNOSUPPORT: return WSAESOCKTNOSUPPORT;
721 case EOPNOTSUPP: return WSAEOPNOTSUPP;
722 case EPFNOSUPPORT: return WSAEPFNOSUPPORT;
723 case EAFNOSUPPORT: return WSAEAFNOSUPPORT;
724 case EADDRINUSE: return WSAEADDRINUSE;
725 case EADDRNOTAVAIL: return WSAEADDRNOTAVAIL;
726 case ENETDOWN: return WSAENETDOWN;
727 case ENETUNREACH: return WSAENETUNREACH;
728 case ENETRESET: return WSAENETRESET;
729 case ECONNABORTED: return WSAECONNABORTED;
731 case ECONNRESET: return WSAECONNRESET;
732 case ENOBUFS: return WSAENOBUFS;
733 case EISCONN: return WSAEISCONN;
734 case ENOTCONN: return WSAENOTCONN;
735 case ESHUTDOWN: return WSAESHUTDOWN;
736 case ETOOMANYREFS: return WSAETOOMANYREFS;
737 case ETIMEDOUT: return WSAETIMEDOUT;
738 case ECONNREFUSED: return WSAECONNREFUSED;
739 case ELOOP: return WSAELOOP;
740 case ENAMETOOLONG: return WSAENAMETOOLONG;
741 case EHOSTDOWN: return WSAEHOSTDOWN;
742 case EHOSTUNREACH: return WSAEHOSTUNREACH;
743 case ENOTEMPTY: return WSAENOTEMPTY;
745 case EPROCLIM: return WSAEPROCLIM;
748 case EUSERS: return WSAEUSERS;
751 case EDQUOT: return WSAEDQUOT;
754 case ESTALE: return WSAESTALE;
757 case EREMOTE: return WSAEREMOTE;
759 default: errno=err; perror("sock_set_error"); return WSAEFAULT;
763 /* set the last error depending on errno */
764 static void sock_set_error(void)
766 set_error( sock_get_error( errno ) );
769 /* create a socket */
770 DECL_HANDLER(create_socket)
775 if ((obj = create_socket( req->family, req->type, req->protocol, req->flags )) != NULL)
777 reply->handle = alloc_handle( current->process, obj, req->access, req->attributes );
778 release_object( obj );
782 /* accept a socket */
783 DECL_HANDLER(accept_socket)
788 if ((sock = accept_socket( req->lhandle )) != NULL)
790 reply->handle = alloc_handle( current->process, &sock->obj, req->access, req->attributes );
791 sock->wparam = reply->handle; /* wparam for message is the socket handle */
792 sock_reselect( sock );
793 release_object( &sock->obj );
797 /* set socket event parameters */
798 DECL_HANDLER(set_socket_event)
801 struct event *old_event;
804 if (!(sock = (struct sock*)get_handle_obj( current->process, req->handle,
805 GENERIC_READ|GENERIC_WRITE|SYNCHRONIZE, &sock_ops)))
807 old_event = sock->event;
808 sock->mask = req->mask;
810 sock->window = req->window;
811 sock->message = req->msg;
812 sock->wparam = req->handle; /* wparam is the socket handle */
813 if (req->event) sock->event = get_event_obj( current->process, req->event, EVENT_MODIFY_STATE );
815 if (debug_level && sock->event) fprintf(stderr, "event ptr: %p\n", sock->event);
817 pollev = sock_reselect( sock );
818 if ( pollev ) sock_try_event( sock, pollev );
821 sock->state |= FD_WINE_NONBLOCKING;
823 /* if a network event is pending, signal the event object
824 it is possible that FD_CONNECT or FD_ACCEPT network events has happened
825 before a WSAEventSelect() was done on it.
826 (when dealing with Asynchronous socket) */
827 if (sock->pmask & sock->mask) sock_wake_up( sock, pollev );
829 if (old_event) release_object( old_event ); /* we're through with it */
830 release_object( &sock->obj );
833 /* get socket event parameters */
834 DECL_HANDLER(get_socket_event)
838 sock=(struct sock*)get_handle_obj(current->process,req->handle,GENERIC_READ|GENERIC_WRITE|SYNCHRONIZE,&sock_ops);
844 set_error( WSAENOTSOCK );
847 reply->mask = sock->mask;
848 reply->pmask = sock->pmask;
849 reply->state = sock->state;
850 set_reply_data( sock->errors, min( get_reply_max_size(), sizeof(sock->errors) ));
856 struct event *cevent = get_event_obj( current->process, req->c_event,
857 EVENT_MODIFY_STATE );
860 reset_event( cevent );
861 release_object( cevent );
865 sock_reselect( sock );
867 release_object( &sock->obj );
870 /* re-enable pending socket events */
871 DECL_HANDLER(enable_socket_event)
876 if (!(sock = (struct sock*)get_handle_obj( current->process, req->handle,
877 GENERIC_READ|GENERIC_WRITE|SYNCHRONIZE, &sock_ops)))
880 sock->pmask &= ~req->mask; /* is this safe? */
881 sock->hmask &= ~req->mask;
882 if ( req->mask & FD_READ )
883 sock->hmask &= ~FD_CLOSE;
884 sock->state |= req->sstate;
885 sock->state &= ~req->cstate;
886 if ( sock->type != SOCK_STREAM ) sock->state &= ~STREAM_FLAG_MASK;
888 pollev = sock_reselect( sock );
889 if ( pollev ) sock_try_event( sock, pollev );
891 release_object( &sock->obj );
894 DECL_HANDLER(set_socket_deferred)
896 struct sock *sock, *acceptsock;
898 sock=(struct sock*)get_handle_obj( current->process,req->handle,
899 GENERIC_READ|GENERIC_WRITE|SYNCHRONIZE,&sock_ops );
902 set_error( WSAENOTSOCK );
905 acceptsock = (struct sock*)get_handle_obj( current->process,req->deferred,
906 GENERIC_READ|GENERIC_WRITE|SYNCHRONIZE,&sock_ops );
909 release_object( sock );
910 set_error( WSAENOTSOCK );
913 sock->deferred = acceptsock;
914 release_object( sock );