2 * Server-side pipe management
4 * Copyright (C) 1998 Alexandre Julliard
5 * Copyright (C) 2001 Mike McCormack
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 #include "wine/port.h"
35 #include <sys/types.h>
36 #ifdef HAVE_SYS_SOCKET_H
37 #include <sys/socket.h>
61 ps_disconnected_server
,
69 struct object obj
; /* object header */
70 struct fd
*fd
; /* pipe file descriptor */
71 struct list entry
; /* entry in named pipe servers list */
72 enum pipe_state state
; /* server state */
73 struct pipe_client
*client
; /* client that this server is connected to */
74 struct named_pipe
*pipe
;
75 struct timeout_user
*flush_poll
;
77 struct list wait_q
; /* only a single one can be queued */
78 unsigned int options
; /* pipe options */
83 struct object obj
; /* object header */
84 struct fd
*fd
; /* pipe file descriptor */
85 struct pipe_server
*server
; /* server that this client is connected to */
86 unsigned int flags
; /* file flags */
91 struct object obj
; /* object header */
93 unsigned int maxinstances
;
97 unsigned int instances
;
98 struct list servers
; /* list of servers using this pipe */
99 struct list waiters
; /* list of clients waiting to connect */
102 static void named_pipe_dump( struct object
*obj
, int verbose
);
103 static void named_pipe_destroy( struct object
*obj
);
105 static const struct object_ops named_pipe_ops
=
107 sizeof(struct named_pipe
), /* size */
108 named_pipe_dump
, /* dump */
109 no_add_queue
, /* add_queue */
110 NULL
, /* remove_queue */
112 NULL
, /* satisfied */
113 no_signal
, /* signal */
114 no_get_fd
, /* get_fd */
115 no_close_handle
, /* close_handle */
116 named_pipe_destroy
/* destroy */
119 /* server end functions */
120 static void pipe_server_dump( struct object
*obj
, int verbose
);
121 static struct fd
*pipe_server_get_fd( struct object
*obj
);
122 static void pipe_server_destroy( struct object
*obj
);
123 static int pipe_server_flush( struct fd
*fd
, struct event
**event
);
124 static int pipe_server_get_info( struct fd
*fd
);
126 static const struct object_ops pipe_server_ops
=
128 sizeof(struct pipe_server
), /* size */
129 pipe_server_dump
, /* dump */
130 default_fd_add_queue
, /* add_queue */
131 default_fd_remove_queue
, /* remove_queue */
132 default_fd_signaled
, /* signaled */
133 no_satisfied
, /* satisfied */
134 no_signal
, /* signal */
135 pipe_server_get_fd
, /* get_fd */
136 no_close_handle
, /* close_handle */
137 pipe_server_destroy
/* destroy */
140 static const struct fd_ops pipe_server_fd_ops
=
142 default_fd_get_poll_events
, /* get_poll_events */
143 default_poll_event
, /* poll_event */
144 pipe_server_flush
, /* flush */
145 pipe_server_get_info
, /* get_file_info */
146 default_fd_queue_async
, /* queue_async */
147 default_fd_cancel_async
, /* cancel_async */
150 /* client end functions */
151 static void pipe_client_dump( struct object
*obj
, int verbose
);
152 static struct fd
*pipe_client_get_fd( struct object
*obj
);
153 static void pipe_client_destroy( struct object
*obj
);
154 static int pipe_client_flush( struct fd
*fd
, struct event
**event
);
155 static int pipe_client_get_info( struct fd
*fd
);
157 static const struct object_ops pipe_client_ops
=
159 sizeof(struct pipe_client
), /* size */
160 pipe_client_dump
, /* dump */
161 default_fd_add_queue
, /* add_queue */
162 default_fd_remove_queue
, /* remove_queue */
163 default_fd_signaled
, /* signaled */
164 no_satisfied
, /* satisfied */
165 no_signal
, /* signal */
166 pipe_client_get_fd
, /* get_fd */
167 no_close_handle
, /* close_handle */
168 pipe_client_destroy
/* destroy */
171 static const struct fd_ops pipe_client_fd_ops
=
173 default_fd_get_poll_events
, /* get_poll_events */
174 default_poll_event
, /* poll_event */
175 pipe_client_flush
, /* flush */
176 pipe_client_get_info
, /* get_file_info */
177 default_fd_queue_async
, /* queue_async */
178 default_fd_cancel_async
/* cancel_async */
181 static void named_pipe_dump( struct object
*obj
, int verbose
)
183 struct named_pipe
*pipe
= (struct named_pipe
*) obj
;
184 assert( obj
->ops
== &named_pipe_ops
);
185 fprintf( stderr
, "Named pipe " );
186 dump_object_name( &pipe
->obj
);
187 fprintf( stderr
, "\n" );
190 static void pipe_server_dump( struct object
*obj
, int verbose
)
192 struct pipe_server
*server
= (struct pipe_server
*) obj
;
193 assert( obj
->ops
== &pipe_server_ops
);
194 fprintf( stderr
, "Named pipe server pipe=%p state=%d\n", server
->pipe
, server
->state
);
197 static void pipe_client_dump( struct object
*obj
, int verbose
)
199 struct pipe_client
*client
= (struct pipe_client
*) obj
;
200 assert( obj
->ops
== &pipe_client_ops
);
201 fprintf( stderr
, "Named pipe client server=%p\n", client
->server
);
204 static void named_pipe_destroy( struct object
*obj
)
206 struct named_pipe
*pipe
= (struct named_pipe
*) obj
;
208 assert( list_empty( &pipe
->servers
) );
209 assert( !pipe
->instances
);
210 async_terminate_queue( &pipe
->waiters
, STATUS_HANDLES_CLOSED
);
213 static struct fd
*pipe_client_get_fd( struct object
*obj
)
215 struct pipe_client
*client
= (struct pipe_client
*) obj
;
217 return (struct fd
*) grab_object( client
->fd
);
218 set_error( STATUS_PIPE_DISCONNECTED
);
222 static struct fd
*pipe_server_get_fd( struct object
*obj
)
224 struct pipe_server
*server
= (struct pipe_server
*) obj
;
226 switch(server
->state
)
228 case ps_connected_server
:
229 case ps_wait_disconnect
:
230 assert( server
->fd
);
231 return (struct fd
*) grab_object( server
->fd
);
235 set_error( STATUS_PIPE_LISTENING
);
238 case ps_disconnected_server
:
239 case ps_wait_connect
:
240 set_error( STATUS_PIPE_DISCONNECTED
);
247 static void notify_empty( struct pipe_server
*server
)
249 if (!server
->flush_poll
)
251 assert( server
->state
== ps_connected_server
);
252 assert( server
->event
);
253 remove_timeout_user( server
->flush_poll
);
254 server
->flush_poll
= NULL
;
255 set_event( server
->event
);
256 release_object( server
->event
);
257 server
->event
= NULL
;
260 static void do_disconnect( struct pipe_server
*server
)
262 /* we may only have a server fd, if the client disconnected */
265 assert( server
->client
->server
== server
);
266 assert( server
->client
->fd
);
267 release_object( server
->client
->fd
);
268 server
->client
->fd
= NULL
;
270 assert( server
->fd
);
271 release_object( server
->fd
);
275 static void pipe_server_destroy( struct object
*obj
)
277 struct pipe_server
*server
= (struct pipe_server
*)obj
;
279 assert( obj
->ops
== &pipe_server_ops
);
283 notify_empty( server
);
284 do_disconnect( server
);
289 server
->client
->server
= NULL
;
290 server
->client
= NULL
;
293 async_terminate_head( &server
->wait_q
, STATUS_HANDLES_CLOSED
);
295 assert( server
->pipe
->instances
);
296 server
->pipe
->instances
--;
298 list_remove( &server
->entry
);
299 release_object( server
->pipe
);
302 static void pipe_client_destroy( struct object
*obj
)
304 struct pipe_client
*client
= (struct pipe_client
*)obj
;
305 struct pipe_server
*server
= client
->server
;
307 assert( obj
->ops
== &pipe_client_ops
);
311 notify_empty( server
);
313 switch(server
->state
)
315 case ps_connected_server
:
316 /* Don't destroy the server's fd here as we can't
317 do a successful flush without it. */
318 server
->state
= ps_wait_disconnect
;
319 release_object( client
->fd
);
322 case ps_disconnected_server
:
323 server
->state
= ps_wait_connect
;
327 case ps_wait_disconnect
:
328 case ps_wait_connect
:
331 assert( server
->client
);
332 server
->client
= NULL
;
333 client
->server
= NULL
;
335 assert( !client
->fd
);
338 static int pipe_data_remaining( struct pipe_server
*server
)
343 assert( server
->client
);
345 fd
= get_unix_fd( server
->client
->fd
);
352 if (0 > poll( &pfd
, 1, 0 ))
355 return pfd
.revents
&POLLIN
;
358 static void check_flushed( void *arg
)
360 struct pipe_server
*server
= (struct pipe_server
*) arg
;
362 assert( server
->event
);
363 if (pipe_data_remaining( server
))
367 gettimeofday( &tv
, NULL
);
368 add_timeout( &tv
, 100 );
369 server
->flush_poll
= add_timeout_user( &tv
, check_flushed
, server
);
373 /* notify_empty( server ); */
374 server
->flush_poll
= NULL
;
375 set_event( server
->event
);
376 release_object( server
->event
);
377 server
->event
= NULL
;
381 static int pipe_server_flush( struct fd
*fd
, struct event
**event
)
383 struct pipe_server
*server
= get_fd_user( fd
);
388 if (server
->state
!= ps_connected_server
)
391 /* FIXME: if multiple threads flush the same pipe,
392 maybe should create a list of processes to notify */
393 if (server
->flush_poll
)
396 if (pipe_data_remaining( server
))
400 /* this kind of sux -
401 there's no unix way to be alerted when a pipe becomes empty */
402 server
->event
= create_event( NULL
, 0, 0, 0 );
405 gettimeofday( &tv
, NULL
);
406 add_timeout( &tv
, 100 );
407 server
->flush_poll
= add_timeout_user( &tv
, check_flushed
, server
);
408 *event
= server
->event
;
414 static int pipe_client_flush( struct fd
*fd
, struct event
**event
)
416 /* FIXME: what do we have to do for this? */
420 static inline int is_overlapped( unsigned int options
)
422 return !(options
& (FILE_SYNCHRONOUS_IO_ALERT
| FILE_SYNCHRONOUS_IO_NONALERT
));
425 static int pipe_server_get_info( struct fd
*fd
)
427 struct pipe_server
*server
= get_fd_user( fd
);
428 int flags
= FD_FLAG_AVAILABLE
;
430 if (is_overlapped( server
->options
)) flags
|= FD_FLAG_OVERLAPPED
;
435 static int pipe_client_get_info( struct fd
*fd
)
437 struct pipe_client
*client
= get_fd_user( fd
);
438 int flags
= FD_FLAG_AVAILABLE
;
440 if (is_overlapped( client
->flags
)) flags
|= FD_FLAG_OVERLAPPED
;
445 static struct named_pipe
*create_named_pipe( const WCHAR
*name
, size_t len
)
447 struct named_pipe
*pipe
;
449 pipe
= create_named_object( sync_namespace
, &named_pipe_ops
, name
, len
);
452 if (get_error() != STATUS_OBJECT_NAME_COLLISION
)
454 /* initialize it if it didn't already exist */
456 list_init( &pipe
->servers
);
457 list_init( &pipe
->waiters
);
463 static struct named_pipe
*open_named_pipe( const WCHAR
*name
, size_t len
)
467 if ((obj
= find_object( sync_namespace
, name
, len
)))
469 if (obj
->ops
== &named_pipe_ops
) return (struct named_pipe
*)obj
;
470 release_object( obj
);
471 set_error( STATUS_OBJECT_TYPE_MISMATCH
);
473 else set_error( STATUS_OBJECT_NAME_NOT_FOUND
);
478 static struct pipe_server
*get_pipe_server_obj( struct process
*process
,
479 obj_handle_t handle
, unsigned int access
)
482 obj
= get_handle_obj( process
, handle
, access
, &pipe_server_ops
);
483 return (struct pipe_server
*) obj
;
486 static struct pipe_server
*create_pipe_server( struct named_pipe
*pipe
, unsigned int options
)
488 struct pipe_server
*server
;
490 server
= alloc_object( &pipe_server_ops
);
496 server
->state
= ps_idle_server
;
497 server
->client
= NULL
;
498 server
->flush_poll
= NULL
;
499 server
->options
= options
;
500 list_init( &server
->wait_q
);
502 list_add_head( &pipe
->servers
, &server
->entry
);
508 static struct pipe_client
*create_pipe_client( struct pipe_server
*server
, unsigned int flags
)
510 struct pipe_client
*client
;
512 client
= alloc_object( &pipe_client_ops
);
517 client
->server
= server
;
518 client
->flags
= flags
;
523 static inline struct pipe_server
*find_server( struct named_pipe
*pipe
, enum pipe_state state
)
525 struct pipe_server
*server
;
527 LIST_FOR_EACH_ENTRY( server
, &pipe
->servers
, struct pipe_server
, entry
)
529 if (server
->state
== state
) return (struct pipe_server
*)grab_object( server
);
534 static inline struct pipe_server
*find_server2( struct named_pipe
*pipe
,
535 enum pipe_state state1
, enum pipe_state state2
)
537 struct pipe_server
*server
;
539 LIST_FOR_EACH_ENTRY( server
, &pipe
->servers
, struct pipe_server
, entry
)
541 if (server
->state
== state1
|| server
->state
== state2
)
542 return (struct pipe_server
*)grab_object( server
);
547 DECL_HANDLER(create_named_pipe
)
549 struct named_pipe
*pipe
;
550 struct pipe_server
*server
;
553 pipe
= create_named_pipe( get_req_data(), get_req_data_size() );
557 if (get_error() != STATUS_OBJECT_NAME_COLLISION
)
559 pipe
->insize
= req
->insize
;
560 pipe
->outsize
= req
->outsize
;
561 pipe
->maxinstances
= req
->maxinstances
;
562 pipe
->timeout
= req
->timeout
;
563 pipe
->flags
= req
->flags
;
567 set_error( 0 ); /* clear the name collision */
568 if (pipe
->maxinstances
<= pipe
->instances
)
570 set_error( STATUS_PIPE_BUSY
);
571 release_object( pipe
);
574 if ((pipe
->maxinstances
!= req
->maxinstances
) ||
575 (pipe
->timeout
!= req
->timeout
) ||
576 (pipe
->flags
!= req
->flags
))
578 set_error( STATUS_ACCESS_DENIED
);
579 release_object( pipe
);
584 server
= create_pipe_server( pipe
, req
->options
);
587 reply
->handle
= alloc_handle( current
->process
, server
,
588 GENERIC_READ
|GENERIC_WRITE
, req
->inherit
);
589 server
->pipe
->instances
++;
590 release_object( server
);
593 release_object( pipe
);
596 DECL_HANDLER(open_named_pipe
)
598 struct pipe_server
*server
;
599 struct pipe_client
*client
;
600 struct named_pipe
*pipe
;
603 pipe
= open_named_pipe( get_req_data(), get_req_data_size() );
606 set_error( STATUS_NO_SUCH_FILE
);
610 server
= find_server2( pipe
, ps_idle_server
, ps_wait_open
);
611 release_object( pipe
);
615 set_error( STATUS_PIPE_NOT_AVAILABLE
);
619 client
= create_pipe_client( server
, req
->flags
);
622 if (!socketpair( PF_UNIX
, SOCK_STREAM
, 0, fds
))
626 assert( !client
->fd
);
627 assert( !server
->fd
);
629 /* for performance reasons, only set nonblocking mode when using
630 * overlapped I/O. Otherwise, we will be doing too much busy
632 if (is_overlapped( req
->flags
))
633 res
= fcntl( fds
[1], F_SETFL
, O_NONBLOCK
);
634 if ((res
!= -1) && is_overlapped( server
->options
))
635 res
= fcntl( fds
[0], F_SETFL
, O_NONBLOCK
);
637 client
->fd
= create_anonymous_fd( &pipe_client_fd_ops
,
638 fds
[1], &client
->obj
);
639 server
->fd
= create_anonymous_fd( &pipe_server_fd_ops
,
640 fds
[0], &server
->obj
);
641 if (client
->fd
&& server
->fd
&& res
!= 1)
643 if (server
->state
== ps_wait_open
)
644 async_terminate_head( &server
->wait_q
, STATUS_SUCCESS
);
645 assert( list_empty( &server
->wait_q
) );
646 server
->state
= ps_connected_server
;
647 server
->client
= client
;
648 client
->server
= server
;
649 reply
->handle
= alloc_handle( current
->process
, client
,
650 req
->access
, req
->inherit
);
656 release_object( client
);
658 release_object( server
);
661 DECL_HANDLER(connect_named_pipe
)
663 struct pipe_server
*server
;
665 server
= get_pipe_server_obj(current
->process
, req
->handle
, 0);
669 switch(server
->state
)
672 case ps_wait_connect
:
673 assert( !server
->fd
);
674 server
->state
= ps_wait_open
;
675 create_async( current
, NULL
, &server
->wait_q
,
676 req
->func
, req
->overlapped
, NULL
);
677 async_terminate_queue( &server
->pipe
->waiters
, STATUS_SUCCESS
);
679 case ps_connected_server
:
680 assert( server
->fd
);
681 set_error( STATUS_PIPE_CONNECTED
);
683 case ps_disconnected_server
:
684 set_error( STATUS_PIPE_BUSY
);
686 case ps_wait_disconnect
:
687 set_error( STATUS_NO_DATA_DETECTED
);
690 set_error( STATUS_INVALID_HANDLE
);
694 release_object(server
);
697 DECL_HANDLER(wait_named_pipe
)
699 struct named_pipe
*pipe
;
700 struct pipe_server
*server
;
702 if (!(pipe
= open_named_pipe( get_req_data(), get_req_data_size() )))
704 set_error( STATUS_PIPE_NOT_AVAILABLE
);
707 server
= find_server( pipe
, ps_wait_open
);
710 /* there's already a server waiting for a client to connect */
711 thread_queue_apc( current
, NULL
, req
->func
, APC_ASYNC_IO
,
712 1, req
->overlapped
, NULL
, (void *)STATUS_SUCCESS
);
713 release_object( server
);
717 unsigned int timeout
;
718 if (req
->timeout
== NMPWAIT_USE_DEFAULT_WAIT
)
719 timeout
= pipe
->timeout
;
721 timeout
= req
->timeout
;
723 if (req
->timeout
== NMPWAIT_WAIT_FOREVER
)
724 create_async( current
, NULL
, &pipe
->waiters
,
725 req
->func
, req
->overlapped
, NULL
);
727 create_async( current
, &timeout
, &pipe
->waiters
,
728 req
->func
, req
->overlapped
, NULL
);
731 release_object( pipe
);
734 DECL_HANDLER(disconnect_named_pipe
)
736 struct pipe_server
*server
;
739 server
= get_pipe_server_obj( current
->process
, req
->handle
, 0 );
742 switch(server
->state
)
744 case ps_connected_server
:
745 assert( server
->fd
);
746 assert( server
->client
);
747 assert( server
->client
->fd
);
749 notify_empty( server
);
751 /* Dump the client and server fds, but keep the pointers
752 around - client loses all waiting data */
753 server
->state
= ps_disconnected_server
;
754 do_disconnect( server
);
755 reply
->fd
= flush_cached_fd( current
->process
, req
->handle
);
758 case ps_wait_disconnect
:
759 assert( !server
->client
);
760 assert( server
->fd
);
761 do_disconnect( server
);
762 server
->state
= ps_wait_connect
;
763 reply
->fd
= flush_cached_fd( current
->process
, req
->handle
);
768 case ps_disconnected_server
:
769 case ps_wait_connect
:
770 set_error( STATUS_PIPE_DISCONNECTED
);
773 release_object( server
);
776 DECL_HANDLER(get_named_pipe_info
)
778 struct pipe_server
*server
;
780 server
= get_pipe_server_obj( current
->process
, req
->handle
, 0 );
784 reply
->flags
= server
->pipe
->flags
;
785 reply
->maxinstances
= server
->pipe
->maxinstances
;
786 reply
->insize
= server
->pipe
->insize
;
787 reply
->outsize
= server
->pipe
->outsize
;
789 release_object(server
);