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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
26 #include "wine/port.h"
35 #include <sys/types.h>
36 #ifdef HAVE_SYS_SOCKET_H
37 #include <sys/socket.h>
46 #define WIN32_NO_STATUS
62 ps_disconnected_server,
70 struct object obj; /* object header */
71 struct fd *fd; /* pipe file descriptor */
72 struct list entry; /* entry in named pipe servers list */
73 enum pipe_state state; /* server state */
74 struct pipe_client *client; /* client that this server is connected to */
75 struct named_pipe *pipe;
76 struct timeout_user *flush_poll;
78 struct async_queue *wait_q; /* only a single one can be queued */
79 unsigned int options; /* pipe options */
84 struct object obj; /* object header */
85 struct fd *fd; /* pipe file descriptor */
86 struct pipe_server *server; /* server that this client is connected to */
87 unsigned int flags; /* file flags */
92 struct object obj; /* object header */
94 unsigned int maxinstances;
97 unsigned int instances;
99 struct list servers; /* list of servers using this pipe */
100 struct async_queue *waiters; /* list of clients waiting to connect */
103 struct named_pipe_device
105 struct object obj; /* object header */
106 struct fd *fd; /* pseudo-fd for ioctls */
107 struct namespace *pipes; /* named pipe namespace */
110 static void named_pipe_dump( struct object *obj, int verbose );
111 static unsigned int named_pipe_map_access( struct object *obj, unsigned int access );
112 static struct object *named_pipe_open_file( struct object *obj, unsigned int access,
113 unsigned int sharing, unsigned int options );
114 static void named_pipe_destroy( struct object *obj );
116 static const struct object_ops named_pipe_ops =
118 sizeof(struct named_pipe), /* size */
119 named_pipe_dump, /* dump */
120 no_add_queue, /* add_queue */
121 NULL, /* remove_queue */
123 NULL, /* satisfied */
124 no_signal, /* signal */
125 no_get_fd, /* get_fd */
126 named_pipe_map_access, /* map_access */
127 no_lookup_name, /* lookup_name */
128 named_pipe_open_file, /* open_file */
129 no_close_handle, /* close_handle */
130 named_pipe_destroy /* destroy */
133 /* functions common to server and client */
134 static unsigned int pipe_map_access( struct object *obj, unsigned int access );
136 /* server end functions */
137 static void pipe_server_dump( struct object *obj, int verbose );
138 static struct fd *pipe_server_get_fd( struct object *obj );
139 static void pipe_server_destroy( struct object *obj);
140 static void pipe_server_flush( struct fd *fd, struct event **event );
141 static enum server_fd_type pipe_server_get_fd_type( struct fd *fd );
142 static void pipe_server_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async,
143 const void *data, data_size_t size );
145 static const struct object_ops pipe_server_ops =
147 sizeof(struct pipe_server), /* size */
148 pipe_server_dump, /* dump */
149 add_queue, /* add_queue */
150 remove_queue, /* remove_queue */
151 default_fd_signaled, /* signaled */
152 no_satisfied, /* satisfied */
153 no_signal, /* signal */
154 pipe_server_get_fd, /* get_fd */
155 pipe_map_access, /* map_access */
156 no_lookup_name, /* lookup_name */
157 no_open_file, /* open_file */
158 fd_close_handle, /* close_handle */
159 pipe_server_destroy /* destroy */
162 static const struct fd_ops pipe_server_fd_ops =
164 default_fd_get_poll_events, /* get_poll_events */
165 default_poll_event, /* poll_event */
166 pipe_server_flush, /* flush */
167 pipe_server_get_fd_type, /* get_fd_type */
168 pipe_server_ioctl, /* ioctl */
169 default_fd_queue_async, /* queue_async */
170 default_fd_reselect_async, /* reselect_async */
171 default_fd_cancel_async, /* cancel_async */
174 /* client end functions */
175 static void pipe_client_dump( struct object *obj, int verbose );
176 static struct fd *pipe_client_get_fd( struct object *obj );
177 static void pipe_client_destroy( struct object *obj );
178 static void pipe_client_flush( struct fd *fd, struct event **event );
179 static enum server_fd_type pipe_client_get_fd_type( struct fd *fd );
181 static const struct object_ops pipe_client_ops =
183 sizeof(struct pipe_client), /* size */
184 pipe_client_dump, /* dump */
185 add_queue, /* add_queue */
186 remove_queue, /* remove_queue */
187 default_fd_signaled, /* signaled */
188 no_satisfied, /* satisfied */
189 no_signal, /* signal */
190 pipe_client_get_fd, /* get_fd */
191 pipe_map_access, /* map_access */
192 no_lookup_name, /* lookup_name */
193 no_open_file, /* open_file */
194 fd_close_handle, /* close_handle */
195 pipe_client_destroy /* destroy */
198 static const struct fd_ops pipe_client_fd_ops =
200 default_fd_get_poll_events, /* get_poll_events */
201 default_poll_event, /* poll_event */
202 pipe_client_flush, /* flush */
203 pipe_client_get_fd_type, /* get_fd_type */
204 default_fd_ioctl, /* ioctl */
205 default_fd_queue_async, /* queue_async */
206 default_fd_reselect_async, /* reselect_async */
207 default_fd_cancel_async /* cancel_async */
210 static void named_pipe_device_dump( struct object *obj, int verbose );
211 static struct fd *named_pipe_device_get_fd( struct object *obj );
212 static struct object *named_pipe_device_lookup_name( struct object *obj,
213 struct unicode_str *name, unsigned int attr );
214 static struct object *named_pipe_device_open_file( struct object *obj, unsigned int access,
215 unsigned int sharing, unsigned int options );
216 static void named_pipe_device_destroy( struct object *obj );
217 static enum server_fd_type named_pipe_device_get_fd_type( struct fd *fd );
218 static void named_pipe_device_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async_data,
219 const void *data, data_size_t size );
221 static const struct object_ops named_pipe_device_ops =
223 sizeof(struct named_pipe_device), /* size */
224 named_pipe_device_dump, /* dump */
225 no_add_queue, /* add_queue */
226 NULL, /* remove_queue */
228 no_satisfied, /* satisfied */
229 no_signal, /* signal */
230 named_pipe_device_get_fd, /* get_fd */
231 pipe_map_access, /* map_access */
232 named_pipe_device_lookup_name, /* lookup_name */
233 named_pipe_device_open_file, /* open_file */
234 fd_close_handle, /* close_handle */
235 named_pipe_device_destroy /* destroy */
238 static const struct fd_ops named_pipe_device_fd_ops =
240 default_fd_get_poll_events, /* get_poll_events */
241 default_poll_event, /* poll_event */
242 no_flush, /* flush */
243 named_pipe_device_get_fd_type, /* get_fd_type */
244 named_pipe_device_ioctl, /* ioctl */
245 default_fd_queue_async, /* queue_async */
246 default_fd_reselect_async, /* reselect_async */
247 default_fd_cancel_async /* cancel_async */
250 static void named_pipe_dump( struct object *obj, int verbose )
252 struct named_pipe *pipe = (struct named_pipe *) obj;
253 assert( obj->ops == &named_pipe_ops );
254 fprintf( stderr, "Named pipe " );
255 dump_object_name( &pipe->obj );
256 fprintf( stderr, "\n" );
259 static unsigned int named_pipe_map_access( struct object *obj, unsigned int access )
261 if (access & GENERIC_READ) access |= STANDARD_RIGHTS_READ;
262 if (access & GENERIC_WRITE) access |= STANDARD_RIGHTS_WRITE | FILE_CREATE_PIPE_INSTANCE;
263 if (access & GENERIC_EXECUTE) access |= STANDARD_RIGHTS_EXECUTE;
264 if (access & GENERIC_ALL) access |= STANDARD_RIGHTS_ALL;
265 return access & ~(GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | GENERIC_ALL);
268 static void pipe_server_dump( struct object *obj, int verbose )
270 struct pipe_server *server = (struct pipe_server *) obj;
271 assert( obj->ops == &pipe_server_ops );
272 fprintf( stderr, "Named pipe server pipe=%p state=%d\n", server->pipe, server->state );
275 static void pipe_client_dump( struct object *obj, int verbose )
277 struct pipe_client *client = (struct pipe_client *) obj;
278 assert( obj->ops == &pipe_client_ops );
279 fprintf( stderr, "Named pipe client server=%p\n", client->server );
282 static void named_pipe_destroy( struct object *obj)
284 struct named_pipe *pipe = (struct named_pipe *) obj;
286 assert( list_empty( &pipe->servers ) );
287 assert( !pipe->instances );
288 free_async_queue( pipe->waiters );
291 static struct fd *pipe_client_get_fd( struct object *obj )
293 struct pipe_client *client = (struct pipe_client *) obj;
295 return (struct fd *) grab_object( client->fd );
296 set_error( STATUS_PIPE_DISCONNECTED );
300 static struct fd *pipe_server_get_fd( struct object *obj )
302 struct pipe_server *server = (struct pipe_server *) obj;
304 switch(server->state)
306 case ps_connected_server:
307 case ps_wait_disconnect:
308 assert( server->fd );
309 return (struct fd *) grab_object( server->fd );
313 set_error( STATUS_PIPE_LISTENING );
316 case ps_disconnected_server:
317 case ps_wait_connect:
318 set_error( STATUS_PIPE_DISCONNECTED );
325 static void notify_empty( struct pipe_server *server )
327 if (!server->flush_poll)
329 assert( server->state == ps_connected_server );
330 assert( server->event );
331 remove_timeout_user( server->flush_poll );
332 server->flush_poll = NULL;
333 set_event( server->event );
334 release_object( server->event );
335 server->event = NULL;
338 static void do_disconnect( struct pipe_server *server )
340 /* we may only have a server fd, if the client disconnected */
343 assert( server->client->server == server );
344 assert( server->client->fd );
345 release_object( server->client->fd );
346 server->client->fd = NULL;
348 assert( server->fd );
349 shutdown( get_unix_fd( server->fd ), SHUT_RDWR );
350 release_object( server->fd );
354 static unsigned int pipe_map_access( struct object *obj, unsigned int access )
356 if (access & GENERIC_READ) access |= FILE_GENERIC_READ;
357 if (access & GENERIC_WRITE) access |= FILE_GENERIC_WRITE;
358 if (access & GENERIC_EXECUTE) access |= FILE_GENERIC_EXECUTE;
359 if (access & GENERIC_ALL) access |= FILE_ALL_ACCESS;
360 return access & ~(GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | GENERIC_ALL);
363 static void pipe_server_destroy( struct object *obj)
365 struct pipe_server *server = (struct pipe_server *)obj;
367 assert( obj->ops == &pipe_server_ops );
371 notify_empty( server );
372 do_disconnect( server );
377 server->client->server = NULL;
378 server->client = NULL;
381 free_async_queue( server->wait_q );
383 assert( server->pipe->instances );
384 server->pipe->instances--;
386 list_remove( &server->entry );
387 release_object( server->pipe );
390 static void pipe_client_destroy( struct object *obj)
392 struct pipe_client *client = (struct pipe_client *)obj;
393 struct pipe_server *server = client->server;
395 assert( obj->ops == &pipe_client_ops );
399 notify_empty( server );
401 switch(server->state)
403 case ps_connected_server:
404 /* Don't destroy the server's fd here as we can't
405 do a successful flush without it. */
406 server->state = ps_wait_disconnect;
407 release_object( client->fd );
410 case ps_disconnected_server:
411 server->state = ps_wait_connect;
415 case ps_wait_disconnect:
416 case ps_wait_connect:
419 assert( server->client );
420 server->client = NULL;
421 client->server = NULL;
423 assert( !client->fd );
426 static void named_pipe_device_dump( struct object *obj, int verbose )
428 assert( obj->ops == &named_pipe_device_ops );
429 fprintf( stderr, "Named pipe device\n" );
432 static struct fd *named_pipe_device_get_fd( struct object *obj )
434 struct named_pipe_device *device = (struct named_pipe_device *)obj;
435 return (struct fd *)grab_object( device->fd );
438 static struct object *named_pipe_device_lookup_name( struct object *obj, struct unicode_str *name,
441 struct named_pipe_device *device = (struct named_pipe_device*)obj;
442 struct object *found;
444 assert( obj->ops == &named_pipe_device_ops );
445 assert( device->pipes );
447 if ((found = find_object( device->pipes, name, attr | OBJ_CASE_INSENSITIVE )))
453 static struct object *named_pipe_device_open_file( struct object *obj, unsigned int access,
454 unsigned int sharing, unsigned int options )
456 return grab_object( obj );
459 static void named_pipe_device_destroy( struct object *obj )
461 struct named_pipe_device *device = (struct named_pipe_device*)obj;
462 assert( obj->ops == &named_pipe_device_ops );
463 if (device->fd) release_object( device->fd );
464 free( device->pipes );
467 static enum server_fd_type named_pipe_device_get_fd_type( struct fd *fd )
469 return FD_TYPE_DEVICE;
472 void create_named_pipe_device( struct directory *root, const struct unicode_str *name )
474 struct named_pipe_device *dev;
476 if ((dev = create_named_object_dir( root, name, 0, &named_pipe_device_ops )) &&
477 get_error() != STATUS_OBJECT_NAME_EXISTS)
480 if (!(dev->fd = alloc_pseudo_fd( &named_pipe_device_fd_ops, &dev->obj )) ||
481 !(dev->pipes = create_namespace( 7 )))
483 release_object( dev );
487 if (dev) make_object_static( &dev->obj );
490 static int pipe_data_remaining( struct pipe_server *server )
495 assert( server->client );
497 fd = get_unix_fd( server->client->fd );
504 if (0 > poll( &pfd, 1, 0 ))
507 return pfd.revents&POLLIN;
510 static void check_flushed( void *arg )
512 struct pipe_server *server = (struct pipe_server*) arg;
514 assert( server->event );
515 if (pipe_data_remaining( server ))
517 server->flush_poll = add_timeout_user( -TICKS_PER_SEC / 10, check_flushed, server );
521 /* notify_empty( server ); */
522 server->flush_poll = NULL;
523 set_event( server->event );
524 release_object( server->event );
525 server->event = NULL;
529 static void pipe_server_flush( struct fd *fd, struct event **event )
531 struct pipe_server *server = get_fd_user( fd );
533 if (!server || server->state != ps_connected_server) return;
535 /* FIXME: if multiple threads flush the same pipe,
536 maybe should create a list of processes to notify */
537 if (server->flush_poll) return;
539 if (pipe_data_remaining( server ))
541 /* this kind of sux -
542 there's no unix way to be alerted when a pipe becomes empty */
543 server->event = create_event( NULL, NULL, 0, 0, 0 );
544 if (!server->event) return;
545 server->flush_poll = add_timeout_user( -TICKS_PER_SEC / 10, check_flushed, server );
546 *event = server->event;
550 static void pipe_client_flush( struct fd *fd, struct event **event )
552 /* FIXME: what do we have to do for this? */
555 static inline int is_overlapped( unsigned int options )
557 return !(options & (FILE_SYNCHRONOUS_IO_ALERT | FILE_SYNCHRONOUS_IO_NONALERT));
560 static enum server_fd_type pipe_server_get_fd_type( struct fd *fd )
565 static enum server_fd_type pipe_client_get_fd_type( struct fd *fd )
570 static void pipe_server_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async,
571 const void *data, data_size_t size )
573 struct pipe_server *server = get_fd_user( fd );
577 case FSCTL_PIPE_DISCONNECT:
578 switch(server->state)
580 case ps_connected_server:
581 assert( server->client );
582 assert( server->client->fd );
584 notify_empty( server );
586 /* dump the client and server fds, but keep the pointers
587 around - client loses all waiting data */
588 server->state = ps_disconnected_server;
589 do_disconnect( server );
591 case ps_wait_disconnect:
592 assert( !server->client );
593 do_disconnect( server );
594 server->state = ps_wait_connect;
598 case ps_disconnected_server:
599 case ps_wait_connect:
600 assert(0); /* shouldn't even get an fd */
605 default_fd_ioctl( fd, code, async, data, size );
610 static struct named_pipe *create_named_pipe( struct directory *root, const struct unicode_str *name,
614 struct named_pipe *pipe = NULL;
615 struct unicode_str new_name;
617 if (!name || !name->len) return alloc_object( &named_pipe_ops );
619 if (!(obj = find_object_dir( root, name, attr, &new_name )))
621 set_error( STATUS_OBJECT_NAME_INVALID );
626 if (attr & OBJ_OPENIF && obj->ops == &named_pipe_ops)
627 set_error( STATUS_OBJECT_NAME_EXISTS );
630 release_object( obj );
632 if (attr & OBJ_OPENIF)
633 set_error( STATUS_OBJECT_TYPE_MISMATCH );
635 set_error( STATUS_OBJECT_NAME_COLLISION );
637 return (struct named_pipe *)obj;
640 if (obj->ops != &named_pipe_device_ops)
641 set_error( STATUS_OBJECT_NAME_INVALID );
644 struct named_pipe_device *dev = (struct named_pipe_device *)obj;
645 if ((pipe = create_object( dev->pipes, &named_pipe_ops, &new_name, NULL )))
649 release_object( obj );
653 static struct pipe_server *get_pipe_server_obj( struct process *process,
654 obj_handle_t handle, unsigned int access )
657 obj = get_handle_obj( process, handle, access, &pipe_server_ops );
658 return (struct pipe_server *) obj;
661 static struct pipe_server *create_pipe_server( struct named_pipe *pipe, unsigned int options )
663 struct pipe_server *server;
665 server = alloc_object( &pipe_server_ops );
671 server->state = ps_idle_server;
672 server->client = NULL;
673 server->flush_poll = NULL;
674 server->options = options;
675 server->wait_q = create_async_queue( NULL );
677 list_add_head( &pipe->servers, &server->entry );
683 static struct pipe_client *create_pipe_client( unsigned int flags )
685 struct pipe_client *client;
687 client = alloc_object( &pipe_client_ops );
692 client->server = NULL;
693 client->flags = flags;
698 static struct pipe_server *find_available_server( struct named_pipe *pipe )
700 struct pipe_server *server;
702 LIST_FOR_EACH_ENTRY( server, &pipe->servers, struct pipe_server, entry )
704 if (server->state == ps_idle_server || server->state == ps_wait_open)
705 return (struct pipe_server *)grab_object( server );
710 static struct object *named_pipe_open_file( struct object *obj, unsigned int access,
711 unsigned int sharing, unsigned int options )
713 struct named_pipe *pipe = (struct named_pipe *)obj;
714 struct pipe_server *server;
715 struct pipe_client *client;
718 if (!(server = find_available_server( pipe )))
720 set_error( STATUS_PIPE_NOT_AVAILABLE );
724 if ((client = create_pipe_client( options )))
726 if (!socketpair( PF_UNIX, SOCK_STREAM, 0, fds ))
730 assert( !client->fd );
731 assert( !server->fd );
733 /* for performance reasons, only set nonblocking mode when using
734 * overlapped I/O. Otherwise, we will be doing too much busy
736 if (is_overlapped( options ))
737 res = fcntl( fds[1], F_SETFL, O_NONBLOCK );
738 if ((res != -1) && is_overlapped( server->options ))
739 res = fcntl( fds[0], F_SETFL, O_NONBLOCK );
743 setsockopt( fds[0], SOL_SOCKET, SO_RCVBUF, &pipe->insize, sizeof(pipe->insize) );
744 setsockopt( fds[1], SOL_SOCKET, SO_RCVBUF, &pipe->insize, sizeof(pipe->insize) );
748 setsockopt( fds[0], SOL_SOCKET, SO_SNDBUF, &pipe->outsize, sizeof(pipe->outsize) );
749 setsockopt( fds[1], SOL_SOCKET, SO_SNDBUF, &pipe->outsize, sizeof(pipe->outsize) );
752 client->fd = create_anonymous_fd( &pipe_client_fd_ops, fds[1], &client->obj, options );
753 server->fd = create_anonymous_fd( &pipe_server_fd_ops, fds[0], &server->obj, server->options );
754 if (client->fd && server->fd && res != 1)
756 if (server->state == ps_wait_open)
757 async_wake_up( server->wait_q, STATUS_SUCCESS );
758 server->state = ps_connected_server;
759 server->client = client;
760 client->server = server;
766 release_object( server );
770 static void named_pipe_device_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async_data,
771 const void *data, data_size_t size )
773 struct named_pipe_device *device = get_fd_user( fd );
777 case FSCTL_PIPE_WAIT:
779 const FILE_PIPE_WAIT_FOR_BUFFER *buffer = data;
780 struct named_pipe *pipe;
781 struct pipe_server *server;
782 struct unicode_str name;
784 if (size < sizeof(*buffer) ||
785 size < FIELD_OFFSET(FILE_PIPE_WAIT_FOR_BUFFER, Name[buffer->NameLength/sizeof(WCHAR)]))
787 set_error( STATUS_INVALID_PARAMETER );
790 name.str = buffer->Name;
791 name.len = (buffer->NameLength / sizeof(WCHAR)) * sizeof(WCHAR);
792 if (!(pipe = (struct named_pipe *)find_object( device->pipes, &name, OBJ_CASE_INSENSITIVE )))
794 set_error( STATUS_PIPE_NOT_AVAILABLE );
797 if (!(server = find_available_server( pipe )))
801 if (!pipe->waiters && !(pipe->waiters = create_async_queue( NULL )))
803 release_object( pipe );
807 if ((async = create_async( current, pipe->waiters, async_data )))
809 timeout_t when = buffer->TimeoutSpecified ? buffer->Timeout.QuadPart : pipe->timeout;
810 async_set_timeout( async, when, STATUS_IO_TIMEOUT );
811 release_object( async );
812 set_error( STATUS_PENDING );
815 else release_object( server );
817 release_object( pipe );
822 default_fd_ioctl( fd, code, async_data, data, size );
828 DECL_HANDLER(create_named_pipe)
830 struct named_pipe *pipe;
831 struct pipe_server *server;
832 struct unicode_str name;
833 struct directory *root = NULL;
836 get_req_unicode_str( &name );
837 if (req->rootdir && !(root = get_directory_obj( current->process, req->rootdir, 0 )))
840 pipe = create_named_pipe( root, &name, req->attributes | OBJ_OPENIF );
842 if (root) release_object( root );
845 if (get_error() != STATUS_OBJECT_NAME_EXISTS)
847 /* initialize it if it didn't already exist */
849 pipe->waiters = NULL;
850 list_init( &pipe->servers );
851 pipe->insize = req->insize;
852 pipe->outsize = req->outsize;
853 pipe->maxinstances = req->maxinstances;
854 pipe->timeout = req->timeout;
855 pipe->flags = req->flags;
859 if (pipe->maxinstances <= pipe->instances)
861 set_error( STATUS_INSTANCE_NOT_AVAILABLE );
862 release_object( pipe );
865 if ((pipe->maxinstances != req->maxinstances) ||
866 (pipe->timeout != req->timeout) ||
867 (pipe->flags != req->flags))
869 set_error( STATUS_ACCESS_DENIED );
870 release_object( pipe );
873 clear_error(); /* clear the name collision */
876 server = create_pipe_server( pipe, req->options );
879 reply->handle = alloc_handle( current->process, server, req->access, req->attributes );
880 server->pipe->instances++;
881 release_object( server );
884 release_object( pipe );
887 DECL_HANDLER(connect_named_pipe)
889 struct pipe_server *server;
892 server = get_pipe_server_obj(current->process, req->handle, 0);
896 switch(server->state)
899 case ps_wait_connect:
900 assert( !server->fd );
901 server->state = ps_wait_open;
902 if ((async = create_async( current, server->wait_q, &req->async )))
904 if (server->pipe->waiters) async_wake_up( server->pipe->waiters, STATUS_SUCCESS );
905 release_object( async );
906 set_error( STATUS_PENDING );
909 case ps_connected_server:
910 assert( server->fd );
911 set_error( STATUS_PIPE_CONNECTED );
913 case ps_disconnected_server:
914 set_error( STATUS_PIPE_BUSY );
916 case ps_wait_disconnect:
917 set_error( STATUS_NO_DATA_DETECTED );
920 set_error( STATUS_INVALID_HANDLE );
924 release_object(server);
927 DECL_HANDLER(get_named_pipe_info)
929 struct pipe_server *server;
930 struct pipe_client *client = NULL;
932 server = get_pipe_server_obj( current->process, req->handle, FILE_READ_ATTRIBUTES );
936 client = (struct pipe_client *)get_handle_obj( current->process, req->handle,
937 FILE_READ_ATTRIBUTES, &pipe_client_ops );
939 server = client->server;
942 reply->flags = server->pipe->flags;
943 reply->maxinstances = server->pipe->maxinstances;
944 reply->instances = server->pipe->instances;
945 reply->insize = server->pipe->insize;
946 reply->outsize = server->pipe->outsize;
949 release_object(client);
952 reply->flags |= NAMED_PIPE_SERVER_END;
953 release_object(server);