Release 20040408.
[wine/multimedia.git] / server / named_pipe.c
blob3cd69b156e9ba9ff0d56e3188ce310f92b003a56
1 /*
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
21 * TODO:
22 * message mode
25 #include "config.h"
26 #include "wine/port.h"
28 #include <assert.h>
29 #include <fcntl.h>
30 #include <string.h>
31 #include <stdarg.h>
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <sys/time.h>
35 #include <sys/types.h>
36 #ifdef HAVE_SYS_SOCKET_H
37 #include <sys/socket.h>
38 #endif
39 #include <time.h>
40 #include <unistd.h>
42 #include "windef.h"
43 #include "winbase.h"
45 #include "file.h"
46 #include "handle.h"
47 #include "thread.h"
48 #include "request.h"
50 enum pipe_state
52 ps_none,
53 ps_idle_server,
54 ps_wait_open,
55 ps_connected_server,
56 ps_wait_disconnect,
57 ps_disconnected_server,
58 ps_wait_connect
61 struct wait_info
63 struct thread *thread;
64 void *func;
65 void *overlapped;
68 struct named_pipe;
70 struct pipe_server
72 struct object obj;
73 struct fd *fd;
74 enum pipe_state state;
75 struct pipe_client *client;
76 struct named_pipe *pipe;
77 struct pipe_server *next;
78 struct pipe_server *prev;
79 struct timeout_user *flush_poll;
80 struct event *event;
81 struct wait_info wait;
84 struct pipe_client
86 struct object obj;
87 struct fd *fd;
88 struct pipe_server *server;
89 struct wait_info wait;
92 struct connect_wait
94 struct wait_info wait;
95 struct connect_wait *next;
98 struct named_pipe
100 struct object obj; /* object header */
101 unsigned int pipemode;
102 unsigned int maxinstances;
103 unsigned int outsize;
104 unsigned int insize;
105 unsigned int timeout;
106 unsigned int instances;
107 struct pipe_server *servers;
108 struct connect_wait *connect_waiters;
111 static void named_pipe_dump( struct object *obj, int verbose );
112 static void named_pipe_destroy( struct object *obj );
114 static const struct object_ops named_pipe_ops =
116 sizeof(struct named_pipe), /* size */
117 named_pipe_dump, /* dump */
118 no_add_queue, /* add_queue */
119 NULL, /* remove_queue */
120 NULL, /* signaled */
121 NULL, /* satisfied */
122 no_get_fd, /* get_fd */
123 named_pipe_destroy /* destroy */
126 /* common to clients and servers */
127 static int pipe_end_get_poll_events( struct fd *fd );
128 static int pipe_end_get_info( struct fd *fd, int *flags );
130 /* server end functions */
131 static void pipe_server_dump( struct object *obj, int verbose );
132 static struct fd *pipe_server_get_fd( struct object *obj );
133 static void pipe_server_destroy( struct object *obj);
134 static int pipe_server_flush( struct fd *fd, struct event **event );
136 static const struct object_ops pipe_server_ops =
138 sizeof(struct pipe_server), /* size */
139 pipe_server_dump, /* dump */
140 default_fd_add_queue, /* add_queue */
141 default_fd_remove_queue, /* remove_queue */
142 default_fd_signaled, /* signaled */
143 no_satisfied, /* satisfied */
144 pipe_server_get_fd, /* get_fd */
145 pipe_server_destroy /* destroy */
148 static const struct fd_ops pipe_server_fd_ops =
150 pipe_end_get_poll_events, /* get_poll_events */
151 default_poll_event, /* poll_event */
152 pipe_server_flush, /* flush */
153 pipe_end_get_info, /* get_file_info */
154 no_queue_async /* queue_async */
157 /* client end functions */
158 static void pipe_client_dump( struct object *obj, int verbose );
159 static struct fd *pipe_client_get_fd( struct object *obj );
160 static void pipe_client_destroy( struct object *obj );
161 static int pipe_client_flush( struct fd *fd, struct event **event );
163 static const struct object_ops pipe_client_ops =
165 sizeof(struct pipe_client), /* size */
166 pipe_client_dump, /* dump */
167 default_fd_add_queue, /* add_queue */
168 default_fd_remove_queue, /* remove_queue */
169 default_fd_signaled, /* signaled */
170 no_satisfied, /* satisfied */
171 pipe_client_get_fd, /* get_fd */
172 pipe_client_destroy /* destroy */
175 static const struct fd_ops pipe_client_fd_ops =
177 pipe_end_get_poll_events, /* get_poll_events */
178 default_poll_event, /* poll_event */
179 pipe_client_flush, /* flush */
180 pipe_end_get_info, /* get_file_info */
181 no_queue_async /* queue_async */
184 static void named_pipe_dump( struct object *obj, int verbose )
186 struct named_pipe *pipe = (struct named_pipe *) obj;
187 assert( obj->ops == &named_pipe_ops );
188 fprintf( stderr, "named pipe %p\n" ,pipe);
191 static void pipe_server_dump( struct object *obj, int verbose )
193 struct pipe_server *server = (struct pipe_server *) obj;
194 assert( obj->ops == &pipe_server_ops );
195 fprintf( stderr, "named pipe server %p (state %d)\n",
196 server, server->state );
199 static void pipe_client_dump( struct object *obj, int verbose )
201 struct pipe_client *client = (struct pipe_client *) obj;
202 assert( obj->ops == &pipe_server_ops );
203 fprintf( stderr, "named pipe client %p (server state %d)\n",
204 client, client->server->state );
207 static void named_pipe_destroy( struct object *obj)
209 struct named_pipe *pipe = (struct named_pipe *) obj;
210 assert( !pipe->servers );
211 assert( !pipe->instances );
214 static void notify_waiter( struct wait_info *wait, unsigned int status )
216 if( wait->thread && wait->func && wait->overlapped )
218 /* queue a system APC, to notify a waiting thread */
219 thread_queue_apc( wait->thread, NULL, wait->func, APC_ASYNC,
220 1, wait->overlapped, (void *)status, NULL );
222 if( wait->thread ) release_object( wait->thread );
223 wait->thread = NULL;
226 static void set_waiter( struct wait_info *wait, void *func, void *ov )
228 wait->thread = (struct thread *) grab_object( current );
229 wait->func = func;
230 wait->overlapped = ov;
233 static void notify_connect_waiters( struct named_pipe *pipe )
235 struct connect_wait *cw, **x = &pipe->connect_waiters;
237 while( *x )
239 cw = *x;
240 notify_waiter( &cw->wait, STATUS_SUCCESS );
241 release_object( pipe );
242 *x = cw->next;
243 free( cw );
247 static void queue_connect_waiter( struct named_pipe *pipe,
248 void *func, void *overlapped )
250 struct connect_wait *waiter;
252 waiter = mem_alloc( sizeof(*waiter) );
253 if( waiter )
255 set_waiter( &waiter->wait, func, overlapped );
256 waiter->next = pipe->connect_waiters;
257 pipe->connect_waiters = waiter;
258 grab_object( pipe );
262 static struct fd *pipe_client_get_fd( struct object *obj )
264 struct pipe_client *client = (struct pipe_client *) obj;
265 if( client->fd )
266 return (struct fd *) grab_object( client->fd );
267 set_error( STATUS_PIPE_DISCONNECTED );
268 return NULL;
271 static struct fd *pipe_server_get_fd( struct object *obj )
273 struct pipe_server *server = (struct pipe_server *) obj;
275 switch(server->state)
277 case ps_connected_server:
278 case ps_wait_disconnect:
279 assert( server->fd );
280 return (struct fd *) grab_object( server->fd );
282 case ps_wait_open:
283 case ps_idle_server:
284 set_error( STATUS_PIPE_LISTENING );
285 break;
287 case ps_disconnected_server:
288 case ps_wait_connect:
289 set_error( STATUS_PIPE_DISCONNECTED );
290 break;
292 default:
293 assert( 0 );
295 return NULL;
299 static void notify_empty( struct pipe_server *server )
301 if( !server->flush_poll )
302 return;
303 assert( server->state == ps_connected_server );
304 assert( server->event );
305 remove_timeout_user( server->flush_poll );
306 server->flush_poll = NULL;
307 set_event( server->event );
308 release_object( server->event );
309 server->event = NULL;
312 static void do_disconnect( struct pipe_server *server )
314 /* we may only have a server fd, if the client disconnected */
315 if( server->client )
317 assert( server->client->server == server );
318 assert( server->client->fd );
319 release_object( server->client->fd );
320 server->client->fd = NULL;
322 assert( server->fd );
323 release_object( server->fd );
324 server->fd = NULL;
327 static void pipe_server_destroy( struct object *obj)
329 struct pipe_server *server = (struct pipe_server *)obj;
331 assert( obj->ops == &pipe_server_ops );
333 if( server->fd )
335 notify_empty( server );
336 do_disconnect( server );
339 if( server->client )
341 server->client->server = NULL;
342 server->client = NULL;
345 notify_waiter( &server->wait, STATUS_HANDLES_CLOSED );
347 assert( server->pipe->instances );
348 server->pipe->instances--;
350 /* remove server from pipe's server list */
351 if( server->next ) server->next->prev = server->prev;
352 if( server->prev ) server->prev->next = server->next;
353 else server->pipe->servers = server->next;
354 release_object( server->pipe );
357 static void pipe_client_destroy( struct object *obj)
359 struct pipe_client *client = (struct pipe_client *)obj;
360 struct pipe_server *server = client->server;
362 assert( obj->ops == &pipe_client_ops );
364 notify_waiter( &client->wait, STATUS_HANDLES_CLOSED );
366 if( server )
368 notify_empty( server );
370 switch( server->state )
372 case ps_connected_server:
373 /* Don't destroy the server's fd here as we can't
374 do a successful flush without it. */
375 server->state = ps_wait_disconnect;
376 release_object( client->fd );
377 client->fd = NULL;
378 break;
379 case ps_disconnected_server:
380 server->state = ps_wait_connect;
381 break;
382 default:
383 assert( 0 );
385 assert( server->client );
386 server->client = NULL;
387 client->server = NULL;
389 assert( !client->fd );
392 static int pipe_end_get_poll_events( struct fd *fd )
394 return POLLIN | POLLOUT; /* FIXME */
397 static int pipe_data_remaining( struct pipe_server *server )
399 struct pollfd pfd;
400 int fd;
402 assert( server->client );
404 fd = get_unix_fd( server->client->fd );
405 if( fd < 0 )
406 return 0;
407 pfd.fd = fd;
408 pfd.events = POLLIN;
409 pfd.revents = 0;
411 if( 0 > poll( &pfd, 1, 0 ) )
412 return 0;
414 return pfd.revents&POLLIN;
417 static void check_flushed( void *arg )
419 struct pipe_server *server = (struct pipe_server*) arg;
421 assert( server->event );
422 if( pipe_data_remaining( server ) )
424 struct timeval tv;
426 gettimeofday( &tv, 0 );
427 add_timeout( &tv, 100 );
428 server->flush_poll = add_timeout_user( &tv, check_flushed, server );
430 else
431 notify_empty( server );
434 static int pipe_server_flush( struct fd *fd, struct event **event )
436 struct pipe_server *server = get_fd_user( fd );
438 if( !server )
439 return 0;
441 if( server->state != ps_connected_server )
442 return 0;
444 /* FIXME: if multiple threads flush the same pipe,
445 maybe should create a list of processes to notify */
446 if( server->flush_poll )
447 return 0;
449 if( pipe_data_remaining( server ) )
451 struct timeval tv;
453 /* this kind of sux -
454 there's no unix way to be alerted when a pipe becomes empty */
455 server->event = create_event( NULL, 0, 0, 0 );
456 if( !server->event )
457 return 0;
458 gettimeofday( &tv, 0 );
459 add_timeout( &tv, 100 );
460 server->flush_poll = add_timeout_user( &tv, check_flushed, server );
461 *event = server->event;
464 return 0;
467 static int pipe_client_flush( struct fd *fd, struct event **event )
469 /* FIXME: what do we have to do for this? */
470 return 0;
473 static int pipe_end_get_info( struct fd *fd, int *flags )
475 *flags = 0;
476 return FD_TYPE_DEFAULT;
479 static struct named_pipe *create_named_pipe( const WCHAR *name, size_t len )
481 struct named_pipe *pipe;
483 pipe = create_named_object( sync_namespace, &named_pipe_ops, name, len );
484 if( pipe )
486 if( get_error() != STATUS_OBJECT_NAME_COLLISION )
488 /* initialize it if it didn't already exist */
489 pipe->servers = 0;
490 pipe->instances = 0;
491 pipe->connect_waiters = NULL;
494 return pipe;
497 static struct named_pipe *open_named_pipe( const WCHAR *name, size_t len )
499 struct object *obj;
501 if ((obj = find_object( sync_namespace, name, len )))
503 if (obj->ops == &named_pipe_ops) return (struct named_pipe *)obj;
504 release_object( obj );
505 set_error( STATUS_OBJECT_TYPE_MISMATCH );
507 else set_error( STATUS_OBJECT_NAME_NOT_FOUND );
509 return NULL;
512 static struct pipe_server *get_pipe_server_obj( struct process *process,
513 obj_handle_t handle, unsigned int access )
515 struct object *obj;
516 obj = get_handle_obj( process, handle, access, &pipe_server_ops );
517 return (struct pipe_server *) obj;
520 static struct pipe_server *create_pipe_server( struct named_pipe *pipe )
522 struct pipe_server *server;
524 server = alloc_object( &pipe_server_ops );
525 if( !server )
526 return NULL;
528 server->fd = NULL;
529 server->pipe = pipe;
530 server->state = ps_none;
531 server->client = NULL;
532 server->flush_poll = NULL;
533 server->wait.thread = NULL;
535 /* add to list of pipe servers */
536 if ((server->next = pipe->servers)) server->next->prev = server;
537 server->prev = NULL;
538 pipe->servers = server;
540 grab_object( pipe );
542 return server;
545 static struct pipe_client *create_pipe_client( struct pipe_server *server )
547 struct pipe_client *client;
549 client = alloc_object( &pipe_client_ops );
550 if( !client )
551 return NULL;
553 client->fd = NULL;
554 client->server = server;
555 client->wait.thread = NULL;
557 return client;
560 static struct pipe_server *find_server( struct named_pipe *pipe,
561 enum pipe_state state )
563 struct pipe_server *x;
565 for( x = pipe->servers; x; x = x->next )
566 if( x->state == state )
567 break;
569 if( !x )
570 return NULL;
572 return (struct pipe_server *) grab_object( x );
575 DECL_HANDLER(create_named_pipe)
577 struct named_pipe *pipe;
578 struct pipe_server *server;
580 reply->handle = 0;
581 pipe = create_named_pipe( get_req_data(), get_req_data_size() );
582 if( !pipe )
583 return;
585 if( get_error() != STATUS_OBJECT_NAME_COLLISION )
587 pipe->insize = req->insize;
588 pipe->outsize = req->outsize;
589 pipe->maxinstances = req->maxinstances;
590 pipe->timeout = req->timeout;
591 pipe->pipemode = req->pipemode;
593 else
595 set_error( 0 ); /* clear the name collision */
596 if( pipe->maxinstances <= pipe->instances )
598 set_error( STATUS_PIPE_BUSY );
599 release_object( pipe );
600 return;
602 if( ( pipe->maxinstances != req->maxinstances ) ||
603 ( pipe->timeout != req->timeout ) ||
604 ( pipe->pipemode != req->pipemode ) )
606 set_error( STATUS_ACCESS_DENIED );
607 release_object( pipe );
608 return;
612 server = create_pipe_server( pipe );
613 if(server)
615 server->state = ps_idle_server;
616 reply->handle = alloc_handle( current->process, server,
617 GENERIC_READ|GENERIC_WRITE, req->inherit );
618 server->pipe->instances++;
619 release_object( server );
622 release_object( pipe );
625 DECL_HANDLER(open_named_pipe)
627 struct pipe_server *server;
628 struct pipe_client *client;
629 struct named_pipe *pipe;
630 int fds[2];
632 reply->handle = 0;
634 pipe = open_named_pipe( get_req_data(), get_req_data_size() );
635 if ( !pipe )
637 set_error( STATUS_NO_SUCH_FILE );
638 return;
641 for( server = pipe->servers; server; server = server->next )
642 if( ( server->state==ps_idle_server ) ||
643 ( server->state==ps_wait_open ) )
644 break;
645 release_object( pipe );
647 if ( !server )
649 set_error( STATUS_PIPE_NOT_AVAILABLE );
650 return;
653 client = create_pipe_client( server );
654 if( client )
656 if( !socketpair( PF_UNIX, SOCK_STREAM, 0, fds ) )
658 assert( !client->fd );
659 assert( !server->fd );
660 client->fd = create_anonymous_fd( &pipe_server_fd_ops,
661 fds[1], &client->obj );
662 server->fd = create_anonymous_fd( &pipe_server_fd_ops,
663 fds[0], &server->obj );
664 if (client->fd && server->fd)
666 if( server->state == ps_wait_open )
667 notify_waiter( &server->wait, STATUS_SUCCESS );
668 assert( !server->wait.thread );
669 server->state = ps_connected_server;
670 server->client = client;
671 client->server = server;
672 reply->handle = alloc_handle( current->process, client,
673 req->access, req->inherit );
676 else
677 file_set_error();
679 release_object( client );
683 DECL_HANDLER(connect_named_pipe)
685 struct pipe_server *server;
687 server = get_pipe_server_obj(current->process, req->handle, 0);
688 if(!server)
689 return;
691 switch( server->state )
693 case ps_idle_server:
694 case ps_wait_connect:
695 assert( !server->fd );
696 server->state = ps_wait_open;
697 set_waiter( &server->wait, req->func, req->overlapped );
698 notify_connect_waiters( server->pipe );
699 break;
700 case ps_connected_server:
701 assert( server->fd );
702 set_error( STATUS_PIPE_CONNECTED );
703 break;
704 case ps_disconnected_server:
705 set_error( STATUS_PIPE_BUSY );
706 break;
707 case ps_wait_disconnect:
708 set_error( STATUS_NO_DATA_DETECTED );
709 break;
710 default:
711 set_error( STATUS_INVALID_HANDLE );
712 break;
715 release_object(server);
718 DECL_HANDLER(wait_named_pipe)
720 struct named_pipe *pipe;
721 struct pipe_server *server;
723 if (!(pipe = open_named_pipe( get_req_data(), get_req_data_size() )))
725 set_error( STATUS_PIPE_NOT_AVAILABLE );
726 return;
728 server = find_server( pipe, ps_wait_open );
729 if( server )
731 /* there's already a server waiting for a client to connect */
732 struct wait_info wait;
733 set_waiter( &wait, req->func, req->overlapped );
734 notify_waiter( &wait, STATUS_SUCCESS );
735 release_object( server );
737 else
738 queue_connect_waiter( pipe, req->func, req->overlapped );
740 release_object( pipe );
743 DECL_HANDLER(disconnect_named_pipe)
745 struct pipe_server *server;
747 reply->fd = -1;
748 server = get_pipe_server_obj( current->process, req->handle, 0 );
749 if( !server )
750 return;
751 switch( server->state )
753 case ps_connected_server:
754 assert( server->fd );
755 assert( server->client );
756 assert( server->client->fd );
758 notify_empty( server );
759 notify_waiter( &server->client->wait, STATUS_PIPE_DISCONNECTED );
761 /* Dump the client and server fds, but keep the pointers
762 around - client loses all waiting data */
763 server->state = ps_disconnected_server;
764 do_disconnect( server );
765 reply->fd = flush_cached_fd( current->process, req->handle );
766 break;
768 case ps_wait_disconnect:
769 assert( !server->client );
770 assert( server->fd );
771 do_disconnect( server );
772 server->state = ps_wait_connect;
773 reply->fd = flush_cached_fd( current->process, req->handle );
774 break;
776 default:
777 set_error( STATUS_PIPE_DISCONNECTED );
779 release_object( server );
782 DECL_HANDLER(get_named_pipe_info)
784 struct pipe_server *server;
786 server = get_pipe_server_obj( current->process, req->handle, 0 );
787 if(!server)
788 return;
790 reply->flags = server->pipe->pipemode;
791 reply->maxinstances = server->pipe->maxinstances;
792 reply->insize = server->pipe->insize;
793 reply->outsize = server->pipe->outsize;
795 release_object(server);