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?
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>
50 #ifdef HAVE_LINUX_RTNETLINK_H
51 # include <linux/rtnetlink.h>
55 #define WIN32_NO_STATUS
70 #define FD_MAX_EVENTS 10
72 #define FD_WRITE_BIT 1
74 #define FD_ACCEPT_BIT 3
75 #define FD_CONNECT_BIT 4
76 #define FD_CLOSE_BIT 5
79 * Define flags to be used with the WSAAsyncSelect() call.
81 #define FD_READ 0x00000001
82 #define FD_WRITE 0x00000002
83 #define FD_OOB 0x00000004
84 #define FD_ACCEPT 0x00000008
85 #define FD_CONNECT 0x00000010
86 #define FD_CLOSE 0x00000020
88 /* internal per-socket flags */
89 #define FD_WINE_LISTENING 0x10000000
90 #define FD_WINE_NONBLOCKING 0x20000000
91 #define FD_WINE_CONNECTED 0x40000000
92 #define FD_WINE_RAW 0x80000000
93 #define FD_WINE_INTERNAL 0xFFFF0000
97 struct object obj
; /* object header */
98 struct fd
*fd
; /* socket file descriptor */
99 unsigned int state
; /* status bits */
100 unsigned int mask
; /* event mask */
101 unsigned int hmask
; /* held (blocked) events */
102 unsigned int pmask
; /* pending events */
103 unsigned int flags
; /* socket flags */
104 int polling
; /* is socket being polled? */
105 unsigned short proto
; /* socket protocol */
106 unsigned short type
; /* socket type */
107 unsigned short family
; /* socket family */
108 struct event
*event
; /* event object */
109 user_handle_t window
; /* window to send the message to */
110 unsigned int message
; /* message to send */
111 obj_handle_t wparam
; /* message wparam (socket handle) */
112 int errors
[FD_MAX_EVENTS
]; /* event errors */
113 timeout_t connect_time
;/* time the socket was connected */
114 struct sock
*deferred
; /* socket that waits for a deferred accept */
115 struct async_queue
*read_q
; /* queue for asynchronous reads */
116 struct async_queue
*write_q
; /* queue for asynchronous writes */
117 struct async_queue
*ifchange_q
; /* queue for interface change notifications */
118 struct object
*ifchange_obj
; /* the interface change notification object */
119 struct list ifchange_entry
; /* entry in ifchange notification list */
122 static void sock_dump( struct object
*obj
, int verbose
);
123 static int sock_add_ifchange( struct sock
*sock
, const async_data_t
*async_data
);
124 static int sock_signaled( struct object
*obj
, struct wait_queue_entry
*entry
);
125 static struct fd
*sock_get_fd( struct object
*obj
);
126 static void sock_destroy( struct object
*obj
);
127 static struct async_queue
*sock_get_ifchange_q( struct sock
*sock
);
128 static void sock_destroy_ifchange_q( struct sock
*sock
);
130 static int sock_get_poll_events( struct fd
*fd
);
131 static void sock_poll_event( struct fd
*fd
, int event
);
132 static enum server_fd_type
sock_get_fd_type( struct fd
*fd
);
133 static obj_handle_t
sock_ioctl( struct fd
*fd
, ioctl_code_t code
, const async_data_t
*async
, int blocking
);
134 static void sock_queue_async( struct fd
*fd
, const async_data_t
*data
, int type
, int count
);
135 static void sock_reselect_async( struct fd
*fd
, struct async_queue
*queue
);
136 static int sock_cancel_async( struct fd
*fd
, struct process
*process
, struct thread
*thread
, client_ptr_t iosb
);
138 static int sock_get_ntstatus( int err
);
139 static int sock_get_error( int err
);
140 static void sock_set_error(void);
142 static const struct object_ops sock_ops
=
144 sizeof(struct sock
), /* size */
145 sock_dump
, /* dump */
146 no_get_type
, /* get_type */
147 add_queue
, /* add_queue */
148 remove_queue
, /* remove_queue */
149 sock_signaled
, /* signaled */
150 no_satisfied
, /* satisfied */
151 no_signal
, /* signal */
152 sock_get_fd
, /* get_fd */
153 default_fd_map_access
, /* map_access */
154 default_get_sd
, /* get_sd */
155 default_set_sd
, /* set_sd */
156 no_lookup_name
, /* lookup_name */
157 no_open_file
, /* open_file */
158 fd_close_handle
, /* close_handle */
159 sock_destroy
/* destroy */
162 static const struct fd_ops sock_fd_ops
=
164 sock_get_poll_events
, /* get_poll_events */
165 sock_poll_event
, /* poll_event */
166 sock_get_fd_type
, /* get_fd_type */
167 no_fd_read
, /* read */
168 no_fd_write
, /* write */
169 no_fd_flush
, /* flush */
170 sock_ioctl
, /* ioctl */
171 sock_queue_async
, /* queue_async */
172 sock_reselect_async
, /* reselect_async */
173 sock_cancel_async
/* cancel_async */
177 /* Permutation of 0..FD_MAX_EVENTS - 1 representing the order in which
178 * we post messages if there are multiple events. Used to send
179 * messages. The problem is if there is both a FD_CONNECT event and,
180 * say, an FD_READ event available on the same socket, we want to
181 * notify the app of the connect event first. Otherwise it may
182 * discard the read event because it thinks it hasn't connected yet.
184 static const int event_bitorder
[FD_MAX_EVENTS
] =
192 6, 7, 8, 9 /* leftovers */
195 /* Flags that make sense only for SOCK_STREAM sockets */
196 #define STREAM_FLAG_MASK ((unsigned int) (FD_CONNECT | FD_ACCEPT | FD_WINE_LISTENING | FD_WINE_CONNECTED))
199 SOCK_SHUTDOWN_ERROR
= -1,
200 SOCK_SHUTDOWN_EOF
= 0,
201 SOCK_SHUTDOWN_POLLHUP
= 1
204 static sock_shutdown_t sock_shutdown_type
= SOCK_SHUTDOWN_ERROR
;
206 static sock_shutdown_t
sock_check_pollhup(void)
208 sock_shutdown_t ret
= SOCK_SHUTDOWN_ERROR
;
213 if ( socketpair( AF_UNIX
, SOCK_STREAM
, 0, fd
) ) return ret
;
214 if ( shutdown( fd
[0], 1 ) ) goto out
;
220 /* Solaris' poll() sometimes returns nothing if given a 0ms timeout here */
221 n
= poll( &pfd
, 1, 1 );
222 if ( n
!= 1 ) goto out
; /* error or timeout */
223 if ( pfd
.revents
& POLLHUP
)
224 ret
= SOCK_SHUTDOWN_POLLHUP
;
225 else if ( pfd
.revents
& POLLIN
&&
226 read( fd
[1], &dummy
, 1 ) == 0 )
227 ret
= SOCK_SHUTDOWN_EOF
;
237 sock_shutdown_type
= sock_check_pollhup();
239 switch ( sock_shutdown_type
)
241 case SOCK_SHUTDOWN_EOF
:
242 if (debug_level
) fprintf( stderr
, "sock_init: shutdown() causes EOF\n" );
244 case SOCK_SHUTDOWN_POLLHUP
:
245 if (debug_level
) fprintf( stderr
, "sock_init: shutdown() causes POLLHUP\n" );
248 fprintf( stderr
, "sock_init: ERROR in sock_check_pollhup()\n" );
249 sock_shutdown_type
= SOCK_SHUTDOWN_EOF
;
253 static int sock_reselect( struct sock
*sock
)
255 int ev
= sock_get_poll_events( sock
->fd
);
258 fprintf(stderr
,"sock_reselect(%p): new mask %x\n", sock
, ev
);
260 if (!sock
->polling
) /* FIXME: should find a better way to do this */
262 /* previously unconnected socket, is this reselect supposed to connect it? */
263 if (!(sock
->state
& ~FD_WINE_NONBLOCKING
)) return 0;
264 /* ok, it is, attach it to the wineserver's main poll loop */
266 allow_fd_caching( sock
->fd
);
268 /* update condition mask */
269 set_fd_events( sock
->fd
, ev
);
273 /* wake anybody waiting on the socket event or send the associated message */
274 static void sock_wake_up( struct sock
*sock
)
276 unsigned int events
= sock
->pmask
& sock
->mask
;
279 if ( !events
) return;
283 if (debug_level
) fprintf(stderr
, "signalling events %x ptr %p\n", events
, sock
->event
);
284 set_event( sock
->event
);
288 if (debug_level
) fprintf(stderr
, "signalling events %x win %08x\n", events
, sock
->window
);
289 for (i
= 0; i
< FD_MAX_EVENTS
; i
++)
291 int event
= event_bitorder
[i
];
292 if (sock
->pmask
& (1 << event
))
294 lparam_t lparam
= (1 << event
) | (sock_get_error(sock
->errors
[event
]) << 16);
295 post_message( sock
->window
, sock
->message
, sock
->wparam
, lparam
);
299 sock_reselect( sock
);
303 static inline int sock_error( struct fd
*fd
)
305 unsigned int optval
= 0;
306 socklen_t optlen
= sizeof(optval
);
308 getsockopt( get_unix_fd(fd
), SOL_SOCKET
, SO_ERROR
, (void *) &optval
, &optlen
);
312 static int sock_dispatch_asyncs( struct sock
*sock
, int event
, int error
)
314 if ( sock
->flags
& WSA_FLAG_OVERLAPPED
)
316 if ( event
& (POLLIN
|POLLPRI
) && async_waiting( sock
->read_q
) )
318 if (debug_level
) fprintf( stderr
, "activating read queue for socket %p\n", sock
);
319 async_wake_up( sock
->read_q
, STATUS_ALERTED
);
320 event
&= ~(POLLIN
|POLLPRI
);
322 if ( event
& POLLOUT
&& async_waiting( sock
->write_q
) )
324 if (debug_level
) fprintf( stderr
, "activating write queue for socket %p\n", sock
);
325 async_wake_up( sock
->write_q
, STATUS_ALERTED
);
328 if ( event
& (POLLERR
|POLLHUP
) )
330 int status
= sock_get_ntstatus( error
);
332 if ( !(sock
->state
& FD_READ
) )
333 async_wake_up( sock
->read_q
, status
);
334 if ( !(sock
->state
& FD_WRITE
) )
335 async_wake_up( sock
->write_q
, status
);
341 static void sock_dispatch_events( struct sock
*sock
, int prevstate
, int event
, int error
)
343 if (prevstate
& FD_CONNECT
)
345 sock
->pmask
|= FD_CONNECT
;
346 sock
->hmask
|= FD_CONNECT
;
347 sock
->errors
[FD_CONNECT_BIT
] = error
;
350 if (prevstate
& FD_WINE_LISTENING
)
352 sock
->pmask
|= FD_ACCEPT
;
353 sock
->hmask
|= FD_ACCEPT
;
354 sock
->errors
[FD_ACCEPT_BIT
] = error
;
360 sock
->pmask
|= FD_READ
;
361 sock
->hmask
|= FD_READ
;
362 sock
->errors
[FD_READ_BIT
] = 0;
367 sock
->pmask
|= FD_WRITE
;
368 sock
->hmask
|= FD_WRITE
;
369 sock
->errors
[FD_WRITE_BIT
] = 0;
374 sock
->pmask
|= FD_OOB
;
375 sock
->hmask
|= FD_OOB
;
376 sock
->errors
[FD_OOB_BIT
] = 0;
379 if (event
& (POLLERR
|POLLHUP
))
381 sock
->pmask
|= FD_CLOSE
;
382 sock
->hmask
|= FD_CLOSE
;
383 sock
->errors
[FD_CLOSE_BIT
] = error
;
386 sock_wake_up( sock
);
389 static void sock_poll_event( struct fd
*fd
, int event
)
391 struct sock
*sock
= get_fd_user( fd
);
393 int prevstate
= sock
->state
;
396 assert( sock
->obj
.ops
== &sock_ops
);
398 fprintf(stderr
, "socket %p select event: %x\n", sock
, event
);
400 /* we may change event later, remove from loop here */
401 if (event
& (POLLERR
|POLLHUP
)) set_fd_events( sock
->fd
, -1 );
403 if (sock
->state
& FD_CONNECT
)
405 if (event
& (POLLERR
|POLLHUP
))
407 /* we didn't get connected? */
408 sock
->state
&= ~FD_CONNECT
;
410 error
= sock_error( fd
);
412 else if (event
& POLLOUT
)
414 /* we got connected */
415 sock
->state
|= FD_WINE_CONNECTED
|FD_READ
|FD_WRITE
;
416 sock
->state
&= ~FD_CONNECT
;
417 sock
->connect_time
= current_time
;
420 else if (sock
->state
& FD_WINE_LISTENING
)
423 if (event
& (POLLERR
|POLLHUP
))
424 error
= sock_error( fd
);
428 /* normal data flow */
429 if ( sock
->type
== SOCK_STREAM
&& ( event
& POLLIN
) )
434 /* Linux 2.4 doesn't report POLLHUP if only one side of the socket
435 * has been closed, so we need to check for it explicitly here */
436 nr
= recv( get_unix_fd( fd
), &dummy
, 1, MSG_PEEK
);
445 /* EAGAIN can happen if an async recv() falls between the server's poll()
446 call and the invocation of this routine */
447 if ( errno
!= EAGAIN
)
452 fprintf( stderr
, "recv error on socket %p: %d\n", sock
, errno
);
457 if ( (hangup_seen
|| event
& (POLLHUP
|POLLERR
)) && (sock
->state
& (FD_READ
|FD_WRITE
)) )
459 error
= error
? error
: sock_error( fd
);
460 if ( (event
& POLLERR
) || ( sock_shutdown_type
== SOCK_SHUTDOWN_EOF
&& (event
& POLLHUP
) ))
461 sock
->state
&= ~FD_WRITE
;
462 sock
->state
&= ~FD_READ
;
465 fprintf(stderr
, "socket %p aborted by error %d, event: %x\n", sock
, error
, event
);
472 event
= sock_dispatch_asyncs( sock
, event
, error
);
473 sock_dispatch_events( sock
, prevstate
, event
, error
);
475 /* if anyone is stupid enough to wait on the socket object itself,
476 * maybe we should wake them up too, just in case? */
477 wake_up( &sock
->obj
, 0 );
479 sock_reselect( sock
);
482 static void sock_dump( struct object
*obj
, int verbose
)
484 struct sock
*sock
= (struct sock
*)obj
;
485 assert( obj
->ops
== &sock_ops
);
486 fprintf( stderr
, "Socket fd=%p, state=%x, mask=%x, pending=%x, held=%x\n",
487 sock
->fd
, sock
->state
,
488 sock
->mask
, sock
->pmask
, sock
->hmask
);
491 static int sock_signaled( struct object
*obj
, struct wait_queue_entry
*entry
)
493 struct sock
*sock
= (struct sock
*)obj
;
494 assert( obj
->ops
== &sock_ops
);
496 return check_fd_events( sock
->fd
, sock_get_poll_events( sock
->fd
) ) != 0;
499 static int sock_get_poll_events( struct fd
*fd
)
501 struct sock
*sock
= get_fd_user( fd
);
502 unsigned int mask
= sock
->mask
& ~sock
->hmask
;
503 unsigned int smask
= sock
->state
& mask
;
506 assert( sock
->obj
.ops
== &sock_ops
);
508 if (sock
->state
& FD_CONNECT
)
509 /* connecting, wait for writable */
512 if ( async_queued( sock
->read_q
) )
514 if ( async_waiting( sock
->read_q
) ) ev
|= POLLIN
| POLLPRI
;
516 else if (smask
& FD_READ
|| (sock
->state
& FD_WINE_LISTENING
&& mask
& FD_ACCEPT
))
517 ev
|= POLLIN
| POLLPRI
;
518 /* We use POLLIN with 0 bytes recv() as FD_CLOSE indication for stream sockets. */
519 else if ( sock
->type
== SOCK_STREAM
&& sock
->state
& FD_READ
&& mask
& FD_CLOSE
&&
520 !(sock
->hmask
& FD_READ
) )
523 if ( async_queued( sock
->write_q
) )
525 if ( async_waiting( sock
->write_q
) ) ev
|= POLLOUT
;
527 else if (smask
& FD_WRITE
)
533 static enum server_fd_type
sock_get_fd_type( struct fd
*fd
)
535 return FD_TYPE_SOCKET
;
538 obj_handle_t
sock_ioctl( struct fd
*fd
, ioctl_code_t code
, const async_data_t
*async_data
, int blocking
)
540 struct sock
*sock
= get_fd_user( fd
);
541 obj_handle_t wait_handle
= 0;
542 async_data_t new_data
;
544 assert( sock
->obj
.ops
== &sock_ops
);
548 case WS_SIO_ADDRESS_LIST_CHANGE
:
551 if (!(wait_handle
= alloc_wait_event( current
->process
))) return 0;
552 new_data
= *async_data
;
553 new_data
.event
= wait_handle
;
554 async_data
= &new_data
;
556 if (!sock_add_ifchange( sock
, async_data
) && wait_handle
)
558 close_handle( current
->process
, wait_handle
);
563 set_error( STATUS_NOT_SUPPORTED
);
568 static void sock_queue_async( struct fd
*fd
, const async_data_t
*data
, int type
, int count
)
570 struct sock
*sock
= get_fd_user( fd
);
572 struct async_queue
*queue
;
574 assert( sock
->obj
.ops
== &sock_ops
);
578 case ASYNC_TYPE_READ
:
579 if (!sock
->read_q
&& !(sock
->read_q
= create_async_queue( sock
->fd
))) return;
580 queue
= sock
->read_q
;
582 case ASYNC_TYPE_WRITE
:
583 if (!sock
->write_q
&& !(sock
->write_q
= create_async_queue( sock
->fd
))) return;
584 queue
= sock
->write_q
;
587 set_error( STATUS_INVALID_PARAMETER
);
591 if ( ( !( sock
->state
& (FD_READ
|FD_CONNECT
|FD_WINE_LISTENING
) ) && type
== ASYNC_TYPE_READ
) ||
592 ( !( sock
->state
& (FD_WRITE
|FD_CONNECT
) ) && type
== ASYNC_TYPE_WRITE
) )
594 set_error( STATUS_PIPE_DISCONNECTED
);
598 if (!(async
= create_async( current
, queue
, data
))) return;
599 release_object( async
);
601 sock_reselect( sock
);
603 set_error( STATUS_PENDING
);
606 static void sock_reselect_async( struct fd
*fd
, struct async_queue
*queue
)
608 struct sock
*sock
= get_fd_user( fd
);
609 sock_reselect( sock
);
612 static int sock_cancel_async( struct fd
*fd
, struct process
*process
, struct thread
*thread
, client_ptr_t iosb
)
614 struct sock
*sock
= get_fd_user( fd
);
617 assert( sock
->obj
.ops
== &sock_ops
);
619 n
+= async_wake_up_by( sock
->read_q
, process
, thread
, iosb
, STATUS_CANCELLED
);
620 n
+= async_wake_up_by( sock
->write_q
, process
, thread
, iosb
, STATUS_CANCELLED
);
621 n
+= async_wake_up_by( sock
->ifchange_q
, process
, thread
, iosb
, STATUS_CANCELLED
);
625 static struct fd
*sock_get_fd( struct object
*obj
)
627 struct sock
*sock
= (struct sock
*)obj
;
628 return (struct fd
*)grab_object( sock
->fd
);
631 static void sock_destroy( struct object
*obj
)
633 struct sock
*sock
= (struct sock
*)obj
;
634 assert( obj
->ops
== &sock_ops
);
636 /* FIXME: special socket shutdown stuff? */
638 if ( sock
->deferred
)
639 release_object( sock
->deferred
);
641 free_async_queue( sock
->read_q
);
642 free_async_queue( sock
->write_q
);
643 sock_destroy_ifchange_q( sock
);
644 if (sock
->event
) release_object( sock
->event
);
647 /* shut the socket down to force pending poll() calls in the client to return */
648 shutdown( get_unix_fd(sock
->fd
), SHUT_RDWR
);
649 release_object( sock
->fd
);
653 static void init_sock(struct sock
*sock
)
667 sock
->connect_time
= 0;
668 sock
->deferred
= NULL
;
670 sock
->write_q
= NULL
;
671 sock
->ifchange_q
= NULL
;
672 sock
->ifchange_obj
= NULL
;
673 memset( sock
->errors
, 0, sizeof(sock
->errors
) );
676 /* create a new and unconnected socket */
677 static struct object
*create_socket( int family
, int type
, int protocol
, unsigned int flags
)
682 sockfd
= socket( family
, type
, protocol
);
684 fprintf(stderr
,"socket(%d,%d,%d)=%d\n",family
,type
,protocol
,sockfd
);
690 fcntl(sockfd
, F_SETFL
, O_NONBLOCK
); /* make socket nonblocking */
691 if (!(sock
= alloc_object( &sock_ops
)))
697 sock
->state
= (type
!= SOCK_STREAM
) ? (FD_READ
|FD_WRITE
) : 0;
699 sock
->proto
= protocol
;
701 sock
->family
= family
;
703 if (!(sock
->fd
= create_anonymous_fd( &sock_fd_ops
, sockfd
, &sock
->obj
,
704 (flags
& WSA_FLAG_OVERLAPPED
) ? 0 : FILE_SYNCHRONOUS_IO_NONALERT
)))
706 release_object( sock
);
709 sock_reselect( sock
);
714 /* accepts a socket and inits it */
715 static int accept_new_fd( struct sock
*sock
)
718 /* Try to accept(2). We can't be safe that this an already connected socket
719 * or that accept() is allowed on it. In those cases we will get -1/errno
723 struct sockaddr saddr
;
724 socklen_t slen
= sizeof(saddr
);
725 acceptfd
= accept( get_unix_fd(sock
->fd
), &saddr
, &slen
);
732 fcntl(acceptfd
, F_SETFL
, O_NONBLOCK
); /* make socket nonblocking */
736 /* accept a socket (creates a new fd) */
737 static struct sock
*accept_socket( obj_handle_t handle
)
739 struct sock
*acceptsock
;
743 sock
= (struct sock
*)get_handle_obj( current
->process
, handle
, FILE_READ_DATA
, &sock_ops
);
747 if ( sock
->deferred
)
749 acceptsock
= sock
->deferred
;
750 sock
->deferred
= NULL
;
754 if ((acceptfd
= accept_new_fd( sock
)) == -1)
756 release_object( sock
);
759 if (!(acceptsock
= alloc_object( &sock_ops
)))
762 release_object( sock
);
766 init_sock( acceptsock
);
767 /* newly created socket gets the same properties of the listening socket */
768 acceptsock
->state
= FD_WINE_CONNECTED
|FD_READ
|FD_WRITE
;
769 if (sock
->state
& FD_WINE_NONBLOCKING
)
770 acceptsock
->state
|= FD_WINE_NONBLOCKING
;
771 acceptsock
->mask
= sock
->mask
;
772 acceptsock
->proto
= sock
->proto
;
773 acceptsock
->type
= sock
->type
;
774 acceptsock
->family
= sock
->family
;
775 acceptsock
->window
= sock
->window
;
776 acceptsock
->message
= sock
->message
;
777 acceptsock
->connect_time
= current_time
;
778 if (sock
->event
) acceptsock
->event
= (struct event
*)grab_object( sock
->event
);
779 acceptsock
->flags
= sock
->flags
;
780 if (!(acceptsock
->fd
= create_anonymous_fd( &sock_fd_ops
, acceptfd
, &acceptsock
->obj
,
781 get_fd_options( sock
->fd
) )))
783 release_object( acceptsock
);
784 release_object( sock
);
789 sock
->pmask
&= ~FD_ACCEPT
;
790 sock
->hmask
&= ~FD_ACCEPT
;
791 sock_reselect( sock
);
792 release_object( sock
);
796 static int accept_into_socket( struct sock
*sock
, struct sock
*acceptsock
)
800 if ( sock
->deferred
)
802 newfd
= dup_fd_object( sock
->deferred
->fd
, 0, 0,
803 get_fd_options( acceptsock
->fd
) );
807 set_fd_user( newfd
, &sock_fd_ops
, &acceptsock
->obj
);
809 release_object( sock
->deferred
);
810 sock
->deferred
= NULL
;
814 if ((acceptfd
= accept_new_fd( sock
)) == -1)
817 if (!(newfd
= create_anonymous_fd( &sock_fd_ops
, acceptfd
, &acceptsock
->obj
,
818 get_fd_options( acceptsock
->fd
) )))
822 acceptsock
->state
|= FD_WINE_CONNECTED
|FD_READ
|FD_WRITE
;
823 acceptsock
->hmask
= 0;
824 acceptsock
->pmask
= 0;
825 acceptsock
->polling
= 0;
826 acceptsock
->proto
= sock
->proto
;
827 acceptsock
->type
= sock
->type
;
828 acceptsock
->family
= sock
->family
;
829 acceptsock
->wparam
= 0;
830 acceptsock
->deferred
= NULL
;
831 acceptsock
->connect_time
= current_time
;
832 fd_copy_completion( acceptsock
->fd
, newfd
);
833 release_object( acceptsock
->fd
);
834 acceptsock
->fd
= newfd
;
837 sock
->pmask
&= ~FD_ACCEPT
;
838 sock
->hmask
&= ~FD_ACCEPT
;
839 sock_reselect( sock
);
844 /* return an errno value mapped to a WSA error */
845 static int sock_get_error( int err
)
849 case EINTR
: return WSAEINTR
;
850 case EBADF
: return WSAEBADF
;
852 case EACCES
: return WSAEACCES
;
853 case EFAULT
: return WSAEFAULT
;
854 case EINVAL
: return WSAEINVAL
;
855 case EMFILE
: return WSAEMFILE
;
856 case EWOULDBLOCK
: return WSAEWOULDBLOCK
;
857 case EINPROGRESS
: return WSAEINPROGRESS
;
858 case EALREADY
: return WSAEALREADY
;
859 case ENOTSOCK
: return WSAENOTSOCK
;
860 case EDESTADDRREQ
: return WSAEDESTADDRREQ
;
861 case EMSGSIZE
: return WSAEMSGSIZE
;
862 case EPROTOTYPE
: return WSAEPROTOTYPE
;
863 case ENOPROTOOPT
: return WSAENOPROTOOPT
;
864 case EPROTONOSUPPORT
: return WSAEPROTONOSUPPORT
;
865 case ESOCKTNOSUPPORT
: return WSAESOCKTNOSUPPORT
;
866 case EOPNOTSUPP
: return WSAEOPNOTSUPP
;
867 case EPFNOSUPPORT
: return WSAEPFNOSUPPORT
;
868 case EAFNOSUPPORT
: return WSAEAFNOSUPPORT
;
869 case EADDRINUSE
: return WSAEADDRINUSE
;
870 case EADDRNOTAVAIL
: return WSAEADDRNOTAVAIL
;
871 case ENETDOWN
: return WSAENETDOWN
;
872 case ENETUNREACH
: return WSAENETUNREACH
;
873 case ENETRESET
: return WSAENETRESET
;
874 case ECONNABORTED
: return WSAECONNABORTED
;
876 case ECONNRESET
: return WSAECONNRESET
;
877 case ENOBUFS
: return WSAENOBUFS
;
878 case EISCONN
: return WSAEISCONN
;
879 case ENOTCONN
: return WSAENOTCONN
;
880 case ESHUTDOWN
: return WSAESHUTDOWN
;
881 case ETOOMANYREFS
: return WSAETOOMANYREFS
;
882 case ETIMEDOUT
: return WSAETIMEDOUT
;
883 case ECONNREFUSED
: return WSAECONNREFUSED
;
884 case ELOOP
: return WSAELOOP
;
885 case ENAMETOOLONG
: return WSAENAMETOOLONG
;
886 case EHOSTDOWN
: return WSAEHOSTDOWN
;
887 case EHOSTUNREACH
: return WSAEHOSTUNREACH
;
888 case ENOTEMPTY
: return WSAENOTEMPTY
;
890 case EPROCLIM
: return WSAEPROCLIM
;
893 case EUSERS
: return WSAEUSERS
;
896 case EDQUOT
: return WSAEDQUOT
;
899 case ESTALE
: return WSAESTALE
;
902 case EREMOTE
: return WSAEREMOTE
;
908 perror("wineserver: sock_get_error() can't map error");
913 static int sock_get_ntstatus( int err
)
917 case EBADF
: return STATUS_INVALID_HANDLE
;
918 case EBUSY
: return STATUS_DEVICE_BUSY
;
920 case EACCES
: return STATUS_ACCESS_DENIED
;
921 case EFAULT
: return STATUS_NO_MEMORY
;
922 case EINVAL
: return STATUS_INVALID_PARAMETER
;
924 case EMFILE
: return STATUS_TOO_MANY_OPENED_FILES
;
925 case EWOULDBLOCK
: return STATUS_CANT_WAIT
;
926 case EINPROGRESS
: return STATUS_PENDING
;
927 case EALREADY
: return STATUS_NETWORK_BUSY
;
928 case ENOTSOCK
: return STATUS_OBJECT_TYPE_MISMATCH
;
929 case EDESTADDRREQ
: return STATUS_INVALID_PARAMETER
;
930 case EMSGSIZE
: return STATUS_BUFFER_OVERFLOW
;
931 case EPROTONOSUPPORT
:
932 case ESOCKTNOSUPPORT
:
935 case EPROTOTYPE
: return STATUS_NOT_SUPPORTED
;
936 case ENOPROTOOPT
: return STATUS_INVALID_PARAMETER
;
937 case EOPNOTSUPP
: return STATUS_NOT_SUPPORTED
;
938 case EADDRINUSE
: return STATUS_ADDRESS_ALREADY_ASSOCIATED
;
939 case EADDRNOTAVAIL
: return STATUS_INVALID_PARAMETER
;
940 case ECONNREFUSED
: return STATUS_CONNECTION_REFUSED
;
941 case ESHUTDOWN
: return STATUS_PIPE_DISCONNECTED
;
942 case ENOTCONN
: return STATUS_CONNECTION_DISCONNECTED
;
943 case ETIMEDOUT
: return STATUS_IO_TIMEOUT
;
944 case ENETUNREACH
: return STATUS_NETWORK_UNREACHABLE
;
945 case EHOSTUNREACH
: return STATUS_HOST_UNREACHABLE
;
946 case ENETDOWN
: return STATUS_NETWORK_BUSY
;
948 case ECONNRESET
: return STATUS_CONNECTION_RESET
;
949 case ECONNABORTED
: return STATUS_CONNECTION_ABORTED
;
951 case 0: return STATUS_SUCCESS
;
954 perror("wineserver: sock_get_ntstatus() can't map error");
955 return STATUS_UNSUCCESSFUL
;
959 /* set the last error depending on errno */
960 static void sock_set_error(void)
962 set_error( sock_get_ntstatus( errno
) );
965 /* add interface change notification to a socket */
966 static int sock_add_ifchange( struct sock
*sock
, const async_data_t
*async_data
)
968 struct async_queue
*ifchange_q
;
971 if (!(ifchange_q
= sock_get_ifchange_q( sock
)))
974 if (!(async
= create_async( current
, ifchange_q
, async_data
)))
976 if (!async_queued( ifchange_q
))
977 sock_destroy_ifchange_q( sock
);
979 set_error( STATUS_NO_MEMORY
);
983 release_object( async
);
984 set_error( STATUS_PENDING
);
988 #ifdef HAVE_LINUX_RTNETLINK_H
990 /* only keep one ifchange object around, all sockets waiting for wakeups will look to it */
991 static struct object
*ifchange_object
;
993 static void ifchange_dump( struct object
*obj
, int verbose
);
994 static struct fd
*ifchange_get_fd( struct object
*obj
);
995 static void ifchange_destroy( struct object
*obj
);
997 static int ifchange_get_poll_events( struct fd
*fd
);
998 static void ifchange_poll_event( struct fd
*fd
, int event
);
999 static void ifchange_reselect_async( struct fd
*fd
, struct async_queue
*queue
);
1003 struct object obj
; /* object header */
1004 struct fd
*fd
; /* interface change file descriptor */
1005 struct list sockets
; /* list of sockets to send interface change notifications */
1008 static const struct object_ops ifchange_ops
=
1010 sizeof(struct ifchange
), /* size */
1011 ifchange_dump
, /* dump */
1012 no_get_type
, /* get_type */
1013 add_queue
, /* add_queue */
1014 NULL
, /* remove_queue */
1015 NULL
, /* signaled */
1016 no_satisfied
, /* satisfied */
1017 no_signal
, /* signal */
1018 ifchange_get_fd
, /* get_fd */
1019 default_fd_map_access
, /* map_access */
1020 default_get_sd
, /* get_sd */
1021 default_set_sd
, /* set_sd */
1022 no_lookup_name
, /* lookup_name */
1023 no_open_file
, /* open_file */
1024 no_close_handle
, /* close_handle */
1025 ifchange_destroy
/* destroy */
1028 static const struct fd_ops ifchange_fd_ops
=
1030 ifchange_get_poll_events
, /* get_poll_events */
1031 ifchange_poll_event
, /* poll_event */
1032 NULL
, /* get_fd_type */
1033 no_fd_read
, /* read */
1034 no_fd_write
, /* write */
1035 no_fd_flush
, /* flush */
1036 no_fd_ioctl
, /* ioctl */
1037 NULL
, /* queue_async */
1038 ifchange_reselect_async
, /* reselect_async */
1039 NULL
/* cancel_async */
1042 static void ifchange_dump( struct object
*obj
, int verbose
)
1044 assert( obj
->ops
== &ifchange_ops
);
1045 fprintf( stderr
, "Interface change\n" );
1048 static struct fd
*ifchange_get_fd( struct object
*obj
)
1050 struct ifchange
*ifchange
= (struct ifchange
*)obj
;
1051 return (struct fd
*)grab_object( ifchange
->fd
);
1054 static void ifchange_destroy( struct object
*obj
)
1056 struct ifchange
*ifchange
= (struct ifchange
*)obj
;
1057 assert( obj
->ops
== &ifchange_ops
);
1059 release_object( ifchange
->fd
);
1061 /* reset the global ifchange object so that it will be recreated if it is needed again */
1062 assert( obj
== ifchange_object
);
1063 ifchange_object
= NULL
;
1066 static int ifchange_get_poll_events( struct fd
*fd
)
1071 /* wake up all the sockets waiting for a change notification event */
1072 static void ifchange_wake_up( struct object
*obj
, unsigned int status
)
1074 struct ifchange
*ifchange
= (struct ifchange
*)obj
;
1075 struct list
*ptr
, *next
;
1076 assert( obj
->ops
== &ifchange_ops
);
1077 assert( obj
== ifchange_object
);
1079 LIST_FOR_EACH_SAFE( ptr
, next
, &ifchange
->sockets
)
1081 struct sock
*sock
= LIST_ENTRY( ptr
, struct sock
, ifchange_entry
);
1083 assert( sock
->ifchange_q
);
1084 async_wake_up( sock
->ifchange_q
, status
); /* issue ifchange notification for the socket */
1085 sock_destroy_ifchange_q( sock
); /* remove socket from list and decrement ifchange refcount */
1089 static void ifchange_poll_event( struct fd
*fd
, int event
)
1091 struct object
*ifchange
= get_fd_user( fd
);
1092 unsigned int status
= STATUS_PENDING
;
1093 char buffer
[PIPE_BUF
];
1096 r
= recv( get_unix_fd(fd
), buffer
, sizeof(buffer
), MSG_DONTWAIT
);
1099 if (errno
== EWOULDBLOCK
|| errno
== EAGAIN
)
1100 return; /* retry when poll() says the socket is ready */
1101 status
= sock_get_ntstatus( errno
);
1105 struct nlmsghdr
*nlh
;
1107 for (nlh
= (struct nlmsghdr
*)buffer
; NLMSG_OK(nlh
, r
); nlh
= NLMSG_NEXT(nlh
, r
))
1109 if (nlh
->nlmsg_type
== NLMSG_DONE
)
1111 if (nlh
->nlmsg_type
== RTM_NEWADDR
|| nlh
->nlmsg_type
== RTM_DELADDR
)
1112 status
= STATUS_SUCCESS
;
1115 else status
= STATUS_CANCELLED
;
1117 if (status
!= STATUS_PENDING
) ifchange_wake_up( ifchange
, status
);
1120 static void ifchange_reselect_async( struct fd
*fd
, struct async_queue
*queue
)
1122 /* do nothing, this object is about to disappear */
1127 /* we only need one of these interface notification objects, all of the sockets dependent upon
1128 * it will wake up when a notification event occurs */
1129 static struct object
*get_ifchange( void )
1131 #ifdef HAVE_LINUX_RTNETLINK_H
1132 struct ifchange
*ifchange
;
1133 struct sockaddr_nl addr
;
1136 if (ifchange_object
)
1138 /* increment the refcount for each socket that uses the ifchange object */
1139 return grab_object( ifchange_object
);
1142 /* create the socket we need for processing interface change notifications */
1143 unix_fd
= socket( PF_NETLINK
, SOCK_RAW
, NETLINK_ROUTE
);
1149 fcntl( unix_fd
, F_SETFL
, O_NONBLOCK
); /* make socket nonblocking */
1150 memset( &addr
, 0, sizeof(addr
) );
1151 addr
.nl_family
= AF_NETLINK
;
1152 addr
.nl_groups
= RTMGRP_IPV4_IFADDR
;
1153 /* bind the socket to the special netlink kernel interface */
1154 if (bind( unix_fd
, (struct sockaddr
*)&addr
, sizeof(addr
) ) == -1)
1160 if (!(ifchange
= alloc_object( &ifchange_ops
)))
1163 set_error( STATUS_NO_MEMORY
);
1166 list_init( &ifchange
->sockets
);
1167 if (!(ifchange
->fd
= create_anonymous_fd( &ifchange_fd_ops
, unix_fd
, &ifchange
->obj
, 0 )))
1169 release_object( ifchange
);
1170 set_error( STATUS_NO_MEMORY
);
1173 set_fd_events( ifchange
->fd
, POLLIN
); /* enable read wakeup on the file descriptor */
1175 /* the ifchange object is now successfully configured */
1176 ifchange_object
= &ifchange
->obj
;
1177 return &ifchange
->obj
;
1179 set_error( STATUS_NOT_SUPPORTED
);
1184 /* add the socket to the interface change notification list */
1185 static void ifchange_add_sock( struct object
*obj
, struct sock
*sock
)
1187 #ifdef HAVE_LINUX_RTNETLINK_H
1188 struct ifchange
*ifchange
= (struct ifchange
*)obj
;
1190 list_add_tail( &ifchange
->sockets
, &sock
->ifchange_entry
);
1194 /* create a new ifchange queue for a specific socket or, if one already exists, reuse the existing one */
1195 static struct async_queue
*sock_get_ifchange_q( struct sock
*sock
)
1197 struct object
*ifchange
;
1200 if (sock
->ifchange_q
) /* reuse existing ifchange_q for this socket */
1201 return sock
->ifchange_q
;
1203 if (!(ifchange
= get_ifchange()))
1206 /* create the ifchange notification queue */
1207 fd
= ifchange
->ops
->get_fd( ifchange
);
1208 sock
->ifchange_q
= create_async_queue( fd
);
1209 release_object( fd
);
1210 if (!sock
->ifchange_q
)
1212 release_object( ifchange
);
1213 set_error( STATUS_NO_MEMORY
);
1217 /* add the socket to the ifchange notification list */
1218 ifchange_add_sock( ifchange
, sock
);
1219 sock
->ifchange_obj
= ifchange
;
1220 return sock
->ifchange_q
;
1223 /* destroy an existing ifchange queue for a specific socket */
1224 static void sock_destroy_ifchange_q( struct sock
*sock
)
1226 if (sock
->ifchange_q
)
1228 list_remove( &sock
->ifchange_entry
);
1229 free_async_queue( sock
->ifchange_q
);
1230 sock
->ifchange_q
= NULL
;
1231 release_object( sock
->ifchange_obj
);
1235 /* create a socket */
1236 DECL_HANDLER(create_socket
)
1241 if ((obj
= create_socket( req
->family
, req
->type
, req
->protocol
, req
->flags
)) != NULL
)
1243 reply
->handle
= alloc_handle( current
->process
, obj
, req
->access
, req
->attributes
);
1244 release_object( obj
);
1248 /* accept a socket */
1249 DECL_HANDLER(accept_socket
)
1254 if ((sock
= accept_socket( req
->lhandle
)) != NULL
)
1256 reply
->handle
= alloc_handle( current
->process
, &sock
->obj
, req
->access
, req
->attributes
);
1257 sock
->wparam
= reply
->handle
; /* wparam for message is the socket handle */
1258 sock_reselect( sock
);
1259 release_object( &sock
->obj
);
1263 /* accept a socket into an initialized socket */
1264 DECL_HANDLER(accept_into_socket
)
1266 struct sock
*sock
, *acceptsock
;
1267 const int all_attributes
= FILE_READ_ATTRIBUTES
|FILE_WRITE_ATTRIBUTES
|FILE_READ_DATA
;
1269 if (!(sock
= (struct sock
*)get_handle_obj( current
->process
, req
->lhandle
,
1270 all_attributes
, &sock_ops
)))
1273 if (!(acceptsock
= (struct sock
*)get_handle_obj( current
->process
, req
->ahandle
,
1274 all_attributes
, &sock_ops
)))
1276 release_object( sock
);
1280 if (accept_into_socket( sock
, acceptsock
))
1282 acceptsock
->wparam
= req
->ahandle
; /* wparam for message is the socket handle */
1283 sock_reselect( acceptsock
);
1285 release_object( acceptsock
);
1286 release_object( sock
);
1289 /* set socket event parameters */
1290 DECL_HANDLER(set_socket_event
)
1293 struct event
*old_event
;
1295 if (!(sock
= (struct sock
*)get_handle_obj( current
->process
, req
->handle
,
1296 FILE_WRITE_ATTRIBUTES
, &sock_ops
))) return;
1297 old_event
= sock
->event
;
1298 sock
->mask
= req
->mask
;
1299 sock
->hmask
&= ~req
->mask
; /* re-enable held events */
1301 sock
->window
= req
->window
;
1302 sock
->message
= req
->msg
;
1303 sock
->wparam
= req
->handle
; /* wparam is the socket handle */
1304 if (req
->event
) sock
->event
= get_event_obj( current
->process
, req
->event
, EVENT_MODIFY_STATE
);
1306 if (debug_level
&& sock
->event
) fprintf(stderr
, "event ptr: %p\n", sock
->event
);
1308 sock_reselect( sock
);
1310 sock
->state
|= FD_WINE_NONBLOCKING
;
1312 /* if a network event is pending, signal the event object
1313 it is possible that FD_CONNECT or FD_ACCEPT network events has happened
1314 before a WSAEventSelect() was done on it.
1315 (when dealing with Asynchronous socket) */
1316 sock_wake_up( sock
);
1318 if (old_event
) release_object( old_event
); /* we're through with it */
1319 release_object( &sock
->obj
);
1322 /* get socket event parameters */
1323 DECL_HANDLER(get_socket_event
)
1327 int errors
[FD_MAX_EVENTS
];
1329 sock
= (struct sock
*)get_handle_obj( current
->process
, req
->handle
, FILE_READ_ATTRIBUTES
, &sock_ops
);
1337 reply
->mask
= sock
->mask
;
1338 reply
->pmask
= sock
->pmask
;
1339 reply
->state
= sock
->state
;
1340 for (i
= 0; i
< FD_MAX_EVENTS
; i
++)
1341 errors
[i
] = sock_get_ntstatus(sock
->errors
[i
]);
1343 set_reply_data( errors
, min( get_reply_max_size(), sizeof(errors
) ));
1349 struct event
*cevent
= get_event_obj( current
->process
, req
->c_event
,
1350 EVENT_MODIFY_STATE
);
1353 reset_event( cevent
);
1354 release_object( cevent
);
1358 sock_reselect( sock
);
1360 release_object( &sock
->obj
);
1363 /* re-enable pending socket events */
1364 DECL_HANDLER(enable_socket_event
)
1368 if (!(sock
= (struct sock
*)get_handle_obj( current
->process
, req
->handle
,
1369 FILE_WRITE_ATTRIBUTES
, &sock_ops
)))
1372 /* for event-based notification, windows erases stale events */
1373 sock
->pmask
&= ~req
->mask
;
1375 sock
->hmask
&= ~req
->mask
;
1376 sock
->state
|= req
->sstate
;
1377 sock
->state
&= ~req
->cstate
;
1378 if ( sock
->type
!= SOCK_STREAM
) sock
->state
&= ~STREAM_FLAG_MASK
;
1380 sock_reselect( sock
);
1382 release_object( &sock
->obj
);
1385 DECL_HANDLER(set_socket_deferred
)
1387 struct sock
*sock
, *acceptsock
;
1389 sock
=(struct sock
*)get_handle_obj( current
->process
, req
->handle
, FILE_WRITE_ATTRIBUTES
, &sock_ops
);
1393 acceptsock
= (struct sock
*)get_handle_obj( current
->process
, req
->deferred
, 0, &sock_ops
);
1396 release_object( sock
);
1399 sock
->deferred
= acceptsock
;
1400 release_object( sock
);
1403 DECL_HANDLER(get_socket_info
)
1407 sock
= (struct sock
*)get_handle_obj( current
->process
, req
->handle
, FILE_READ_ATTRIBUTES
, &sock_ops
);
1410 reply
->family
= sock
->family
;
1411 reply
->type
= sock
->type
;
1412 reply
->protocol
= sock
->proto
;
1414 release_object( &sock
->obj
);