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