2 * Server-side socket management
4 * Copyright (C) 1999 Marcus Meissner, Ove Kåven
6 * FIXME: we use read|write access in all cases. Shouldn't we depend that
7 * on the access of the current handle?
18 #ifdef HAVE_SYS_ERRNO_H
19 # include <sys/errno.h>
22 #include <sys/types.h>
23 #ifdef HAVE_SYS_SOCKET_H
24 # include <sys/socket.h>
26 #include <sys/ioctl.h>
27 #ifdef HAVE_SYS_FILIO_H
28 # include <sys/filio.h>
43 struct object obj
; /* object header */
44 unsigned int state
; /* status bits */
45 unsigned int mask
; /* event mask */
46 unsigned int hmask
; /* held (blocked) events */
47 unsigned int pmask
; /* pending events */
48 struct event
*event
; /* event object */
49 int errors
[FD_MAX_EVENTS
]; /* event errors */
52 static void sock_dump( struct object
*obj
, int verbose
);
53 static int sock_signaled( struct object
*obj
, struct thread
*thread
);
54 static int sock_get_poll_events( struct object
*obj
);
55 static void sock_poll_event( struct object
*obj
, int event
);
56 static int sock_get_fd( struct object
*obj
);
57 static int sock_get_info( struct object
*obj
, struct get_file_info_request
*req
);
58 static void sock_destroy( struct object
*obj
);
59 static int sock_get_error( int err
);
60 static void sock_set_error(void);
62 static const struct object_ops sock_ops
=
64 sizeof(struct sock
), /* size */
66 add_queue
, /* add_queue */
67 remove_queue
, /* remove_queue */
68 sock_signaled
, /* signaled */
69 no_satisfied
, /* satisfied */
70 sock_get_poll_events
, /* get_poll_events */
71 sock_poll_event
, /* poll_event */
72 sock_get_fd
, /* get_fd */
74 sock_get_info
, /* get_file_info */
75 sock_destroy
/* destroy */
78 static void sock_reselect( struct sock
*sock
)
80 int ev
= sock_get_poll_events( &sock
->obj
);
84 fprintf(stderr
,"sock_reselect(%d): new mask %x\n", sock
->obj
.fd
, ev
);
86 if (sock
->obj
.select
== -1) {
87 /* previously unconnected socket, is this reselect supposed to connect it? */
88 if (!(sock
->state
& ~FD_WINE_NONBLOCKING
)) return;
89 /* ok, it is, attach it to the wineserver's main poll loop */
90 add_select_user( &sock
->obj
);
92 /* update condition mask */
93 set_select_events( &sock
->obj
, ev
);
95 /* check whether condition is satisfied already */
96 pfd
.fd
= sock
->obj
.fd
;
101 sock_poll_event( &sock
->obj
, pfd
.revents
);
104 inline static int sock_error(int s
)
106 unsigned int optval
= 0, optlen
;
108 optlen
= sizeof(optval
);
109 getsockopt(s
, SOL_SOCKET
, SO_ERROR
, (void *) &optval
, &optlen
);
110 return optval
? sock_get_error(optval
) : 0;
113 static void sock_poll_event( struct object
*obj
, int event
)
115 struct sock
*sock
= (struct sock
*)obj
;
117 assert( sock
->obj
.ops
== &sock_ops
);
119 fprintf(stderr
, "socket %d select event: %x\n", sock
->obj
.fd
, event
);
120 if (sock
->state
& FD_CONNECT
)
125 /* we got connected */
126 sock
->state
|= FD_WINE_CONNECTED
|FD_READ
|FD_WRITE
;
127 sock
->state
&= ~FD_CONNECT
;
128 sock
->pmask
|= FD_CONNECT
;
129 sock
->errors
[FD_CONNECT_BIT
] = 0;
131 fprintf(stderr
, "socket %d connection success\n", sock
->obj
.fd
);
133 else if (event
& (POLLERR
|POLLHUP
))
135 /* we didn't get connected? */
136 sock
->state
&= ~FD_CONNECT
;
137 sock
->pmask
|= FD_CONNECT
;
138 sock
->errors
[FD_CONNECT_BIT
] = sock_error( sock
->obj
.fd
);
140 fprintf(stderr
, "socket %d connection failure\n", sock
->obj
.fd
);
143 if (sock
->state
& FD_WINE_LISTENING
)
148 /* incoming connection */
149 sock
->pmask
|= FD_ACCEPT
;
150 sock
->errors
[FD_ACCEPT_BIT
] = 0;
151 sock
->hmask
|= FD_ACCEPT
;
153 else if (event
& (POLLERR
|POLLHUP
))
155 /* failed incoming connection? */
156 sock
->pmask
|= FD_ACCEPT
;
157 sock
->errors
[FD_ACCEPT_BIT
] = sock_error( sock
->obj
.fd
);
158 sock
->hmask
|= FD_ACCEPT
;
162 /* normal data flow */
167 /* Linux 2.4 doesn't report POLLHUP if only one side of the socket
168 * has been closed, so we need to check for it explicitly here */
169 if (!recv( sock
->obj
.fd
, &dummy
, 1, MSG_PEEK
)) event
= POLLHUP
;
173 sock
->pmask
|= FD_READ
;
174 sock
->hmask
|= FD_READ
;
175 sock
->errors
[FD_READ_BIT
] = 0;
177 fprintf(stderr
, "socket %d is readable\n", sock
->obj
.fd
);
182 sock
->pmask
|= FD_WRITE
;
183 sock
->hmask
|= FD_WRITE
;
184 sock
->errors
[FD_WRITE_BIT
] = 0;
186 fprintf(stderr
, "socket %d is writable\n", sock
->obj
.fd
);
190 sock
->pmask
|= FD_OOB
;
191 sock
->hmask
|= FD_OOB
;
192 sock
->errors
[FD_OOB_BIT
] = 0;
194 fprintf(stderr
, "socket %d got OOB data\n", sock
->obj
.fd
);
196 if (((event
& POLLERR
) || ((event
& (POLLIN
|POLLHUP
)) == POLLHUP
))
197 && (sock
->state
& (FD_READ
|FD_WRITE
))) {
199 sock
->errors
[FD_CLOSE_BIT
] = sock_error( sock
->obj
.fd
);
200 sock
->state
&= ~(FD_WINE_CONNECTED
|FD_READ
|FD_WRITE
);
201 sock
->pmask
|= FD_CLOSE
;
203 fprintf(stderr
, "socket %d aborted by error %d\n",
204 sock
->obj
.fd
, sock
->errors
[FD_CLOSE_BIT
]);
208 if (event
& (POLLERR
|POLLHUP
))
209 set_select_events( &sock
->obj
, -1 );
211 sock_reselect( sock
);
212 /* wake up anyone waiting for whatever just happened */
213 emask
= sock
->pmask
& sock
->mask
;
214 if (debug_level
&& emask
)
215 fprintf(stderr
, "socket %d pending events: %x\n", sock
->obj
.fd
, emask
);
216 if (emask
&& sock
->event
) {
217 if (debug_level
) fprintf(stderr
, "signalling event ptr %p\n", sock
->event
);
218 set_event(sock
->event
);
221 /* if anyone is stupid enough to wait on the socket object itself,
222 * maybe we should wake them up too, just in case? */
223 wake_up( &sock
->obj
, 0 );
226 static void sock_dump( struct object
*obj
, int verbose
)
228 struct sock
*sock
= (struct sock
*)obj
;
229 assert( obj
->ops
== &sock_ops
);
230 printf( "Socket fd=%d, state=%x, mask=%x, pending=%x, held=%x\n",
231 sock
->obj
.fd
, sock
->state
,
232 sock
->mask
, sock
->pmask
, sock
->hmask
);
235 static int sock_signaled( struct object
*obj
, struct thread
*thread
)
237 struct sock
*sock
= (struct sock
*)obj
;
238 assert( obj
->ops
== &sock_ops
);
240 return check_select_events( sock
->obj
.fd
, sock_get_poll_events( &sock
->obj
) );
243 static int sock_get_poll_events( struct object
*obj
)
245 struct sock
*sock
= (struct sock
*)obj
;
246 unsigned int mask
= sock
->mask
& sock
->state
& ~sock
->hmask
;
249 assert( obj
->ops
== &sock_ops
);
251 if (sock
->state
& FD_CONNECT
)
252 /* connecting, wait for writable */
254 if (sock
->state
& FD_WINE_LISTENING
)
255 /* listening, wait for readable */
256 return (sock
->hmask
& FD_ACCEPT
) ? 0 : POLLIN
;
258 if (mask
& FD_READ
) ev
|= POLLIN
| POLLPRI
;
259 if (mask
& FD_WRITE
) ev
|= POLLOUT
;
263 static int sock_get_fd( struct object
*obj
)
265 struct sock
*sock
= (struct sock
*)obj
;
266 assert( obj
->ops
== &sock_ops
);
270 static int sock_get_info( struct object
*obj
, struct get_file_info_request
*req
)
274 req
->type
= FILE_TYPE_PIPE
;
276 req
->access_time
= 0;
285 return FD_TYPE_DEFAULT
;
288 static void sock_destroy( struct object
*obj
)
290 struct sock
*sock
= (struct sock
*)obj
;
291 assert( obj
->ops
== &sock_ops
);
293 /* FIXME: special socket shutdown stuff? */
296 /* if the service thread was waiting for the event object,
297 * we should now signal it, to let the service thread
298 * object detect that it is now orphaned... */
299 if (sock
->mask
& FD_WINE_SERVEVENT
)
300 set_event( sock
->event
);
301 /* we're through with it */
302 release_object( sock
->event
);
306 /* create a new and unconnected socket */
307 static struct object
*create_socket( int family
, int type
, int protocol
)
312 sockfd
= socket( family
, type
, protocol
);
314 fprintf(stderr
,"socket(%d,%d,%d)=%d\n",family
,type
,protocol
,sockfd
);
319 fcntl(sockfd
, F_SETFL
, O_NONBLOCK
); /* make socket nonblocking */
320 if (!(sock
= alloc_object( &sock_ops
, -1 ))) return NULL
;
321 sock
->obj
.fd
= sockfd
;
322 sock
->state
= (type
!= SOCK_STREAM
) ? (FD_READ
|FD_WRITE
) : 0;
327 sock_reselect( sock
);
332 /* accept a socket (creates a new fd) */
333 static struct object
*accept_socket( handle_t handle
)
335 struct sock
*acceptsock
;
338 struct sockaddr saddr
;
341 sock
=(struct sock
*)get_handle_obj(current
->process
,handle
,
342 GENERIC_READ
|GENERIC_WRITE
|SYNCHRONIZE
,&sock_ops
);
345 /* Try to accept(2). We can't be safe that this an already connected socket
346 * or that accept() is allowed on it. In those cases we will get -1/errno
349 slen
= sizeof(saddr
);
350 acceptfd
= accept(sock
->obj
.fd
,&saddr
,&slen
);
353 release_object( sock
);
356 if (!(acceptsock
= alloc_object( &sock_ops
, -1 )))
358 release_object( sock
);
362 /* newly created socket gets the same properties of the listening socket */
363 fcntl(acceptfd
, F_SETFL
, O_NONBLOCK
); /* make socket nonblocking */
364 acceptsock
->obj
.fd
= acceptfd
;
365 acceptsock
->state
= FD_WINE_CONNECTED
|FD_READ
|FD_WRITE
;
366 if (sock
->state
& FD_WINE_NONBLOCKING
)
367 acceptsock
->state
|= FD_WINE_NONBLOCKING
;
368 acceptsock
->mask
= sock
->mask
;
369 acceptsock
->hmask
= 0;
370 acceptsock
->pmask
= 0;
371 acceptsock
->event
= NULL
;
372 if (sock
->event
&& !(sock
->mask
& FD_WINE_SERVEVENT
))
373 acceptsock
->event
= (struct event
*)grab_object( sock
->event
);
375 sock_reselect( acceptsock
);
377 sock
->pmask
&= ~FD_ACCEPT
;
378 sock
->hmask
&= ~FD_ACCEPT
;
379 sock_reselect( sock
);
380 release_object( sock
);
381 return &acceptsock
->obj
;
384 /* set the last error depending on errno */
385 static int sock_get_error( int err
)
389 case EINTR
: return WSAEINTR
; break;
390 case EBADF
: return WSAEBADF
; break;
392 case EACCES
: return WSAEACCES
; break;
393 case EFAULT
: return WSAEFAULT
; break;
394 case EINVAL
: return WSAEINVAL
; break;
395 case EMFILE
: return WSAEMFILE
; break;
396 case EWOULDBLOCK
: return WSAEWOULDBLOCK
; break;
397 case EINPROGRESS
: return WSAEINPROGRESS
; break;
398 case EALREADY
: return WSAEALREADY
; break;
399 case ENOTSOCK
: return WSAENOTSOCK
; break;
400 case EDESTADDRREQ
: return WSAEDESTADDRREQ
; break;
401 case EMSGSIZE
: return WSAEMSGSIZE
; break;
402 case EPROTOTYPE
: return WSAEPROTOTYPE
; break;
403 case ENOPROTOOPT
: return WSAENOPROTOOPT
; break;
404 case EPROTONOSUPPORT
: return WSAEPROTONOSUPPORT
; break;
405 case ESOCKTNOSUPPORT
: return WSAESOCKTNOSUPPORT
; break;
406 case EOPNOTSUPP
: return WSAEOPNOTSUPP
; break;
407 case EPFNOSUPPORT
: return WSAEPFNOSUPPORT
; break;
408 case EAFNOSUPPORT
: return WSAEAFNOSUPPORT
; break;
409 case EADDRINUSE
: return WSAEADDRINUSE
; break;
410 case EADDRNOTAVAIL
: return WSAEADDRNOTAVAIL
; break;
411 case ENETDOWN
: return WSAENETDOWN
; break;
412 case ENETUNREACH
: return WSAENETUNREACH
; break;
413 case ENETRESET
: return WSAENETRESET
; break;
414 case ECONNABORTED
: return WSAECONNABORTED
; break;
416 case ECONNRESET
: return WSAECONNRESET
; break;
417 case ENOBUFS
: return WSAENOBUFS
; break;
418 case EISCONN
: return WSAEISCONN
; break;
419 case ENOTCONN
: return WSAENOTCONN
; break;
420 case ESHUTDOWN
: return WSAESHUTDOWN
; break;
421 case ETOOMANYREFS
: return WSAETOOMANYREFS
; break;
422 case ETIMEDOUT
: return WSAETIMEDOUT
; break;
423 case ECONNREFUSED
: return WSAECONNREFUSED
; break;
424 case ELOOP
: return WSAELOOP
; break;
425 case ENAMETOOLONG
: return WSAENAMETOOLONG
; break;
426 case EHOSTDOWN
: return WSAEHOSTDOWN
; break;
427 case EHOSTUNREACH
: return WSAEHOSTUNREACH
; break;
428 case ENOTEMPTY
: return WSAENOTEMPTY
; break;
430 case EPROCLIM
: return WSAEPROCLIM
; break;
433 case EUSERS
: return WSAEUSERS
; break;
436 case EDQUOT
: return WSAEDQUOT
; break;
439 case ESTALE
: return WSAESTALE
; break;
442 case EREMOTE
: return WSAEREMOTE
; break;
444 default: errno
=err
; perror("sock_set_error"); return ERROR_UNKNOWN
; break;
448 /* set the last error depending on errno */
449 static void sock_set_error(void)
451 set_error( sock_get_error( errno
) );
454 /* create a socket */
455 DECL_HANDLER(create_socket
)
460 if ((obj
= create_socket( req
->family
, req
->type
, req
->protocol
)) != NULL
)
462 req
->handle
= alloc_handle( current
->process
, obj
, req
->access
, req
->inherit
);
463 release_object( obj
);
467 /* accept a socket */
468 DECL_HANDLER(accept_socket
)
473 if ((obj
= accept_socket( req
->lhandle
)) != NULL
)
475 req
->handle
= alloc_handle( current
->process
, obj
, req
->access
, req
->inherit
);
476 release_object( obj
);
480 /* set socket event parameters */
481 DECL_HANDLER(set_socket_event
)
484 struct event
*oevent
;
487 sock
=(struct sock
*)get_handle_obj(current
->process
,req
->handle
,GENERIC_READ
|GENERIC_WRITE
|SYNCHRONIZE
,&sock_ops
);
490 oevent
= sock
->event
;
492 sock
->mask
= req
->mask
;
493 sock
->event
= get_event_obj( current
->process
, req
->event
, EVENT_MODIFY_STATE
);
494 if (debug_level
&& sock
->event
) fprintf(stderr
, "event ptr: %p\n", sock
->event
);
495 sock_reselect( sock
);
497 sock
->state
|= FD_WINE_NONBLOCKING
;
499 /* if a network event is pending, signal the event object
500 it is possible that FD_CONNECT or FD_ACCEPT network events has happened
501 before a WSAEventSelect() was done on it.
502 (when dealing with Asynchronous socket) */
503 if (sock
->pmask
& sock
->mask
)
504 set_event(sock
->event
);
508 if ((oevent
!= sock
->event
) && (omask
& FD_WINE_SERVEVENT
))
509 /* if the service thread was waiting for the old event object,
510 * we should now signal it, to let the service thread
511 * object detect that it is now orphaned... */
513 /* we're through with it */
514 release_object( oevent
);
516 release_object( &sock
->obj
);
519 /* get socket event parameters */
520 DECL_HANDLER(get_socket_event
)
525 sock
=(struct sock
*)get_handle_obj(current
->process
,req
->handle
,GENERIC_READ
|GENERIC_WRITE
|SYNCHRONIZE
,&sock_ops
);
531 set_error(WSAENOTSOCK
);
534 req
->mask
= sock
->mask
;
535 req
->pmask
= sock
->pmask
;
536 req
->state
= sock
->state
;
537 size
= min( get_req_data_size(req
), sizeof(sock
->errors
) );
538 memcpy( get_req_data(req
), sock
->errors
, size
);
539 set_req_data_size( req
, size
);
545 struct event
*sevent
= get_event_obj(current
->process
, req
->s_event
, 0);
546 if (sevent
== sock
->event
)
548 release_object( sevent
);
554 struct event
*cevent
= get_event_obj(current
->process
, req
->c_event
, EVENT_MODIFY_STATE
);
555 reset_event( cevent
);
556 release_object( cevent
);
559 sock_reselect( sock
);
561 else set_error(WSAEINVAL
);
563 release_object( &sock
->obj
);
566 /* re-enable pending socket events */
567 DECL_HANDLER(enable_socket_event
)
571 sock
=(struct sock
*)get_handle_obj(current
->process
,req
->handle
,GENERIC_READ
|GENERIC_WRITE
|SYNCHRONIZE
,&sock_ops
);
574 sock
->pmask
&= ~req
->mask
; /* is this safe? */
575 sock
->hmask
&= ~req
->mask
;
576 sock
->state
|= req
->sstate
;
577 sock
->state
&= ~req
->cstate
;
578 sock_reselect( sock
);
580 /* service trigger */
581 if (req
->mask
& FD_WINE_SERVEVENT
)
583 sock
->pmask
|= FD_WINE_SERVEVENT
;
585 if (debug_level
) fprintf(stderr
, "signalling service event ptr %p\n", sock
->event
);
586 set_event(sock
->event
);
590 release_object( &sock
->obj
);