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