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_idle_server,
  53     ps_wait_open,
  54     ps_connected_server,
  55     ps_wait_disconnect,
  56     ps_disconnected_server,
  57     ps_wait_connect
  58 };
  59
  60 struct wait_info
  61 {
  62     struct thread       *thread;
  63     void                *func;
  64     void                *overlapped;
  65 };
  66
  67 struct named_pipe;
  68
  69 struct pipe_server
  70 {
  71     struct object        obj;        /* object header */
  72     struct fd           *fd;         /* pipe file descriptor */
  73     struct list          entry;      /* entry in named pipe servers list */
  74     enum pipe_state      state;      /* server state */
  75     struct pipe_client  *client;     /* client that this server is connected to */
  76     struct named_pipe   *pipe;
  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;        /* object header */
  85     struct fd           *fd;         /* pipe file descriptor */
  86     struct pipe_server  *server;     /* server that this client is connected to */
  87     struct wait_info     wait;
  88 };
  89
  90 struct connect_wait
  91 {
  92     struct list          entry;      /* entry in named pipe wait list */
  93     struct wait_info     wait;
  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 list         servers;     /* list of servers using this pipe */
 106     struct list         waiters;     /* list of clients waiting to connect */
 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
 128 /* server end functions */
 129 static void pipe_server_dump( struct object *obj, int verbose );
 130 static struct fd *pipe_server_get_fd( struct object *obj );
 131 static void pipe_server_destroy( struct object *obj);
 132 static int pipe_server_flush( struct fd *fd, struct event **event );
 133
 134 static const struct object_ops pipe_server_ops =
 135 {
 136     sizeof(struct pipe_server),   /* size */
 137     pipe_server_dump,             /* dump */
 138     default_fd_add_queue,         /* add_queue */
 139     default_fd_remove_queue,      /* remove_queue */
 140     default_fd_signaled,          /* signaled */
 141     no_satisfied,                 /* satisfied */
 142     pipe_server_get_fd,           /* get_fd */
 143     pipe_server_destroy           /* destroy */
 144 };
 145
 146 static const struct fd_ops pipe_server_fd_ops =
 147 {
 148     pipe_end_get_poll_events,     /* get_poll_events */
 149     default_poll_event,           /* poll_event */
 150     pipe_server_flush,            /* flush */
 151     pipe_end_get_info,            /* get_file_info */
 152     no_queue_async,               /* queue_async */
 153     no_cancel_async,              /* cancel_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     no_cancel_async               /* cancel_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 " );
 189     dump_object_name( &pipe->obj );
 190     fprintf( stderr, "\n" );
 191 }
 192
 193 static void pipe_server_dump( struct object *obj, int verbose )
 194 {
 195     struct pipe_server *server = (struct pipe_server *) obj;
 196     assert( obj->ops == &pipe_server_ops );
 197     fprintf( stderr, "Named pipe server pipe=%p state=%d\n", server->pipe, server->state );
 198 }
 199
 200 static void pipe_client_dump( struct object *obj, int verbose )
 201 {
 202     struct pipe_client *client = (struct pipe_client *) obj;
 203     assert( obj->ops == &pipe_client_ops );
 204     fprintf( stderr, "Named pipe client server=%p\n", client->server );
 205 }
 206
 207 static void notify_waiter( struct wait_info *wait, unsigned int status )
 208 {
 209     if( wait->thread && wait->func && wait->overlapped )
 210     {
 211         /* queue a system APC, to notify a waiting thread */
 212         thread_queue_apc( wait->thread, NULL, wait->func, APC_ASYNC,
 213                           1, wait->overlapped, (void *)status, NULL );
 214     }
 215     if( wait->thread ) release_object( wait->thread );
 216     wait->thread = NULL;
 217 }
 218
 219 static void set_waiter( struct wait_info *wait, void *func, void *ov )
 220 {
 221     wait->thread = (struct thread *) grab_object( current );
 222     wait->func = func;
 223     wait->overlapped = ov;
 224 }
 225
 226 static void notify_connect_waiters( struct named_pipe *pipe, unsigned int status )
 227 {
 228     struct list *ptr;
 229
 230     while ((ptr = list_head( &pipe->waiters )) != NULL)
 231     {
 232         struct connect_wait *waiter = LIST_ENTRY( ptr, struct connect_wait, entry );
 233         notify_waiter( &waiter->wait, status );
 234         list_remove( &waiter->entry );
 235         free( waiter );
 236     }
 237 }
 238
 239 static void named_pipe_destroy( struct object *obj)
 240 {
 241     struct named_pipe *pipe = (struct named_pipe *) obj;
 242
 243     assert( list_empty( &pipe->servers ) );
 244     assert( !pipe->instances );
 245     notify_connect_waiters( pipe, STATUS_HANDLES_CLOSED );
 246 }
 247
 248 static void queue_connect_waiter( struct named_pipe *pipe, 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         list_add_tail( &pipe->waiters, &waiter->entry );
 257     }
 258 }
 259
 260 static struct fd *pipe_client_get_fd( struct object *obj )
 261 {
 262     struct pipe_client *client = (struct pipe_client *) obj;
 263     if( client->fd )
 264         return (struct fd *) grab_object( client->fd );
 265     set_error( STATUS_PIPE_DISCONNECTED );
 266     return NULL;
 267 }
 268
 269 static struct fd *pipe_server_get_fd( struct object *obj )
 270 {
 271     struct pipe_server *server = (struct pipe_server *) obj;
 272
 273     switch(server->state)
 274     {
 275     case ps_connected_server:
 276     case ps_wait_disconnect:
 277         assert( server->fd );
 278         return (struct fd *) grab_object( server->fd );
 279
 280     case ps_wait_open:
 281     case ps_idle_server:
 282         set_error( STATUS_PIPE_LISTENING );
 283         break;
 284
 285     case ps_disconnected_server:
 286     case ps_wait_connect:
 287         set_error( STATUS_PIPE_DISCONNECTED );
 288         break;
 289     }
 290     return NULL;
 291 }
 292
 293
 294 static void notify_empty( struct pipe_server *server )
 295 {
 296     if( !server->flush_poll )
 297         return;
 298     assert( server->state == ps_connected_server );
 299     assert( server->event );
 300     remove_timeout_user( server->flush_poll );
 301     server->flush_poll = NULL;
 302     set_event( server->event );
 303     release_object( server->event );
 304     server->event = NULL;
 305 }
 306
 307 static void do_disconnect( struct pipe_server *server )
 308 {
 309     /* we may only have a server fd, if the client disconnected */
 310     if( server->client )
 311     {
 312         assert( server->client->server == server );
 313         assert( server->client->fd );
 314         release_object( server->client->fd );
 315         server->client->fd = NULL;
 316     }
 317     assert( server->fd );
 318     release_object( server->fd );
 319     server->fd = NULL;
 320 }
 321
 322 static void pipe_server_destroy( struct object *obj)
 323 {
 324     struct pipe_server *server = (struct pipe_server *)obj;
 325
 326     assert( obj->ops == &pipe_server_ops );
 327
 328     if( server->fd )
 329     {
 330         notify_empty( server );
 331         do_disconnect( server );
 332     }
 333
 334     if( server->client )
 335     {
 336         server->client->server = NULL;
 337         server->client = NULL;
 338     }
 339
 340     notify_waiter( &server->wait, STATUS_HANDLES_CLOSED );
 341
 342     assert( server->pipe->instances );
 343     server->pipe->instances--;
 344
 345     list_remove( &server->entry );
 346     release_object( server->pipe );
 347 }
 348
 349 static void pipe_client_destroy( struct object *obj)
 350 {
 351     struct pipe_client *client = (struct pipe_client *)obj;
 352     struct pipe_server *server = client->server;
 353
 354     assert( obj->ops == &pipe_client_ops );
 355
 356     notify_waiter( &client->wait, STATUS_HANDLES_CLOSED );
 357
 358     if( server )
 359     {
 360         notify_empty( server );
 361
 362         switch( server->state )
 363         {
 364         case ps_connected_server:
 365             /* Don't destroy the server's fd here as we can't
 366                do a successful flush without it. */
 367             server->state = ps_wait_disconnect;
 368             release_object( client->fd );
 369             client->fd = NULL;
 370             break;
 371         case ps_disconnected_server:
 372             server->state = ps_wait_connect;
 373             break;
 374         case ps_idle_server:
 375         case ps_wait_open:
 376         case ps_wait_disconnect:
 377         case ps_wait_connect:
 378             assert( 0 );
 379         }
 380         assert( server->client );
 381         server->client = NULL;
 382         client->server = NULL;
 383     }
 384     assert( !client->fd );
 385 }
 386
 387 static int pipe_end_get_poll_events( struct fd *fd )
 388 {
 389     return POLLIN | POLLOUT;  /* FIXME */
 390 }
 391
 392 static int pipe_data_remaining( struct pipe_server *server )
 393 {
 394     struct pollfd pfd;
 395     int fd;
 396
 397     assert( server->client );
 398
 399     fd = get_unix_fd( server->client->fd );
 400     if( fd < 0 )
 401         return 0;
 402     pfd.fd = fd;
 403     pfd.events = POLLIN;
 404     pfd.revents = 0;
 405
 406     if( 0 > poll( &pfd, 1, 0 ) )
 407         return 0;
 408
 409     return pfd.revents&POLLIN;
 410 }
 411
 412 static void check_flushed( void *arg )
 413 {
 414     struct pipe_server *server = (struct pipe_server*) arg;
 415
 416     assert( server->event );
 417     if( pipe_data_remaining( server ) )
 418     {
 419         struct timeval tv;
 420
 421         gettimeofday( &tv, 0 );
 422         add_timeout( &tv, 100 );
 423         server->flush_poll = add_timeout_user( &tv, check_flushed, server );
 424     }
 425     else
 426     {
 427         /* notify_empty( server ); */
 428         server->flush_poll = NULL;
 429         set_event( server->event );
 430         release_object( server->event );
 431         server->event = NULL;
 432     }
 433 }
 434
 435 static int pipe_server_flush( struct fd *fd, struct event **event )
 436 {
 437     struct pipe_server *server = get_fd_user( fd );
 438
 439     if( !server )
 440         return 0;
 441
 442     if( server->state != ps_connected_server )
 443         return 0;
 444
 445     /* FIXME: if multiple threads flush the same pipe,
 446               maybe should create a list of processes to notify */
 447     if( server->flush_poll )
 448         return 0;
 449
 450     if( pipe_data_remaining( server ) )
 451     {
 452         struct timeval tv;
 453
 454         /* this kind of sux -
 455            there's no unix way to be alerted when a pipe becomes empty */
 456         server->event = create_event( NULL, 0, 0, 0 );
 457         if( !server->event )
 458             return 0;
 459         gettimeofday( &tv, 0 );
 460         add_timeout( &tv, 100 );
 461         server->flush_poll = add_timeout_user( &tv, check_flushed, server );
 462         *event = server->event;
 463     }
 464
 465     return 0;
 466 }
 467
 468 static int pipe_client_flush( struct fd *fd, struct event **event )
 469 {
 470     /* FIXME: what do we have to do for this? */
 471     return 0;
 472 }
 473
 474 static int pipe_end_get_info( struct fd *fd )
 475 {
 476     return 0;
 477 }
 478
 479 static struct named_pipe *create_named_pipe( const WCHAR *name, size_t len )
 480 {
 481     struct named_pipe *pipe;
 482
 483     pipe = create_named_object( sync_namespace, &named_pipe_ops, name, len );
 484     if( pipe )
 485     {
 486         if( get_error() != STATUS_OBJECT_NAME_COLLISION )
 487         {
 488             /* initialize it if it didn't already exist */
 489             pipe->instances = 0;
 490             list_init( &pipe->servers );
 491             list_init( &pipe->waiters );
 492         }
 493     }
 494     return pipe;
 495 }
 496
 497 static struct named_pipe *open_named_pipe( const WCHAR *name, size_t len )
 498 {
 499     struct object *obj;
 500
 501     if ((obj = find_object( sync_namespace, name, len )))
 502     {
 503         if (obj->ops == &named_pipe_ops) return (struct named_pipe *)obj;
 504         release_object( obj );
 505         set_error( STATUS_OBJECT_TYPE_MISMATCH );
 506     }
 507     else set_error( STATUS_OBJECT_NAME_NOT_FOUND );
 508
 509     return NULL;
 510 }
 511
 512 static struct pipe_server *get_pipe_server_obj( struct process *process,
 513                                 obj_handle_t handle, unsigned int access )
 514 {
 515     struct object *obj;
 516     obj = get_handle_obj( process, handle, access, &pipe_server_ops );
 517     return (struct pipe_server *) obj;
 518 }
 519
 520 static struct pipe_server *create_pipe_server( struct named_pipe *pipe )
 521 {
 522     struct pipe_server *server;
 523
 524     server = alloc_object( &pipe_server_ops );
 525     if( !server )
 526         return NULL;
 527
 528     server->fd = NULL;
 529     server->pipe = pipe;
 530     server->state = ps_idle_server;
 531     server->client = NULL;
 532     server->flush_poll = NULL;
 533     server->wait.thread = NULL;
 534
 535     list_add_head( &pipe->servers, &server->entry );
 536     grab_object( pipe );
 537
 538     return server;
 539 }
 540
 541 static struct pipe_client *create_pipe_client( struct pipe_server *server )
 542 {
 543     struct pipe_client *client;
 544
 545     client = alloc_object( &pipe_client_ops );
 546     if( !client )
 547         return NULL;
 548
 549     client->fd = NULL;
 550     client->server = server;
 551     client->wait.thread = NULL;
 552
 553     return client;
 554 }
 555
 556 static inline struct pipe_server *find_server( struct named_pipe *pipe, enum pipe_state state )
 557 {
 558     struct pipe_server *server;
 559
 560     LIST_FOR_EACH_ENTRY( server, &pipe->servers, struct pipe_server, entry )
 561     {
 562         if (server->state == state) return (struct pipe_server *)grab_object( server );
 563     }
 564     return NULL;
 565 }
 566
 567 static inline struct pipe_server *find_server2( struct named_pipe *pipe,
 568                                                 enum pipe_state state1, enum pipe_state state2 )
 569 {
 570     struct pipe_server *server;
 571
 572     LIST_FOR_EACH_ENTRY( server, &pipe->servers, struct pipe_server, entry )
 573     {
 574         if (server->state == state1 || server->state == state2)
 575             return (struct pipe_server *)grab_object( server );
 576     }
 577     return NULL;
 578 }
 579
 580 DECL_HANDLER(create_named_pipe)
 581 {
 582     struct named_pipe *pipe;
 583     struct pipe_server *server;
 584
 585     reply->handle = 0;
 586     pipe = create_named_pipe( get_req_data(), get_req_data_size() );
 587     if( !pipe )
 588         return;
 589
 590     if( get_error() != STATUS_OBJECT_NAME_COLLISION )
 591     {
 592         pipe->insize = req->insize;
 593         pipe->outsize = req->outsize;
 594         pipe->maxinstances = req->maxinstances;
 595         pipe->timeout = req->timeout;
 596         pipe->pipemode = req->pipemode;
 597     }
 598     else
 599     {
 600         set_error( 0 );  /* clear the name collision */
 601         if( pipe->maxinstances <= pipe->instances )
 602         {
 603             set_error( STATUS_PIPE_BUSY );
 604             release_object( pipe );
 605             return;
 606         }
 607         if( ( pipe->maxinstances != req->maxinstances ) ||
 608             ( pipe->timeout != req->timeout ) ||
 609             ( pipe->pipemode != req->pipemode ) )
 610         {
 611             set_error( STATUS_ACCESS_DENIED );
 612             release_object( pipe );
 613             return;
 614         }
 615     }
 616
 617     server = create_pipe_server( pipe );
 618     if(server)
 619     {
 620         reply->handle = alloc_handle( current->process, server,
 621                                       GENERIC_READ|GENERIC_WRITE, req->inherit );
 622         server->pipe->instances++;
 623         release_object( server );
 624     }
 625
 626     release_object( pipe );
 627 }
 628
 629 DECL_HANDLER(open_named_pipe)
 630 {
 631     struct pipe_server *server;
 632     struct pipe_client *client;
 633     struct named_pipe *pipe;
 634     int fds[2];
 635
 636     pipe = open_named_pipe( get_req_data(), get_req_data_size() );
 637     if ( !pipe )
 638     {
 639         set_error( STATUS_NO_SUCH_FILE );
 640         return;
 641     }
 642
 643     server = find_server2( pipe, ps_idle_server, ps_wait_open );
 644     release_object( pipe );
 645
 646     if ( !server )
 647     {
 648         set_error( STATUS_PIPE_NOT_AVAILABLE );
 649         return;
 650     }
 651
 652     client = create_pipe_client( server );
 653     if( client )
 654     {
 655         if( !socketpair( PF_UNIX, SOCK_STREAM, 0, fds ) )
 656         {
 657             assert( !client->fd );
 658             assert( !server->fd );
 659             client->fd = create_anonymous_fd( &pipe_server_fd_ops,
 660                                             fds[1], &client->obj );
 661             server->fd = create_anonymous_fd( &pipe_server_fd_ops,
 662                                             fds[0], &server->obj );
 663             if (client->fd && server->fd)
 664             {
 665                 if( server->state == ps_wait_open )
 666                     notify_waiter( &server->wait, STATUS_SUCCESS );
 667                 assert( !server->wait.thread );
 668                 server->state = ps_connected_server;
 669                 server->client = client;
 670                 client->server = server;
 671                 reply->handle = alloc_handle( current->process, client,
 672                                               req->access, req->inherit );
 673             }
 674         }
 675         else
 676             file_set_error();
 677
 678         release_object( client );
 679     }
 680     release_object( server );
 681 }
 682
 683 DECL_HANDLER(connect_named_pipe)
 684 {
 685     struct pipe_server *server;
 686
 687     server = get_pipe_server_obj(current->process, req->handle, 0);
 688     if(!server)
 689         return;
 690
 691     switch( server->state )
 692     {
 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, STATUS_SUCCESS );
 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     case ps_wait_open:
 711         set_error( STATUS_INVALID_HANDLE );
 712         break;
 713     }
 714
 715     release_object(server);
 716 }
 717
 718 DECL_HANDLER(wait_named_pipe)
 719 {
 720     struct named_pipe *pipe;
 721     struct pipe_server *server;
 722
 723     if (!(pipe = open_named_pipe( get_req_data(), get_req_data_size() )))
 724     {
 725         set_error( STATUS_PIPE_NOT_AVAILABLE );
 726         return;
 727     }
 728     server = find_server( pipe, ps_wait_open );
 729     if( server )
 730     {
 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 );
 736     }
 737     else
 738         queue_connect_waiter( pipe, req->func, req->overlapped );
 739
 740     release_object( pipe );
 741 }
 742
 743 DECL_HANDLER(disconnect_named_pipe)
 744 {
 745     struct pipe_server *server;
 746
 747     reply->fd = -1;
 748     server = get_pipe_server_obj( current->process, req->handle, 0 );
 749     if( !server )
 750         return;
 751     switch( server->state )
 752     {
 753     case ps_connected_server:
 754         assert( server->fd );
 755         assert( server->client );
 756         assert( server->client->fd );
 757
 758         notify_empty( server );
 759         notify_waiter( &server->client->wait, STATUS_PIPE_DISCONNECTED );
 760
 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;
 767
 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;
 775
 776     case ps_idle_server:
 777     case ps_wait_open:
 778     case ps_disconnected_server:
 779     case ps_wait_connect:
 780         set_error( STATUS_PIPE_DISCONNECTED );
 781         break;
 782     }
 783     release_object( server );
 784 }
 785
 786 DECL_HANDLER(get_named_pipe_info)
 787 {
 788     struct pipe_server *server;
 789
 790     server = get_pipe_server_obj( current->process, req->handle, 0 );
 791     if(!server)
 792         return;
 793
 794     reply->flags        = server->pipe->pipemode;
 795     reply->maxinstances = server->pipe->maxinstances;
 796     reply->insize       = server->pipe->insize;
 797     reply->outsize      = server->pipe->outsize;
 798
 799     release_object(server);
 800 }