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 struct named_pipe_device
 103 {
 104     struct object       obj;         /* object header */
 105     struct fd          *fd;          /* pseudo-fd for ioctls */
 106     struct namespace   *pipes;       /* named pipe namespace */
 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_signal,                    /* signal */
 121     no_get_fd,                    /* get_fd */
 122     no_lookup_name,               /* lookup_name */
 123     no_close_handle,              /* close_handle */
 124     named_pipe_destroy            /* destroy */
 125 };
 126
 127 /* server end functions */
 128 static void pipe_server_dump( struct object *obj, int verbose );
 129 static struct fd *pipe_server_get_fd( struct object *obj );
 130 static void pipe_server_destroy( struct object *obj);
 131 static int pipe_server_flush( struct fd *fd, struct event **event );
 132 static int pipe_server_get_info( struct fd *fd );
 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     no_signal,                    /* signal */
 143     pipe_server_get_fd,           /* get_fd */
 144     no_lookup_name,               /* lookup_name */
 145     no_close_handle,              /* close_handle */
 146     pipe_server_destroy           /* destroy */
 147 };
 148
 149 static const struct fd_ops pipe_server_fd_ops =
 150 {
 151     default_fd_get_poll_events,     /* get_poll_events */
 152     default_poll_event,           /* poll_event */
 153     pipe_server_flush,            /* flush */
 154     pipe_server_get_info,         /* get_file_info */
 155     default_fd_queue_async,       /* queue_async */
 156     default_fd_cancel_async,      /* cancel_async */
 157 };
 158
 159 /* client end functions */
 160 static void pipe_client_dump( struct object *obj, int verbose );
 161 static struct fd *pipe_client_get_fd( struct object *obj );
 162 static void pipe_client_destroy( struct object *obj );
 163 static int pipe_client_flush( struct fd *fd, struct event **event );
 164 static int pipe_client_get_info( struct fd *fd );
 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     no_signal,                    /* signal */
 175     pipe_client_get_fd,           /* get_fd */
 176     no_lookup_name,               /* lookup_name */
 177     no_close_handle,              /* close_handle */
 178     pipe_client_destroy           /* destroy */
 179 };
 180
 181 static const struct fd_ops pipe_client_fd_ops =
 182 {
 183     default_fd_get_poll_events,   /* get_poll_events */
 184     default_poll_event,           /* poll_event */
 185     pipe_client_flush,            /* flush */
 186     pipe_client_get_info,         /* get_file_info */
 187     default_fd_queue_async,       /* queue_async */
 188     default_fd_cancel_async       /* cancel_async */
 189 };
 190
 191 static void named_pipe_device_dump( struct object *obj, int verbose );
 192 static struct fd *named_pipe_device_get_fd( struct object *obj );
 193 static struct object *named_pipe_device_lookup_name( struct object *obj,
 194     struct unicode_str *name, unsigned int attr );
 195 static void named_pipe_device_destroy( struct object *obj );
 196
 197 static const struct object_ops named_pipe_device_ops =
 198 {
 199     sizeof(struct named_pipe_device), /* size */
 200     named_pipe_device_dump,           /* dump */
 201     no_add_queue,                     /* add_queue */
 202     NULL,                             /* remove_queue */
 203     NULL,                             /* signaled */
 204     no_satisfied,                     /* satisfied */
 205     no_signal,                        /* signal */
 206     named_pipe_device_get_fd,         /* get_fd */
 207     named_pipe_device_lookup_name,    /* lookup_name */
 208     no_close_handle,                  /* close_handle */
 209     named_pipe_device_destroy         /* destroy */
 210 };
 211
 212 static const struct fd_ops named_pipe_device_fd_ops =
 213 {
 214     default_fd_get_poll_events,   /* get_poll_events */
 215     default_poll_event,           /* poll_event */
 216     no_flush,                     /* flush */
 217     no_get_file_info,             /* get_file_info */
 218     default_fd_queue_async,       /* queue_async */
 219     default_fd_cancel_async       /* cancel_async */
 220 };
 221
 222 static void named_pipe_dump( struct object *obj, int verbose )
 223 {
 224     struct named_pipe *pipe = (struct named_pipe *) obj;
 225     assert( obj->ops == &named_pipe_ops );
 226     fprintf( stderr, "Named pipe " );
 227     dump_object_name( &pipe->obj );
 228     fprintf( stderr, "\n" );
 229 }
 230
 231 static void pipe_server_dump( struct object *obj, int verbose )
 232 {
 233     struct pipe_server *server = (struct pipe_server *) obj;
 234     assert( obj->ops == &pipe_server_ops );
 235     fprintf( stderr, "Named pipe server pipe=%p state=%d\n", server->pipe, server->state );
 236 }
 237
 238 static void pipe_client_dump( struct object *obj, int verbose )
 239 {
 240     struct pipe_client *client = (struct pipe_client *) obj;
 241     assert( obj->ops == &pipe_client_ops );
 242     fprintf( stderr, "Named pipe client server=%p\n", client->server );
 243 }
 244
 245 static void named_pipe_destroy( struct object *obj)
 246 {
 247     struct named_pipe *pipe = (struct named_pipe *) obj;
 248
 249     assert( list_empty( &pipe->servers ) );
 250     assert( !pipe->instances );
 251     async_terminate_queue( &pipe->waiters, STATUS_HANDLES_CLOSED );
 252 }
 253
 254 static struct fd *pipe_client_get_fd( struct object *obj )
 255 {
 256     struct pipe_client *client = (struct pipe_client *) obj;
 257     if (client->fd)
 258         return (struct fd *) grab_object( client->fd );
 259     set_error( STATUS_PIPE_DISCONNECTED );
 260     return NULL;
 261 }
 262
 263 static struct fd *pipe_server_get_fd( struct object *obj )
 264 {
 265     struct pipe_server *server = (struct pipe_server *) obj;
 266
 267     switch(server->state)
 268     {
 269     case ps_connected_server:
 270     case ps_wait_disconnect:
 271         assert( server->fd );
 272         return (struct fd *) grab_object( server->fd );
 273
 274     case ps_wait_open:
 275     case ps_idle_server:
 276         set_error( STATUS_PIPE_LISTENING );
 277         break;
 278
 279     case ps_disconnected_server:
 280     case ps_wait_connect:
 281         set_error( STATUS_PIPE_DISCONNECTED );
 282         break;
 283     }
 284     return NULL;
 285 }
 286
 287
 288 static void notify_empty( struct pipe_server *server )
 289 {
 290     if (!server->flush_poll)
 291         return;
 292     assert( server->state == ps_connected_server );
 293     assert( server->event );
 294     remove_timeout_user( server->flush_poll );
 295     server->flush_poll = NULL;
 296     set_event( server->event );
 297     release_object( server->event );
 298     server->event = NULL;
 299 }
 300
 301 static void do_disconnect( struct pipe_server *server )
 302 {
 303     /* we may only have a server fd, if the client disconnected */
 304     if (server->client)
 305     {
 306         assert( server->client->server == server );
 307         assert( server->client->fd );
 308         release_object( server->client->fd );
 309         server->client->fd = NULL;
 310     }
 311     assert( server->fd );
 312     release_object( server->fd );
 313     server->fd = NULL;
 314 }
 315
 316 static void pipe_server_destroy( struct object *obj)
 317 {
 318     struct pipe_server *server = (struct pipe_server *)obj;
 319
 320     assert( obj->ops == &pipe_server_ops );
 321
 322     if (server->fd)
 323     {
 324         notify_empty( server );
 325         do_disconnect( server );
 326     }
 327
 328     if (server->client)
 329     {
 330         server->client->server = NULL;
 331         server->client = NULL;
 332     }
 333
 334     async_terminate_head( &server->wait_q, STATUS_HANDLES_CLOSED );
 335
 336     assert( server->pipe->instances );
 337     server->pipe->instances--;
 338
 339     list_remove( &server->entry );
 340     release_object( server->pipe );
 341 }
 342
 343 static void pipe_client_destroy( struct object *obj)
 344 {
 345     struct pipe_client *client = (struct pipe_client *)obj;
 346     struct pipe_server *server = client->server;
 347
 348     assert( obj->ops == &pipe_client_ops );
 349
 350     if (server)
 351     {
 352         notify_empty( server );
 353
 354         switch(server->state)
 355         {
 356         case ps_connected_server:
 357             /* Don't destroy the server's fd here as we can't
 358                do a successful flush without it. */
 359             server->state = ps_wait_disconnect;
 360             release_object( client->fd );
 361             client->fd = NULL;
 362             break;
 363         case ps_disconnected_server:
 364             server->state = ps_wait_connect;
 365             break;
 366         case ps_idle_server:
 367         case ps_wait_open:
 368         case ps_wait_disconnect:
 369         case ps_wait_connect:
 370             assert( 0 );
 371         }
 372         assert( server->client );
 373         server->client = NULL;
 374         client->server = NULL;
 375     }
 376     assert( !client->fd );
 377 }
 378
 379 static void named_pipe_device_dump( struct object *obj, int verbose )
 380 {
 381     assert( obj->ops == &named_pipe_device_ops );
 382     fprintf( stderr, "Named pipe device\n" );
 383 }
 384
 385 static struct fd *named_pipe_device_get_fd( struct object *obj )
 386 {
 387     struct named_pipe_device *device = (struct named_pipe_device *)obj;
 388     return device->fd;
 389 }
 390
 391 static struct object *named_pipe_device_lookup_name( struct object *obj, struct unicode_str *name,
 392                                                      unsigned int attr )
 393 {
 394     struct named_pipe_device *device = (struct named_pipe_device*)obj;
 395     struct object *found;
 396
 397     assert( obj->ops == &named_pipe_device_ops );
 398     assert( device->pipes );
 399
 400     if ((found = find_object( device->pipes, name, attr | OBJ_CASE_INSENSITIVE )))
 401         name->len = 0;
 402
 403     return found;
 404 }
 405
 406 static void named_pipe_device_destroy( struct object *obj )
 407 {
 408     struct named_pipe_device *device = (struct named_pipe_device*)obj;
 409     assert( obj->ops == &named_pipe_device_ops );
 410     if (device->fd) release_object( device->fd );
 411     if (device->pipes) free( device->pipes );
 412 }
 413
 414 /* this will be deleted as soon an we fix wait_named_pipe */
 415 static struct named_pipe_device *named_pipe_device;
 416
 417 struct named_pipe_device *create_named_pipe_device( struct directory *root,
 418                                                     const struct unicode_str *name )
 419 {
 420     struct named_pipe_device *dev;
 421
 422     if ((dev = create_named_object_dir( root, name, 0, &named_pipe_device_ops )) &&
 423         get_error() != STATUS_OBJECT_NAME_EXISTS)
 424     {
 425         dev->pipes = NULL;
 426         if (!(dev->fd = alloc_pseudo_fd( &named_pipe_device_fd_ops, &dev->obj )) ||
 427             !(dev->pipes = create_namespace( 7 )))
 428         {
 429             release_object( dev );
 430             dev = NULL;
 431         }
 432     }
 433     named_pipe_device = dev;
 434     return dev;
 435 }
 436
 437 static int pipe_data_remaining( struct pipe_server *server )
 438 {
 439     struct pollfd pfd;
 440     int fd;
 441
 442     assert( server->client );
 443
 444     fd = get_unix_fd( server->client->fd );
 445     if (fd < 0)
 446         return 0;
 447     pfd.fd = fd;
 448     pfd.events = POLLIN;
 449     pfd.revents = 0;
 450
 451     if (0 > poll( &pfd, 1, 0 ))
 452         return 0;
 453
 454     return pfd.revents&POLLIN;
 455 }
 456
 457 static void check_flushed( void *arg )
 458 {
 459     struct pipe_server *server = (struct pipe_server*) arg;
 460
 461     assert( server->event );
 462     if (pipe_data_remaining( server ))
 463     {
 464         struct timeval tv;
 465
 466         gettimeofday( &tv, NULL );
 467         add_timeout( &tv, 100 );
 468         server->flush_poll = add_timeout_user( &tv, check_flushed, server );
 469     }
 470     else
 471     {
 472         /* notify_empty( server ); */
 473         server->flush_poll = NULL;
 474         set_event( server->event );
 475         release_object( server->event );
 476         server->event = NULL;
 477     }
 478 }
 479
 480 static int pipe_server_flush( struct fd *fd, struct event **event )
 481 {
 482     struct pipe_server *server = get_fd_user( fd );
 483
 484     if (!server)
 485         return 0;
 486
 487     if (server->state != ps_connected_server)
 488         return 0;
 489
 490     /* FIXME: if multiple threads flush the same pipe,
 491               maybe should create a list of processes to notify */
 492     if (server->flush_poll)
 493         return 0;
 494
 495     if (pipe_data_remaining( server ))
 496     {
 497         struct timeval tv;
 498
 499         /* this kind of sux -
 500            there's no unix way to be alerted when a pipe becomes empty */
 501         server->event = create_event( NULL, NULL, 0, 0, 0 );
 502         if (!server->event)
 503             return 0;
 504         gettimeofday( &tv, NULL );
 505         add_timeout( &tv, 100 );
 506         server->flush_poll = add_timeout_user( &tv, check_flushed, server );
 507         *event = server->event;
 508     }
 509
 510     return 0;
 511 }
 512
 513 static int pipe_client_flush( struct fd *fd, struct event **event )
 514 {
 515     /* FIXME: what do we have to do for this? */
 516     return 0;
 517 }
 518
 519 static inline int is_overlapped( unsigned int options )
 520 {
 521     return !(options & (FILE_SYNCHRONOUS_IO_ALERT | FILE_SYNCHRONOUS_IO_NONALERT));
 522 }
 523
 524 static int pipe_server_get_info( struct fd *fd )
 525 {
 526     struct pipe_server *server = get_fd_user( fd );
 527     int flags = FD_FLAG_AVAILABLE;
 528
 529     if (is_overlapped( server->options )) flags |= FD_FLAG_OVERLAPPED;
 530
 531     return flags;
 532 }
 533
 534 static int pipe_client_get_info( struct fd *fd )
 535 {
 536     struct pipe_client *client = get_fd_user( fd );
 537     int flags = FD_FLAG_AVAILABLE;
 538
 539     if (is_overlapped( client->flags )) flags |= FD_FLAG_OVERLAPPED;
 540
 541     return flags;
 542 }
 543
 544 static struct named_pipe *create_named_pipe( struct directory *root, const struct unicode_str *name,
 545                                              unsigned int attr )
 546 {
 547     struct object *obj;
 548     struct named_pipe *pipe = NULL;
 549     struct unicode_str new_name;
 550
 551     if (!name || !name->len) return alloc_object( &named_pipe_ops );
 552
 553     if (!(obj = find_object_dir( root, name, attr, &new_name ))) return NULL;
 554     if (!new_name.len)
 555     {
 556         if (attr & OBJ_OPENIF && obj->ops == &named_pipe_ops)
 557             set_error( STATUS_OBJECT_NAME_EXISTS );
 558         else
 559         {
 560             release_object( obj );
 561             obj = NULL;
 562             if (attr & OBJ_OPENIF)
 563                 set_error( STATUS_OBJECT_TYPE_MISMATCH );
 564             else
 565                 set_error( STATUS_OBJECT_NAME_COLLISION );
 566         }
 567         return (struct named_pipe *)obj;
 568     }
 569
 570     if (obj->ops != &named_pipe_device_ops)
 571         set_error( STATUS_OBJECT_TYPE_MISMATCH );
 572     else
 573     {
 574         struct named_pipe_device *dev = (struct named_pipe_device *)obj;
 575         if ((pipe = create_object( dev->pipes, &named_pipe_ops, &new_name, NULL )))
 576             clear_error();
 577     }
 578
 579     release_object( obj );
 580     return pipe;
 581 }
 582
 583 static struct pipe_server *get_pipe_server_obj( struct process *process,
 584                                 obj_handle_t handle, unsigned int access )
 585 {
 586     struct object *obj;
 587     obj = get_handle_obj( process, handle, access, &pipe_server_ops );
 588     return (struct pipe_server *) obj;
 589 }
 590
 591 static struct pipe_server *create_pipe_server( struct named_pipe *pipe, unsigned int options )
 592 {
 593     struct pipe_server *server;
 594
 595     server = alloc_object( &pipe_server_ops );
 596     if (!server)
 597         return NULL;
 598
 599     server->fd = NULL;
 600     server->pipe = pipe;
 601     server->state = ps_idle_server;
 602     server->client = NULL;
 603     server->flush_poll = NULL;
 604     server->options = options;
 605     list_init( &server->wait_q );
 606
 607     list_add_head( &pipe->servers, &server->entry );
 608     grab_object( pipe );
 609
 610     return server;
 611 }
 612
 613 static struct pipe_client *create_pipe_client( struct pipe_server *server, unsigned int flags )
 614 {
 615     struct pipe_client *client;
 616
 617     client = alloc_object( &pipe_client_ops );
 618     if (!client)
 619         return NULL;
 620
 621     client->fd = NULL;
 622     client->server = server;
 623     client->flags = flags;
 624
 625     return client;
 626 }
 627
 628 static inline struct pipe_server *find_server( struct named_pipe *pipe, enum pipe_state state )
 629 {
 630     struct pipe_server *server;
 631
 632     LIST_FOR_EACH_ENTRY( server, &pipe->servers, struct pipe_server, entry )
 633     {
 634         if (server->state == state) return (struct pipe_server *)grab_object( server );
 635     }
 636     return NULL;
 637 }
 638
 639 static inline struct pipe_server *find_server2( struct named_pipe *pipe,
 640                                                 enum pipe_state state1, enum pipe_state state2 )
 641 {
 642     struct pipe_server *server;
 643
 644     LIST_FOR_EACH_ENTRY( server, &pipe->servers, struct pipe_server, entry )
 645     {
 646         if (server->state == state1 || server->state == state2)
 647             return (struct pipe_server *)grab_object( server );
 648     }
 649     return NULL;
 650 }
 651
 652 DECL_HANDLER(create_named_pipe)
 653 {
 654     struct named_pipe *pipe;
 655     struct pipe_server *server;
 656     struct unicode_str name;
 657     struct directory *root = NULL;
 658
 659     reply->handle = 0;
 660     get_req_unicode_str( &name );
 661     if (req->rootdir && !(root = get_directory_obj( current->process, req->rootdir, 0 )))
 662         return;
 663
 664     pipe = create_named_pipe( root, &name, req->attributes | OBJ_OPENIF );
 665
 666     if (root) release_object( root );
 667     if (!pipe) return;
 668
 669     if (get_error() != STATUS_OBJECT_NAME_EXISTS)
 670     {
 671         /* initialize it if it didn't already exist */
 672         pipe->instances = 0;
 673         list_init( &pipe->servers );
 674         list_init( &pipe->waiters );
 675         pipe->insize = req->insize;
 676         pipe->outsize = req->outsize;
 677         pipe->maxinstances = req->maxinstances;
 678         pipe->timeout = req->timeout;
 679         pipe->flags = req->flags;
 680     }
 681     else
 682     {
 683         if (pipe->maxinstances <= pipe->instances)
 684         {
 685             set_error( STATUS_INSTANCE_NOT_AVAILABLE );
 686             release_object( pipe );
 687             return;
 688         }
 689         if ((pipe->maxinstances != req->maxinstances) ||
 690             (pipe->timeout != req->timeout) ||
 691             (pipe->flags != req->flags))
 692         {
 693             set_error( STATUS_ACCESS_DENIED );
 694             release_object( pipe );
 695             return;
 696         }
 697         set_error( 0 );  /* clear the name collision */
 698     }
 699
 700     server = create_pipe_server( pipe, req->options );
 701     if (server)
 702     {
 703         reply->handle = alloc_handle( current->process, server, req->access, req->attributes );
 704         server->pipe->instances++;
 705         release_object( server );
 706     }
 707
 708     release_object( pipe );
 709 }
 710
 711 DECL_HANDLER(open_named_pipe)
 712 {
 713     struct pipe_server *server;
 714     struct pipe_client *client;
 715     struct unicode_str name;
 716     struct directory *root = NULL;
 717     struct named_pipe *pipe;
 718     int fds[2];
 719
 720     get_req_unicode_str( &name );
 721     if (req->rootdir && !(root = get_directory_obj( current->process, req->rootdir, 0 )))
 722         return;
 723
 724     pipe = open_object_dir( root, &name, req->attributes, &named_pipe_ops );
 725
 726     if (root) release_object( root );
 727     if (!pipe) return;
 728
 729     server = find_server2( pipe, ps_idle_server, ps_wait_open );
 730     release_object( pipe );
 731
 732     if (!server)
 733     {
 734         set_error( STATUS_PIPE_NOT_AVAILABLE );
 735         return;
 736     }
 737
 738     client = create_pipe_client( server, req->flags );
 739     if (client)
 740     {
 741         if (!socketpair( PF_UNIX, SOCK_STREAM, 0, fds ))
 742         {
 743             int res = 0;
 744
 745             assert( !client->fd );
 746             assert( !server->fd );
 747
 748             /* for performance reasons, only set nonblocking mode when using
 749              * overlapped I/O. Otherwise, we will be doing too much busy
 750              * looping */
 751             if (is_overlapped( req->flags ))
 752                 res = fcntl( fds[1], F_SETFL, O_NONBLOCK );
 753             if ((res != -1) && is_overlapped( server->options ))
 754                 res = fcntl( fds[0], F_SETFL, O_NONBLOCK );
 755
 756             client->fd = create_anonymous_fd( &pipe_client_fd_ops,
 757                                             fds[1], &client->obj );
 758             server->fd = create_anonymous_fd( &pipe_server_fd_ops,
 759                                             fds[0], &server->obj );
 760             if (client->fd && server->fd && res != 1)
 761             {
 762                 if (server->state == ps_wait_open)
 763                     async_terminate_head( &server->wait_q, STATUS_SUCCESS );
 764                 assert( list_empty( &server->wait_q ) );
 765                 server->state = ps_connected_server;
 766                 server->client = client;
 767                 client->server = server;
 768                 reply->handle = alloc_handle( current->process, client, req->access, req->attributes );
 769             }
 770         }
 771         else
 772             file_set_error();
 773
 774         release_object( client );
 775     }
 776     release_object( server );
 777 }
 778
 779 DECL_HANDLER(connect_named_pipe)
 780 {
 781     struct pipe_server *server;
 782
 783     server = get_pipe_server_obj(current->process, req->handle, 0);
 784     if (!server)
 785         return;
 786
 787     switch(server->state)
 788     {
 789     case ps_idle_server:
 790     case ps_wait_connect:
 791         assert( !server->fd );
 792         server->state = ps_wait_open;
 793         create_async( current, NULL, &server->wait_q,
 794                       req->func, req->event, NULL );
 795         async_terminate_queue( &server->pipe->waiters, STATUS_SUCCESS );
 796         break;
 797     case ps_connected_server:
 798         assert( server->fd );
 799         set_error( STATUS_PIPE_CONNECTED );
 800         break;
 801     case ps_disconnected_server:
 802         set_error( STATUS_PIPE_BUSY );
 803         break;
 804     case ps_wait_disconnect:
 805         set_error( STATUS_NO_DATA_DETECTED );
 806         break;
 807     case ps_wait_open:
 808         set_error( STATUS_INVALID_HANDLE );
 809         break;
 810     }
 811
 812     release_object(server);
 813 }
 814
 815 DECL_HANDLER(wait_named_pipe)
 816 {
 817     struct named_pipe *pipe;
 818     struct pipe_server *server;
 819     struct unicode_str name;
 820
 821     get_req_unicode_str( &name );
 822     pipe = (struct named_pipe *)find_object( named_pipe_device->pipes, &name, OBJ_CASE_INSENSITIVE );
 823     if (!pipe)
 824     {
 825         set_error( STATUS_PIPE_NOT_AVAILABLE );
 826         return;
 827     }
 828     server = find_server( pipe, ps_wait_open );
 829     if (server)
 830     {
 831         /* there's already a server waiting for a client to connect */
 832         thread_queue_apc( current, NULL, req->func, APC_ASYNC_IO,
 833                           1, req->overlapped, NULL, (void *)STATUS_SUCCESS );
 834         release_object( server );
 835     }
 836     else
 837     {
 838         int timeout;
 839         if (req->timeout == NMPWAIT_USE_DEFAULT_WAIT)
 840             timeout = pipe->timeout;
 841         else
 842             timeout = req->timeout;
 843
 844         if (req->timeout == NMPWAIT_WAIT_FOREVER)
 845             create_async( current, NULL, &pipe->waiters,
 846                           req->func, req->overlapped, NULL );
 847         else
 848             create_async( current, &timeout, &pipe->waiters,
 849                           req->func, req->overlapped, NULL );
 850     }
 851
 852     release_object( pipe );
 853 }
 854
 855 DECL_HANDLER(disconnect_named_pipe)
 856 {
 857     struct pipe_server *server;
 858
 859     reply->fd = -1;
 860     server = get_pipe_server_obj( current->process, req->handle, 0 );
 861     if (!server)
 862         return;
 863     switch(server->state)
 864     {
 865     case ps_connected_server:
 866         assert( server->fd );
 867         assert( server->client );
 868         assert( server->client->fd );
 869
 870         notify_empty( server );
 871
 872         /* Dump the client and server fds, but keep the pointers
 873            around - client loses all waiting data */
 874         server->state = ps_disconnected_server;
 875         do_disconnect( server );
 876         reply->fd = flush_cached_fd( current->process, req->handle );
 877         break;
 878
 879     case ps_wait_disconnect:
 880         assert( !server->client );
 881         assert( server->fd );
 882         do_disconnect( server );
 883         server->state = ps_wait_connect;
 884         reply->fd = flush_cached_fd( current->process, req->handle );
 885         break;
 886
 887     case ps_idle_server:
 888     case ps_wait_open:
 889     case ps_disconnected_server:
 890     case ps_wait_connect:
 891         set_error( STATUS_PIPE_DISCONNECTED );
 892         break;
 893     }
 894     release_object( server );
 895 }
 896
 897 DECL_HANDLER(get_named_pipe_info)
 898 {
 899     struct pipe_server *server;
 900
 901     server = get_pipe_server_obj( current->process, req->handle, 0 );
 902     if (!server)
 903         return;
 904
 905     reply->flags        = server->pipe->flags;
 906     reply->maxinstances = server->pipe->maxinstances;
 907     reply->insize       = server->pipe->insize;
 908     reply->outsize      = server->pipe->outsize;
 909
 910     release_object(server);
 911 }