server/named_pipe.c

   1 /*
   2  * Server-side pipe management
   3  *
   4  * Copyright (C) 1998 Alexandre Julliard
   5  * Copyright (C) 2001 Mike McCormack
   6  *
   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.
  11  *
  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.
  16  *
  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
  20  *
  21  * TODO:
  22  *   message mode
  23  */
  24
  25 #include "config.h"
  26 #include "wine/port.h"
  27
  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>
  41
  42 #include "windef.h"
  43 #include "winbase.h"
  44
  45 #include "file.h"
  46 #include "handle.h"
  47 #include "thread.h"
  48 #include "request.h"
  49
  50 enum pipe_state
  51 {
  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
  59 };
  60
  61 struct wait_info
  62 {
  63     struct thread       *thread;
  64     void                *func;
  65     void                *overlapped;
  66 };
  67
  68 struct named_pipe;
  69
  70 struct pipe_server
  71 {
  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;
  82 };
  83
  84 struct pipe_client
  85 {
  86     struct object        obj;
  87     struct fd           *fd;
  88     struct pipe_server  *server;
  89     struct wait_info     wait;
  90 };
  91
  92 struct connect_wait
  93 {
  94     struct wait_info     wait;
  95     struct connect_wait *next;
  96 };
  97
  98 struct named_pipe
  99 {
 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;
 109 };
 110
 111 static void named_pipe_dump( struct object *obj, int verbose );
 112 static void named_pipe_destroy( struct object *obj );
 113
 114 static const struct object_ops named_pipe_ops =
 115 {
 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 */
 124 };
 125
 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 );
 129
 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 );
 135
 136 static const struct object_ops pipe_server_ops =
 137 {
 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 */
 146 };
 147
 148 static const struct fd_ops pipe_server_fd_ops =
 149 {
 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 */
 155 };
 156
 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 );
 162
 163 static const struct object_ops pipe_client_ops =
 164 {
 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 */
 173 };
 174
 175 static const struct fd_ops pipe_client_fd_ops =
 176 {
 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 */
 182 };
 183
 184 static void named_pipe_dump( struct object *obj, int verbose )
 185 {
 186     struct named_pipe *pipe = (struct named_pipe *) obj;
 187     assert( obj->ops == &named_pipe_ops );
 188     fprintf( stderr, "named pipe %p\n" ,pipe);
 189 }
 190
 191 static void pipe_server_dump( struct object *obj, int verbose )
 192 {
 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 );
 197 }
 198
 199 static void pipe_client_dump( struct object *obj, int verbose )
 200 {
 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 );
 205 }
 206
 207 static void named_pipe_destroy( struct object *obj)
 208 {
 209     struct named_pipe *pipe = (struct named_pipe *) obj;
 210     assert( !pipe->servers );
 211     assert( !pipe->instances );
 212 }
 213
 214 static void notify_waiter( struct wait_info *wait, unsigned int status )
 215 {
 216     if( wait->thread && wait->func && wait->overlapped )
 217     {
 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 );
 221     }
 222     if( wait->thread ) release_object( wait->thread );
 223     wait->thread = NULL;
 224 }
 225
 226 static void set_waiter( struct wait_info *wait, void *func, void *ov )
 227 {
 228     wait->thread = (struct thread *) grab_object( current );
 229     wait->func = func;
 230     wait->overlapped = ov;
 231 }
 232
 233 static void notify_connect_waiters( struct named_pipe *pipe )
 234 {
 235     struct connect_wait *cw, **x = &pipe->connect_waiters;
 236
 237     while( *x )
 238     {
 239         cw = *x;
 240         notify_waiter( &cw->wait, STATUS_SUCCESS );
 241         release_object( pipe );
 242         *x = cw->next;
 243         free( cw );
 244     }
 245 }
 246
 247 static void queue_connect_waiter( struct named_pipe *pipe,
 248                                   void *func, void *overlapped )
 249 {
 250     struct connect_wait *waiter;
 251
 252     waiter = mem_alloc( sizeof(*waiter) );
 253     if( waiter )
 254     {
 255         set_waiter( &waiter->wait, func, overlapped );
 256         waiter->next = pipe->connect_waiters;
 257         pipe->connect_waiters = waiter;
 258         grab_object( pipe );
 259     }
 260 }
 261
 262 static struct fd *pipe_client_get_fd( struct object *obj )
 263 {
 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;
 269 }
 270
 271 static struct fd *pipe_server_get_fd( struct object *obj )
 272 {
 273     struct pipe_server *server = (struct pipe_server *) obj;
 274
 275     switch(server->state)
 276     {
 277     case ps_connected_server:
 278     case ps_wait_disconnect:
 279         assert( server->fd );
 280         return (struct fd *) grab_object( server->fd );
 281
 282     case ps_wait_open:
 283     case ps_idle_server:
 284         set_error( STATUS_PIPE_LISTENING );
 285         break;
 286
 287     case ps_disconnected_server:
 288     case ps_wait_connect:
 289         set_error( STATUS_PIPE_DISCONNECTED );
 290         break;
 291
 292     default:
 293         assert( 0 );
 294     }
 295     return NULL;
 296 }
 297
 298
 299 static void notify_empty( struct pipe_server *server )
 300 {
 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;
 310 }
 311
 312 static void do_disconnect( struct pipe_server *server )
 313 {
 314     /* we may only have a server fd, if the client disconnected */
 315     if( server->client )
 316     {
 317         assert( server->client->server == server );
 318         assert( server->client->fd );
 319         release_object( server->client->fd );
 320         server->client->fd = NULL;
 321     }
 322     assert( server->fd );
 323     release_object( server->fd );
 324     server->fd = NULL;
 325 }
 326
 327 static void pipe_server_destroy( struct object *obj)
 328 {
 329     struct pipe_server *server = (struct pipe_server *)obj;
 330
 331     assert( obj->ops == &pipe_server_ops );
 332
 333     if( server->fd )
 334     {
 335         notify_empty( server );
 336         do_disconnect( server );
 337     }
 338
 339     if( server->client )
 340     {
 341         server->client->server = NULL;
 342         server->client = NULL;
 343     }
 344
 345     notify_waiter( &server->wait, STATUS_HANDLES_CLOSED );
 346
 347     assert( server->pipe->instances );
 348     server->pipe->instances--;
 349
 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 );
 355 }
 356
 357 static void pipe_client_destroy( struct object *obj)
 358 {
 359     struct pipe_client *client = (struct pipe_client *)obj;
 360     struct pipe_server *server = client->server;
 361
 362     assert( obj->ops == &pipe_client_ops );
 363
 364     notify_waiter( &client->wait, STATUS_HANDLES_CLOSED );
 365
 366     if( server )
 367     {
 368         notify_empty( server );
 369
 370         switch( server->state )
 371         {
 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 );
 384         }
 385         assert( server->client );
 386         server->client = NULL;
 387         client->server = NULL;
 388     }
 389     assert( !client->fd );
 390 }
 391
 392 static int pipe_end_get_poll_events( struct fd *fd )
 393 {
 394     return POLLIN | POLLOUT;  /* FIXME */
 395 }
 396
 397 static int pipe_data_remaining( struct pipe_server *server )
 398 {
 399     struct pollfd pfd;
 400     int fd;
 401
 402     assert( server->client );
 403
 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;
 410
 411     if( 0 > poll( &pfd, 1, 0 ) )
 412         return 0;
 413
 414     return pfd.revents&POLLIN;
 415 }
 416
 417 static void check_flushed( void *arg )
 418 {
 419     struct pipe_server *server = (struct pipe_server*) arg;
 420
 421     assert( server->event );
 422     if( pipe_data_remaining( server ) )
 423     {
 424         struct timeval tv;
 425
 426         gettimeofday( &tv, 0 );
 427         add_timeout( &tv, 100 );
 428         server->flush_poll = add_timeout_user( &tv, check_flushed, server );
 429     }
 430     else
 431     {
 432         /* notify_empty( server ); */
 433         server->flush_poll = NULL;
 434         set_event( server->event );
 435         release_object( server->event );
 436         server->event = NULL;
 437     }
 438 }
 439
 440 static int pipe_server_flush( struct fd *fd, struct event **event )
 441 {
 442     struct pipe_server *server = get_fd_user( fd );
 443
 444     if( !server )
 445         return 0;
 446
 447     if( server->state != ps_connected_server )
 448         return 0;
 449
 450     /* FIXME: if multiple threads flush the same pipe,
 451               maybe should create a list of processes to notify */
 452     if( server->flush_poll )
 453         return 0;
 454
 455     if( pipe_data_remaining( server ) )
 456     {
 457         struct timeval tv;
 458
 459         /* this kind of sux -
 460            there's no unix way to be alerted when a pipe becomes empty */
 461         server->event = create_event( NULL, 0, 0, 0 );
 462         if( !server->event )
 463             return 0;
 464         gettimeofday( &tv, 0 );
 465         add_timeout( &tv, 100 );
 466         server->flush_poll = add_timeout_user( &tv, check_flushed, server );
 467         *event = server->event;
 468     }
 469
 470     return 0;
 471 }
 472
 473 static int pipe_client_flush( struct fd *fd, struct event **event )
 474 {
 475     /* FIXME: what do we have to do for this? */
 476     return 0;
 477 }
 478
 479 static int pipe_end_get_info( struct fd *fd, int *flags )
 480 {
 481     *flags = 0;
 482     return FD_TYPE_DEFAULT;
 483 }
 484
 485 static struct named_pipe *create_named_pipe( const WCHAR *name, size_t len )
 486 {
 487     struct named_pipe *pipe;
 488
 489     pipe = create_named_object( sync_namespace, &named_pipe_ops, name, len );
 490     if( pipe )
 491     {
 492         if( get_error() != STATUS_OBJECT_NAME_COLLISION )
 493         {
 494             /* initialize it if it didn't already exist */
 495             pipe->servers = 0;
 496             pipe->instances = 0;
 497             pipe->connect_waiters = NULL;
 498         }
 499     }
 500     return pipe;
 501 }
 502
 503 static struct named_pipe *open_named_pipe( const WCHAR *name, size_t len )
 504 {
 505     struct object *obj;
 506
 507     if ((obj = find_object( sync_namespace, name, len )))
 508     {
 509         if (obj->ops == &named_pipe_ops) return (struct named_pipe *)obj;
 510         release_object( obj );
 511         set_error( STATUS_OBJECT_TYPE_MISMATCH );
 512     }
 513     else set_error( STATUS_OBJECT_NAME_NOT_FOUND );
 514
 515     return NULL;
 516 }
 517
 518 static struct pipe_server *get_pipe_server_obj( struct process *process,
 519                                 obj_handle_t handle, unsigned int access )
 520 {
 521     struct object *obj;
 522     obj = get_handle_obj( process, handle, access, &pipe_server_ops );
 523     return (struct pipe_server *) obj;
 524 }
 525
 526 static struct pipe_server *create_pipe_server( struct named_pipe *pipe )
 527 {
 528     struct pipe_server *server;
 529
 530     server = alloc_object( &pipe_server_ops );
 531     if( !server )
 532         return NULL;
 533
 534     server->fd = NULL;
 535     server->pipe = pipe;
 536     server->state = ps_none;
 537     server->client = NULL;
 538     server->flush_poll = NULL;
 539     server->wait.thread = NULL;
 540
 541     /* add to list of pipe servers */
 542     if ((server->next = pipe->servers)) server->next->prev = server;
 543     server->prev = NULL;
 544     pipe->servers = server;
 545
 546     grab_object( pipe );
 547
 548     return server;
 549 }
 550
 551 static struct pipe_client *create_pipe_client( struct pipe_server *server )
 552 {
 553     struct pipe_client *client;
 554
 555     client = alloc_object( &pipe_client_ops );
 556     if( !client )
 557         return NULL;
 558
 559     client->fd = NULL;
 560     client->server = server;
 561     client->wait.thread = NULL;
 562
 563     return client;
 564 }
 565
 566 static struct pipe_server *find_server( struct named_pipe *pipe,
 567                                         enum pipe_state state )
 568 {
 569     struct pipe_server *x;
 570
 571     for( x = pipe->servers; x; x = x->next )
 572         if( x->state == state )
 573             break;
 574
 575     if( !x )
 576         return NULL;
 577
 578     return (struct pipe_server *) grab_object( x );
 579 }
 580
 581 DECL_HANDLER(create_named_pipe)
 582 {
 583     struct named_pipe *pipe;
 584     struct pipe_server *server;
 585
 586     reply->handle = 0;
 587     pipe = create_named_pipe( get_req_data(), get_req_data_size() );
 588     if( !pipe )
 589         return;
 590
 591     if( get_error() != STATUS_OBJECT_NAME_COLLISION )
 592     {
 593         pipe->insize = req->insize;
 594         pipe->outsize = req->outsize;
 595         pipe->maxinstances = req->maxinstances;
 596         pipe->timeout = req->timeout;
 597         pipe->pipemode = req->pipemode;
 598     }
 599     else
 600     {
 601         set_error( 0 );  /* clear the name collision */
 602         if( pipe->maxinstances <= pipe->instances )
 603         {
 604             set_error( STATUS_PIPE_BUSY );
 605             release_object( pipe );
 606             return;
 607         }
 608         if( ( pipe->maxinstances != req->maxinstances ) ||
 609             ( pipe->timeout != req->timeout ) ||
 610             ( pipe->pipemode != req->pipemode ) )
 611         {
 612             set_error( STATUS_ACCESS_DENIED );
 613             release_object( pipe );
 614             return;
 615         }
 616     }
 617
 618     server = create_pipe_server( pipe );
 619     if(server)
 620     {
 621         server->state = ps_idle_server;
 622         reply->handle = alloc_handle( current->process, server,
 623                                       GENERIC_READ|GENERIC_WRITE, req->inherit );
 624         server->pipe->instances++;
 625         release_object( server );
 626     }
 627
 628     release_object( pipe );
 629 }
 630
 631 DECL_HANDLER(open_named_pipe)
 632 {
 633     struct pipe_server *server;
 634     struct pipe_client *client;
 635     struct named_pipe *pipe;
 636     int fds[2];
 637
 638     reply->handle = 0;
 639
 640     pipe = open_named_pipe( get_req_data(), get_req_data_size() );
 641     if ( !pipe )
 642     {
 643         set_error( STATUS_NO_SUCH_FILE );
 644         return;
 645     }
 646
 647     for( server = pipe->servers; server; server = server->next )
 648         if( ( server->state==ps_idle_server ) ||
 649             ( server->state==ps_wait_open ) )
 650             break;
 651     release_object( pipe );
 652
 653     if ( !server )
 654     {
 655         set_error( STATUS_PIPE_NOT_AVAILABLE );
 656         return;
 657     }
 658
 659     client = create_pipe_client( server );
 660     if( client )
 661     {
 662         if( !socketpair( PF_UNIX, SOCK_STREAM, 0, fds ) )
 663         {
 664             assert( !client->fd );
 665             assert( !server->fd );
 666             client->fd = create_anonymous_fd( &pipe_server_fd_ops,
 667                                             fds[1], &client->obj );
 668             server->fd = create_anonymous_fd( &pipe_server_fd_ops,
 669                                             fds[0], &server->obj );
 670             if (client->fd && server->fd)
 671             {
 672                 if( server->state == ps_wait_open )
 673                     notify_waiter( &server->wait, STATUS_SUCCESS );
 674                 assert( !server->wait.thread );
 675                 server->state = ps_connected_server;
 676                 server->client = client;
 677                 client->server = server;
 678                 reply->handle = alloc_handle( current->process, client,
 679                                               req->access, req->inherit );
 680             }
 681         }
 682         else
 683             file_set_error();
 684
 685         release_object( client );
 686     }
 687 }
 688
 689 DECL_HANDLER(connect_named_pipe)
 690 {
 691     struct pipe_server *server;
 692
 693     server = get_pipe_server_obj(current->process, req->handle, 0);
 694     if(!server)
 695         return;
 696
 697     switch( server->state )
 698     {
 699     case ps_idle_server:
 700     case ps_wait_connect:
 701         assert( !server->fd );
 702         server->state = ps_wait_open;
 703         set_waiter( &server->wait, req->func, req->overlapped );
 704         notify_connect_waiters( server->pipe );
 705         break;
 706     case ps_connected_server:
 707         assert( server->fd );
 708         set_error( STATUS_PIPE_CONNECTED );
 709         break;
 710     case ps_disconnected_server:
 711         set_error( STATUS_PIPE_BUSY );
 712         break;
 713     case ps_wait_disconnect:
 714         set_error( STATUS_NO_DATA_DETECTED );
 715         break;
 716     default:
 717         set_error( STATUS_INVALID_HANDLE );
 718         break;
 719     }
 720
 721     release_object(server);
 722 }
 723
 724 DECL_HANDLER(wait_named_pipe)
 725 {
 726     struct named_pipe *pipe;
 727     struct pipe_server *server;
 728
 729     if (!(pipe = open_named_pipe( get_req_data(), get_req_data_size() )))
 730     {
 731         set_error( STATUS_PIPE_NOT_AVAILABLE );
 732         return;
 733     }
 734     server = find_server( pipe, ps_wait_open );
 735     if( server )
 736     {
 737         /* there's already a server waiting for a client to connect */
 738         struct wait_info wait;
 739         set_waiter( &wait, req->func, req->overlapped );
 740         notify_waiter( &wait, STATUS_SUCCESS );
 741         release_object( server );
 742     }
 743     else
 744         queue_connect_waiter( pipe, req->func, req->overlapped );
 745
 746     release_object( pipe );
 747 }
 748
 749 DECL_HANDLER(disconnect_named_pipe)
 750 {
 751     struct pipe_server *server;
 752
 753     reply->fd = -1;
 754     server = get_pipe_server_obj( current->process, req->handle, 0 );
 755     if( !server )
 756         return;
 757     switch( server->state )
 758     {
 759     case ps_connected_server:
 760         assert( server->fd );
 761         assert( server->client );
 762         assert( server->client->fd );
 763
 764         notify_empty( server );
 765         notify_waiter( &server->client->wait, STATUS_PIPE_DISCONNECTED );
 766
 767         /* Dump the client and server fds, but keep the pointers
 768            around - client loses all waiting data */
 769         server->state = ps_disconnected_server;
 770         do_disconnect( server );
 771         reply->fd = flush_cached_fd( current->process, req->handle );
 772         break;
 773
 774     case ps_wait_disconnect:
 775         assert( !server->client );
 776         assert( server->fd );
 777         do_disconnect( server );
 778         server->state = ps_wait_connect;
 779         reply->fd = flush_cached_fd( current->process, req->handle );
 780         break;
 781
 782     default:
 783         set_error( STATUS_PIPE_DISCONNECTED );
 784     }
 785     release_object( server );
 786 }
 787
 788 DECL_HANDLER(get_named_pipe_info)
 789 {
 790     struct pipe_server *server;
 791
 792     server = get_pipe_server_obj( current->process, req->handle, 0 );
 793     if(!server)
 794         return;
 795
 796     reply->flags        = server->pipe->pipemode;
 797     reply->maxinstances = server->pipe->maxinstances;
 798     reply->insize       = server->pipe->insize;
 799     reply->outsize      = server->pipe->outsize;
 800
 801     release_object(server);
 802 }