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?
32 #ifdef HAVE_SYS_ERRNO_H
33 # include <sys/errno.h>
36 #include <sys/types.h>
37 #ifdef HAVE_SYS_SOCKET_H
38 # include <sys/socket.h>
40 #ifdef HAVE_SYS_IOCTL_H
41 #include <sys/ioctl.h>
43 #ifdef HAVE_SYS_FILIO_H
44 # include <sys/filio.h>
59 /* To avoid conflicts with the Unix socket headers. Plus we only need a few
67 struct object obj
; /* object header */
68 unsigned int state
; /* status bits */
69 unsigned int mask
; /* event mask */
70 unsigned int hmask
; /* held (blocked) events */
71 unsigned int pmask
; /* pending events */
72 unsigned int flags
; /* socket flags */
73 unsigned short type
; /* socket type */
74 unsigned short family
; /* socket family */
75 struct event
*event
; /* event object */
76 user_handle_t window
; /* window to send the message to */
77 unsigned int message
; /* message to send */
78 obj_handle_t wparam
; /* message wparam (socket handle) */
79 int errors
[FD_MAX_EVENTS
]; /* event errors */
80 struct sock
* deferred
; /* socket that waits for a deferred accept */
81 struct async_queue read_q
; /* Queue for asynchronous reads */
82 struct async_queue write_q
; /* Queue for asynchronous writes */
85 static void sock_dump( struct object
*obj
, int verbose
);
86 static int sock_signaled( struct object
*obj
, struct thread
*thread
);
87 static int sock_get_poll_events( struct object
*obj
);
88 static void sock_poll_event( struct object
*obj
, int event
);
89 static int sock_get_info( struct object
*obj
, struct get_file_info_reply
*reply
, int *flags
);
90 static void sock_destroy( struct object
*obj
);
91 static int sock_get_error( int err
);
92 static void sock_set_error(void);
93 static void sock_queue_async(struct object
*obj
, void *ptr
, unsigned int status
, int type
, int count
);
95 static const struct object_ops sock_ops
=
97 sizeof(struct sock
), /* size */
99 add_queue
, /* add_queue */
100 remove_queue
, /* remove_queue */
101 sock_signaled
, /* signaled */
102 no_satisfied
, /* satisfied */
103 default_get_fd
, /* get_fd */
104 sock_get_info
, /* get_file_info */
105 sock_destroy
/* destroy */
108 static const struct fd_ops sock_fd_ops
=
110 sock_get_poll_events
, /* get_poll_events */
111 sock_poll_event
, /* poll_event */
112 no_flush
, /* flush */
113 sock_get_info
, /* get_file_info */
114 sock_queue_async
/* queue_async */
118 /* Permutation of 0..FD_MAX_EVENTS - 1 representing the order in which
119 * we post messages if there are multiple events. Used to send
120 * messages. The problem is if there is both a FD_CONNECT event and,
121 * say, an FD_READ event available on the same socket, we want to
122 * notify the app of the connect event first. Otherwise it may
123 * discard the read event because it thinks it hasn't connected yet.
125 static const int event_bitorder
[FD_MAX_EVENTS
] =
133 6, 7, 8, 9 /* leftovers */
136 /* Flags that make sense only for SOCK_STREAM sockets */
137 #define STREAM_FLAG_MASK ((unsigned int) (FD_CONNECT | FD_ACCEPT | FD_WINE_LISTENING | FD_WINE_CONNECTED))
140 SOCK_SHUTDOWN_ERROR
= -1,
141 SOCK_SHUTDOWN_EOF
= 0,
142 SOCK_SHUTDOWN_POLLHUP
= 1
145 static sock_shutdown_t sock_shutdown_type
= SOCK_SHUTDOWN_ERROR
;
147 static sock_shutdown_t
sock_check_pollhup (void)
149 sock_shutdown_t ret
= SOCK_SHUTDOWN_ERROR
;
154 if ( socketpair ( AF_UNIX
, SOCK_STREAM
, 0, fd
) ) goto out
;
155 if ( shutdown ( fd
[0], 1 ) ) goto out
;
161 n
= poll ( &pfd
, 1, 0 );
162 if ( n
!= 1 ) goto out
; /* error or timeout */
163 if ( pfd
.revents
& POLLHUP
)
164 ret
= SOCK_SHUTDOWN_POLLHUP
;
165 else if ( pfd
.revents
& POLLIN
&&
166 read ( fd
[1], &dummy
, 1 ) == 0 )
167 ret
= SOCK_SHUTDOWN_EOF
;
177 sock_shutdown_type
= sock_check_pollhup ();
179 switch ( sock_shutdown_type
)
181 case SOCK_SHUTDOWN_EOF
:
182 if (debug_level
) fprintf ( stderr
, "sock_init: shutdown() causes EOF\n" );
184 case SOCK_SHUTDOWN_POLLHUP
:
185 if (debug_level
) fprintf ( stderr
, "sock_init: shutdown() causes POLLHUP\n" );
188 fprintf ( stderr
, "sock_init: ERROR in sock_check_pollhup()\n" );
189 sock_shutdown_type
= SOCK_SHUTDOWN_EOF
;
193 static int sock_reselect( struct sock
*sock
)
195 int ev
= sock_get_poll_events( &sock
->obj
);
198 fprintf(stderr
,"sock_reselect(%d): new mask %x\n", sock
->obj
.fd
, ev
);
200 if (sock
->obj
.select
== -1) {
201 /* previously unconnected socket, is this reselect supposed to connect it? */
202 if (!(sock
->state
& ~FD_WINE_NONBLOCKING
)) return 0;
203 /* ok, it is, attach it to the wineserver's main poll loop */
204 add_select_user( &sock
->obj
);
206 /* update condition mask */
207 set_select_events( &sock
->obj
, ev
);
211 /* After POLLHUP is received, the socket will no longer be in the main select loop.
212 This function is used to signal pending events nevertheless */
213 static void sock_try_event ( struct sock
*sock
, int event
)
217 pfd
.fd
= sock
->obj
.fd
;
224 if ( debug_level
) fprintf ( stderr
, "sock_try_event: %x\n", pfd
.revents
);
225 sock_poll_event ( &sock
->obj
, pfd
.revents
);
229 /* wake anybody waiting on the socket event or send the associated message */
230 static void sock_wake_up( struct sock
*sock
, int pollev
)
232 unsigned int events
= sock
->pmask
& sock
->mask
;
234 int async_active
= 0;
236 if ( sock
->flags
& FD_FLAG_OVERLAPPED
)
238 if( pollev
& (POLLIN
|POLLPRI
) && IS_READY( sock
->read_q
) )
240 if (debug_level
) fprintf ( stderr
, "activating read queue for socket %p\n", sock
);
241 async_notify( sock
->read_q
.head
, STATUS_ALERTED
);
244 if( pollev
& POLLOUT
&& IS_READY( sock
->write_q
) )
246 if (debug_level
) fprintf ( stderr
, "activating write queue for socket %p\n", sock
);
247 async_notify( sock
->write_q
.head
, STATUS_ALERTED
);
252 /* Do not signal events if there are still pending asynchronous IO requests */
253 /* We need this to delay FD_CLOSE events until all pending overlapped requests are processed */
254 if ( !events
|| async_active
) return;
258 if (debug_level
) fprintf(stderr
, "signalling events %x ptr %p\n", events
, sock
->event
);
259 set_event( sock
->event
);
263 if (debug_level
) fprintf(stderr
, "signalling events %x win %p\n", events
, sock
->window
);
264 for (i
= 0; i
< FD_MAX_EVENTS
; i
++)
266 int event
= event_bitorder
[i
];
267 if (sock
->pmask
& (1 << event
))
269 unsigned int lparam
= (1 << event
) | (sock
->errors
[event
] << 16);
270 post_message( sock
->window
, sock
->message
, (unsigned int)sock
->wparam
, lparam
);
274 sock_reselect( sock
);
278 inline static int sock_error(int s
)
280 unsigned int optval
= 0, optlen
;
282 optlen
= sizeof(optval
);
283 getsockopt(s
, SOL_SOCKET
, SO_ERROR
, (void *) &optval
, &optlen
);
284 return optval
? sock_get_error(optval
) : 0;
287 static void sock_poll_event( struct object
*obj
, int event
)
289 struct sock
*sock
= (struct sock
*)obj
;
292 assert( sock
->obj
.ops
== &sock_ops
);
294 fprintf(stderr
, "socket %d select event: %x\n", sock
->obj
.fd
, event
);
295 if (sock
->state
& FD_CONNECT
)
300 /* we got connected */
301 sock
->state
|= FD_WINE_CONNECTED
|FD_READ
|FD_WRITE
;
302 sock
->state
&= ~FD_CONNECT
;
303 sock
->pmask
|= FD_CONNECT
;
304 sock
->errors
[FD_CONNECT_BIT
] = 0;
306 fprintf(stderr
, "socket %d connection success\n", sock
->obj
.fd
);
308 else if (event
& (POLLERR
|POLLHUP
))
310 /* we didn't get connected? */
311 sock
->state
&= ~FD_CONNECT
;
312 sock
->pmask
|= FD_CONNECT
;
313 sock
->errors
[FD_CONNECT_BIT
] = sock_error( sock
->obj
.fd
);
315 fprintf(stderr
, "socket %d connection failure\n", sock
->obj
.fd
);
318 if (sock
->state
& FD_WINE_LISTENING
)
323 /* incoming connection */
324 sock
->pmask
|= FD_ACCEPT
;
325 sock
->errors
[FD_ACCEPT_BIT
] = 0;
326 sock
->hmask
|= FD_ACCEPT
;
328 else if (event
& (POLLERR
|POLLHUP
))
330 /* failed incoming connection? */
331 sock
->pmask
|= FD_ACCEPT
;
332 sock
->errors
[FD_ACCEPT_BIT
] = sock_error( sock
->obj
.fd
);
333 sock
->hmask
|= FD_ACCEPT
;
337 /* normal data flow */
338 if ( sock
->type
== SOCK_STREAM
&& ( event
& POLLIN
) )
343 /* Linux 2.4 doesn't report POLLHUP if only one side of the socket
344 * has been closed, so we need to check for it explicitly here */
345 nr
= recv( sock
->obj
.fd
, &dummy
, 1, MSG_PEEK
);
349 sock
->pmask
|= FD_READ
;
350 sock
->hmask
|= (FD_READ
|FD_CLOSE
);
351 sock
->errors
[FD_READ_BIT
] = 0;
353 fprintf(stderr
, "socket %d is readable\n", sock
->obj
.fd
);
359 /* EAGAIN can happen if an async recv() falls between the server's poll()
360 call and the invocation of this routine */
361 if ( errno
== EAGAIN
)
366 fprintf ( stderr
, "recv error on socket %d: %d\n", sock
->obj
.fd
, errno
);
372 else if ( sock_shutdown_type
== SOCK_SHUTDOWN_POLLHUP
&& (event
& POLLHUP
) )
376 else if ( event
& POLLIN
) /* POLLIN for non-stream socket */
378 sock
->pmask
|= FD_READ
;
379 sock
->hmask
|= (FD_READ
|FD_CLOSE
);
380 sock
->errors
[FD_READ_BIT
] = 0;
382 fprintf(stderr
, "socket %d is readable\n", sock
->obj
.fd
);
388 sock
->pmask
|= FD_WRITE
;
389 sock
->hmask
|= FD_WRITE
;
390 sock
->errors
[FD_WRITE_BIT
] = 0;
392 fprintf(stderr
, "socket %d is writable\n", sock
->obj
.fd
);
396 sock
->pmask
|= FD_OOB
;
397 sock
->hmask
|= FD_OOB
;
398 sock
->errors
[FD_OOB_BIT
] = 0;
400 fprintf(stderr
, "socket %d got OOB data\n", sock
->obj
.fd
);
402 /* According to WS2 specs, FD_CLOSE is only delivered when there is
403 no more data to be read (i.e. hangup_seen = 1) */
404 else if ( hangup_seen
&& (sock
->state
& (FD_READ
|FD_WRITE
) ))
406 sock
->errors
[FD_CLOSE_BIT
] = sock_error( sock
->obj
.fd
);
407 if ( (event
& POLLERR
) || ( sock_shutdown_type
== SOCK_SHUTDOWN_EOF
&& (event
& POLLHUP
) ))
408 sock
->state
&= ~FD_WRITE
;
409 sock
->pmask
|= FD_CLOSE
;
410 sock
->hmask
|= FD_CLOSE
;
412 fprintf(stderr
, "socket %d aborted by error %d, event: %x - removing from select loop\n",
413 sock
->obj
.fd
, sock
->errors
[FD_CLOSE_BIT
], event
);
417 if ( sock
->pmask
& FD_CLOSE
|| event
& (POLLERR
|POLLHUP
) )
420 fprintf ( stderr
, "removing socket %d from select loop\n", sock
->obj
.fd
);
421 set_select_events( &sock
->obj
, -1 );
424 sock_reselect( sock
);
426 /* wake up anyone waiting for whatever just happened */
427 if ( sock
->pmask
& sock
->mask
|| sock
->flags
& FD_FLAG_OVERLAPPED
) sock_wake_up( sock
, event
);
429 /* if anyone is stupid enough to wait on the socket object itself,
430 * maybe we should wake them up too, just in case? */
431 wake_up( &sock
->obj
, 0 );
434 static void sock_dump( struct object
*obj
, int verbose
)
436 struct sock
*sock
= (struct sock
*)obj
;
437 assert( obj
->ops
== &sock_ops
);
438 printf( "Socket fd=%d, state=%x, mask=%x, pending=%x, held=%x\n",
439 sock
->obj
.fd
, sock
->state
,
440 sock
->mask
, sock
->pmask
, sock
->hmask
);
443 static int sock_signaled( struct object
*obj
, struct thread
*thread
)
445 struct sock
*sock
= (struct sock
*)obj
;
446 assert( obj
->ops
== &sock_ops
);
448 return check_select_events( get_unix_fd(obj
), sock_get_poll_events( &sock
->obj
) );
451 static int sock_get_poll_events( struct object
*obj
)
453 struct sock
*sock
= (struct sock
*)obj
;
454 unsigned int mask
= sock
->mask
& sock
->state
& ~sock
->hmask
;
457 assert( obj
->ops
== &sock_ops
);
459 if (sock
->state
& FD_CONNECT
)
460 /* connecting, wait for writable */
462 if (sock
->state
& FD_WINE_LISTENING
)
463 /* listening, wait for readable */
464 return (sock
->hmask
& FD_ACCEPT
) ? 0 : POLLIN
;
466 if (mask
& (FD_READ
) || (sock
->flags
& WSA_FLAG_OVERLAPPED
&& IS_READY (sock
->read_q
)))
467 ev
|= POLLIN
| POLLPRI
;
468 if (mask
& FD_WRITE
|| (sock
->flags
& WSA_FLAG_OVERLAPPED
&& IS_READY (sock
->write_q
)))
470 /* We use POLLIN with 0 bytes recv() as FD_CLOSE indication for stream sockets. */
471 if ( sock
->type
== SOCK_STREAM
&& ( sock
->mask
& ~sock
->hmask
& FD_CLOSE
) )
477 static int sock_get_info( struct object
*obj
, struct get_file_info_reply
*reply
, int *flags
)
479 struct sock
*sock
= (struct sock
*) obj
;
480 assert ( obj
->ops
== &sock_ops
);
484 reply
->type
= FILE_TYPE_PIPE
;
486 reply
->access_time
= 0;
487 reply
->write_time
= 0;
488 reply
->size_high
= 0;
491 reply
->index_high
= 0;
492 reply
->index_low
= 0;
496 if (sock
->flags
& WSA_FLAG_OVERLAPPED
) *flags
|= FD_FLAG_OVERLAPPED
;
497 if ( sock
->type
!= SOCK_STREAM
|| sock
->state
& FD_WINE_CONNECTED
)
499 if ( !(sock
->state
& FD_READ
) ) *flags
|= FD_FLAG_RECV_SHUTDOWN
;
500 if ( !(sock
->state
& FD_WRITE
) ) *flags
|= FD_FLAG_SEND_SHUTDOWN
;
502 return FD_TYPE_SOCKET
;
505 static void sock_queue_async(struct object
*obj
, void *ptr
, unsigned int status
, int type
, int count
)
507 struct sock
*sock
= (struct sock
*)obj
;
508 struct async_queue
*q
;
512 assert( obj
->ops
== &sock_ops
);
514 if ( !(sock
->flags
& WSA_FLAG_OVERLAPPED
) )
516 set_error ( STATUS_INVALID_HANDLE
);
522 case ASYNC_TYPE_READ
:
524 sock
->hmask
&= ~FD_CLOSE
;
526 case ASYNC_TYPE_WRITE
:
530 set_error( STATUS_INVALID_PARAMETER
);
534 async
= find_async ( q
, current
, ptr
);
536 if ( status
== STATUS_PENDING
)
538 if ( ( !( sock
->state
& FD_READ
) && type
== ASYNC_TYPE_READ
) ||
539 ( !( sock
->state
& FD_WRITE
) && type
== ASYNC_TYPE_WRITE
) )
541 set_error ( STATUS_PIPE_DISCONNECTED
);
542 if ( async
) destroy_async ( async
);
547 async
= create_async ( obj
, current
, ptr
);
551 async
->status
= STATUS_PENDING
;
553 async_insert ( q
, async
);
556 else if ( async
) destroy_async ( async
);
557 else set_error ( STATUS_INVALID_PARAMETER
);
559 pollev
= sock_reselect ( sock
);
560 if ( pollev
) sock_try_event ( sock
, pollev
);
563 static void sock_destroy( struct object
*obj
)
565 struct sock
*sock
= (struct sock
*)obj
;
566 assert( obj
->ops
== &sock_ops
);
568 /* FIXME: special socket shutdown stuff? */
570 if ( sock
->deferred
)
571 release_object ( sock
->deferred
);
573 if ( sock
->flags
& WSA_FLAG_OVERLAPPED
)
575 destroy_async_queue ( &sock
->read_q
);
576 destroy_async_queue ( &sock
->write_q
);
578 if (sock
->event
) release_object( sock
->event
);
581 /* create a new and unconnected socket */
582 static struct object
*create_socket( int family
, int type
, int protocol
, unsigned int flags
)
587 sockfd
= socket( family
, type
, protocol
);
589 fprintf(stderr
,"socket(%d,%d,%d)=%d\n",family
,type
,protocol
,sockfd
);
594 fcntl(sockfd
, F_SETFL
, O_NONBLOCK
); /* make socket nonblocking */
595 if (!(sock
= alloc_fd_object( &sock_ops
, &sock_fd_ops
, -1 ))) return NULL
;
596 set_unix_fd( &sock
->obj
, sockfd
);
597 sock
->state
= (type
!= SOCK_STREAM
) ? (FD_READ
|FD_WRITE
) : 0;
603 sock
->family
= family
;
608 sock
->deferred
= NULL
;
609 if (sock
->flags
& WSA_FLAG_OVERLAPPED
)
611 init_async_queue (&sock
->read_q
);
612 init_async_queue (&sock
->write_q
);
614 sock_reselect( sock
);
619 /* accept a socket (creates a new fd) */
620 static struct sock
*accept_socket( obj_handle_t handle
)
622 struct sock
*acceptsock
;
625 struct sockaddr saddr
;
628 sock
=(struct sock
*)get_handle_obj(current
->process
,handle
,
629 GENERIC_READ
|GENERIC_WRITE
|SYNCHRONIZE
,&sock_ops
);
633 if ( sock
->deferred
) {
634 acceptsock
= sock
->deferred
;
635 sock
->deferred
= NULL
;
638 /* Try to accept(2). We can't be safe that this an already connected socket
639 * or that accept() is allowed on it. In those cases we will get -1/errno
642 slen
= sizeof(saddr
);
643 acceptfd
= accept( get_unix_fd(&sock
->obj
), &saddr
, &slen
);
646 release_object( sock
);
649 if (!(acceptsock
= alloc_fd_object( &sock_ops
, &sock_fd_ops
, acceptfd
)))
651 release_object( sock
);
655 /* newly created socket gets the same properties of the listening socket */
656 fcntl(acceptfd
, F_SETFL
, O_NONBLOCK
); /* make socket nonblocking */
657 acceptsock
->state
= FD_WINE_CONNECTED
|FD_READ
|FD_WRITE
;
658 if (sock
->state
& FD_WINE_NONBLOCKING
)
659 acceptsock
->state
|= FD_WINE_NONBLOCKING
;
660 acceptsock
->mask
= sock
->mask
;
661 acceptsock
->hmask
= 0;
662 acceptsock
->pmask
= 0;
663 acceptsock
->type
= sock
->type
;
664 acceptsock
->family
= sock
->family
;
665 acceptsock
->event
= NULL
;
666 acceptsock
->window
= sock
->window
;
667 acceptsock
->message
= sock
->message
;
668 acceptsock
->wparam
= 0;
669 if (sock
->event
) acceptsock
->event
= (struct event
*)grab_object( sock
->event
);
670 acceptsock
->flags
= sock
->flags
;
671 acceptsock
->deferred
= 0;
672 if ( acceptsock
->flags
& WSA_FLAG_OVERLAPPED
)
674 init_async_queue ( &acceptsock
->read_q
);
675 init_async_queue ( &acceptsock
->write_q
);
679 sock
->pmask
&= ~FD_ACCEPT
;
680 sock
->hmask
&= ~FD_ACCEPT
;
681 sock_reselect( sock
);
682 release_object( sock
);
686 /* set the last error depending on errno */
687 static int sock_get_error( int err
)
691 case EINTR
: return WSAEINTR
; break;
692 case EBADF
: return WSAEBADF
; break;
694 case EACCES
: return WSAEACCES
; break;
695 case EFAULT
: return WSAEFAULT
; break;
696 case EINVAL
: return WSAEINVAL
; break;
697 case EMFILE
: return WSAEMFILE
; break;
698 case EWOULDBLOCK
: return WSAEWOULDBLOCK
; break;
699 case EINPROGRESS
: return WSAEINPROGRESS
; break;
700 case EALREADY
: return WSAEALREADY
; break;
701 case ENOTSOCK
: return WSAENOTSOCK
; break;
702 case EDESTADDRREQ
: return WSAEDESTADDRREQ
; break;
703 case EMSGSIZE
: return WSAEMSGSIZE
; break;
704 case EPROTOTYPE
: return WSAEPROTOTYPE
; break;
705 case ENOPROTOOPT
: return WSAENOPROTOOPT
; break;
706 case EPROTONOSUPPORT
: return WSAEPROTONOSUPPORT
; break;
707 case ESOCKTNOSUPPORT
: return WSAESOCKTNOSUPPORT
; break;
708 case EOPNOTSUPP
: return WSAEOPNOTSUPP
; break;
709 case EPFNOSUPPORT
: return WSAEPFNOSUPPORT
; break;
710 case EAFNOSUPPORT
: return WSAEAFNOSUPPORT
; break;
711 case EADDRINUSE
: return WSAEADDRINUSE
; break;
712 case EADDRNOTAVAIL
: return WSAEADDRNOTAVAIL
; break;
713 case ENETDOWN
: return WSAENETDOWN
; break;
714 case ENETUNREACH
: return WSAENETUNREACH
; break;
715 case ENETRESET
: return WSAENETRESET
; break;
716 case ECONNABORTED
: return WSAECONNABORTED
; break;
718 case ECONNRESET
: return WSAECONNRESET
; break;
719 case ENOBUFS
: return WSAENOBUFS
; break;
720 case EISCONN
: return WSAEISCONN
; break;
721 case ENOTCONN
: return WSAENOTCONN
; break;
722 case ESHUTDOWN
: return WSAESHUTDOWN
; break;
723 case ETOOMANYREFS
: return WSAETOOMANYREFS
; break;
724 case ETIMEDOUT
: return WSAETIMEDOUT
; break;
725 case ECONNREFUSED
: return WSAECONNREFUSED
; break;
726 case ELOOP
: return WSAELOOP
; break;
727 case ENAMETOOLONG
: return WSAENAMETOOLONG
; break;
728 case EHOSTDOWN
: return WSAEHOSTDOWN
; break;
729 case EHOSTUNREACH
: return WSAEHOSTUNREACH
; break;
730 case ENOTEMPTY
: return WSAENOTEMPTY
; break;
732 case EPROCLIM
: return WSAEPROCLIM
; break;
735 case EUSERS
: return WSAEUSERS
; break;
738 case EDQUOT
: return WSAEDQUOT
; break;
741 case ESTALE
: return WSAESTALE
; break;
744 case EREMOTE
: return WSAEREMOTE
; break;
746 default: errno
=err
; perror("sock_set_error"); return ERROR_UNKNOWN
; break;
750 /* set the last error depending on errno */
751 static void sock_set_error(void)
753 set_error( sock_get_error( errno
) );
756 /* create a socket */
757 DECL_HANDLER(create_socket
)
762 if ((obj
= create_socket( req
->family
, req
->type
, req
->protocol
, req
->flags
)) != NULL
)
764 reply
->handle
= alloc_handle( current
->process
, obj
, req
->access
, req
->inherit
);
765 release_object( obj
);
769 /* accept a socket */
770 DECL_HANDLER(accept_socket
)
775 if ((sock
= accept_socket( req
->lhandle
)) != NULL
)
777 reply
->handle
= alloc_handle( current
->process
, &sock
->obj
, req
->access
, req
->inherit
);
778 sock
->wparam
= reply
->handle
; /* wparam for message is the socket handle */
779 sock_reselect( sock
);
780 release_object( &sock
->obj
);
784 /* set socket event parameters */
785 DECL_HANDLER(set_socket_event
)
788 struct event
*old_event
;
791 if (!(sock
= (struct sock
*)get_handle_obj( current
->process
, req
->handle
,
792 GENERIC_READ
|GENERIC_WRITE
|SYNCHRONIZE
, &sock_ops
)))
794 old_event
= sock
->event
;
795 sock
->mask
= req
->mask
;
797 sock
->window
= req
->window
;
798 sock
->message
= req
->msg
;
799 sock
->wparam
= req
->handle
; /* wparam is the socket handle */
800 if (req
->event
) sock
->event
= get_event_obj( current
->process
, req
->event
, EVENT_MODIFY_STATE
);
802 if (debug_level
&& sock
->event
) fprintf(stderr
, "event ptr: %p\n", sock
->event
);
804 pollev
= sock_reselect( sock
);
805 if ( pollev
) sock_try_event ( sock
, pollev
);
808 sock
->state
|= FD_WINE_NONBLOCKING
;
810 /* if a network event is pending, signal the event object
811 it is possible that FD_CONNECT or FD_ACCEPT network events has happened
812 before a WSAEventSelect() was done on it.
813 (when dealing with Asynchronous socket) */
814 if (sock
->pmask
& sock
->mask
) sock_wake_up( sock
, pollev
);
816 if (old_event
) release_object( old_event
); /* we're through with it */
817 release_object( &sock
->obj
);
820 /* get socket event parameters */
821 DECL_HANDLER(get_socket_event
)
825 sock
=(struct sock
*)get_handle_obj(current
->process
,req
->handle
,GENERIC_READ
|GENERIC_WRITE
|SYNCHRONIZE
,&sock_ops
);
831 set_error( WSAENOTSOCK
);
834 reply
->mask
= sock
->mask
;
835 reply
->pmask
= sock
->pmask
;
836 reply
->state
= sock
->state
;
837 set_reply_data( sock
->errors
, min( get_reply_max_size(), sizeof(sock
->errors
) ));
843 struct event
*cevent
= get_event_obj( current
->process
, req
->c_event
,
844 EVENT_MODIFY_STATE
);
847 reset_event( cevent
);
848 release_object( cevent
);
852 sock_reselect( sock
);
854 release_object( &sock
->obj
);
857 /* re-enable pending socket events */
858 DECL_HANDLER(enable_socket_event
)
863 if (!(sock
= (struct sock
*)get_handle_obj( current
->process
, req
->handle
,
864 GENERIC_READ
|GENERIC_WRITE
|SYNCHRONIZE
, &sock_ops
)))
867 sock
->pmask
&= ~req
->mask
; /* is this safe? */
868 sock
->hmask
&= ~req
->mask
;
869 if ( req
->mask
& FD_READ
)
870 sock
->hmask
&= ~FD_CLOSE
;
871 sock
->state
|= req
->sstate
;
872 sock
->state
&= ~req
->cstate
;
873 if ( sock
->type
!= SOCK_STREAM
) sock
->state
&= ~STREAM_FLAG_MASK
;
875 pollev
= sock_reselect( sock
);
876 if ( pollev
) sock_try_event ( sock
, pollev
);
878 release_object( &sock
->obj
);
881 DECL_HANDLER(set_socket_deferred
)
883 struct sock
*sock
, *acceptsock
;
885 sock
=(struct sock
*)get_handle_obj( current
->process
,req
->handle
,
886 GENERIC_READ
|GENERIC_WRITE
|SYNCHRONIZE
,&sock_ops
);
889 set_error ( WSAENOTSOCK
);
892 acceptsock
= (struct sock
*)get_handle_obj( current
->process
,req
->deferred
,
893 GENERIC_READ
|GENERIC_WRITE
|SYNCHRONIZE
,&sock_ops
);
896 release_object ( sock
);
897 set_error ( WSAENOTSOCK
);
900 sock
->deferred
= acceptsock
;
901 release_object ( sock
);