git.oblomov.eu Git - wine/blob - 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 <stdio.h>
  32 #include <stdlib.h>
  33 #include <sys/time.h>
  34 #include <sys/types.h>
  35 #ifdef HAVE_SYS_SOCKET_H
  36 #include <sys/socket.h>
  37 #endif
  38 #include <time.h>
  39 #include <unistd.h>
  40
  41 #include "winbase.h"
  42
  43 #include "file.h"
  44 #include "handle.h"
  45 #include "thread.h"
  46 #include "request.h"
  47
  48 enum pipe_state
  49 {
  50     ps_none,
  51     ps_idle_server,
  52     ps_wait_open,
  53     ps_connected_server,
  54     ps_wait_disconnect,
  55     ps_disconnected_server,
  56     ps_wait_connect
  57 };
  58
  59 struct wait_info
  60 {
  61     struct thread       *thread;
  62     void                *func;
  63     void                *overlapped;
  64 };
  65
  66 struct named_pipe;
  67
  68 struct pipe_server
  69 {
  70     struct object        obj;
  71     struct fd           *fd;
  72     enum pipe_state      state;
  73     struct pipe_client  *client;
  74     struct named_pipe   *pipe;
  75     struct pipe_server  *next;
  76     struct pipe_server  *prev;
  77     struct timeout_user *flush_poll;
  78     struct event        *event;
  79     struct wait_info     wait;
  80 };
  81
  82 struct pipe_client
  83 {
  84     struct object        obj;
  85     struct fd           *fd;
  86     struct pipe_server  *server;
  87     struct wait_info     wait;
  88 };
  89
  90 struct connect_wait
  91 {
  92     struct wait_info     wait;
  93     struct connect_wait *next;
  94 };
  95
  96 struct named_pipe
  97 {
  98     struct object       obj;         /* object header */
  99     unsigned int        pipemode;
 100     unsigned int        maxinstances;
 101     unsigned int        outsize;
 102     unsigned int        insize;
 103     unsigned int        timeout;
 104     unsigned int        instances;
 105     struct pipe_server *servers;
 106     struct connect_wait *connect_waiters;
 107 };
 108
 109 static void named_pipe_dump( struct object *obj, int verbose );
 110 static void named_pipe_destroy( struct object *obj );
 111
 112 static const struct object_ops named_pipe_ops =
 113 {
 114     sizeof(struct named_pipe),    /* size */
 115     named_pipe_dump,              /* dump */
 116     no_add_queue,                 /* add_queue */
 117     NULL,                         /* remove_queue */
 118     NULL,                         /* signaled */
 119     NULL,                         /* satisfied */
 120     no_get_fd,                    /* get_fd */
 121     named_pipe_destroy            /* destroy */
 122 };
 123
 124 /* common to clients and servers */
 125 static int pipe_end_get_poll_events( struct fd *fd );
 126 static int pipe_end_get_info( struct fd *fd,
 127                   struct get_file_info_reply *reply, int *flags );
 128
 129 /* server end functions */
 130 static void pipe_server_dump( struct object *obj, int verbose );
 131 static struct fd *pipe_server_get_fd( struct object *obj );
 132 static void pipe_server_destroy( struct object *obj);
 133 static int pipe_server_flush( struct fd *fd, struct event **event );
 134
 135 static const struct object_ops pipe_server_ops =
 136 {
 137     sizeof(struct pipe_server),   /* size */
 138     pipe_server_dump,             /* dump */
 139     default_fd_add_queue,         /* add_queue */
 140     default_fd_remove_queue,      /* remove_queue */
 141     default_fd_signaled,          /* signaled */
 142     no_satisfied,                 /* satisfied */
 143     pipe_server_get_fd,           /* get_fd */
 144     pipe_server_destroy           /* destroy */
 145 };
 146
 147 static const struct fd_ops pipe_server_fd_ops =
 148 {
 149     pipe_end_get_poll_events,     /* get_poll_events */
 150     default_poll_event,           /* poll_event */
 151     pipe_server_flush,            /* flush */
 152     pipe_end_get_info,            /* get_file_info */
 153     no_queue_async                /* queue_async */
 154 };
 155
 156 /* client end functions */
 157 static void pipe_client_dump( struct object *obj, int verbose );
 158 static struct fd *pipe_client_get_fd( struct object *obj );
 159 static void pipe_client_destroy( struct object *obj );
 160 static int pipe_client_flush( struct fd *fd, struct event **event );
 161
 162 static const struct object_ops pipe_client_ops =
 163 {
 164     sizeof(struct pipe_client),   /* size */
 165     pipe_client_dump,             /* dump */
 166     default_fd_add_queue,         /* add_queue */
 167     default_fd_remove_queue,      /* remove_queue */
 168     default_fd_signaled,          /* signaled */
 169     no_satisfied,                 /* satisfied */
 170     pipe_client_get_fd,           /* get_fd */
 171     pipe_client_destroy           /* destroy */
 172 };
 173
 174 static const struct fd_ops pipe_client_fd_ops =
 175 {
 176     pipe_end_get_poll_events,     /* get_poll_events */
 177     default_poll_event,           /* poll_event */
 178     pipe_client_flush,            /* flush */
 179     pipe_end_get_info,            /* get_file_info */
 180     no_queue_async                /* queue_async */
 181 };
 182
 183 static void named_pipe_dump( struct object *obj, int verbose )
 184 {
 185     struct named_pipe *pipe = (struct named_pipe *) obj;
 186     assert( obj->ops == &named_pipe_ops );
 187     fprintf( stderr, "named pipe %p\n" ,pipe);
 188 }
 189
 190 static void pipe_server_dump( struct object *obj, int verbose )
 191 {
 192     struct pipe_server *server = (struct pipe_server *) obj;
 193     assert( obj->ops == &pipe_server_ops );
 194     fprintf( stderr, "named pipe server %p (state %d)\n",
 195              server, server->state );
 196 }
 197
 198 static void pipe_client_dump( struct object *obj, int verbose )
 199 {
 200     struct pipe_client *client = (struct pipe_client *) obj;
 201     assert( obj->ops == &pipe_server_ops );
 202     fprintf( stderr, "named pipe client %p (server state %d)\n",
 203              client, client->server->state );
 204 }
 205
 206 static void named_pipe_destroy( struct object *obj)
 207 {
 208     struct named_pipe *pipe = (struct named_pipe *) obj;
 209     assert( !pipe->servers );
 210     assert( !pipe->instances );
 211 }
 212
 213 static void notify_waiter( struct wait_info *wait, unsigned int status )
 214 {
 215     if( wait->thread && wait->func && wait->overlapped )
 216     {
 217         /* queue a system APC, to notify a waiting thread */
 218         thread_queue_apc( wait->thread, NULL, wait->func, APC_ASYNC,
 219                           1, wait->overlapped, (void *)status, NULL );
 220     }
 221     if( wait->thread ) release_object( wait->thread );
 222     wait->thread = NULL;
 223 }
 224
 225 static void set_waiter( struct wait_info *wait, void *func, void *ov )
 226 {
 227     wait->thread = (struct thread *) grab_object( current );
 228     wait->func = func;
 229     wait->overlapped = ov;
 230 }
 231
 232 static void notify_connect_waiters( struct named_pipe *pipe )
 233 {
 234     struct connect_wait *cw, **x = &pipe->connect_waiters;
 235
 236     while( *x )
 237     {
 238         cw = *x;
 239         notify_waiter( &cw->wait, STATUS_SUCCESS );
 240         release_object( pipe );
 241         *x = cw->next;
 242         free( cw );
 243     }
 244 }
 245
 246 static void queue_connect_waiter( struct named_pipe *pipe,
 247                                   void *func, void *overlapped )
 248 {
 249     struct connect_wait *waiter;
 250
 251     waiter = mem_alloc( sizeof(*waiter) );
 252     if( waiter )
 253     {
 254         set_waiter( &waiter->wait, func, overlapped );
 255         waiter->next = pipe->connect_waiters;
 256         pipe->connect_waiters = waiter;
 257         grab_object( pipe );
 258     }
 259 }
 260
 261 static struct fd *pipe_client_get_fd( struct object *obj )
 262 {
 263     struct pipe_client *client = (struct pipe_client *) obj;
 264     if( client->fd )
 265         return (struct fd *) grab_object( client->fd );
 266     set_error( STATUS_PIPE_DISCONNECTED );
 267     return NULL;
 268 }
 269
 270 static struct fd *pipe_server_get_fd( struct object *obj )
 271 {
 272     struct pipe_server *server = (struct pipe_server *) obj;
 273
 274     switch(server->state)
 275     {
 276     case ps_connected_server:
 277     case ps_wait_disconnect:
 278         assert( server->fd );
 279         return (struct fd *) grab_object( server->fd );
 280
 281     case ps_wait_open:
 282     case ps_idle_server:
 283         set_error( STATUS_PIPE_LISTENING );
 284         break;
 285
 286     case ps_disconnected_server:
 287     case ps_wait_connect:
 288         set_error( STATUS_PIPE_DISCONNECTED );
 289         break;
 290
 291     default:
 292         assert( 0 );
 293     }
 294     return NULL;
 295 }
 296
 297
 298 static void notify_empty( struct pipe_server *server )
 299 {
 300     if( !server->flush_poll )
 301         return;
 302     assert( server->state == ps_connected_server );
 303     assert( server->event );
 304     remove_timeout_user( server->flush_poll );
 305     server->flush_poll = NULL;
 306     set_event( server->event );
 307     release_object( server->event );
 308     server->event = NULL;
 309 }
 310
 311 static void do_disconnect( struct pipe_server *server )
 312 {
 313     /* we may only have a server fd, if the client disconnected */
 314     if( server->client )
 315     {
 316         assert( server->client->server == server );
 317         assert( server->client->fd );
 318         release_object( server->client->fd );
 319         server->client->fd = NULL;
 320     }
 321     assert( server->fd );
 322     release_object( server->fd );
 323     server->fd = NULL;
 324 }
 325
 326 static void pipe_server_destroy( struct object *obj)
 327 {
 328     struct pipe_server *server = (struct pipe_server *)obj;
 329
 330     assert( obj->ops == &pipe_server_ops );
 331
 332     if( server->fd )
 333     {
 334         notify_empty( server );
 335         do_disconnect( server );
 336     }
 337
 338     if( server->client )
 339     {
 340         server->client->server = NULL;
 341         server->client = NULL;
 342     }
 343
 344     notify_waiter( &server->wait, STATUS_HANDLES_CLOSED );
 345
 346     assert( server->pipe->instances );
 347     server->pipe->instances--;
 348
 349     /* remove server from pipe's server list */
 350     if( server->next ) server->next->prev = server->prev;
 351     if( server->prev ) server->prev->next = server->next;
 352     else server->pipe->servers = server->next;
 353     release_object( server->pipe );
 354 }
 355
 356 static void pipe_client_destroy( struct object *obj)
 357 {
 358     struct pipe_client *client = (struct pipe_client *)obj;
 359     struct pipe_server *server = client->server;
 360
 361     assert( obj->ops == &pipe_client_ops );
 362
 363     notify_waiter( &client->wait, STATUS_HANDLES_CLOSED );
 364
 365     if( server )
 366     {
 367         notify_empty( server );
 368
 369         switch( server->state )
 370         {
 371         case ps_connected_server:
 372             /* Don't destroy the server's fd here as we can't
 373                do a successful flush without it. */
 374             server->state = ps_wait_disconnect;
 375             release_object( client->fd );
 376             client->fd = NULL;
 377             break;
 378         case ps_disconnected_server:
 379             server->state = ps_wait_connect;
 380             break;
 381         default:
 382             assert( 0 );
 383         }
 384         assert( server->client );
 385         server->client = NULL;
 386         client->server = NULL;
 387     }
 388     assert( !client->fd );
 389 }
 390
 391 static int pipe_end_get_poll_events( struct fd *fd )
 392 {
 393     return POLLIN | POLLOUT;  /* FIXME */
 394 }
 395
 396 static int pipe_data_remaining( struct pipe_server *server )
 397 {
 398     struct pollfd pfd;
 399     int fd;
 400
 401     assert( server->client );
 402
 403     fd = get_unix_fd( server->client->fd );
 404     if( fd < 0 )
 405         return 0;
 406     pfd.fd = fd;
 407     pfd.events = POLLIN;
 408     pfd.revents = 0;
 409
 410     if( 0 > poll( &pfd, 1, 0 ) )
 411         return 0;
 412
 413     return pfd.revents&POLLIN;
 414 }
 415
 416 static void check_flushed( void *arg )
 417 {
 418     struct pipe_server *server = (struct pipe_server*) arg;
 419
 420     assert( server->event );
 421     if( pipe_data_remaining( server ) )
 422     {
 423         struct timeval tv;
 424
 425         gettimeofday( &tv, 0 );
 426         add_timeout( &tv, 100 );
 427         server->flush_poll = add_timeout_user( &tv, check_flushed, server );
 428     }
 429     else
 430         notify_empty( server );
 431 }
 432
 433 static int pipe_server_flush( struct fd *fd, struct event **event )
 434 {
 435     struct pipe_server *server = get_fd_user( fd );
 436
 437     if( !server )
 438         return 0;
 439
 440     if( server->state != ps_connected_server )
 441         return 0;
 442
 443     /* FIXME: if multiple threads flush the same pipe,
 444               maybe should create a list of processes to notify */
 445     if( server->flush_poll )
 446         return 0;
 447
 448     if( pipe_data_remaining( server ) )
 449     {
 450         struct timeval tv;
 451
 452         /* this kind of sux -
 453            there's no unix way to be alerted when a pipe becomes empty */
 454         server->event = create_event( NULL, 0, 0, 0 );
 455         if( !server->event )
 456             return 0;
 457         gettimeofday( &tv, 0 );
 458         add_timeout( &tv, 100 );
 459         server->flush_poll = add_timeout_user( &tv, check_flushed, server );
 460         *event = server->event;
 461     }
 462
 463     return 0;
 464 }
 465
 466 static int pipe_client_flush( struct fd *fd, struct event **event )
 467 {
 468     /* FIXME: what do we have to do for this? */
 469     return 0;
 470 }
 471
 472 static int pipe_end_get_info( struct fd *fd,
 473                         struct get_file_info_reply *reply, int *flags )
 474 {
 475     if (reply)
 476     {
 477         reply->type        = FILE_TYPE_PIPE;
 478         reply->attr        = 0;
 479         reply->access_time = 0;
 480         reply->write_time  = 0;
 481         reply->size_high   = 0;
 482         reply->size_low    = 0;
 483         reply->links       = 0;
 484         reply->index_high  = 0;
 485         reply->index_low   = 0;
 486         reply->serial      = 0;
 487     }
 488     *flags = 0;
 489     return FD_TYPE_DEFAULT;
 490 }
 491
 492 static struct named_pipe *create_named_pipe( const WCHAR *name, size_t len )
 493 {
 494     struct named_pipe *pipe;
 495
 496     pipe = create_named_object( sync_namespace, &named_pipe_ops, name, len );
 497     if( pipe )
 498     {
 499         if( get_error() != STATUS_OBJECT_NAME_COLLISION )
 500         {
 501             /* initialize it if it didn't already exist */
 502             pipe->servers = 0;
 503             pipe->instances = 0;
 504             pipe->connect_waiters = NULL;
 505         }
 506     }
 507     return pipe;
 508 }
 509
 510 static struct named_pipe *open_named_pipe( const WCHAR *name, size_t len )
 511 {
 512     struct object *obj;
 513
 514     if ((obj = find_object( sync_namespace, name, len )))
 515     {
 516         if (obj->ops == &named_pipe_ops) return (struct named_pipe *)obj;
 517         release_object( obj );
 518         set_error( STATUS_OBJECT_TYPE_MISMATCH );
 519     }
 520     else set_error( STATUS_OBJECT_NAME_NOT_FOUND );
 521
 522     return NULL;
 523 }
 524
 525 static struct pipe_server *get_pipe_server_obj( struct process *process,
 526                                 obj_handle_t handle, unsigned int access )
 527 {
 528     struct object *obj;
 529     obj = get_handle_obj( process, handle, access, &pipe_server_ops );
 530     return (struct pipe_server *) obj;
 531 }
 532
 533 static struct pipe_server *create_pipe_server( struct named_pipe *pipe )
 534 {
 535     struct pipe_server *server;
 536
 537     server = alloc_object( &pipe_server_ops );
 538     if( !server )
 539         return NULL;
 540
 541     server->fd = NULL;
 542     server->pipe = pipe;
 543     server->state = ps_none;
 544     server->client = NULL;
 545     server->flush_poll = NULL;
 546     server->wait.thread = NULL;
 547
 548     /* add to list of pipe servers */
 549     if ((server->next = pipe->servers)) server->next->prev = server;
 550     server->prev = NULL;
 551     pipe->servers = server;
 552
 553     grab_object( pipe );
 554
 555     return server;
 556 }
 557
 558 static struct pipe_client *create_pipe_client( struct pipe_server *server )
 559 {
 560     struct pipe_client *client;
 561
 562     client = alloc_object( &pipe_client_ops );
 563     if( !client )
 564         return NULL;
 565
 566     client->fd = NULL;
 567     client->server = server;
 568     client->wait.thread = NULL;
 569
 570     return client;
 571 }
 572
 573 static struct pipe_server *find_server( struct named_pipe *pipe,
 574                                         enum pipe_state state )
 575 {
 576     struct pipe_server *x;
 577
 578     for( x = pipe->servers; x; x = x->next )
 579         if( x->state == state )
 580             break;
 581
 582     if( !x )
 583         return NULL;
 584
 585     return (struct pipe_server *) grab_object( x );
 586 }
 587
 588 DECL_HANDLER(create_named_pipe)
 589 {
 590     struct named_pipe *pipe;
 591     struct pipe_server *server;
 592
 593     reply->handle = 0;
 594     pipe = create_named_pipe( get_req_data(), get_req_data_size() );
 595     if( !pipe )
 596         return;
 597
 598     if( get_error() != STATUS_OBJECT_NAME_COLLISION )
 599     {
 600         pipe->insize = req->insize;
 601         pipe->outsize = req->outsize;
 602         pipe->maxinstances = req->maxinstances;
 603         pipe->timeout = req->timeout;
 604         pipe->pipemode = req->pipemode;
 605     }
 606     else
 607     {
 608         set_error( 0 );  /* clear the name collision */
 609         if( pipe->maxinstances <= pipe->instances )
 610         {
 611             set_error( STATUS_PIPE_BUSY );
 612             release_object( pipe );
 613             return;
 614         }
 615         if( ( pipe->maxinstances != req->maxinstances ) ||
 616             ( pipe->timeout != req->timeout ) ||
 617             ( pipe->pipemode != req->pipemode ) )
 618         {
 619             set_error( STATUS_ACCESS_DENIED );
 620             release_object( pipe );
 621             return;
 622         }
 623     }
 624
 625     server = create_pipe_server( pipe );
 626     if(server)
 627     {
 628         server->state = ps_idle_server;
 629         reply->handle = alloc_handle( current->process, server,
 630                                       GENERIC_READ|GENERIC_WRITE, 0 );
 631         server->pipe->instances++;
 632         release_object( server );
 633     }
 634
 635     release_object( pipe );
 636 }
 637
 638 DECL_HANDLER(open_named_pipe)
 639 {
 640     struct pipe_server *server;
 641     struct pipe_client *client;
 642     struct named_pipe *pipe;
 643     int fds[2];
 644
 645     reply->handle = 0;
 646
 647     pipe = open_named_pipe( get_req_data(), get_req_data_size() );
 648     if ( !pipe )
 649     {
 650         set_error( STATUS_NO_SUCH_FILE );
 651         return;
 652     }
 653
 654     for( server = pipe->servers; server; server = server->next )
 655         if( ( server->state==ps_idle_server ) ||
 656             ( server->state==ps_wait_open ) )
 657             break;
 658     release_object( pipe );
 659
 660     if ( !server )
 661     {
 662         set_error( STATUS_PIPE_NOT_AVAILABLE );
 663         return;
 664     }
 665
 666     client = create_pipe_client( server );
 667     if( client )
 668     {
 669         if( !socketpair( PF_UNIX, SOCK_STREAM, 0, fds ) )
 670         {
 671             assert( !client->fd );
 672             assert( !server->fd );
 673             client->fd = create_anonymous_fd( &pipe_server_fd_ops,
 674                                             fds[1], &client->obj );
 675             server->fd = create_anonymous_fd( &pipe_server_fd_ops,
 676                                             fds[0], &server->obj );
 677             if (client->fd && server->fd)
 678             {
 679                 if( server->state == ps_wait_open )
 680                     notify_waiter( &server->wait, STATUS_SUCCESS );
 681                 assert( !server->wait.thread );
 682                 server->state = ps_connected_server;
 683                 server->client = client;
 684                 client->server = server;
 685                 reply->handle = alloc_handle( current->process, client,
 686                                               req->access, req->inherit );
 687             }
 688         }
 689         else
 690             file_set_error();
 691
 692         release_object( client );
 693     }
 694 }
 695
 696 DECL_HANDLER(connect_named_pipe)
 697 {
 698     struct pipe_server *server;
 699
 700     server = get_pipe_server_obj(current->process, req->handle, 0);
 701     if(!server)
 702         return;
 703
 704     switch( server->state )
 705     {
 706     case ps_idle_server:
 707     case ps_wait_connect:
 708         assert( !server->fd );
 709         server->state = ps_wait_open;
 710         set_waiter( &server->wait, req->func, req->overlapped );
 711         notify_connect_waiters( server->pipe );
 712         break;
 713     case ps_connected_server:
 714         assert( server->fd );
 715         set_error( STATUS_PIPE_CONNECTED );
 716         break;
 717     case ps_disconnected_server:
 718         set_error( STATUS_PIPE_BUSY );
 719         break;
 720     case ps_wait_disconnect:
 721         set_error( STATUS_NO_DATA_DETECTED );
 722         break;
 723     default:
 724         set_error( STATUS_INVALID_HANDLE );
 725         break;
 726     }
 727
 728     release_object(server);
 729 }
 730
 731 DECL_HANDLER(wait_named_pipe)
 732 {
 733     struct named_pipe *pipe;
 734     struct pipe_server *server;
 735
 736     if (!(pipe = open_named_pipe( get_req_data(), get_req_data_size() )))
 737     {
 738         set_error( STATUS_PIPE_NOT_AVAILABLE );
 739         return;
 740     }
 741     server = find_server( pipe, ps_wait_open );
 742     if( server )
 743     {
 744         /* there's already a server waiting for a client to connect */
 745         struct wait_info wait;
 746         set_waiter( &wait, req->func, req->overlapped );
 747         notify_waiter( &wait, STATUS_SUCCESS );
 748         release_object( server );
 749     }
 750     else
 751         queue_connect_waiter( pipe, req->func, req->overlapped );
 752
 753     release_object( pipe );
 754 }
 755
 756 DECL_HANDLER(disconnect_named_pipe)
 757 {
 758     struct pipe_server *server;
 759
 760     reply->fd = -1;
 761     server = get_pipe_server_obj( current->process, req->handle, 0 );
 762     if( !server )
 763         return;
 764     switch( server->state )
 765     {
 766     case ps_connected_server:
 767         assert( server->fd );
 768         assert( server->client );
 769         assert( server->client->fd );
 770
 771         notify_empty( server );
 772         notify_waiter( &server->client->wait, STATUS_PIPE_DISCONNECTED );
 773
 774         /* Dump the client and server fds, but keep the pointers
 775            around - client loses all waiting data */
 776         server->state = ps_disconnected_server;
 777         do_disconnect( server );
 778         reply->fd = flush_cached_fd( current->process, req->handle );
 779         break;
 780
 781     case ps_wait_disconnect:
 782         assert( !server->client );
 783         assert( server->fd );
 784         do_disconnect( server );
 785         server->state = ps_wait_connect;
 786         reply->fd = flush_cached_fd( current->process, req->handle );
 787         break;
 788
 789     default:
 790         set_error( STATUS_PIPE_DISCONNECTED );
 791     }
 792     release_object( server );
 793 }
 794
 795 DECL_HANDLER(get_named_pipe_info)
 796 {
 797     struct pipe_server *server;
 798
 799     server = get_pipe_server_obj( current->process, req->handle, 0 );
 800     if(!server)
 801         return;
 802
 803     reply->flags        = server->pipe->pipemode;
 804     reply->maxinstances = server->pipe->maxinstances;
 805     reply->insize       = server->pipe->insize;
 806     reply->outsize      = server->pipe->outsize;
 807
 808     release_object(server);
 809 }