?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
usp10/tests: Add missing return value tests (Coverity).
[wine.git] / server / named_pipe.c
blobc6b37cef06f3d3042b29e04034ea67cc1ff75412
1 /*
2 * Server-side pipe management
3 *
4 * Copyright (C) 1998 Alexandre Julliard
5 * Copyright (C) 2001 Mike McCormack
6 * Copyright 2016 Jacek Caban for CodeWeavers
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <assert.h>
27 #include <string.h>
28 #include <stdarg.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31
32 #include "ntstatus.h"
33 #define WIN32_NO_STATUS
34 #include "windef.h"
35 #include "winternl.h"
36 #include "winioctl.h"
37
38 #include "file.h"
39 #include "handle.h"
40 #include "thread.h"
41 #include "request.h"
42 #include "security.h"
43
44 enum pipe_state
45 {
46 ps_idle_server,
47 ps_wait_open,
48 ps_connected_server,
49 ps_wait_disconnect,
50 ps_wait_connect
51 };
52
53 struct named_pipe;
54
55 struct pipe_message
56 {
57 struct list entry; /* entry in message queue */
58 data_size_t read_pos; /* already read bytes */
59 struct iosb *iosb; /* message iosb */
60 struct async *async; /* async of pending write */
61 };
62
63 struct pipe_end
64 {
65 struct object obj; /* object header */
66 struct fd *fd; /* pipe file descriptor */
67 unsigned int flags; /* pipe flags */
68 struct pipe_end *connection; /* the other end of the pipe */
69 data_size_t buffer_size;/* size of buffered data that doesn't block caller */
70 struct list message_queue;
71 struct async_queue read_q; /* read queue */
72 struct async_queue write_q; /* write queue */
73 };
74
75 struct pipe_server
76 {
77 struct pipe_end pipe_end; /* common header for pipe_client and pipe_server */
78 struct list entry; /* entry in named pipe servers list */
79 enum pipe_state state; /* server state */
80 struct pipe_client *client; /* client that this server is connected to */
81 struct named_pipe *pipe;
82 unsigned int options; /* pipe options */
83 };
84
85 struct pipe_client
86 {
87 struct pipe_end pipe_end; /* common header for pipe_client and pipe_server */
88 struct pipe_server *server; /* server that this client is connected to */
89 unsigned int flags; /* file flags */
90 };
91
92 struct named_pipe
93 {
94 struct object obj; /* object header */
95 unsigned int flags;
96 unsigned int sharing;
97 unsigned int maxinstances;
98 unsigned int outsize;
99 unsigned int insize;
100 unsigned int instances;
101 timeout_t timeout;
102 struct list servers; /* list of servers using this pipe */
103 struct async_queue waiters; /* list of clients waiting to connect */
104 };
105
106 struct named_pipe_device
107 {
108 struct object obj; /* object header */
109 struct fd *fd; /* pseudo-fd for ioctls */
110 struct namespace *pipes; /* named pipe namespace */
111 };
112
113 static void named_pipe_dump( struct object *obj, int verbose );
114 static unsigned int named_pipe_map_access( struct object *obj, unsigned int access );
115 static int named_pipe_link_name( struct object *obj, struct object_name *name, struct object *parent );
116 static struct object *named_pipe_open_file( struct object *obj, unsigned int access,
117 unsigned int sharing, unsigned int options );
118 static void named_pipe_destroy( struct object *obj );
119
120 static const struct object_ops named_pipe_ops =
121 {
122 sizeof(struct named_pipe), /* size */
123 named_pipe_dump, /* dump */
124 no_get_type, /* get_type */
125 no_add_queue, /* add_queue */
126 NULL, /* remove_queue */
127 NULL, /* signaled */
128 NULL, /* satisfied */
129 no_signal, /* signal */
130 no_get_fd, /* get_fd */
131 named_pipe_map_access, /* map_access */
132 default_get_sd, /* get_sd */
133 default_set_sd, /* set_sd */
134 no_lookup_name, /* lookup_name */
135 named_pipe_link_name, /* link_name */
136 default_unlink_name, /* unlink_name */
137 named_pipe_open_file, /* open_file */
138 no_close_handle, /* close_handle */
139 named_pipe_destroy /* destroy */
140 };
141
142 /* common server and client pipe end functions */
143 static enum server_fd_type pipe_end_get_fd_type( struct fd *fd );
144 static struct fd *pipe_end_get_fd( struct object *obj );
145 static int pipe_end_read( struct fd *fd, struct async *async, file_pos_t pos );
146 static int pipe_end_write( struct fd *fd, struct async *async_data, file_pos_t pos );
147 static int pipe_end_flush( struct fd *fd, struct async *async );
148 static void pipe_end_get_volume_info( struct fd *fd, unsigned int info_class );
149 static void pipe_end_reselect_async( struct fd *fd, struct async_queue *queue );
150
151 /* server end functions */
152 static void pipe_server_dump( struct object *obj, int verbose );
153 static void pipe_server_destroy( struct object *obj);
154 static int pipe_server_ioctl( struct fd *fd, ioctl_code_t code, struct async *async );
155 static void pipe_server_get_file_info( struct fd *fd, unsigned int info_class );
156
157 static const struct object_ops pipe_server_ops =
158 {
159 sizeof(struct pipe_server), /* size */
160 pipe_server_dump, /* dump */
161 no_get_type, /* get_type */
162 add_queue, /* add_queue */
163 remove_queue, /* remove_queue */
164 default_fd_signaled, /* signaled */
165 no_satisfied, /* satisfied */
166 no_signal, /* signal */
167 pipe_end_get_fd, /* get_fd */
168 default_fd_map_access, /* map_access */
169 default_get_sd, /* get_sd */
170 default_set_sd, /* set_sd */
171 no_lookup_name, /* lookup_name */
172 no_link_name, /* link_name */
173 NULL, /* unlink_name */
174 no_open_file, /* open_file */
175 fd_close_handle, /* close_handle */
176 pipe_server_destroy /* destroy */
177 };
178
179 static const struct fd_ops pipe_server_fd_ops =
180 {
181 default_fd_get_poll_events, /* get_poll_events */
182 default_poll_event, /* poll_event */
183 pipe_end_get_fd_type, /* get_fd_type */
184 pipe_end_read, /* read */
185 pipe_end_write, /* write */
186 pipe_end_flush, /* flush */
187 pipe_server_get_file_info, /* get_file_info */
188 pipe_end_get_volume_info, /* get_volume_info */
189 pipe_server_ioctl, /* ioctl */
190 no_fd_queue_async, /* queue_async */
191 pipe_end_reselect_async /* reselect_async */
192 };
193
194 /* client end functions */
195 static void pipe_client_dump( struct object *obj, int verbose );
196 static void pipe_client_destroy( struct object *obj );
197 static int pipe_client_ioctl( struct fd *fd, ioctl_code_t code, struct async *async );
198 static void pipe_client_get_file_info( struct fd *fd, unsigned int info_class );
199
200 static const struct object_ops pipe_client_ops =
201 {
202 sizeof(struct pipe_client), /* size */
203 pipe_client_dump, /* dump */
204 no_get_type, /* get_type */
205 add_queue, /* add_queue */
206 remove_queue, /* remove_queue */
207 default_fd_signaled, /* signaled */
208 no_satisfied, /* satisfied */
209 no_signal, /* signal */
210 pipe_end_get_fd, /* get_fd */
211 default_fd_map_access, /* map_access */
212 default_get_sd, /* get_sd */
213 default_set_sd, /* set_sd */
214 no_lookup_name, /* lookup_name */
215 no_link_name, /* link_name */
216 NULL, /* unlink_name */
217 no_open_file, /* open_file */
218 fd_close_handle, /* close_handle */
219 pipe_client_destroy /* destroy */
220 };
221
222 static const struct fd_ops pipe_client_fd_ops =
223 {
224 default_fd_get_poll_events, /* get_poll_events */
225 default_poll_event, /* poll_event */
226 pipe_end_get_fd_type, /* get_fd_type */
227 pipe_end_read, /* read */
228 pipe_end_write, /* write */
229 pipe_end_flush, /* flush */
230 pipe_client_get_file_info, /* get_file_info */
231 pipe_end_get_volume_info, /* get_volume_info */
232 pipe_client_ioctl, /* ioctl */
233 no_fd_queue_async, /* queue_async */
234 pipe_end_reselect_async /* reselect_async */
235 };
236
237 static void named_pipe_device_dump( struct object *obj, int verbose );
238 static struct object_type *named_pipe_device_get_type( struct object *obj );
239 static struct fd *named_pipe_device_get_fd( struct object *obj );
240 static struct object *named_pipe_device_lookup_name( struct object *obj,
241 struct unicode_str *name, unsigned int attr );
242 static struct object *named_pipe_device_open_file( struct object *obj, unsigned int access,
243 unsigned int sharing, unsigned int options );
244 static void named_pipe_device_destroy( struct object *obj );
245 static enum server_fd_type named_pipe_device_get_fd_type( struct fd *fd );
246 static int named_pipe_device_ioctl( struct fd *fd, ioctl_code_t code, struct async *async );
247
248 static const struct object_ops named_pipe_device_ops =
249 {
250 sizeof(struct named_pipe_device), /* size */
251 named_pipe_device_dump, /* dump */
252 named_pipe_device_get_type, /* get_type */
253 no_add_queue, /* add_queue */
254 NULL, /* remove_queue */
255 NULL, /* signaled */
256 no_satisfied, /* satisfied */
257 no_signal, /* signal */
258 named_pipe_device_get_fd, /* get_fd */
259 no_map_access, /* map_access */
260 default_get_sd, /* get_sd */
261 default_set_sd, /* set_sd */
262 named_pipe_device_lookup_name, /* lookup_name */
263 directory_link_name, /* link_name */
264 default_unlink_name, /* unlink_name */
265 named_pipe_device_open_file, /* open_file */
266 fd_close_handle, /* close_handle */
267 named_pipe_device_destroy /* destroy */
268 };
269
270 static const struct fd_ops named_pipe_device_fd_ops =
271 {
272 default_fd_get_poll_events, /* get_poll_events */
273 default_poll_event, /* poll_event */
274 named_pipe_device_get_fd_type, /* get_fd_type */
275 no_fd_read, /* read */
276 no_fd_write, /* write */
277 no_fd_flush, /* flush */
278 no_fd_get_file_info, /* get_file_info */
279 no_fd_get_volume_info, /* get_volume_info */
280 named_pipe_device_ioctl, /* ioctl */
281 default_fd_queue_async, /* queue_async */
282 default_fd_reselect_async /* reselect_async */
283 };
284
285 static void named_pipe_dump( struct object *obj, int verbose )
286 {
287 fputs( "Named pipe\n", stderr );
288 }
289
290 static unsigned int named_pipe_map_access( struct object *obj, unsigned int access )
291 {
292 if (access & GENERIC_READ) access |= STANDARD_RIGHTS_READ;
293 if (access & GENERIC_WRITE) access |= STANDARD_RIGHTS_WRITE | FILE_CREATE_PIPE_INSTANCE;
294 if (access & GENERIC_EXECUTE) access |= STANDARD_RIGHTS_EXECUTE;
295 if (access & GENERIC_ALL) access |= STANDARD_RIGHTS_ALL;
296 return access & ~(GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | GENERIC_ALL);
297 }
298
299 static void pipe_server_dump( struct object *obj, int verbose )
300 {
301 struct pipe_server *server = (struct pipe_server *) obj;
302 assert( obj->ops == &pipe_server_ops );
303 fprintf( stderr, "Named pipe server pipe=%p state=%d\n", server->pipe, server->state );
304 }
305
306 static void pipe_client_dump( struct object *obj, int verbose )
307 {
308 struct pipe_client *client = (struct pipe_client *) obj;
309 assert( obj->ops == &pipe_client_ops );
310 fprintf( stderr, "Named pipe client server=%p\n", client->server );
311 }
312
313 static void named_pipe_destroy( struct object *obj)
314 {
315 struct named_pipe *pipe = (struct named_pipe *) obj;
316
317 assert( list_empty( &pipe->servers ) );
318 assert( !pipe->instances );
319 free_async_queue( &pipe->waiters );
320 }
321
322 static struct fd *pipe_end_get_fd( struct object *obj )
323 {
324 struct pipe_end *pipe_end = (struct pipe_end *) obj;
325 return (struct fd *) grab_object( pipe_end->fd );
326 }
327
328 static void set_server_state( struct pipe_server *server, enum pipe_state state )
329 {
330 server->state = state;
331
332 switch(state)
333 {
334 case ps_connected_server:
335 case ps_wait_disconnect:
336 break;
337 case ps_wait_open:
338 case ps_idle_server:
339 set_no_fd_status( server->pipe_end.fd, STATUS_PIPE_LISTENING );
340 break;
341 case ps_wait_connect:
342 set_no_fd_status( server->pipe_end.fd, STATUS_PIPE_DISCONNECTED );
343 break;
344 }
345 }
346
347
348 static void wake_message( struct pipe_message *message )
349 {
350 struct async *async = message->async;
351
352 message->async = NULL;
353 message->iosb->status = STATUS_SUCCESS;
354 message->iosb->result = message->iosb->in_size;
355 if (async)
356 {
357 async_terminate( async, message->iosb->result ? STATUS_ALERTED : STATUS_SUCCESS );
358 release_object( async );
359 }
360 }
361
362 static void free_message( struct pipe_message *message )
363 {
364 list_remove( &message->entry );
365 if (message->iosb) release_object( message->iosb );
366 free( message );
367 }
368
369 static void pipe_end_disconnect( struct pipe_end *pipe_end, unsigned int status )
370 {
371 struct pipe_end *connection = pipe_end->connection;
372 struct pipe_message *message, *next;
373 struct async *async;
374
375 pipe_end->connection = NULL;
376
377 fd_async_wake_up( pipe_end->fd, ASYNC_TYPE_WAIT, status );
378 async_wake_up( &pipe_end->read_q, status );
379 LIST_FOR_EACH_ENTRY_SAFE( message, next, &pipe_end->message_queue, struct pipe_message, entry )
380 {
381 async = message->async;
382 if (async || status == STATUS_PIPE_DISCONNECTED) free_message( message );
383 if (!async) continue;
384 async_terminate( async, status );
385 release_object( async );
386 }
387 if (status == STATUS_PIPE_DISCONNECTED) set_fd_signaled( pipe_end->fd, 0 );
388
389 if (connection)
390 {
391 connection->connection = NULL;
392 pipe_end_disconnect( connection, status );
393 }
394 }
395
396 static void pipe_end_destroy( struct pipe_end *pipe_end )
397 {
398 struct pipe_message *message;
399
400 while (!list_empty( &pipe_end->message_queue ))
401 {
402 message = LIST_ENTRY( list_head(&pipe_end->message_queue), struct pipe_message, entry );
403 assert( !message->async );
404 free_message( message );
405 }
406
407 free_async_queue( &pipe_end->read_q );
408 free_async_queue( &pipe_end->write_q );
409 if (pipe_end->fd) release_object( pipe_end->fd );
410 }
411
412 static void pipe_server_destroy( struct object *obj)
413 {
414 struct pipe_server *server = (struct pipe_server *)obj;
415
416 assert( obj->ops == &pipe_server_ops );
417
418 pipe_end_disconnect( &server->pipe_end, STATUS_PIPE_BROKEN );
419
420 pipe_end_destroy( &server->pipe_end );
421 if (server->client)
422 {
423 server->client->server = NULL;
424 server->client = NULL;
425 }
426
427 assert( server->pipe->instances );
428 server->pipe->instances--;
429
430 list_remove( &server->entry );
431 release_object( server->pipe );
432 }
433
434 static void pipe_client_destroy( struct object *obj)
435 {
436 struct pipe_client *client = (struct pipe_client *)obj;
437 struct pipe_server *server = client->server;
438
439 assert( obj->ops == &pipe_client_ops );
440
441 pipe_end_disconnect( &client->pipe_end, STATUS_PIPE_BROKEN );
442
443 if (server)
444 {
445 switch(server->state)
446 {
447 case ps_connected_server:
448 /* Don't destroy the server's fd here as we can't
449 do a successful flush without it. */
450 set_server_state( server, ps_wait_disconnect );
451 break;
452 case ps_idle_server:
453 case ps_wait_open:
454 case ps_wait_disconnect:
455 case ps_wait_connect:
456 assert( 0 );
457 }
458 assert( server->client );
459 server->client = NULL;
460 client->server = NULL;
461 }
462
463 pipe_end_destroy( &client->pipe_end );
464 }
465
466 static void named_pipe_device_dump( struct object *obj, int verbose )
467 {
468 fputs( "Named pipe device\n", stderr );
469 }
470
471 static struct object_type *named_pipe_device_get_type( struct object *obj )
472 {
473 static const WCHAR name[] = {'D','e','v','i','c','e'};
474 static const struct unicode_str str = { name, sizeof(name) };
475 return get_object_type( &str );
476 }
477
478 static struct fd *named_pipe_device_get_fd( struct object *obj )
479 {
480 struct named_pipe_device *device = (struct named_pipe_device *)obj;
481 return (struct fd *)grab_object( device->fd );
482 }
483
484 static struct object *named_pipe_device_lookup_name( struct object *obj, struct unicode_str *name,
485 unsigned int attr )
486 {
487 struct named_pipe_device *device = (struct named_pipe_device*)obj;
488 struct object *found;
489
490 assert( obj->ops == &named_pipe_device_ops );
491 assert( device->pipes );
492
493 if (!name) return NULL; /* open the device itself */
494
495 if ((found = find_object( device->pipes, name, attr | OBJ_CASE_INSENSITIVE )))
496 name->len = 0;
497
498 return found;
499 }
500
501 static struct object *named_pipe_device_open_file( struct object *obj, unsigned int access,
502 unsigned int sharing, unsigned int options )
503 {
504 return grab_object( obj );
505 }
506
507 static void named_pipe_device_destroy( struct object *obj )
508 {
509 struct named_pipe_device *device = (struct named_pipe_device*)obj;
510 assert( obj->ops == &named_pipe_device_ops );
511 if (device->fd) release_object( device->fd );
512 free( device->pipes );
513 }
514
515 static enum server_fd_type named_pipe_device_get_fd_type( struct fd *fd )
516 {
517 return FD_TYPE_DEVICE;
518 }
519
520 struct object *create_named_pipe_device( struct object *root, const struct unicode_str *name )
521 {
522 struct named_pipe_device *dev;
523
524 if ((dev = create_named_object( root, &named_pipe_device_ops, name, 0, NULL )) &&
525 get_error() != STATUS_OBJECT_NAME_EXISTS)
526 {
527 dev->pipes = NULL;
528 if (!(dev->fd = alloc_pseudo_fd( &named_pipe_device_fd_ops, &dev->obj, 0 )) ||
529 !(dev->pipes = create_namespace( 7 )))
530 {
531 release_object( dev );
532 dev = NULL;
533 }
534 }
535 return &dev->obj;
536 }
537
538 static int pipe_end_flush( struct fd *fd, struct async *async )
539 {
540 struct pipe_end *pipe_end = get_fd_user( fd );
541
542 if (pipe_end->connection && !list_empty( &pipe_end->connection->message_queue ))
543 {
544 fd_queue_async( pipe_end->fd, async, ASYNC_TYPE_WAIT );
545 set_error( STATUS_PENDING );
546 }
547 return 1;
548 }
549
550 static void pipe_end_get_file_info( struct fd *fd, struct named_pipe *pipe, unsigned int info_class )
551 {
552 switch (info_class)
553 {
554 case FileNameInformation:
555 {
556 FILE_NAME_INFORMATION *name_info;
557 data_size_t name_len, reply_size;
558 const WCHAR *name;
559
560 if (get_reply_max_size() < sizeof(*name_info))
561 {
562 set_error( STATUS_INFO_LENGTH_MISMATCH );
563 return;
564 }
565
566 name = get_object_name( &pipe->obj, &name_len );
567 reply_size = offsetof( FILE_NAME_INFORMATION, FileName[name_len/sizeof(WCHAR) + 1] );
568 if (reply_size > get_reply_max_size())
569 {
570 reply_size = get_reply_max_size();
571 set_error( STATUS_BUFFER_OVERFLOW );
572 }
573
574 if (!(name_info = set_reply_data_size( reply_size ))) return;
575 name_info->FileNameLength = name_len + sizeof(WCHAR);
576 name_info->FileName[0] = '\\';
577 reply_size -= offsetof( FILE_NAME_INFORMATION, FileName[1] );
578 if (reply_size) memcpy( &name_info->FileName[1], name, reply_size );
579 break;
580 }
581 default:
582 no_fd_get_file_info( fd, info_class );
583 }
584 }
585
586 static void pipe_server_get_file_info( struct fd *fd, unsigned int info_class )
587 {
588 struct pipe_server *server = get_fd_user( fd );
589 pipe_end_get_file_info( fd, server->pipe, info_class );
590 }
591
592 static void pipe_client_get_file_info( struct fd *fd, unsigned int info_class )
593 {
594 struct pipe_client *client = get_fd_user( fd );
595 if (client->server) pipe_end_get_file_info( fd, client->server->pipe, info_class );
596 else set_error( STATUS_PIPE_DISCONNECTED );
597 }
598
599 static void pipe_end_get_volume_info( struct fd *fd, unsigned int info_class )
600 {
601 switch (info_class)
602 {
603 case FileFsDeviceInformation:
604 {
605 static const FILE_FS_DEVICE_INFORMATION device_info =
606 {
607 FILE_DEVICE_NAMED_PIPE,
608 FILE_DEVICE_ALLOW_APPCONTAINER_TRAVERSAL
609 };
610 if (get_reply_max_size() >= sizeof(device_info))
611 set_reply_data( &device_info, sizeof(device_info) );
612 else
613 set_error( STATUS_BUFFER_TOO_SMALL );
614 break;
615 }
616 default:
617 set_error( STATUS_NOT_IMPLEMENTED );
618 }
619 }
620
621 static void message_queue_read( struct pipe_end *pipe_end, struct iosb *iosb )
622 {
623 struct pipe_message *message;
624
625 if (pipe_end->flags & NAMED_PIPE_MESSAGE_STREAM_READ)
626 {
627 message = LIST_ENTRY( list_head(&pipe_end->message_queue), struct pipe_message, entry );
628 iosb->out_size = min( iosb->out_size, message->iosb->in_size - message->read_pos );
629 iosb->status = message->read_pos + iosb->out_size < message->iosb->in_size
630 ? STATUS_BUFFER_OVERFLOW : STATUS_SUCCESS;
631 }
632 else
633 {
634 data_size_t avail = 0;
635 LIST_FOR_EACH_ENTRY( message, &pipe_end->message_queue, struct pipe_message, entry )
636 {
637 avail += message->iosb->in_size - message->read_pos;
638 if (avail >= iosb->out_size) break;
639 }
640 iosb->out_size = min( iosb->out_size, avail );
641 iosb->status = STATUS_SUCCESS;
642 }
643
644 message = LIST_ENTRY( list_head(&pipe_end->message_queue), struct pipe_message, entry );
645 if (!message->read_pos && message->iosb->in_size == iosb->out_size) /* fast path */
646 {
647 iosb->out_data = message->iosb->in_data;
648 message->iosb->in_data = NULL;
649 wake_message( message );
650 free_message( message );
651 }
652 else
653 {
654 data_size_t write_pos = 0, writing;
655 char *buf = NULL;
656
657 if (iosb->out_size && !(buf = iosb->out_data = malloc( iosb->out_size )))
658 {
659 iosb->out_size = 0;
660 iosb->status = STATUS_NO_MEMORY;
661 return;
662 }
663
664 do
665 {
666 message = LIST_ENTRY( list_head(&pipe_end->message_queue), struct pipe_message, entry );
667 writing = min( iosb->out_size - write_pos, message->iosb->in_size - message->read_pos );
668 if (writing) memcpy( buf + write_pos, (const char *)message->iosb->in_data + message->read_pos, writing );
669 write_pos += writing;
670 message->read_pos += writing;
671 if (message->read_pos == message->iosb->in_size)
672 {
673 wake_message(message);
674 free_message(message);
675 }
676 } while (write_pos < iosb->out_size);
677 }
678 iosb->result = iosb->out_size;
679 }
680
681 /* We call async_terminate in our reselect implementation, which causes recursive reselect.
682 * We're not interested in such reselect calls, so we ignore them. */
683 static int ignore_reselect;
684
685 static void reselect_write_queue( struct pipe_end *pipe_end );
686
687 static void reselect_read_queue( struct pipe_end *pipe_end )
688 {
689 struct async *async;
690 struct iosb *iosb;
691 int read_done = 0;
692
693 ignore_reselect = 1;
694 while (!list_empty( &pipe_end->message_queue ) && (async = find_pending_async( &pipe_end->read_q )))
695 {
696 iosb = async_get_iosb( async );
697 message_queue_read( pipe_end, iosb );
698 async_terminate( async, iosb->result ? STATUS_ALERTED : iosb->status );
699 release_object( async );
700 release_object( iosb );
701 read_done = 1;
702 }
703 ignore_reselect = 0;
704
705 if (pipe_end->connection)
706 {
707 if (list_empty( &pipe_end->message_queue ))
708 fd_async_wake_up( pipe_end->connection->fd, ASYNC_TYPE_WAIT, STATUS_SUCCESS );
709 else if (read_done)
710 reselect_write_queue( pipe_end->connection );
711 }
712 }
713
714 static void reselect_write_queue( struct pipe_end *pipe_end )
715 {
716 struct pipe_message *message, *next;
717 struct pipe_end *reader = pipe_end->connection;
718 data_size_t avail = 0;
719
720 if (!reader) return;
721
722 ignore_reselect = 1;
723
724 LIST_FOR_EACH_ENTRY_SAFE( message, next, &reader->message_queue, struct pipe_message, entry )
725 {
726 if (message->async && message->iosb->status != STATUS_PENDING)
727 {
728 release_object( message->async );
729 message->async = NULL;
730 free_message( message );
731 }
732 else
733 {
734 avail += message->iosb->in_size - message->read_pos;
735 if (message->iosb->status == STATUS_PENDING && (avail <= reader->buffer_size || !message->iosb->in_size))
736 wake_message( message );
737 }
738 }
739
740 ignore_reselect = 0;
741 reselect_read_queue( reader );
742 }
743
744 static int pipe_end_read( struct fd *fd, struct async *async, file_pos_t pos )
745 {
746 struct pipe_end *pipe_end = get_fd_user( fd );
747
748 if (!pipe_end->connection && list_empty( &pipe_end->message_queue ))
749 {
750 set_error( STATUS_PIPE_BROKEN );
751 return 0;
752 }
753
754 queue_async( &pipe_end->read_q, async );
755 reselect_read_queue( pipe_end );
756 set_error( STATUS_PENDING );
757 return 1;
758 }
759
760 static int pipe_end_write( struct fd *fd, struct async *async, file_pos_t pos )
761 {
762 struct pipe_end *write_end = get_fd_user( fd );
763 struct pipe_end *read_end = write_end->connection;
764 struct pipe_message *message;
765
766 if (!read_end)
767 {
768 set_error( STATUS_PIPE_DISCONNECTED );
769 return 0;
770 }
771
772 if (!(write_end->flags & NAMED_PIPE_MESSAGE_STREAM_WRITE) && !get_req_data_size()) return 1;
773
774 if (!(message = mem_alloc( sizeof(*message) ))) return 0;
775 message->async = (struct async *)grab_object( async );
776 message->iosb = async_get_iosb( async );
777 message->read_pos = 0;
778 list_add_tail( &read_end->message_queue, &message->entry );
779
780 queue_async( &write_end->write_q, async );
781 reselect_write_queue( write_end );
782 set_error( STATUS_PENDING );
783 return 1;
784 }
785
786 static void pipe_end_reselect_async( struct fd *fd, struct async_queue *queue )
787 {
788 struct pipe_end *pipe_end = get_fd_user( fd );
789
790 if (ignore_reselect) return;
791
792 if (&pipe_end->write_q == queue)
793 reselect_write_queue( pipe_end );
794 else if (&pipe_end->read_q == queue)
795 reselect_read_queue( pipe_end );
796 }
797
798 static enum server_fd_type pipe_end_get_fd_type( struct fd *fd )
799 {
800 return FD_TYPE_PIPE;
801 }
802
803 static int pipe_end_peek( struct pipe_end *pipe_end )
804 {
805 unsigned reply_size = get_reply_max_size();
806 FILE_PIPE_PEEK_BUFFER *buffer;
807 struct pipe_message *message;
808 data_size_t avail = 0;
809 data_size_t message_length = 0;
810
811 if (reply_size < offsetof( FILE_PIPE_PEEK_BUFFER, Data ))
812 {
813 set_error( STATUS_INFO_LENGTH_MISMATCH );
814 return 0;
815 }
816 reply_size -= offsetof( FILE_PIPE_PEEK_BUFFER, Data );
817
818 if (!pipe_end->connection && list_empty( &pipe_end->message_queue ))
819 {
820 set_error( STATUS_PIPE_BROKEN );
821 return 0;
822 }
823
824 LIST_FOR_EACH_ENTRY( message, &pipe_end->message_queue, struct pipe_message, entry )
825 avail += message->iosb->in_size - message->read_pos;
826 reply_size = min( reply_size, avail );
827
828 if (avail && (pipe_end->flags & NAMED_PIPE_MESSAGE_STREAM_WRITE))
829 {
830 message = LIST_ENTRY( list_head(&pipe_end->message_queue), struct pipe_message, entry );
831 message_length = message->iosb->in_size - message->read_pos;
832 reply_size = min( reply_size, message_length );
833 }
834
835 if (!(buffer = set_reply_data_size( offsetof( FILE_PIPE_PEEK_BUFFER, Data[reply_size] )))) return 0;
836 buffer->NamedPipeState = 0; /* FIXME */
837 buffer->ReadDataAvailable = avail;
838 buffer->NumberOfMessages = 0; /* FIXME */
839 buffer->MessageLength = message_length;
840
841 if (reply_size)
842 {
843 data_size_t write_pos = 0, writing;
844 LIST_FOR_EACH_ENTRY( message, &pipe_end->message_queue, struct pipe_message, entry )
845 {
846 writing = min( reply_size - write_pos, message->iosb->in_size - message->read_pos );
847 memcpy( buffer->Data + write_pos, (const char *)message->iosb->in_data + message->read_pos,
848 writing );
849 write_pos += writing;
850 if (write_pos == reply_size) break;
851 }
852 }
853 return 1;
854 }
855
856 static int pipe_server_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
857 {
858 struct pipe_server *server = get_fd_user( fd );
859
860 switch(code)
861 {
862 case FSCTL_PIPE_LISTEN:
863 switch(server->state)
864 {
865 case ps_idle_server:
866 case ps_wait_connect:
867 fd_queue_async( server->pipe_end.fd, async, ASYNC_TYPE_WAIT );
868 set_server_state( server, ps_wait_open );
869 async_wake_up( &server->pipe->waiters, STATUS_SUCCESS );
870 set_error( STATUS_PENDING );
871 return 1;
872 case ps_connected_server:
873 set_error( STATUS_PIPE_CONNECTED );
874 break;
875 case ps_wait_disconnect:
876 set_error( STATUS_NO_DATA_DETECTED );
877 break;
878 case ps_wait_open:
879 set_error( STATUS_INVALID_HANDLE );
880 break;
881 }
882 return 0;
883
884 case FSCTL_PIPE_DISCONNECT:
885 switch(server->state)
886 {
887 case ps_connected_server:
888 assert( server->client );
889
890 /* dump the client and server fds - client loses all waiting data */
891 pipe_end_disconnect( &server->pipe_end, STATUS_PIPE_DISCONNECTED );
892 server->client->server = NULL;
893 server->client = NULL;
894 set_server_state( server, ps_wait_connect );
895 break;
896 case ps_wait_disconnect:
897 assert( !server->client );
898 pipe_end_disconnect( &server->pipe_end, STATUS_PIPE_DISCONNECTED );
899 set_server_state( server, ps_wait_connect );
900 break;
901 case ps_idle_server:
902 case ps_wait_open:
903 set_error( STATUS_PIPE_LISTENING );
904 return 0;
905 case ps_wait_connect:
906 set_error( STATUS_PIPE_DISCONNECTED );
907 return 0;
908 }
909 return 1;
910
911 case FSCTL_PIPE_PEEK:
912 return pipe_end_peek( &server->pipe_end );
913
914 default:
915 return default_fd_ioctl( fd, code, async );
916 }
917 }
918
919 static int pipe_client_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
920 {
921 struct pipe_client *client = get_fd_user( fd );
922
923 switch(code)
924 {
925 case FSCTL_PIPE_LISTEN:
926 set_error( STATUS_ILLEGAL_FUNCTION );
927 return 0;
928
929 case FSCTL_PIPE_PEEK:
930 return pipe_end_peek( &client->pipe_end );
931
932 default:
933 return default_fd_ioctl( fd, code, async );
934 }
935 }
936
937 static struct pipe_server *get_pipe_server_obj( struct process *process,
938 obj_handle_t handle, unsigned int access )
939 {
940 struct object *obj;
941 obj = get_handle_obj( process, handle, access, &pipe_server_ops );
942 return (struct pipe_server *) obj;
943 }
944
945 static void init_pipe_end( struct pipe_end *pipe_end, unsigned int pipe_flags, data_size_t buffer_size )
946 {
947 pipe_end->fd = NULL;
948 pipe_end->flags = pipe_flags;
949 pipe_end->connection = NULL;
950 pipe_end->buffer_size = buffer_size;
951 init_async_queue( &pipe_end->read_q );
952 init_async_queue( &pipe_end->write_q );
953 list_init( &pipe_end->message_queue );
954 }
955
956 static struct pipe_server *create_pipe_server( struct named_pipe *pipe, unsigned int options,
957 unsigned int pipe_flags )
958 {
959 struct pipe_server *server;
960
961 server = alloc_object( &pipe_server_ops );
962 if (!server)
963 return NULL;
964
965 server->pipe = pipe;
966 server->client = NULL;
967 server->options = options;
968 init_pipe_end( &server->pipe_end, pipe_flags, pipe->insize );
969
970 list_add_head( &pipe->servers, &server->entry );
971 grab_object( pipe );
972 if (!(server->pipe_end.fd = alloc_pseudo_fd( &pipe_server_fd_ops, &server->pipe_end.obj, options )))
973 {
974 release_object( server );
975 return NULL;
976 }
977 set_fd_signaled( server->pipe_end.fd, 1 );
978 set_server_state( server, ps_idle_server );
979 return server;
980 }
981
982 static struct pipe_client *create_pipe_client( unsigned int flags, unsigned int pipe_flags,
983 data_size_t buffer_size, unsigned int options )
984 {
985 struct pipe_client *client;
986
987 client = alloc_object( &pipe_client_ops );
988 if (!client)
989 return NULL;
990
991 client->server = NULL;
992 client->flags = flags;
993 init_pipe_end( &client->pipe_end, pipe_flags, buffer_size );
994
995 client->pipe_end.fd = alloc_pseudo_fd( &pipe_client_fd_ops, &client->pipe_end.obj, options );
996 if (!client->pipe_end.fd)
997 {
998 release_object( client );
999 return NULL;
1000 }
1001 allow_fd_caching( client->pipe_end.fd );
1002 set_fd_signaled( client->pipe_end.fd, 1 );
1003
1004 return client;
1005 }
1006
1007 static struct pipe_server *find_available_server( struct named_pipe *pipe )
1008 {
1009 struct pipe_server *server;
1010
1011 /* look for pipe servers that are listening */
1012 LIST_FOR_EACH_ENTRY( server, &pipe->servers, struct pipe_server, entry )
1013 {
1014 if (server->state == ps_wait_open)
1015 return (struct pipe_server *)grab_object( server );
1016 }
1017
1018 /* fall back to pipe servers that are idle */
1019 LIST_FOR_EACH_ENTRY( server, &pipe->servers, struct pipe_server, entry )
1020 {
1021 if (server->state == ps_idle_server)
1022 return (struct pipe_server *)grab_object( server );
1023 }
1024
1025 return NULL;
1026 }
1027
1028 static int named_pipe_link_name( struct object *obj, struct object_name *name, struct object *parent )
1029 {
1030 struct named_pipe_device *dev = (struct named_pipe_device *)parent;
1031
1032 if (parent->ops != &named_pipe_device_ops)
1033 {
1034 set_error( STATUS_OBJECT_NAME_INVALID );
1035 return 0;
1036 }
1037 namespace_add( dev->pipes, name );
1038 name->parent = grab_object( parent );
1039 return 1;
1040 }
1041
1042 static struct object *named_pipe_open_file( struct object *obj, unsigned int access,
1043 unsigned int sharing, unsigned int options )
1044 {
1045 struct named_pipe *pipe = (struct named_pipe *)obj;
1046 struct pipe_server *server;
1047 struct pipe_client *client;
1048 unsigned int pipe_sharing;
1049
1050 if (!(server = find_available_server( pipe )))
1051 {
1052 set_error( STATUS_PIPE_NOT_AVAILABLE );
1053 return NULL;
1054 }
1055
1056 pipe_sharing = server->pipe->sharing;
1057 if (((access & GENERIC_READ) && !(pipe_sharing & FILE_SHARE_READ)) ||
1058 ((access & GENERIC_WRITE) && !(pipe_sharing & FILE_SHARE_WRITE)))
1059 {
1060 set_error( STATUS_ACCESS_DENIED );
1061 release_object( server );
1062 return NULL;
1063 }
1064
1065 if ((client = create_pipe_client( options, pipe->flags, pipe->outsize, options )))
1066 {
1067 set_no_fd_status( server->pipe_end.fd, STATUS_BAD_DEVICE_TYPE );
1068 allow_fd_caching( server->pipe_end.fd );
1069 if (server->state == ps_wait_open)
1070 fd_async_wake_up( server->pipe_end.fd, ASYNC_TYPE_WAIT, STATUS_SUCCESS );
1071 set_server_state( server, ps_connected_server );
1072 server->client = client;
1073 client->server = server;
1074 server->pipe_end.connection = &client->pipe_end;
1075 client->pipe_end.connection = &server->pipe_end;
1076 }
1077 release_object( server );
1078 return &client->pipe_end.obj;
1079 }
1080
1081 static int named_pipe_device_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
1082 {
1083 struct named_pipe_device *device = get_fd_user( fd );
1084
1085 switch(code)
1086 {
1087 case FSCTL_PIPE_WAIT:
1088 {
1089 const FILE_PIPE_WAIT_FOR_BUFFER *buffer = get_req_data();
1090 data_size_t size = get_req_data_size();
1091 struct named_pipe *pipe;
1092 struct pipe_server *server;
1093 struct unicode_str name;
1094 timeout_t when;
1095
1096 if (size < sizeof(*buffer) ||
1097 size < FIELD_OFFSET(FILE_PIPE_WAIT_FOR_BUFFER, Name[buffer->NameLength/sizeof(WCHAR)]))
1098 {
1099 set_error( STATUS_INVALID_PARAMETER );
1100 return 0;
1101 }
1102 name.str = buffer->Name;
1103 name.len = (buffer->NameLength / sizeof(WCHAR)) * sizeof(WCHAR);
1104 if (!(pipe = open_named_object( &device->obj, &named_pipe_ops, &name, 0 ))) return 0;
1105
1106 if (!(server = find_available_server( pipe )))
1107 {
1108 queue_async( &pipe->waiters, async );
1109 when = buffer->TimeoutSpecified ? buffer->Timeout.QuadPart : pipe->timeout;
1110 async_set_timeout( async, when, STATUS_IO_TIMEOUT );
1111 release_object( pipe );
1112 set_error( STATUS_PENDING );
1113 return 1;
1114 }
1115
1116 release_object( server );
1117 release_object( pipe );
1118 return 0;
1119 }
1120
1121 default:
1122 return default_fd_ioctl( fd, code, async );
1123 }
1124 }
1125
1126
1127 DECL_HANDLER(create_named_pipe)
1128 {
1129 struct named_pipe *pipe;
1130 struct pipe_server *server;
1131 struct unicode_str name;
1132 struct object *root;
1133 const struct security_descriptor *sd;
1134 const struct object_attributes *objattr = get_req_object_attributes( &sd, &name, &root );
1135
1136 if (!objattr) return;
1137
1138 if (!req->sharing || (req->sharing & ~(FILE_SHARE_READ | FILE_SHARE_WRITE)) ||
1139 (!(req->flags & NAMED_PIPE_MESSAGE_STREAM_WRITE) && (req->flags & NAMED_PIPE_MESSAGE_STREAM_READ)))
1140 {
1141 if (root) release_object( root );
1142 set_error( STATUS_INVALID_PARAMETER );
1143 return;
1144 }
1145
1146 if (!name.len) /* pipes need a root directory even without a name */
1147 {
1148 if (!objattr->rootdir)
1149 {
1150 set_error( STATUS_OBJECT_PATH_SYNTAX_BAD );
1151 return;
1152 }
1153 if (!(root = get_directory_obj( current->process, objattr->rootdir ))) return;
1154 }
1155
1156 pipe = create_named_object( root, &named_pipe_ops, &name, objattr->attributes | OBJ_OPENIF, NULL );
1157
1158 if (root) release_object( root );
1159 if (!pipe) return;
1160
1161 if (get_error() != STATUS_OBJECT_NAME_EXISTS)
1162 {
1163 /* initialize it if it didn't already exist */
1164 pipe->instances = 0;
1165 init_async_queue( &pipe->waiters );
1166 list_init( &pipe->servers );
1167 pipe->insize = req->insize;
1168 pipe->outsize = req->outsize;
1169 pipe->maxinstances = req->maxinstances;
1170 pipe->timeout = req->timeout;
1171 pipe->flags = req->flags & NAMED_PIPE_MESSAGE_STREAM_WRITE;
1172 pipe->sharing = req->sharing;
1173 }
1174 else
1175 {
1176 if (pipe->maxinstances <= pipe->instances)
1177 {
1178 set_error( STATUS_INSTANCE_NOT_AVAILABLE );
1179 release_object( pipe );
1180 return;
1181 }
1182 if (pipe->sharing != req->sharing)
1183 {
1184 set_error( STATUS_ACCESS_DENIED );
1185 release_object( pipe );
1186 return;
1187 }
1188 clear_error(); /* clear the name collision */
1189 }
1190
1191 server = create_pipe_server( pipe, req->options, req->flags );
1192 if (server)
1193 {
1194 reply->handle = alloc_handle( current->process, server, req->access, objattr->attributes );
1195 server->pipe->instances++;
1196 if (sd) default_set_sd( &server->pipe_end.obj, sd, OWNER_SECURITY_INFORMATION |
1197 GROUP_SECURITY_INFORMATION |
1198 DACL_SECURITY_INFORMATION |
1199 SACL_SECURITY_INFORMATION );
1200 release_object( server );
1201 }
1202
1203 release_object( pipe );
1204 }
1205
1206 DECL_HANDLER(get_named_pipe_info)
1207 {
1208 struct pipe_server *server;
1209 struct pipe_client *client = NULL;
1210
1211 server = get_pipe_server_obj( current->process, req->handle, FILE_READ_ATTRIBUTES );
1212 if (!server)
1213 {
1214 if (get_error() != STATUS_OBJECT_TYPE_MISMATCH)
1215 return;
1216
1217 clear_error();
1218 client = (struct pipe_client *)get_handle_obj( current->process, req->handle,
1219 0, &pipe_client_ops );
1220 if (!client) return;
1221 server = client->server;
1222 }
1223
1224 reply->flags = client ? client->pipe_end.flags : server->pipe_end.flags;
1225 if (server)
1226 {
1227 reply->sharing = server->pipe->sharing;
1228 reply->maxinstances = server->pipe->maxinstances;
1229 reply->instances = server->pipe->instances;
1230 reply->insize = server->pipe->insize;
1231 reply->outsize = server->pipe->outsize;
1232 }
1233
1234 if (client)
1235 release_object(client);
1236 else
1237 {
1238 reply->flags |= NAMED_PIPE_SERVER_END;
1239 release_object(server);
1240 }
1241 }
1242
1243 DECL_HANDLER(set_named_pipe_info)
1244 {
1245 struct pipe_server *server;
1246 struct pipe_client *client = NULL;
1247
1248 server = get_pipe_server_obj( current->process, req->handle, FILE_WRITE_ATTRIBUTES );
1249 if (!server)
1250 {
1251 if (get_error() != STATUS_OBJECT_TYPE_MISMATCH)
1252 return;
1253
1254 clear_error();
1255 client = (struct pipe_client *)get_handle_obj( current->process, req->handle,
1256 0, &pipe_client_ops );
1257 if (!client) return;
1258 if (!(server = client->server))
1259 {
1260 release_object( client );
1261 return;
1262 }
1263 }
1264
1265 if ((req->flags & ~(NAMED_PIPE_MESSAGE_STREAM_READ | NAMED_PIPE_NONBLOCKING_MODE)) ||
1266 ((req->flags & NAMED_PIPE_MESSAGE_STREAM_READ) && !(server->pipe->flags & NAMED_PIPE_MESSAGE_STREAM_WRITE)))
1267 {
1268 set_error( STATUS_INVALID_PARAMETER );
1269 }
1270 else if (client)
1271 {
1272 client->pipe_end.flags = server->pipe->flags | req->flags;
1273 }
1274 else
1275 {
1276 server->pipe_end.flags = server->pipe->flags | req->flags;
1277 }
1278
1279 if (client)
1280 release_object(client);
1281 else
1282 release_object(server);
1283 }
Windows API implementation