server/console.c

   1 /*
   2  * Server-side console management
   3  *
   4  * Copyright (C) 1998 Alexandre Julliard
   5  *
   6  * FIXME: all this stuff is a hack to avoid breaking
   7  *        the client-side console support.
   8  */
   9
  10 #include <assert.h>
  11 #include <fcntl.h>
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <sys/errno.h>
  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 "winnt.h"
  23 #include "server/thread.h"
  24
  25 struct console
  26 {
  27     struct object  obj;             /* object header */
  28     int            fd;              /* Unix file descriptor */
  29     int            is_read;         /* is this the read or write part? */
  30 };
  31
  32 static void console_dump( struct object *obj, int verbose );
  33 static int console_add_queue( struct object *obj, struct wait_queue_entry *entry );
  34 static void console_remove_queue( struct object *obj, struct wait_queue_entry *entry );
  35 static int console_signaled( struct object *obj, struct thread *thread );
  36 static int console_get_read_fd( struct object *obj );
  37 static int console_get_write_fd( struct object *obj );
  38 static void console_destroy( struct object *obj );
  39
  40 static const struct object_ops console_ops =
  41 {
  42     console_dump,
  43     console_add_queue,
  44     console_remove_queue,
  45     console_signaled,
  46     no_satisfied,
  47     console_get_read_fd,
  48     console_get_write_fd,
  49     no_flush,
  50     console_destroy
  51 };
  52
  53 static const struct select_ops select_ops =
  54 {
  55     default_select_event,
  56     NULL   /* we never set a timeout on a console */
  57 };
  58
  59 int create_console( int fd, struct object *obj[2] )
  60 {
  61     struct console *console_read, *console_write;
  62     int read_fd, write_fd;
  63
  64     if ((read_fd = (fd != -1) ? dup(fd) : dup(0)) == -1)
  65     {
  66         file_set_error();
  67         return 0;
  68     }
  69     if ((write_fd = (fd != -1) ? dup(fd) : dup(0)) == -1)
  70     {
  71         file_set_error();
  72         close( read_fd );
  73         return 0;
  74     }
  75     if (!(console_read = mem_alloc( sizeof(struct console) )))
  76     {
  77         close( read_fd );
  78         close( write_fd );
  79         return 0;
  80     }
  81     if (!(console_write = mem_alloc( sizeof(struct console) )))
  82     {
  83         close( read_fd );
  84         close( write_fd );
  85         free( console_read );
  86         return 0;
  87     }
  88     init_object( &console_read->obj, &console_ops, NULL );
  89     init_object( &console_write->obj, &console_ops, NULL );
  90     console_read->fd       = read_fd;
  91     console_read->is_read  = 1;
  92     console_write->fd      = write_fd;
  93     console_write->is_read = 0;
  94     CLEAR_ERROR();
  95     obj[0] = &console_read->obj;
  96     obj[1] = &console_write->obj;
  97     return 1;
  98 }
  99
 100 int set_console_fd( int handle, int fd )
 101 {
 102     struct console *console;
 103
 104     if (!(console = (struct console *)get_handle_obj( current->process, handle,
 105                                                       0, &console_ops )))
 106         return 0;
 107     if ((fd = dup(fd)) == -1)
 108     {
 109         file_set_error();
 110         release_object( console );
 111         return 0;
 112     }
 113     close( console->fd );
 114     console->fd = fd;
 115     release_object( console );
 116     return 1;
 117 }
 118
 119 static void console_dump( struct object *obj, int verbose )
 120 {
 121     struct console *console = (struct console *)obj;
 122     assert( obj->ops == &console_ops );
 123     printf( "Console %s fd=%d\n",
 124             console->is_read ? "input" : "output", console->fd );
 125 }
 126
 127 static int console_add_queue( struct object *obj, struct wait_queue_entry *entry )
 128 {
 129     struct console *console = (struct console *)obj;
 130     assert( obj->ops == &console_ops );
 131     if (!obj->head)  /* first on the queue */
 132     {
 133         if (!add_select_user( console->fd,
 134                               console->is_read ? READ_EVENT : WRITE_EVENT,
 135                               &select_ops, console ))
 136         {
 137             SET_ERROR( ERROR_OUTOFMEMORY );
 138             return 0;
 139         }
 140     }
 141     add_queue( obj, entry );
 142     return 1;
 143 }
 144
 145 static void console_remove_queue( struct object *obj, struct wait_queue_entry *entry )
 146 {
 147     struct console *console = (struct console *)grab_object(obj);
 148     assert( obj->ops == &console_ops );
 149
 150     remove_queue( obj, entry );
 151     if (!obj->head)  /* last on the queue is gone */
 152         remove_select_user( console->fd );
 153     release_object( obj );
 154 }
 155
 156 static int console_signaled( struct object *obj, struct thread *thread )
 157 {
 158     fd_set fds;
 159     struct timeval tv = { 0, 0 };
 160     struct console *console = (struct console *)obj;
 161     assert( obj->ops == &console_ops );
 162
 163     FD_ZERO( &fds );
 164     FD_SET( console->fd, &fds );
 165     if (console->is_read)
 166         return select( console->fd + 1, &fds, NULL, NULL, &tv ) > 0;
 167     else
 168         return select( console->fd + 1, NULL, &fds, NULL, &tv ) > 0;
 169 }
 170
 171 static int console_get_read_fd( struct object *obj )
 172 {
 173     struct console *console = (struct console *)obj;
 174     assert( obj->ops == &console_ops );
 175
 176     if (!console->is_read)
 177     {
 178         SET_ERROR( ERROR_ACCESS_DENIED );
 179         return -1;
 180     }
 181     return dup( console->fd );
 182 }
 183
 184 static int console_get_write_fd( struct object *obj )
 185 {
 186     struct console *console = (struct console *)obj;
 187     assert( obj->ops == &console_ops );
 188
 189     if (console->is_read)
 190     {
 191         SET_ERROR( ERROR_ACCESS_DENIED );
 192         return -1;
 193     }
 194     return dup( console->fd );
 195 }
 196
 197 static void console_destroy( struct object *obj )
 198 {
 199     struct console *console = (struct console *)obj;
 200     assert( obj->ops == &console_ops );
 201     close( console->fd );
 202     free( console );
 203 }