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
70 struct object obj
; /* object header */
71 struct fd
*fd
; /* pipe file descriptor */
72 unsigned int flags
; /* pipe flags */
77 struct pipe_end pipe_end
; /* common header for pipe_client and pipe_server */
78 struct fd
*ioctl_fd
; /* file descriptor for ioctls when not connected */
79 struct list entry
; /* entry in named pipe servers list */
80 enum pipe_state state
; /* server state */
81 struct pipe_client
*client
; /* client that this server is connected to */
82 struct named_pipe
*pipe
;
83 struct timeout_user
*flush_poll
;
84 unsigned int options
; /* pipe options */
89 struct pipe_end pipe_end
; /* common header for pipe_client and pipe_server */
90 struct pipe_server
*server
; /* server that this client is connected to */
91 unsigned int flags
; /* file flags */
96 struct object obj
; /* object header */
99 unsigned int maxinstances
;
100 unsigned int outsize
;
102 unsigned int instances
;
104 struct list servers
; /* list of servers using this pipe */
105 struct async_queue
*waiters
; /* list of clients waiting to connect */
108 struct named_pipe_device
110 struct object obj
; /* object header */
111 struct fd
*fd
; /* pseudo-fd for ioctls */
112 struct namespace *pipes
; /* named pipe namespace */
115 static void named_pipe_dump( struct object
*obj
, int verbose
);
116 static unsigned int named_pipe_map_access( struct object
*obj
, unsigned int access
);
117 static int named_pipe_link_name( struct object
*obj
, struct object_name
*name
, struct object
*parent
);
118 static struct object
*named_pipe_open_file( struct object
*obj
, unsigned int access
,
119 unsigned int sharing
, unsigned int options
);
120 static void named_pipe_destroy( struct object
*obj
);
122 static const struct object_ops named_pipe_ops
=
124 sizeof(struct named_pipe
), /* size */
125 named_pipe_dump
, /* dump */
126 no_get_type
, /* get_type */
127 no_add_queue
, /* add_queue */
128 NULL
, /* remove_queue */
130 NULL
, /* satisfied */
131 no_signal
, /* signal */
132 no_get_fd
, /* get_fd */
133 named_pipe_map_access
, /* map_access */
134 default_get_sd
, /* get_sd */
135 default_set_sd
, /* set_sd */
136 no_lookup_name
, /* lookup_name */
137 named_pipe_link_name
, /* link_name */
138 default_unlink_name
, /* unlink_name */
139 named_pipe_open_file
, /* open_file */
140 no_close_handle
, /* close_handle */
141 named_pipe_destroy
/* destroy */
144 /* server end functions */
145 static void pipe_server_dump( struct object
*obj
, int verbose
);
146 static struct fd
*pipe_server_get_fd( struct object
*obj
);
147 static void pipe_server_destroy( struct object
*obj
);
148 static obj_handle_t
pipe_server_flush( struct fd
*fd
, struct async
*async
, int blocking
);
149 static enum server_fd_type
pipe_server_get_fd_type( struct fd
*fd
);
150 static obj_handle_t
pipe_server_ioctl( struct fd
*fd
, ioctl_code_t code
, struct async
*async
,
153 static const struct object_ops pipe_server_ops
=
155 sizeof(struct pipe_server
), /* size */
156 pipe_server_dump
, /* dump */
157 no_get_type
, /* get_type */
158 add_queue
, /* add_queue */
159 remove_queue
, /* remove_queue */
160 default_fd_signaled
, /* signaled */
161 no_satisfied
, /* satisfied */
162 no_signal
, /* signal */
163 pipe_server_get_fd
, /* get_fd */
164 default_fd_map_access
, /* map_access */
165 default_get_sd
, /* get_sd */
166 default_set_sd
, /* set_sd */
167 no_lookup_name
, /* lookup_name */
168 no_link_name
, /* link_name */
169 NULL
, /* unlink_name */
170 no_open_file
, /* open_file */
171 fd_close_handle
, /* close_handle */
172 pipe_server_destroy
/* destroy */
175 static const struct fd_ops pipe_server_fd_ops
=
177 default_fd_get_poll_events
, /* get_poll_events */
178 default_poll_event
, /* poll_event */
179 pipe_server_get_fd_type
, /* get_fd_type */
180 no_fd_read
, /* read */
181 no_fd_write
, /* write */
182 pipe_server_flush
, /* flush */
183 pipe_server_ioctl
, /* ioctl */
184 default_fd_queue_async
, /* queue_async */
185 default_fd_reselect_async
/* reselect_async */
188 /* client end functions */
189 static void pipe_client_dump( struct object
*obj
, int verbose
);
190 static int pipe_client_signaled( struct object
*obj
, struct wait_queue_entry
*entry
);
191 static struct fd
*pipe_client_get_fd( struct object
*obj
);
192 static void pipe_client_destroy( struct object
*obj
);
193 static obj_handle_t
pipe_client_flush( struct fd
*fd
, struct async
*async
, int blocking
);
194 static enum server_fd_type
pipe_client_get_fd_type( struct fd
*fd
);
196 static const struct object_ops pipe_client_ops
=
198 sizeof(struct pipe_client
), /* size */
199 pipe_client_dump
, /* dump */
200 no_get_type
, /* get_type */
201 add_queue
, /* add_queue */
202 remove_queue
, /* remove_queue */
203 pipe_client_signaled
, /* signaled */
204 no_satisfied
, /* satisfied */
205 no_signal
, /* signal */
206 pipe_client_get_fd
, /* get_fd */
207 default_fd_map_access
, /* map_access */
208 default_get_sd
, /* get_sd */
209 default_set_sd
, /* set_sd */
210 no_lookup_name
, /* lookup_name */
211 no_link_name
, /* link_name */
212 NULL
, /* unlink_name */
213 no_open_file
, /* open_file */
214 fd_close_handle
, /* close_handle */
215 pipe_client_destroy
/* destroy */
218 static const struct fd_ops pipe_client_fd_ops
=
220 default_fd_get_poll_events
, /* get_poll_events */
221 default_poll_event
, /* poll_event */
222 pipe_client_get_fd_type
, /* get_fd_type */
223 no_fd_read
, /* read */
224 no_fd_write
, /* write */
225 pipe_client_flush
, /* flush */
226 default_fd_ioctl
, /* ioctl */
227 default_fd_queue_async
, /* queue_async */
228 default_fd_reselect_async
/* reselect_async */
231 static void named_pipe_device_dump( struct object
*obj
, int verbose
);
232 static struct object_type
*named_pipe_device_get_type( struct object
*obj
);
233 static struct fd
*named_pipe_device_get_fd( struct object
*obj
);
234 static struct object
*named_pipe_device_lookup_name( struct object
*obj
,
235 struct unicode_str
*name
, unsigned int attr
);
236 static struct object
*named_pipe_device_open_file( struct object
*obj
, unsigned int access
,
237 unsigned int sharing
, unsigned int options
);
238 static void named_pipe_device_destroy( struct object
*obj
);
239 static enum server_fd_type
named_pipe_device_get_fd_type( struct fd
*fd
);
240 static obj_handle_t
named_pipe_device_ioctl( struct fd
*fd
, ioctl_code_t code
,
241 struct async
*async
, int blocking
);
243 static const struct object_ops named_pipe_device_ops
=
245 sizeof(struct named_pipe_device
), /* size */
246 named_pipe_device_dump
, /* dump */
247 named_pipe_device_get_type
, /* get_type */
248 no_add_queue
, /* add_queue */
249 NULL
, /* remove_queue */
251 no_satisfied
, /* satisfied */
252 no_signal
, /* signal */
253 named_pipe_device_get_fd
, /* get_fd */
254 no_map_access
, /* map_access */
255 default_get_sd
, /* get_sd */
256 default_set_sd
, /* set_sd */
257 named_pipe_device_lookup_name
, /* lookup_name */
258 directory_link_name
, /* link_name */
259 default_unlink_name
, /* unlink_name */
260 named_pipe_device_open_file
, /* open_file */
261 fd_close_handle
, /* close_handle */
262 named_pipe_device_destroy
/* destroy */
265 static const struct fd_ops named_pipe_device_fd_ops
=
267 default_fd_get_poll_events
, /* get_poll_events */
268 default_poll_event
, /* poll_event */
269 named_pipe_device_get_fd_type
, /* get_fd_type */
270 no_fd_read
, /* read */
271 no_fd_write
, /* write */
272 no_fd_flush
, /* flush */
273 named_pipe_device_ioctl
, /* ioctl */
274 default_fd_queue_async
, /* queue_async */
275 default_fd_reselect_async
/* reselect_async */
278 static void named_pipe_dump( struct object
*obj
, int verbose
)
280 fputs( "Named pipe\n", stderr
);
283 static unsigned int named_pipe_map_access( struct object
*obj
, unsigned int access
)
285 if (access
& GENERIC_READ
) access
|= STANDARD_RIGHTS_READ
;
286 if (access
& GENERIC_WRITE
) access
|= STANDARD_RIGHTS_WRITE
| FILE_CREATE_PIPE_INSTANCE
;
287 if (access
& GENERIC_EXECUTE
) access
|= STANDARD_RIGHTS_EXECUTE
;
288 if (access
& GENERIC_ALL
) access
|= STANDARD_RIGHTS_ALL
;
289 return access
& ~(GENERIC_READ
| GENERIC_WRITE
| GENERIC_EXECUTE
| GENERIC_ALL
);
292 static void pipe_server_dump( struct object
*obj
, int verbose
)
294 struct pipe_server
*server
= (struct pipe_server
*) obj
;
295 assert( obj
->ops
== &pipe_server_ops
);
296 fprintf( stderr
, "Named pipe server pipe=%p state=%d\n", server
->pipe
, server
->state
);
299 static void pipe_client_dump( struct object
*obj
, int verbose
)
301 struct pipe_client
*client
= (struct pipe_client
*) obj
;
302 assert( obj
->ops
== &pipe_client_ops
);
303 fprintf( stderr
, "Named pipe client server=%p\n", client
->server
);
306 static int pipe_client_signaled( struct object
*obj
, struct wait_queue_entry
*entry
)
308 struct pipe_client
*client
= (struct pipe_client
*) obj
;
310 return client
->pipe_end
.fd
&& is_fd_signaled(client
->pipe_end
.fd
);
313 static void named_pipe_destroy( struct object
*obj
)
315 struct named_pipe
*pipe
= (struct named_pipe
*) obj
;
317 assert( list_empty( &pipe
->servers
) );
318 assert( !pipe
->instances
);
319 free_async_queue( pipe
->waiters
);
322 static struct fd
*pipe_client_get_fd( struct object
*obj
)
324 struct pipe_client
*client
= (struct pipe_client
*) obj
;
325 if (client
->pipe_end
.fd
)
326 return (struct fd
*) grab_object( client
->pipe_end
.fd
);
327 set_error( STATUS_PIPE_DISCONNECTED
);
331 static void set_server_state( struct pipe_server
*server
, enum pipe_state state
)
333 server
->state
= state
;
337 case ps_connected_server
:
338 case ps_wait_disconnect
:
339 assert( server
->pipe_end
.fd
);
343 assert( !server
->pipe_end
.fd
);
344 set_no_fd_status( server
->ioctl_fd
, STATUS_PIPE_LISTENING
);
346 case ps_wait_connect
:
347 assert( !server
->pipe_end
.fd
);
348 set_no_fd_status( server
->ioctl_fd
, STATUS_PIPE_DISCONNECTED
);
353 static struct fd
*pipe_server_get_fd( struct object
*obj
)
355 struct pipe_server
*server
= (struct pipe_server
*) obj
;
357 return (struct fd
*)grab_object( server
->pipe_end
.fd
? server
->pipe_end
.fd
: server
->ioctl_fd
);
361 static void notify_empty( struct pipe_server
*server
)
363 if (!server
->flush_poll
)
365 assert( server
->state
== ps_connected_server
);
366 remove_timeout_user( server
->flush_poll
);
367 server
->flush_poll
= NULL
;
368 fd_async_wake_up( server
->pipe_end
.fd
, ASYNC_TYPE_WAIT
, STATUS_SUCCESS
);
371 static void do_disconnect( struct pipe_server
*server
)
373 /* we may only have a server fd, if the client disconnected */
376 assert( server
->client
->server
== server
);
377 assert( server
->client
->pipe_end
.fd
);
378 release_object( server
->client
->pipe_end
.fd
);
379 server
->client
->pipe_end
.fd
= NULL
;
381 assert( server
->pipe_end
.fd
);
382 shutdown( get_unix_fd( server
->pipe_end
.fd
), SHUT_RDWR
);
383 release_object( server
->pipe_end
.fd
);
384 server
->pipe_end
.fd
= NULL
;
387 static void pipe_server_destroy( struct object
*obj
)
389 struct pipe_server
*server
= (struct pipe_server
*)obj
;
391 assert( obj
->ops
== &pipe_server_ops
);
393 if (server
->pipe_end
.fd
)
395 notify_empty( server
);
396 do_disconnect( server
);
401 server
->client
->server
= NULL
;
402 server
->client
= NULL
;
405 assert( server
->pipe
->instances
);
406 server
->pipe
->instances
--;
408 if (server
->ioctl_fd
) release_object( server
->ioctl_fd
);
409 list_remove( &server
->entry
);
410 release_object( server
->pipe
);
413 static void pipe_client_destroy( struct object
*obj
)
415 struct pipe_client
*client
= (struct pipe_client
*)obj
;
416 struct pipe_server
*server
= client
->server
;
418 assert( obj
->ops
== &pipe_client_ops
);
422 notify_empty( server
);
424 switch(server
->state
)
426 case ps_connected_server
:
427 /* Don't destroy the server's fd here as we can't
428 do a successful flush without it. */
429 set_server_state( server
, ps_wait_disconnect
);
433 case ps_wait_disconnect
:
434 case ps_wait_connect
:
437 assert( server
->client
);
438 server
->client
= NULL
;
439 client
->server
= NULL
;
441 if (client
->pipe_end
.fd
) release_object( client
->pipe_end
.fd
);
444 static void named_pipe_device_dump( struct object
*obj
, int verbose
)
446 fputs( "Named pipe device\n", stderr
);
449 static struct object_type
*named_pipe_device_get_type( struct object
*obj
)
451 static const WCHAR name
[] = {'D','e','v','i','c','e'};
452 static const struct unicode_str str
= { name
, sizeof(name
) };
453 return get_object_type( &str
);
456 static struct fd
*named_pipe_device_get_fd( struct object
*obj
)
458 struct named_pipe_device
*device
= (struct named_pipe_device
*)obj
;
459 return (struct fd
*)grab_object( device
->fd
);
462 static struct object
*named_pipe_device_lookup_name( struct object
*obj
, struct unicode_str
*name
,
465 struct named_pipe_device
*device
= (struct named_pipe_device
*)obj
;
466 struct object
*found
;
468 assert( obj
->ops
== &named_pipe_device_ops
);
469 assert( device
->pipes
);
471 if (!name
) return NULL
; /* open the device itself */
473 if ((found
= find_object( device
->pipes
, name
, attr
| OBJ_CASE_INSENSITIVE
)))
479 static struct object
*named_pipe_device_open_file( struct object
*obj
, unsigned int access
,
480 unsigned int sharing
, unsigned int options
)
482 return grab_object( obj
);
485 static void named_pipe_device_destroy( struct object
*obj
)
487 struct named_pipe_device
*device
= (struct named_pipe_device
*)obj
;
488 assert( obj
->ops
== &named_pipe_device_ops
);
489 if (device
->fd
) release_object( device
->fd
);
490 free( device
->pipes
);
493 static enum server_fd_type
named_pipe_device_get_fd_type( struct fd
*fd
)
495 return FD_TYPE_DEVICE
;
498 struct object
*create_named_pipe_device( struct object
*root
, const struct unicode_str
*name
)
500 struct named_pipe_device
*dev
;
502 if ((dev
= create_named_object( root
, &named_pipe_device_ops
, name
, 0, NULL
)) &&
503 get_error() != STATUS_OBJECT_NAME_EXISTS
)
506 if (!(dev
->fd
= alloc_pseudo_fd( &named_pipe_device_fd_ops
, &dev
->obj
, 0 )) ||
507 !(dev
->pipes
= create_namespace( 7 )))
509 release_object( dev
);
516 static int pipe_data_remaining( struct pipe_server
*server
)
521 assert( server
->client
);
523 fd
= get_unix_fd( server
->client
->pipe_end
.fd
);
530 if (0 > poll( &pfd
, 1, 0 ))
533 return pfd
.revents
&POLLIN
;
536 static void check_flushed( void *arg
)
538 struct pipe_server
*server
= (struct pipe_server
*) arg
;
540 if (pipe_data_remaining( server
))
542 server
->flush_poll
= add_timeout_user( -TICKS_PER_SEC
/ 10, check_flushed
, server
);
546 server
->flush_poll
= NULL
;
547 fd_async_wake_up( server
->pipe_end
.fd
, ASYNC_TYPE_WAIT
, STATUS_SUCCESS
);
551 static obj_handle_t
pipe_end_flush( struct pipe_end
*pipe_end
, struct async
*async
, int blocking
)
553 obj_handle_t handle
= 0;
555 if (!fd_queue_async( pipe_end
->fd
, async
, ASYNC_TYPE_WAIT
)) return 0;
557 if (!blocking
|| (handle
= alloc_handle( current
->process
, async
, SYNCHRONIZE
, 0 )))
558 set_error( STATUS_PENDING
);
562 static obj_handle_t
pipe_server_flush( struct fd
*fd
, struct async
*async
, int blocking
)
564 struct pipe_server
*server
= get_fd_user( fd
);
567 if (!server
|| server
->state
!= ps_connected_server
) return 0;
569 if (!pipe_data_remaining( server
)) return 0;
571 handle
= pipe_end_flush( &server
->pipe_end
, async
, blocking
);
573 /* there's no unix way to be alerted when a pipe becomes empty, so resort to polling */
574 if (handle
&& !server
->flush_poll
)
575 server
->flush_poll
= add_timeout_user( -TICKS_PER_SEC
/ 10, check_flushed
, server
);
579 static obj_handle_t
pipe_client_flush( struct fd
*fd
, struct async
*async
, int blocking
)
581 /* FIXME: what do we have to do for this? */
585 static inline int is_overlapped( unsigned int options
)
587 return !(options
& (FILE_SYNCHRONOUS_IO_ALERT
| FILE_SYNCHRONOUS_IO_NONALERT
));
590 static enum server_fd_type
pipe_server_get_fd_type( struct fd
*fd
)
595 static enum server_fd_type
pipe_client_get_fd_type( struct fd
*fd
)
600 static obj_handle_t
pipe_server_ioctl( struct fd
*fd
, ioctl_code_t code
, struct async
*async
,
603 struct pipe_server
*server
= get_fd_user( fd
);
604 obj_handle_t wait_handle
= 0;
608 case FSCTL_PIPE_LISTEN
:
609 switch(server
->state
)
612 case ps_wait_connect
:
613 if (fd_queue_async( server
->ioctl_fd
, async
, ASYNC_TYPE_WAIT
))
615 if (blocking
) wait_handle
= alloc_handle( current
->process
, async
, SYNCHRONIZE
, 0 );
616 set_server_state( server
, ps_wait_open
);
617 if (server
->pipe
->waiters
) async_wake_up( server
->pipe
->waiters
, STATUS_SUCCESS
);
618 set_error( STATUS_PENDING
);
622 case ps_connected_server
:
623 set_error( STATUS_PIPE_CONNECTED
);
625 case ps_wait_disconnect
:
626 set_error( STATUS_NO_DATA_DETECTED
);
629 set_error( STATUS_INVALID_HANDLE
);
634 case FSCTL_PIPE_DISCONNECT
:
635 switch(server
->state
)
637 case ps_connected_server
:
638 assert( server
->client
);
639 assert( server
->client
->pipe_end
.fd
);
641 notify_empty( server
);
643 /* dump the client and server fds - client loses all waiting data */
644 do_disconnect( server
);
645 server
->client
->server
= NULL
;
646 server
->client
= NULL
;
647 set_server_state( server
, ps_wait_connect
);
649 case ps_wait_disconnect
:
650 assert( !server
->client
);
651 do_disconnect( server
);
652 set_server_state( server
, ps_wait_connect
);
656 set_error( STATUS_PIPE_LISTENING
);
658 case ps_wait_connect
:
659 set_error( STATUS_PIPE_DISCONNECTED
);
665 return default_fd_ioctl( fd
, code
, async
, blocking
);
669 static struct pipe_server
*get_pipe_server_obj( struct process
*process
,
670 obj_handle_t handle
, unsigned int access
)
673 obj
= get_handle_obj( process
, handle
, access
, &pipe_server_ops
);
674 return (struct pipe_server
*) obj
;
677 static void init_pipe_end( struct pipe_end
*pipe_end
, unsigned int pipe_flags
)
680 pipe_end
->flags
= pipe_flags
;
683 static struct pipe_server
*create_pipe_server( struct named_pipe
*pipe
, unsigned int options
,
684 unsigned int pipe_flags
)
686 struct pipe_server
*server
;
688 server
= alloc_object( &pipe_server_ops
);
693 server
->client
= NULL
;
694 server
->flush_poll
= NULL
;
695 server
->options
= options
;
696 init_pipe_end( &server
->pipe_end
, pipe_flags
);
698 list_add_head( &pipe
->servers
, &server
->entry
);
700 if (!(server
->ioctl_fd
= alloc_pseudo_fd( &pipe_server_fd_ops
, &server
->pipe_end
.obj
, options
)))
702 release_object( server
);
705 set_fd_signaled( server
->ioctl_fd
, 1 );
706 set_server_state( server
, ps_idle_server
);
710 static struct pipe_client
*create_pipe_client( unsigned int flags
, unsigned int pipe_flags
)
712 struct pipe_client
*client
;
714 client
= alloc_object( &pipe_client_ops
);
718 client
->server
= NULL
;
719 client
->flags
= flags
;
720 init_pipe_end( &client
->pipe_end
, pipe_flags
);
725 static struct pipe_server
*find_available_server( struct named_pipe
*pipe
)
727 struct pipe_server
*server
;
729 /* look for pipe servers that are listening */
730 LIST_FOR_EACH_ENTRY( server
, &pipe
->servers
, struct pipe_server
, entry
)
732 if (server
->state
== ps_wait_open
)
733 return (struct pipe_server
*)grab_object( server
);
736 /* fall back to pipe servers that are idle */
737 LIST_FOR_EACH_ENTRY( server
, &pipe
->servers
, struct pipe_server
, entry
)
739 if (server
->state
== ps_idle_server
)
740 return (struct pipe_server
*)grab_object( server
);
746 static int named_pipe_link_name( struct object
*obj
, struct object_name
*name
, struct object
*parent
)
748 struct named_pipe_device
*dev
= (struct named_pipe_device
*)parent
;
750 if (parent
->ops
!= &named_pipe_device_ops
)
752 set_error( STATUS_OBJECT_NAME_INVALID
);
755 namespace_add( dev
->pipes
, name
);
756 name
->parent
= grab_object( parent
);
760 static struct object
*named_pipe_open_file( struct object
*obj
, unsigned int access
,
761 unsigned int sharing
, unsigned int options
)
763 struct named_pipe
*pipe
= (struct named_pipe
*)obj
;
764 struct pipe_server
*server
;
765 struct pipe_client
*client
;
766 unsigned int pipe_sharing
;
769 if (!(server
= find_available_server( pipe
)))
771 set_error( STATUS_PIPE_NOT_AVAILABLE
);
775 pipe_sharing
= server
->pipe
->sharing
;
776 if (((access
& GENERIC_READ
) && !(pipe_sharing
& FILE_SHARE_READ
)) ||
777 ((access
& GENERIC_WRITE
) && !(pipe_sharing
& FILE_SHARE_WRITE
)))
779 set_error( STATUS_ACCESS_DENIED
);
780 release_object( server
);
784 if ((client
= create_pipe_client( options
, pipe
->flags
)))
786 if (!socketpair( PF_UNIX
, SOCK_STREAM
, 0, fds
))
788 assert( !server
->pipe_end
.fd
);
790 /* for performance reasons, only set nonblocking mode when using
791 * overlapped I/O. Otherwise, we will be doing too much busy
793 if (is_overlapped( options
)) fcntl( fds
[1], F_SETFL
, O_NONBLOCK
);
794 if (is_overlapped( server
->options
)) fcntl( fds
[0], F_SETFL
, O_NONBLOCK
);
798 setsockopt( fds
[0], SOL_SOCKET
, SO_RCVBUF
, &pipe
->insize
, sizeof(pipe
->insize
) );
799 setsockopt( fds
[1], SOL_SOCKET
, SO_RCVBUF
, &pipe
->insize
, sizeof(pipe
->insize
) );
803 setsockopt( fds
[0], SOL_SOCKET
, SO_SNDBUF
, &pipe
->outsize
, sizeof(pipe
->outsize
) );
804 setsockopt( fds
[1], SOL_SOCKET
, SO_SNDBUF
, &pipe
->outsize
, sizeof(pipe
->outsize
) );
807 client
->pipe_end
.fd
= create_anonymous_fd( &pipe_client_fd_ops
, fds
[1], &client
->pipe_end
.obj
, options
);
808 server
->pipe_end
.fd
= create_anonymous_fd( &pipe_server_fd_ops
, fds
[0], &server
->pipe_end
.obj
, server
->options
);
809 if (client
->pipe_end
.fd
&& server
->pipe_end
.fd
)
811 allow_fd_caching( client
->pipe_end
.fd
);
812 allow_fd_caching( server
->pipe_end
.fd
);
813 fd_copy_completion( server
->ioctl_fd
, server
->pipe_end
.fd
);
814 if (server
->state
== ps_wait_open
)
815 fd_async_wake_up( server
->ioctl_fd
, ASYNC_TYPE_WAIT
, STATUS_SUCCESS
);
816 set_server_state( server
, ps_connected_server
);
817 server
->client
= client
;
818 client
->server
= server
;
822 release_object( client
);
829 release_object( client
);
833 release_object( server
);
834 return &client
->pipe_end
.obj
;
837 static obj_handle_t
named_pipe_device_ioctl( struct fd
*fd
, ioctl_code_t code
,
838 struct async
*async
, int blocking
)
840 struct named_pipe_device
*device
= get_fd_user( fd
);
844 case FSCTL_PIPE_WAIT
:
846 const FILE_PIPE_WAIT_FOR_BUFFER
*buffer
= get_req_data();
847 data_size_t size
= get_req_data_size();
848 obj_handle_t wait_handle
= 0;
849 struct named_pipe
*pipe
;
850 struct pipe_server
*server
;
851 struct unicode_str name
;
854 if (size
< sizeof(*buffer
) ||
855 size
< FIELD_OFFSET(FILE_PIPE_WAIT_FOR_BUFFER
, Name
[buffer
->NameLength
/sizeof(WCHAR
)]))
857 set_error( STATUS_INVALID_PARAMETER
);
860 name
.str
= buffer
->Name
;
861 name
.len
= (buffer
->NameLength
/ sizeof(WCHAR
)) * sizeof(WCHAR
);
862 if (!(pipe
= open_named_object( &device
->obj
, &named_pipe_ops
, &name
, 0 ))) return 0;
864 if (!(server
= find_available_server( pipe
)))
866 if (!pipe
->waiters
&& !(pipe
->waiters
= create_async_queue( NULL
))) goto done
;
868 queue_async( pipe
->waiters
, async
);
869 when
= buffer
->TimeoutSpecified
? buffer
->Timeout
.QuadPart
: pipe
->timeout
;
870 async_set_timeout( async
, when
, STATUS_IO_TIMEOUT
);
871 if (blocking
) wait_handle
= alloc_handle( current
->process
, async
, SYNCHRONIZE
, 0 );
872 set_error( STATUS_PENDING
);
874 else release_object( server
);
877 release_object( pipe
);
882 return default_fd_ioctl( fd
, code
, async
, blocking
);
887 DECL_HANDLER(create_named_pipe
)
889 struct named_pipe
*pipe
;
890 struct pipe_server
*server
;
891 struct unicode_str name
;
893 const struct security_descriptor
*sd
;
894 const struct object_attributes
*objattr
= get_req_object_attributes( &sd
, &name
, &root
);
896 if (!objattr
) return;
898 if (!req
->sharing
|| (req
->sharing
& ~(FILE_SHARE_READ
| FILE_SHARE_WRITE
)) ||
899 (!(req
->flags
& NAMED_PIPE_MESSAGE_STREAM_WRITE
) && (req
->flags
& NAMED_PIPE_MESSAGE_STREAM_READ
)))
901 if (root
) release_object( root
);
902 set_error( STATUS_INVALID_PARAMETER
);
906 if (!name
.len
) /* pipes need a root directory even without a name */
908 if (!objattr
->rootdir
)
910 set_error( STATUS_OBJECT_PATH_SYNTAX_BAD
);
913 if (!(root
= get_directory_obj( current
->process
, objattr
->rootdir
))) return;
916 pipe
= create_named_object( root
, &named_pipe_ops
, &name
, objattr
->attributes
| OBJ_OPENIF
, NULL
);
918 if (root
) release_object( root
);
921 if (get_error() != STATUS_OBJECT_NAME_EXISTS
)
923 /* initialize it if it didn't already exist */
925 pipe
->waiters
= NULL
;
926 list_init( &pipe
->servers
);
927 pipe
->insize
= req
->insize
;
928 pipe
->outsize
= req
->outsize
;
929 pipe
->maxinstances
= req
->maxinstances
;
930 pipe
->timeout
= req
->timeout
;
931 pipe
->flags
= req
->flags
& NAMED_PIPE_MESSAGE_STREAM_WRITE
;
932 pipe
->sharing
= req
->sharing
;
936 if (pipe
->maxinstances
<= pipe
->instances
)
938 set_error( STATUS_INSTANCE_NOT_AVAILABLE
);
939 release_object( pipe
);
942 if (pipe
->sharing
!= req
->sharing
)
944 set_error( STATUS_ACCESS_DENIED
);
945 release_object( pipe
);
948 clear_error(); /* clear the name collision */
951 server
= create_pipe_server( pipe
, req
->options
, req
->flags
);
954 reply
->handle
= alloc_handle( current
->process
, server
, req
->access
, objattr
->attributes
);
955 server
->pipe
->instances
++;
956 if (sd
) default_set_sd( &server
->pipe_end
.obj
, sd
, OWNER_SECURITY_INFORMATION
|
957 GROUP_SECURITY_INFORMATION
|
958 DACL_SECURITY_INFORMATION
|
959 SACL_SECURITY_INFORMATION
);
960 release_object( server
);
963 release_object( pipe
);
966 DECL_HANDLER(get_named_pipe_info
)
968 struct pipe_server
*server
;
969 struct pipe_client
*client
= NULL
;
971 server
= get_pipe_server_obj( current
->process
, req
->handle
, FILE_READ_ATTRIBUTES
);
974 if (get_error() != STATUS_OBJECT_TYPE_MISMATCH
)
978 client
= (struct pipe_client
*)get_handle_obj( current
->process
, req
->handle
,
979 0, &pipe_client_ops
);
981 server
= client
->server
;
984 reply
->flags
= client
? client
->pipe_end
.flags
: server
->pipe_end
.flags
;
987 reply
->sharing
= server
->pipe
->sharing
;
988 reply
->maxinstances
= server
->pipe
->maxinstances
;
989 reply
->instances
= server
->pipe
->instances
;
990 reply
->insize
= server
->pipe
->insize
;
991 reply
->outsize
= server
->pipe
->outsize
;
995 release_object(client
);
998 reply
->flags
|= NAMED_PIPE_SERVER_END
;
999 release_object(server
);
1003 DECL_HANDLER(set_named_pipe_info
)
1005 struct pipe_server
*server
;
1006 struct pipe_client
*client
= NULL
;
1008 server
= get_pipe_server_obj( current
->process
, req
->handle
, FILE_WRITE_ATTRIBUTES
);
1011 if (get_error() != STATUS_OBJECT_TYPE_MISMATCH
)
1015 client
= (struct pipe_client
*)get_handle_obj( current
->process
, req
->handle
,
1016 0, &pipe_client_ops
);
1017 if (!client
) return;
1018 if (!(server
= client
->server
))
1020 release_object( client
);
1025 if ((req
->flags
& ~(NAMED_PIPE_MESSAGE_STREAM_READ
| NAMED_PIPE_NONBLOCKING_MODE
)) ||
1026 ((req
->flags
& NAMED_PIPE_MESSAGE_STREAM_READ
) && !(server
->pipe
->flags
& NAMED_PIPE_MESSAGE_STREAM_WRITE
)))
1028 set_error( STATUS_INVALID_PARAMETER
);
1032 client
->pipe_end
.flags
= server
->pipe
->flags
| req
->flags
;
1036 server
->pipe_end
.flags
= server
->pipe
->flags
| req
->flags
;
1040 release_object(client
);
1042 release_object(server
);