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  * TODO:
   8  *   improve error handling
   9  */
  10
  11 #include "config.h"
  12
  13 #include <assert.h>
  14 #include <fcntl.h>
  15 #include <string.h>
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <sys/time.h>
  19 #include <sys/types.h>
  20 #include <sys/socket.h>
  21 #include <time.h>
  22 #include <unistd.h>
  23
  24 #include "winbase.h"
  25
  26 #include "handle.h"
  27 #include "thread.h"
  28 #include "request.h"
  29
  30 enum pipe_state
  31 {
  32     ps_none,
  33     ps_idle_server,
  34     ps_wait_open,
  35     ps_wait_connect,
  36     ps_connected_server,
  37     ps_connected_client,
  38     ps_disconnected
  39 };
  40
  41 struct named_pipe;
  42
  43 struct pipe_user
  44 {
  45     struct object       obj;
  46     enum pipe_state     state;
  47     struct pipe_user   *other;
  48     struct named_pipe  *pipe;
  49     struct pipe_user   *next;
  50     struct pipe_user   *prev;
  51     struct event       *event;
  52 };
  53
  54 struct named_pipe
  55 {
  56     struct object       obj;         /* object header */
  57     unsigned int        pipemode;
  58     unsigned int        maxinstances;
  59     unsigned int        outsize;
  60     unsigned int        insize;
  61     unsigned int        timeout;
  62     struct pipe_user   *users;
  63 };
  64
  65 static void named_pipe_dump( struct object *obj, int verbose );
  66 static void named_pipe_destroy( struct object *obj);
  67
  68 static const struct object_ops named_pipe_ops =
  69 {
  70     sizeof(struct named_pipe),    /* size */
  71     named_pipe_dump,              /* dump */
  72     no_add_queue,                 /* add_queue */
  73     NULL,                         /* remove_queue */
  74     NULL,                         /* signaled */
  75     NULL,                         /* satisfied */
  76     NULL,                         /* get_poll_events */
  77     NULL,                         /* poll_event */
  78     no_get_fd,                    /* get_fd */
  79     no_flush,                     /* flush */
  80     no_get_file_info,             /* get_file_info */
  81     named_pipe_destroy            /* destroy */
  82 };
  83
  84 static void pipe_user_dump( struct object *obj, int verbose );
  85 static void pipe_user_destroy( struct object *obj);
  86 static int pipe_user_get_fd( struct object *obj );
  87
  88 static const struct object_ops pipe_user_ops =
  89 {
  90     sizeof(struct pipe_user),     /* size */
  91     pipe_user_dump,               /* dump */
  92     default_poll_add_queue,       /* add_queue */
  93     default_poll_remove_queue,    /* remove_queue */
  94     default_poll_signaled,        /* signaled */
  95     no_satisfied,                 /* satisfied */
  96     NULL,                         /* get_poll_events */
  97     default_poll_event,           /* poll_event */
  98     pipe_user_get_fd,             /* get_fd */
  99     no_flush,                     /* flush */
 100     no_get_file_info,             /* get_file_info */
 101     pipe_user_destroy             /* destroy */
 102 };
 103
 104 static void named_pipe_dump( struct object *obj, int verbose )
 105 {
 106     struct named_pipe *pipe = (struct named_pipe *)obj;
 107     assert( obj->ops == &named_pipe_ops );
 108     fprintf( stderr, "named pipe %p\n" ,pipe);
 109 }
 110
 111 static void pipe_user_dump( struct object *obj, int verbose )
 112 {
 113     struct pipe_user *user = (struct pipe_user *)obj;
 114     assert( obj->ops == &pipe_user_ops );
 115     fprintf( stderr, "named pipe user %p (state %d)\n", user, user->state );
 116 }
 117
 118 static void named_pipe_destroy( struct object *obj)
 119 {
 120     struct named_pipe *pipe = (struct named_pipe *)obj;
 121     assert( !pipe->users );
 122 }
 123
 124 static void pipe_user_destroy( struct object *obj)
 125 {
 126     struct pipe_user *user = (struct pipe_user *)obj;
 127
 128     assert( obj->ops == &pipe_user_ops );
 129
 130     if(user->event)
 131     {
 132         /* FIXME: signal waiter of failure */
 133         release_object(user->event);
 134         user->event = NULL;
 135     }
 136     if(user->other)
 137     {
 138         close(user->other->obj.fd);
 139         user->other->obj.fd = -1;
 140         switch(user->other->state)
 141         {
 142         case ps_connected_server:
 143             user->other->state = ps_idle_server;
 144             break;
 145         case ps_connected_client:
 146             user->other->state = ps_disconnected;
 147             break;
 148         default:
 149             fprintf(stderr,"connected pipe has strange state %d!\n",
 150                             user->other->state);
 151         }
 152         user->other->other=NULL;
 153         user->other = NULL;
 154     }
 155
 156     /* remove user from pipe's user list */
 157     if (user->next) user->next->prev = user->prev;
 158     if (user->prev) user->prev->next = user->next;
 159     else user->pipe->users = user->next;
 160     release_object(user->pipe);
 161 }
 162
 163 static int pipe_user_get_fd( struct object *obj )
 164 {
 165     struct pipe_user *user = (struct pipe_user *)obj;
 166     assert( obj->ops == &pipe_user_ops );
 167     return user->obj.fd;
 168 }
 169
 170 static struct named_pipe *create_named_pipe( const WCHAR *name, size_t len )
 171 {
 172     struct named_pipe *pipe;
 173
 174     if ((pipe = create_named_object( &named_pipe_ops, name, len )))
 175     {
 176         if (get_error() != STATUS_OBJECT_NAME_COLLISION)
 177         {
 178             /* initialize it if it didn't already exist */
 179             pipe->users = 0;
 180         }
 181     }
 182     return pipe;
 183 }
 184
 185 static struct pipe_user *get_pipe_user_obj( struct process *process, handle_t handle,
 186                                             unsigned int access )
 187 {
 188     return (struct pipe_user *)get_handle_obj( process, handle, access, &pipe_user_ops );
 189 }
 190
 191 static struct pipe_user *create_pipe_user( struct named_pipe *pipe, int fd )
 192 {
 193     struct pipe_user *user;
 194
 195     user = alloc_object( &pipe_user_ops, fd );
 196     if(!user)
 197         return NULL;
 198
 199     user->pipe = pipe;
 200     user->state = ps_none;
 201     user->event = NULL;   /* thread wait on this pipe */
 202     user->other = NULL;
 203
 204     /* add to list of pipe users */
 205     if ((user->next = pipe->users)) user->next->prev = user;
 206     user->prev = NULL;
 207     pipe->users = user;
 208
 209     grab_object(pipe);
 210
 211     return user;
 212 }
 213
 214 static struct pipe_user *find_partner(struct named_pipe *pipe, enum pipe_state state)
 215 {
 216     struct pipe_user *x;
 217
 218     for(x = pipe->users; x; x=x->next)
 219     {
 220         if(x->state==state)
 221         break;
 222     }
 223
 224     if(!x)
 225         return NULL;
 226
 227     return (struct pipe_user *)grab_object( x );
 228 }
 229
 230 DECL_HANDLER(create_named_pipe)
 231 {
 232     struct named_pipe *pipe;
 233     struct pipe_user *user;
 234
 235     req->handle = 0;
 236     pipe = create_named_pipe( get_req_data(req), get_req_data_size(req) );
 237     if(!pipe)
 238         return;
 239
 240     if (get_error() != STATUS_OBJECT_NAME_COLLISION)
 241     {
 242         pipe->insize = req->insize;
 243         pipe->outsize = req->outsize;
 244         pipe->maxinstances = req->maxinstances;
 245         pipe->timeout = req->timeout;
 246         pipe->pipemode = req->pipemode;
 247     }
 248
 249     user = create_pipe_user (pipe, -1);
 250
 251     if(user)
 252     {
 253         user->state = ps_idle_server;
 254         req->handle = alloc_handle( current->process, user, GENERIC_READ|GENERIC_WRITE, 0 );
 255         release_object( user );
 256     }
 257
 258     release_object( pipe );
 259 }
 260
 261 DECL_HANDLER(open_named_pipe)
 262 {
 263     struct named_pipe *pipe;
 264
 265     req->handle = 0;
 266     pipe = create_named_pipe( get_req_data(req), get_req_data_size(req) );
 267     if(!pipe)
 268         return;
 269
 270     if (get_error() == STATUS_OBJECT_NAME_COLLISION)
 271     {
 272         struct pipe_user *partner;
 273
 274         if ((partner = find_partner(pipe, ps_wait_open)))
 275         {
 276             int fds[2];
 277
 278             if(!socketpair(PF_UNIX, SOCK_STREAM, 0, fds))
 279             {
 280                 struct pipe_user *user;
 281
 282                 if( (user = create_pipe_user (pipe, fds[1])) )
 283                 {
 284                     partner->obj.fd = fds[0];
 285                     set_event(partner->event);
 286                     release_object(partner->event);
 287                     partner->event = NULL;
 288                     partner->state = ps_connected_server;
 289                     partner->other = user;
 290                     user->state = ps_connected_client;
 291                     user->other = partner;
 292                     req->handle = alloc_handle( current->process, user, req->access, 0 );
 293                     release_object(user);
 294                 }
 295                 else
 296                 {
 297                     close(fds[0]);
 298                 }
 299             }
 300             release_object( partner );
 301         }
 302         else
 303         {
 304             set_error(STATUS_PIPE_NOT_AVAILABLE);
 305         }
 306     }
 307     else
 308     {
 309         set_error(STATUS_NO_SUCH_FILE);
 310     }
 311
 312     release_object(pipe);
 313 }
 314
 315 DECL_HANDLER(connect_named_pipe)
 316 {
 317     struct pipe_user *user, *partner;
 318     struct event *event;
 319
 320     user = get_pipe_user_obj(current->process, req->handle, 0);
 321     if(!user)
 322         return;
 323
 324     if( user->state != ps_idle_server )
 325     {
 326         set_error(STATUS_PORT_ALREADY_SET);
 327     }
 328     else
 329     {
 330         user->state = ps_wait_open;
 331         event = get_event_obj(current->process, req->event, 0);
 332         if(event)
 333             user->event = event;
 334
 335         /* notify all waiters that a pipe just became available */
 336         while( (partner = find_partner(user->pipe,ps_wait_connect)) )
 337         {
 338             set_event(partner->event);
 339             release_object(partner->event);
 340             partner->event = NULL;
 341             release_object(partner);
 342             release_object(partner);
 343         }
 344     }
 345
 346     release_object(user);
 347 }
 348
 349 DECL_HANDLER(wait_named_pipe)
 350 {
 351     struct event *event;
 352     struct named_pipe *pipe;
 353
 354     event = get_event_obj(current->process, req->event, 0);
 355     if(!event)
 356         return;
 357
 358     pipe = create_named_pipe( get_req_data(req), get_req_data_size(req) );
 359     if( pipe )
 360     {
 361         /* only wait if the pipe already exists */
 362         if(get_error() == STATUS_OBJECT_NAME_COLLISION)
 363         {
 364             struct pipe_user *partner;
 365
 366             set_error(STATUS_SUCCESS);
 367             if( (partner = find_partner(pipe,ps_wait_open)) )
 368             {
 369                 set_event(event);
 370                 release_object(partner);
 371             }
 372             else
 373             {
 374                 struct pipe_user *user;
 375
 376                 if( (user = create_pipe_user (pipe, -1)) )
 377                 {
 378                     user->event = (struct event *)grab_object( event );
 379                     user->state = ps_wait_connect;
 380                     /* don't release it */
 381                 }
 382             }
 383         }
 384         else
 385         {
 386             set_error(STATUS_PIPE_NOT_AVAILABLE);
 387         }
 388         release_object(pipe);
 389     }
 390     release_object(event);
 391 }
 392
 393 DECL_HANDLER(disconnect_named_pipe)
 394 {
 395     struct pipe_user *user;
 396
 397     user = get_pipe_user_obj(current->process, req->handle, 0);
 398     if(!user)
 399         return;
 400     if( (user->state == ps_connected_server) &&
 401         (user->other->state == ps_connected_client) )
 402     {
 403         close(user->other->obj.fd);
 404         user->other->obj.fd = -1;
 405         user->other->state = ps_disconnected;
 406         user->other->other = NULL;
 407
 408         close(user->obj.fd);
 409         user->obj.fd = -1;
 410         user->state = ps_idle_server;
 411         user->other = NULL;
 412     }
 413     release_object(user);
 414 }
 415
 416 DECL_HANDLER(get_named_pipe_info)
 417 {
 418     struct pipe_user *user;
 419
 420     user = get_pipe_user_obj(current->process, req->handle, 0);
 421     if(!user)
 422         return;
 423
 424     req->flags        = user->pipe->pipemode;
 425     req->maxinstances = user->pipe->maxinstances;
 426     req->insize       = user->pipe->insize;
 427     req->outsize      = user->pipe->outsize;
 428
 429     release_object(user);
 430 }
 431