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>
60 /* To avoid conflicts with the Unix socket headers. Plus we only need a few
68 struct object obj
; /* object header */
69 struct fd
*fd
; /* socket file descriptor */
70 unsigned int state
; /* status bits */
71 unsigned int mask
; /* event mask */
72 unsigned int hmask
; /* held (blocked) events */
73 unsigned int pmask
; /* pending events */
74 unsigned int flags
; /* socket flags */
75 int polling
; /* is socket being polled? */
76 unsigned short type
; /* socket type */
77 unsigned short family
; /* socket family */
78 struct event
*event
; /* event object */
79 user_handle_t window
; /* window to send the message to */
80 unsigned int message
; /* message to send */
81 obj_handle_t wparam
; /* message wparam (socket handle) */
82 int errors
[FD_MAX_EVENTS
]; /* event errors */
83 struct sock
*deferred
; /* socket that waits for a deferred accept */
84 struct list read_q
; /* queue for asynchronous reads */
85 struct list write_q
; /* queue for asynchronous writes */
88 static void sock_dump( struct object
*obj
, int verbose
);
89 static int sock_signaled( struct object
*obj
, struct thread
*thread
);
90 static struct fd
*sock_get_fd( struct object
*obj
);
91 static void sock_destroy( struct object
*obj
);
93 static int sock_get_poll_events( struct fd
*fd
);
94 static void sock_poll_event( struct fd
*fd
, int event
);
95 static int sock_get_info( struct fd
*fd
);
96 static void sock_queue_async( struct fd
*fd
, void *apc
, void *user
, void *iosb
, int type
, int count
);
97 static void sock_cancel_async( struct fd
*fd
);
99 static int sock_get_error( int err
);
100 static void sock_set_error(void);
102 static const struct object_ops sock_ops
=
104 sizeof(struct sock
), /* size */
105 sock_dump
, /* dump */
106 add_queue
, /* add_queue */
107 remove_queue
, /* remove_queue */
108 sock_signaled
, /* signaled */
109 no_satisfied
, /* satisfied */
110 no_signal
, /* signal */
111 sock_get_fd
, /* get_fd */
112 no_close_handle
, /* close_handle */
113 sock_destroy
/* destroy */
116 static const struct fd_ops sock_fd_ops
=
118 sock_get_poll_events
, /* get_poll_events */
119 sock_poll_event
, /* poll_event */
120 no_flush
, /* flush */
121 sock_get_info
, /* get_file_info */
122 sock_queue_async
, /* queue_async */
123 sock_cancel_async
/* cancel_async */
127 /* Permutation of 0..FD_MAX_EVENTS - 1 representing the order in which
128 * we post messages if there are multiple events. Used to send
129 * messages. The problem is if there is both a FD_CONNECT event and,
130 * say, an FD_READ event available on the same socket, we want to
131 * notify the app of the connect event first. Otherwise it may
132 * discard the read event because it thinks it hasn't connected yet.
134 static const int event_bitorder
[FD_MAX_EVENTS
] =
142 6, 7, 8, 9 /* leftovers */
145 /* Flags that make sense only for SOCK_STREAM sockets */
146 #define STREAM_FLAG_MASK ((unsigned int) (FD_CONNECT | FD_ACCEPT | FD_WINE_LISTENING | FD_WINE_CONNECTED))
149 SOCK_SHUTDOWN_ERROR
= -1,
150 SOCK_SHUTDOWN_EOF
= 0,
151 SOCK_SHUTDOWN_POLLHUP
= 1
154 static sock_shutdown_t sock_shutdown_type
= SOCK_SHUTDOWN_ERROR
;
156 static sock_shutdown_t
sock_check_pollhup(void)
158 sock_shutdown_t ret
= SOCK_SHUTDOWN_ERROR
;
163 if ( socketpair( AF_UNIX
, SOCK_STREAM
, 0, fd
) ) goto out
;
164 if ( shutdown( fd
[0], 1 ) ) goto out
;
170 n
= poll( &pfd
, 1, 0 );
171 if ( n
!= 1 ) goto out
; /* error or timeout */
172 if ( pfd
.revents
& POLLHUP
)
173 ret
= SOCK_SHUTDOWN_POLLHUP
;
174 else if ( pfd
.revents
& POLLIN
&&
175 read( fd
[1], &dummy
, 1 ) == 0 )
176 ret
= SOCK_SHUTDOWN_EOF
;
186 sock_shutdown_type
= sock_check_pollhup();
188 switch ( sock_shutdown_type
)
190 case SOCK_SHUTDOWN_EOF
:
191 if (debug_level
) fprintf( stderr
, "sock_init: shutdown() causes EOF\n" );
193 case SOCK_SHUTDOWN_POLLHUP
:
194 if (debug_level
) fprintf( stderr
, "sock_init: shutdown() causes POLLHUP\n" );
197 fprintf( stderr
, "sock_init: ERROR in sock_check_pollhup()\n" );
198 sock_shutdown_type
= SOCK_SHUTDOWN_EOF
;
202 static int sock_reselect( struct sock
*sock
)
204 int ev
= sock_get_poll_events( sock
->fd
);
207 fprintf(stderr
,"sock_reselect(%p): new mask %x\n", sock
, ev
);
209 if (!sock
->polling
) /* FIXME: should find a better way to do this */
211 /* previously unconnected socket, is this reselect supposed to connect it? */
212 if (!(sock
->state
& ~FD_WINE_NONBLOCKING
)) return 0;
213 /* ok, it is, attach it to the wineserver's main poll loop */
216 /* update condition mask */
217 set_fd_events( sock
->fd
, ev
);
221 /* After POLLHUP is received, the socket will no longer be in the main select loop.
222 This function is used to signal pending events nevertheless */
223 static void sock_try_event( struct sock
*sock
, int event
)
225 event
= check_fd_events( sock
->fd
, event
);
228 if ( debug_level
) fprintf( stderr
, "sock_try_event: %x\n", event
);
229 sock_poll_event( sock
->fd
, event
);
233 /* wake anybody waiting on the socket event or send the associated message */
234 static void sock_wake_up( struct sock
*sock
, int pollev
)
236 unsigned int events
= sock
->pmask
& sock
->mask
;
238 int async_active
= 0;
240 if ( sock
->flags
& WSA_FLAG_OVERLAPPED
)
242 if ( pollev
& (POLLIN
|POLLPRI
) && !list_empty( &sock
->read_q
))
244 if (debug_level
) fprintf( stderr
, "activating read queue for socket %p\n", sock
);
245 async_terminate_head( &sock
->read_q
, STATUS_ALERTED
);
248 if ( pollev
& POLLOUT
&& !list_empty( &sock
->write_q
))
250 if (debug_level
) fprintf( stderr
, "activating write queue for socket %p\n", sock
);
251 async_terminate_head( &sock
->write_q
, STATUS_ALERTED
);
256 /* Do not signal events if there are still pending asynchronous IO requests */
257 /* We need this to delay FD_CLOSE events until all pending overlapped requests are processed */
258 if ( !events
|| async_active
) return;
262 if (debug_level
) fprintf(stderr
, "signalling events %x ptr %p\n", events
, sock
->event
);
263 set_event( sock
->event
);
267 if (debug_level
) fprintf(stderr
, "signalling events %x win %p\n", events
, sock
->window
);
268 for (i
= 0; i
< FD_MAX_EVENTS
; i
++)
270 int event
= event_bitorder
[i
];
271 if (sock
->pmask
& (1 << event
))
273 unsigned int lparam
= (1 << event
) | (sock
->errors
[event
] << 16);
274 post_message( sock
->window
, sock
->message
, (unsigned int)sock
->wparam
, lparam
);
278 sock_reselect( sock
);
282 inline static int sock_error( struct fd
*fd
)
284 unsigned int optval
= 0, optlen
;
286 optlen
= sizeof(optval
);
287 getsockopt( get_unix_fd(fd
), SOL_SOCKET
, SO_ERROR
, (void *) &optval
, &optlen
);
288 return optval
? sock_get_error(optval
) : 0;
291 static void sock_poll_event( struct fd
*fd
, int event
)
293 struct sock
*sock
= get_fd_user( fd
);
296 assert( sock
->obj
.ops
== &sock_ops
);
298 fprintf(stderr
, "socket %p select event: %x\n", sock
, event
);
299 if (sock
->state
& FD_CONNECT
)
304 /* we got connected */
305 sock
->state
|= FD_WINE_CONNECTED
|FD_READ
|FD_WRITE
;
306 sock
->state
&= ~FD_CONNECT
;
307 sock
->pmask
|= FD_CONNECT
;
308 sock
->errors
[FD_CONNECT_BIT
] = 0;
310 fprintf(stderr
, "socket %p connection success\n", sock
);
312 else if (event
& (POLLERR
|POLLHUP
))
314 /* we didn't get connected? */
315 sock
->state
&= ~FD_CONNECT
;
316 sock
->pmask
|= FD_CONNECT
;
317 sock
->errors
[FD_CONNECT_BIT
] = sock_error( fd
);
319 fprintf(stderr
, "socket %p connection failure\n", sock
);
322 else if (sock
->state
& FD_WINE_LISTENING
)
327 /* incoming connection */
328 sock
->pmask
|= FD_ACCEPT
;
329 sock
->errors
[FD_ACCEPT_BIT
] = 0;
330 sock
->hmask
|= FD_ACCEPT
;
332 else if (event
& (POLLERR
|POLLHUP
))
334 /* failed incoming connection? */
335 sock
->pmask
|= FD_ACCEPT
;
336 sock
->errors
[FD_ACCEPT_BIT
] = sock_error( fd
);
337 sock
->hmask
|= FD_ACCEPT
;
342 /* normal data flow */
343 if ( sock
->type
== SOCK_STREAM
&& ( event
& POLLIN
) )
348 /* Linux 2.4 doesn't report POLLHUP if only one side of the socket
349 * has been closed, so we need to check for it explicitly here */
350 nr
= recv( get_unix_fd( fd
), &dummy
, 1, MSG_PEEK
);
354 sock
->pmask
|= FD_READ
;
355 sock
->hmask
|= (FD_READ
|FD_CLOSE
);
356 sock
->errors
[FD_READ_BIT
] = 0;
358 fprintf(stderr
, "socket %p is readable\n", sock
);
364 /* EAGAIN can happen if an async recv() falls between the server's poll()
365 call and the invocation of this routine */
366 if ( errno
== EAGAIN
)
371 fprintf( stderr
, "recv error on socket %p: %d\n", sock
, errno
);
377 else if ( sock_shutdown_type
== SOCK_SHUTDOWN_POLLHUP
&& (event
& POLLHUP
) )
381 else if ( event
& POLLIN
) /* POLLIN for non-stream socket */
383 sock
->pmask
|= FD_READ
;
384 sock
->hmask
|= (FD_READ
|FD_CLOSE
);
385 sock
->errors
[FD_READ_BIT
] = 0;
387 fprintf(stderr
, "socket %p is readable\n", sock
);
393 sock
->pmask
|= FD_WRITE
;
394 sock
->hmask
|= FD_WRITE
;
395 sock
->errors
[FD_WRITE_BIT
] = 0;
397 fprintf(stderr
, "socket %p is writable\n", sock
);
401 sock
->pmask
|= FD_OOB
;
402 sock
->hmask
|= FD_OOB
;
403 sock
->errors
[FD_OOB_BIT
] = 0;
405 fprintf(stderr
, "socket %p got OOB data\n", sock
);
407 /* According to WS2 specs, FD_CLOSE is only delivered when there is
408 no more data to be read (i.e. hangup_seen = 1) */
409 else if ( hangup_seen
&& (sock
->state
& (FD_READ
|FD_WRITE
) ))
411 sock
->errors
[FD_CLOSE_BIT
] = sock_error( fd
);
412 if ( (event
& POLLERR
) || ( sock_shutdown_type
== SOCK_SHUTDOWN_EOF
&& (event
& POLLHUP
) ))
413 sock
->state
&= ~FD_WRITE
;
414 sock
->pmask
|= FD_CLOSE
;
415 sock
->hmask
|= FD_CLOSE
;
417 fprintf(stderr
, "socket %p aborted by error %d, event: %x - removing from select loop\n",
418 sock
, sock
->errors
[FD_CLOSE_BIT
], event
);
422 if ( sock
->pmask
& FD_CLOSE
|| event
& (POLLERR
|POLLHUP
) )
425 fprintf( stderr
, "removing socket %p from select loop\n", sock
);
426 set_fd_events( sock
->fd
, -1 );
429 sock_reselect( sock
);
431 /* wake up anyone waiting for whatever just happened */
432 if ( sock
->pmask
& sock
->mask
|| sock
->flags
& WSA_FLAG_OVERLAPPED
) sock_wake_up( sock
, event
);
434 /* if anyone is stupid enough to wait on the socket object itself,
435 * maybe we should wake them up too, just in case? */
436 wake_up( &sock
->obj
, 0 );
439 static void sock_dump( struct object
*obj
, int verbose
)
441 struct sock
*sock
= (struct sock
*)obj
;
442 assert( obj
->ops
== &sock_ops
);
443 printf( "Socket fd=%p, state=%x, mask=%x, pending=%x, held=%x\n",
444 sock
->fd
, sock
->state
,
445 sock
->mask
, sock
->pmask
, sock
->hmask
);
448 static int sock_signaled( struct object
*obj
, struct thread
*thread
)
450 struct sock
*sock
= (struct sock
*)obj
;
451 assert( obj
->ops
== &sock_ops
);
453 return check_fd_events( sock
->fd
, sock_get_poll_events( sock
->fd
) ) != 0;
456 static int sock_get_poll_events( struct fd
*fd
)
458 struct sock
*sock
= get_fd_user( fd
);
459 unsigned int mask
= sock
->mask
& sock
->state
& ~sock
->hmask
;
462 assert( sock
->obj
.ops
== &sock_ops
);
464 if (sock
->state
& FD_CONNECT
)
465 /* connecting, wait for writable */
467 if (sock
->state
& FD_WINE_LISTENING
)
468 /* listening, wait for readable */
469 return (sock
->hmask
& FD_ACCEPT
) ? 0 : POLLIN
;
471 if (mask
& (FD_READ
) || (sock
->flags
& WSA_FLAG_OVERLAPPED
&& !list_empty( &sock
->read_q
)))
472 ev
|= POLLIN
| POLLPRI
;
473 if (mask
& FD_WRITE
|| (sock
->flags
& WSA_FLAG_OVERLAPPED
&& !list_empty( &sock
->write_q
)))
475 /* We use POLLIN with 0 bytes recv() as FD_CLOSE indication for stream sockets. */
476 if ( sock
->type
== SOCK_STREAM
&& ( sock
->mask
& ~sock
->hmask
& FD_CLOSE
) )
482 static int sock_get_info( struct fd
*fd
)
484 int flags
= FD_FLAG_AVAILABLE
;
485 struct sock
*sock
= get_fd_user( fd
);
486 assert( sock
->obj
.ops
== &sock_ops
);
488 if (sock
->flags
& WSA_FLAG_OVERLAPPED
) flags
|= FD_FLAG_OVERLAPPED
;
489 if ( sock
->type
!= SOCK_STREAM
|| sock
->state
& FD_WINE_CONNECTED
)
491 if ( !(sock
->state
& FD_READ
) ) flags
|= FD_FLAG_RECV_SHUTDOWN
;
492 if ( !(sock
->state
& FD_WRITE
) ) flags
|= FD_FLAG_SEND_SHUTDOWN
;
497 static void sock_queue_async( struct fd
*fd
, void *apc
, void *user
, void *iosb
,
498 int type
, int count
)
500 struct sock
*sock
= get_fd_user( fd
);
504 assert( sock
->obj
.ops
== &sock_ops
);
506 if ( !(sock
->flags
& WSA_FLAG_OVERLAPPED
) )
508 set_error( STATUS_INVALID_HANDLE
);
514 case ASYNC_TYPE_READ
:
515 queue
= &sock
->read_q
;
516 sock
->hmask
&= ~FD_CLOSE
;
518 case ASYNC_TYPE_WRITE
:
519 queue
= &sock
->write_q
;
522 set_error( STATUS_INVALID_PARAMETER
);
526 if ( ( !( sock
->state
& FD_READ
) && type
== ASYNC_TYPE_READ
) ||
527 ( !( sock
->state
& FD_WRITE
) && type
== ASYNC_TYPE_WRITE
) )
529 set_error( STATUS_PIPE_DISCONNECTED
);
533 if (!create_async( current
, NULL
, queue
, apc
, user
, iosb
))
537 pollev
= sock_reselect( sock
);
538 if ( pollev
) sock_try_event( sock
, pollev
);
541 static void sock_cancel_async( struct fd
*fd
)
543 struct sock
*sock
= get_fd_user( fd
);
544 assert( sock
->obj
.ops
== &sock_ops
);
546 async_terminate_queue( &sock
->read_q
, STATUS_CANCELLED
);
547 async_terminate_queue( &sock
->write_q
, STATUS_CANCELLED
);
550 static struct fd
*sock_get_fd( struct object
*obj
)
552 struct sock
*sock
= (struct sock
*)obj
;
553 return (struct fd
*)grab_object( sock
->fd
);
556 static void sock_destroy( struct object
*obj
)
558 struct sock
*sock
= (struct sock
*)obj
;
559 assert( obj
->ops
== &sock_ops
);
561 /* FIXME: special socket shutdown stuff? */
563 if ( sock
->deferred
)
564 release_object( sock
->deferred
);
566 if ( sock
->flags
& WSA_FLAG_OVERLAPPED
)
568 async_terminate_queue( &sock
->read_q
, STATUS_CANCELLED
);
569 async_terminate_queue( &sock
->write_q
, STATUS_CANCELLED
);
571 if (sock
->event
) release_object( sock
->event
);
572 if (sock
->fd
) release_object( sock
->fd
);
575 /* create a new and unconnected socket */
576 static struct object
*create_socket( int family
, int type
, int protocol
, unsigned int flags
)
581 sockfd
= socket( family
, type
, protocol
);
583 fprintf(stderr
,"socket(%d,%d,%d)=%d\n",family
,type
,protocol
,sockfd
);
589 fcntl(sockfd
, F_SETFL
, O_NONBLOCK
); /* make socket nonblocking */
590 if (!(sock
= alloc_object( &sock_ops
)))
595 sock
->state
= (type
!= SOCK_STREAM
) ? (FD_READ
|FD_WRITE
) : 0;
602 sock
->family
= family
;
607 sock
->deferred
= NULL
;
608 if (!(sock
->fd
= create_anonymous_fd( &sock_fd_ops
, sockfd
, &sock
->obj
)))
610 release_object( sock
);
613 list_init( &sock
->read_q
);
614 list_init( &sock
->write_q
);
615 sock_reselect( sock
);
620 /* accept a socket (creates a new fd) */
621 static struct sock
*accept_socket( obj_handle_t handle
)
623 struct sock
*acceptsock
;
626 struct sockaddr saddr
;
629 sock
=(struct sock
*)get_handle_obj(current
->process
,handle
,
630 GENERIC_READ
|GENERIC_WRITE
|SYNCHRONIZE
,&sock_ops
);
634 if ( sock
->deferred
)
636 acceptsock
= sock
->deferred
;
637 sock
->deferred
= NULL
;
642 /* Try to accept(2). We can't be safe that this an already connected socket
643 * or that accept() is allowed on it. In those cases we will get -1/errno
646 slen
= sizeof(saddr
);
647 acceptfd
= accept( get_unix_fd(sock
->fd
), &saddr
, &slen
);
651 release_object( sock
);
654 if (!(acceptsock
= alloc_object( &sock_ops
)))
657 release_object( sock
);
661 /* newly created socket gets the same properties of the listening socket */
662 fcntl(acceptfd
, F_SETFL
, O_NONBLOCK
); /* make socket nonblocking */
663 acceptsock
->state
= FD_WINE_CONNECTED
|FD_READ
|FD_WRITE
;
664 if (sock
->state
& FD_WINE_NONBLOCKING
)
665 acceptsock
->state
|= FD_WINE_NONBLOCKING
;
666 acceptsock
->mask
= sock
->mask
;
667 acceptsock
->hmask
= 0;
668 acceptsock
->pmask
= 0;
669 acceptsock
->polling
= 0;
670 acceptsock
->type
= sock
->type
;
671 acceptsock
->family
= sock
->family
;
672 acceptsock
->event
= NULL
;
673 acceptsock
->window
= sock
->window
;
674 acceptsock
->message
= sock
->message
;
675 acceptsock
->wparam
= 0;
676 if (sock
->event
) acceptsock
->event
= (struct event
*)grab_object( sock
->event
);
677 acceptsock
->flags
= sock
->flags
;
678 acceptsock
->deferred
= NULL
;
679 if (!(acceptsock
->fd
= create_anonymous_fd( &sock_fd_ops
, acceptfd
, &acceptsock
->obj
)))
681 release_object( acceptsock
);
682 release_object( sock
);
685 list_init( &acceptsock
->read_q
);
686 list_init( &acceptsock
->write_q
);
689 sock
->pmask
&= ~FD_ACCEPT
;
690 sock
->hmask
&= ~FD_ACCEPT
;
691 sock_reselect( sock
);
692 release_object( sock
);
696 /* set the last error depending on errno */
697 static int sock_get_error( int err
)
701 case EINTR
: return WSAEINTR
;
702 case EBADF
: return WSAEBADF
;
704 case EACCES
: return WSAEACCES
;
705 case EFAULT
: return WSAEFAULT
;
706 case EINVAL
: return WSAEINVAL
;
707 case EMFILE
: return WSAEMFILE
;
708 case EWOULDBLOCK
: return WSAEWOULDBLOCK
;
709 case EINPROGRESS
: return WSAEINPROGRESS
;
710 case EALREADY
: return WSAEALREADY
;
711 case ENOTSOCK
: return WSAENOTSOCK
;
712 case EDESTADDRREQ
: return WSAEDESTADDRREQ
;
713 case EMSGSIZE
: return WSAEMSGSIZE
;
714 case EPROTOTYPE
: return WSAEPROTOTYPE
;
715 case ENOPROTOOPT
: return WSAENOPROTOOPT
;
716 case EPROTONOSUPPORT
: return WSAEPROTONOSUPPORT
;
717 case ESOCKTNOSUPPORT
: return WSAESOCKTNOSUPPORT
;
718 case EOPNOTSUPP
: return WSAEOPNOTSUPP
;
719 case EPFNOSUPPORT
: return WSAEPFNOSUPPORT
;
720 case EAFNOSUPPORT
: return WSAEAFNOSUPPORT
;
721 case EADDRINUSE
: return WSAEADDRINUSE
;
722 case EADDRNOTAVAIL
: return WSAEADDRNOTAVAIL
;
723 case ENETDOWN
: return WSAENETDOWN
;
724 case ENETUNREACH
: return WSAENETUNREACH
;
725 case ENETRESET
: return WSAENETRESET
;
726 case ECONNABORTED
: return WSAECONNABORTED
;
728 case ECONNRESET
: return WSAECONNRESET
;
729 case ENOBUFS
: return WSAENOBUFS
;
730 case EISCONN
: return WSAEISCONN
;
731 case ENOTCONN
: return WSAENOTCONN
;
732 case ESHUTDOWN
: return WSAESHUTDOWN
;
733 case ETOOMANYREFS
: return WSAETOOMANYREFS
;
734 case ETIMEDOUT
: return WSAETIMEDOUT
;
735 case ECONNREFUSED
: return WSAECONNREFUSED
;
736 case ELOOP
: return WSAELOOP
;
737 case ENAMETOOLONG
: return WSAENAMETOOLONG
;
738 case EHOSTDOWN
: return WSAEHOSTDOWN
;
739 case EHOSTUNREACH
: return WSAEHOSTUNREACH
;
740 case ENOTEMPTY
: return WSAENOTEMPTY
;
742 case EPROCLIM
: return WSAEPROCLIM
;
745 case EUSERS
: return WSAEUSERS
;
748 case EDQUOT
: return WSAEDQUOT
;
751 case ESTALE
: return WSAESTALE
;
754 case EREMOTE
: return WSAEREMOTE
;
756 default: errno
=err
; perror("sock_set_error"); return WSAEFAULT
;
760 /* set the last error depending on errno */
761 static void sock_set_error(void)
763 set_error( sock_get_error( errno
) );
766 /* create a socket */
767 DECL_HANDLER(create_socket
)
772 if ((obj
= create_socket( req
->family
, req
->type
, req
->protocol
, req
->flags
)) != NULL
)
774 reply
->handle
= alloc_handle( current
->process
, obj
, req
->access
, req
->inherit
);
775 release_object( obj
);
779 /* accept a socket */
780 DECL_HANDLER(accept_socket
)
785 if ((sock
= accept_socket( req
->lhandle
)) != NULL
)
787 reply
->handle
= alloc_handle( current
->process
, &sock
->obj
, req
->access
, req
->inherit
);
788 sock
->wparam
= reply
->handle
; /* wparam for message is the socket handle */
789 sock_reselect( sock
);
790 release_object( &sock
->obj
);
794 /* set socket event parameters */
795 DECL_HANDLER(set_socket_event
)
798 struct event
*old_event
;
801 if (!(sock
= (struct sock
*)get_handle_obj( current
->process
, req
->handle
,
802 GENERIC_READ
|GENERIC_WRITE
|SYNCHRONIZE
, &sock_ops
)))
804 old_event
= sock
->event
;
805 sock
->mask
= req
->mask
;
807 sock
->window
= req
->window
;
808 sock
->message
= req
->msg
;
809 sock
->wparam
= req
->handle
; /* wparam is the socket handle */
810 if (req
->event
) sock
->event
= get_event_obj( current
->process
, req
->event
, EVENT_MODIFY_STATE
);
812 if (debug_level
&& sock
->event
) fprintf(stderr
, "event ptr: %p\n", sock
->event
);
814 pollev
= sock_reselect( sock
);
815 if ( pollev
) sock_try_event( sock
, pollev
);
818 sock
->state
|= FD_WINE_NONBLOCKING
;
820 /* if a network event is pending, signal the event object
821 it is possible that FD_CONNECT or FD_ACCEPT network events has happened
822 before a WSAEventSelect() was done on it.
823 (when dealing with Asynchronous socket) */
824 if (sock
->pmask
& sock
->mask
) sock_wake_up( sock
, pollev
);
826 if (old_event
) release_object( old_event
); /* we're through with it */
827 release_object( &sock
->obj
);
830 /* get socket event parameters */
831 DECL_HANDLER(get_socket_event
)
835 sock
=(struct sock
*)get_handle_obj(current
->process
,req
->handle
,GENERIC_READ
|GENERIC_WRITE
|SYNCHRONIZE
,&sock_ops
);
841 set_error( WSAENOTSOCK
);
844 reply
->mask
= sock
->mask
;
845 reply
->pmask
= sock
->pmask
;
846 reply
->state
= sock
->state
;
847 set_reply_data( sock
->errors
, min( get_reply_max_size(), sizeof(sock
->errors
) ));
853 struct event
*cevent
= get_event_obj( current
->process
, req
->c_event
,
854 EVENT_MODIFY_STATE
);
857 reset_event( cevent
);
858 release_object( cevent
);
862 sock_reselect( sock
);
864 release_object( &sock
->obj
);
867 /* re-enable pending socket events */
868 DECL_HANDLER(enable_socket_event
)
873 if (!(sock
= (struct sock
*)get_handle_obj( current
->process
, req
->handle
,
874 GENERIC_READ
|GENERIC_WRITE
|SYNCHRONIZE
, &sock_ops
)))
877 sock
->pmask
&= ~req
->mask
; /* is this safe? */
878 sock
->hmask
&= ~req
->mask
;
879 if ( req
->mask
& FD_READ
)
880 sock
->hmask
&= ~FD_CLOSE
;
881 sock
->state
|= req
->sstate
;
882 sock
->state
&= ~req
->cstate
;
883 if ( sock
->type
!= SOCK_STREAM
) sock
->state
&= ~STREAM_FLAG_MASK
;
885 pollev
= sock_reselect( sock
);
886 if ( pollev
) sock_try_event( sock
, pollev
);
888 release_object( &sock
->obj
);
891 DECL_HANDLER(set_socket_deferred
)
893 struct sock
*sock
, *acceptsock
;
895 sock
=(struct sock
*)get_handle_obj( current
->process
,req
->handle
,
896 GENERIC_READ
|GENERIC_WRITE
|SYNCHRONIZE
,&sock_ops
);
899 set_error( WSAENOTSOCK
);
902 acceptsock
= (struct sock
*)get_handle_obj( current
->process
,req
->deferred
,
903 GENERIC_READ
|GENERIC_WRITE
|SYNCHRONIZE
,&sock_ops
);
906 release_object( sock
);
907 set_error( WSAENOTSOCK
);
910 sock
->deferred
= acceptsock
;
911 release_object( sock
);