server/pipe.c

   1 /*
   2  * Server-side pipe management
   3  *
   4  * Copyright (C) 1998 Alexandre Julliard
   5  */
   6
   7 #include <assert.h>
   8 #include <fcntl.h>
   9 #include <string.h>
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #ifdef HAVE_SYS_ERRNO_H
  13 #include <sys/errno.h>
  14 #endif
  15 #include <sys/stat.h>
  16 #include <sys/time.h>
  17 #include <sys/types.h>
  18 #include <time.h>
  19 #include <unistd.h>
  20
  21 #include "winerror.h"
  22 #include "winbase.h"
  23
  24 #include "handle.h"
  25 #include "thread.h"
  26 #include "request.h"
  27
  28 enum side { READ_SIDE, WRITE_SIDE };
  29
  30 struct pipe
  31 {
  32     struct object       obj;         /* object header */
  33     struct pipe        *other;       /* the pipe other end */
  34     struct select_user  select;      /* select user */
  35     enum side           side;        /* which side of the pipe is this */
  36 };
  37
  38 static void pipe_dump( struct object *obj, int verbose );
  39 static int pipe_add_queue( struct object *obj, struct wait_queue_entry *entry );
  40 static void pipe_remove_queue( struct object *obj, struct wait_queue_entry *entry );
  41 static int pipe_signaled( struct object *obj, struct thread *thread );
  42 static int pipe_get_read_fd( struct object *obj );
  43 static int pipe_get_write_fd( struct object *obj );
  44 static int pipe_get_info( struct object *obj, struct get_file_info_request *req );
  45 static void pipe_destroy( struct object *obj );
  46
  47 static const struct object_ops pipe_ops =
  48 {
  49     sizeof(struct pipe),
  50     pipe_dump,
  51     pipe_add_queue,
  52     pipe_remove_queue,
  53     pipe_signaled,
  54     no_satisfied,
  55     pipe_get_read_fd,
  56     pipe_get_write_fd,
  57     no_flush,
  58     pipe_get_info,
  59     pipe_destroy
  60 };
  61
  62
  63 static struct pipe *create_pipe_side( int fd, int side )
  64 {
  65     struct pipe *pipe;
  66
  67     if ((pipe = alloc_object( &pipe_ops )))
  68     {
  69         pipe->select.fd      = fd;
  70         pipe->select.func    = default_select_event;
  71         pipe->select.private = pipe;
  72         pipe->other          = NULL;
  73         pipe->side           = side;
  74         register_select_user( &pipe->select );
  75     }
  76     return pipe;
  77 }
  78
  79 static int create_pipe( struct object *obj[2] )
  80 {
  81     struct pipe *read_pipe;
  82     struct pipe *write_pipe;
  83     int fd[2];
  84
  85     if (pipe( fd ) == -1)
  86     {
  87         file_set_error();
  88         return 0;
  89     }
  90     if ((read_pipe = create_pipe_side( fd[0], READ_SIDE )))
  91     {
  92         if ((write_pipe = create_pipe_side( fd[1], WRITE_SIDE )))
  93         {
  94             write_pipe->other = read_pipe;
  95             read_pipe->other  = write_pipe;
  96             obj[0] = &read_pipe->obj;
  97             obj[1] = &write_pipe->obj;
  98             return 1;
  99         }
 100         release_object( read_pipe );
 101     }
 102     close( fd[0] );
 103     close( fd[1] );
 104     return 0;
 105 }
 106
 107 static void pipe_dump( struct object *obj, int verbose )
 108 {
 109     struct pipe *pipe = (struct pipe *)obj;
 110     assert( obj->ops == &pipe_ops );
 111     fprintf( stderr, "Pipe %s-side fd=%d\n",
 112              (pipe->side == READ_SIDE) ? "read" : "write", pipe->select.fd );
 113 }
 114
 115 static int pipe_add_queue( struct object *obj, struct wait_queue_entry *entry )
 116 {
 117     struct pipe *pipe = (struct pipe *)obj;
 118     assert( obj->ops == &pipe_ops );
 119     if (!obj->head)  /* first on the queue */
 120         set_select_events( &pipe->select,
 121                            (pipe->side == READ_SIDE) ? READ_EVENT : WRITE_EVENT );
 122     add_queue( obj, entry );
 123     return 1;
 124 }
 125
 126 static void pipe_remove_queue( struct object *obj, struct wait_queue_entry *entry )
 127 {
 128     struct pipe *pipe = (struct pipe *)grab_object(obj);
 129     assert( obj->ops == &pipe_ops );
 130
 131     remove_queue( obj, entry );
 132     if (!obj->head)  /* last on the queue is gone */
 133         set_select_events( &pipe->select, 0 );
 134     release_object( obj );
 135 }
 136
 137 static int pipe_signaled( struct object *obj, struct thread *thread )
 138 {
 139     int event;
 140     struct pipe *pipe = (struct pipe *)obj;
 141     assert( obj->ops == &pipe_ops );
 142
 143     event = (pipe->side == READ_SIDE) ? READ_EVENT : WRITE_EVENT;
 144     if (check_select_events( &pipe->select, event ))
 145     {
 146         /* stop waiting on select() if we are signaled */
 147         set_select_events( &pipe->select, 0 );
 148         return 1;
 149     }
 150     else
 151     {
 152         /* restart waiting on select() if we are no longer signaled */
 153         if (obj->head) set_select_events( &pipe->select, event );
 154         return 0;
 155     }
 156 }
 157
 158 static int pipe_get_read_fd( struct object *obj )
 159 {
 160     struct pipe *pipe = (struct pipe *)obj;
 161     assert( obj->ops == &pipe_ops );
 162
 163     if (!pipe->other)
 164     {
 165         set_error( ERROR_BROKEN_PIPE );
 166         return -1;
 167     }
 168     if (pipe->side != READ_SIDE)  /* FIXME: should not be necessary */
 169     {
 170         set_error( ERROR_ACCESS_DENIED );
 171         return -1;
 172     }
 173     return dup( pipe->select.fd );
 174 }
 175
 176 static int pipe_get_write_fd( struct object *obj )
 177 {
 178     struct pipe *pipe = (struct pipe *)obj;
 179     assert( obj->ops == &pipe_ops );
 180
 181     if (!pipe->other)
 182     {
 183         set_error( ERROR_BROKEN_PIPE );
 184         return -1;
 185     }
 186     if (pipe->side != WRITE_SIDE)  /* FIXME: should not be necessary */
 187     {
 188         set_error( ERROR_ACCESS_DENIED );
 189         return -1;
 190     }
 191     return dup( pipe->select.fd );
 192 }
 193
 194 static int pipe_get_info( struct object *obj, struct get_file_info_request *req )
 195 {
 196     req->type        = FILE_TYPE_PIPE;
 197     req->attr        = 0;
 198     req->access_time = 0;
 199     req->write_time  = 0;
 200     req->size_high   = 0;
 201     req->size_low    = 0;
 202     req->links       = 0;
 203     req->index_high  = 0;
 204     req->index_low   = 0;
 205     req->serial      = 0;
 206     return 1;
 207 }
 208
 209 static void pipe_destroy( struct object *obj )
 210 {
 211     struct pipe *pipe = (struct pipe *)obj;
 212     assert( obj->ops == &pipe_ops );
 213
 214     if (pipe->other) pipe->other->other = NULL;
 215     unregister_select_user( &pipe->select );
 216     close( pipe->select.fd );
 217 }
 218
 219 /* create an anonymous pipe */
 220 DECL_HANDLER(create_pipe)
 221 {
 222     struct object *obj[2];
 223     int hread = -1, hwrite = -1;
 224
 225     if (create_pipe( obj ))
 226     {
 227         hread = alloc_handle( current->process, obj[0],
 228                               STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|GENERIC_READ,
 229                               req->inherit );
 230         if (hread != -1)
 231         {
 232             hwrite = alloc_handle( current->process, obj[1],
 233                                    STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|GENERIC_WRITE,
 234                                    req->inherit );
 235             if (hwrite == -1)
 236                 close_handle( current->process, hread );
 237         }
 238         release_object( obj[0] );
 239         release_object( obj[1] );
 240     }
 241     req->handle_read  = hread;
 242     req->handle_write = hwrite;
 243 }