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 <signal.h>
  13 #include <string.h>
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <sys/errno.h>
  17 #include <sys/stat.h>
  18 #include <sys/time.h>
  19 #include <sys/types.h>
  20 #include <time.h>
  21 #include <unistd.h>
  22
  23 #include "winerror.h"
  24 #include "winnt.h"
  25 #include "wincon.h"
  26
  27 #include "handle.h"
  28 #include "process.h"
  29 #include "thread.h"
  30
  31 struct screen_buffer;
  32
  33 struct console_input
  34 {
  35     struct object         obj;           /* object header */
  36     struct select_user    select;        /* select user */
  37     int                   mode;          /* input mode */
  38     struct screen_buffer *output;        /* associated screen buffer */
  39     int                   recnum;        /* number of input records */
  40     INPUT_RECORD         *records;       /* input records */
  41 };
  42
  43 struct screen_buffer
  44 {
  45     struct object         obj;           /* object header */
  46     struct select_user    select;        /* select user */
  47     int                   mode;          /* output mode */
  48     struct console_input *input;         /* associated console input */
  49     int                   cursor_size;   /* size of cursor (percentage filled) */
  50     int                   cursor_visible;/* cursor visibility flag */
  51     int                   pid;           /* xterm pid (hack) */
  52     char                 *title;         /* console title */
  53 };
  54
  55
  56 static void console_input_dump( struct object *obj, int verbose );
  57 static int console_input_add_queue( struct object *obj, struct wait_queue_entry *entry );
  58 static void console_input_remove_queue( struct object *obj, struct wait_queue_entry *entry );
  59 static int console_input_signaled( struct object *obj, struct thread *thread );
  60 static int console_input_get_read_fd( struct object *obj );
  61 static void console_input_destroy( struct object *obj );
  62
  63 static void screen_buffer_dump( struct object *obj, int verbose );
  64 static int screen_buffer_add_queue( struct object *obj, struct wait_queue_entry *entry );
  65 static void screen_buffer_remove_queue( struct object *obj, struct wait_queue_entry *entry );
  66 static int screen_buffer_signaled( struct object *obj, struct thread *thread );
  67 static int screen_buffer_get_write_fd( struct object *obj );
  68 static void screen_buffer_destroy( struct object *obj );
  69
  70 /* common routine */
  71 static int console_get_info( struct object *obj, struct get_file_info_reply *reply );
  72
  73 static const struct object_ops console_input_ops =
  74 {
  75     console_input_dump,
  76     console_input_add_queue,
  77     console_input_remove_queue,
  78     console_input_signaled,
  79     no_satisfied,
  80     console_input_get_read_fd,
  81     no_write_fd,
  82     no_flush,
  83     console_get_info,
  84     console_input_destroy
  85 };
  86
  87 static const struct object_ops screen_buffer_ops =
  88 {
  89     screen_buffer_dump,
  90     screen_buffer_add_queue,
  91     screen_buffer_remove_queue,
  92     screen_buffer_signaled,
  93     no_satisfied,
  94     no_read_fd,
  95     screen_buffer_get_write_fd,
  96     no_flush,
  97     console_get_info,
  98     screen_buffer_destroy
  99 };
 100
 101
 102 int create_console( int fd, struct object *obj[2] )
 103 {
 104     struct console_input *console_input;
 105     struct screen_buffer *screen_buffer;
 106     int read_fd, write_fd;
 107
 108     if ((read_fd = (fd != -1) ? dup(fd) : dup(0)) == -1)
 109     {
 110         file_set_error();
 111         return 0;
 112     }
 113     if ((write_fd = (fd != -1) ? dup(fd) : dup(1)) == -1)
 114     {
 115         file_set_error();
 116         close( read_fd );
 117         return 0;
 118     }
 119     if (!(console_input = mem_alloc( sizeof(struct console_input) )))
 120     {
 121         close( read_fd );
 122         close( write_fd );
 123         return 0;
 124     }
 125     if (!(screen_buffer = mem_alloc( sizeof(struct screen_buffer) )))
 126     {
 127         close( read_fd );
 128         close( write_fd );
 129         free( console_input );
 130         return 0;
 131     }
 132     init_object( &console_input->obj, &console_input_ops, NULL );
 133     init_object( &screen_buffer->obj, &screen_buffer_ops, NULL );
 134     console_input->select.fd      = read_fd;
 135     console_input->select.func    = default_select_event;
 136     console_input->select.private = console_input;
 137     console_input->mode           = ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT |
 138                                     ENABLE_ECHO_INPUT | ENABLE_MOUSE_INPUT;
 139     console_input->output         = screen_buffer;
 140     console_input->recnum         = 0;
 141     console_input->records        = NULL;
 142     screen_buffer->select.fd      = write_fd;
 143     screen_buffer->select.func    = default_select_event;
 144     screen_buffer->select.private = screen_buffer;
 145     screen_buffer->mode           = ENABLE_PROCESSED_OUTPUT | ENABLE_WRAP_AT_EOL_OUTPUT;
 146     screen_buffer->input          = console_input;
 147     screen_buffer->cursor_size    = 100;
 148     screen_buffer->cursor_visible = 1;
 149     screen_buffer->pid            = 0;
 150     screen_buffer->title          = strdup( "Wine console" );
 151     register_select_user( &console_input->select );
 152     register_select_user( &screen_buffer->select );
 153     CLEAR_ERROR();
 154     obj[0] = &console_input->obj;
 155     obj[1] = &screen_buffer->obj;
 156     return 1;
 157 }
 158
 159 static int set_console_fd( int handle, int fd, int pid )
 160 {
 161     struct console_input *input;
 162     struct screen_buffer *output;
 163     struct object *obj;
 164     int fd_in, fd_out;
 165
 166     if (!(obj = get_handle_obj( current->process, handle, 0, NULL )))
 167         return 0;
 168     if (obj->ops == &console_input_ops)
 169     {
 170         input = (struct console_input *)obj;
 171         output = input->output;
 172         grab_object( output );
 173     }
 174     else if (obj->ops == &screen_buffer_ops)
 175     {
 176         output = (struct screen_buffer *)obj;
 177         input = output->input;
 178         grab_object( input );
 179     }
 180     else
 181     {
 182         SET_ERROR( ERROR_INVALID_HANDLE );
 183         release_object( obj );
 184         return 0;
 185     }
 186
 187     /* can't change the fd if someone is waiting on it */
 188     assert( !input->obj.head );
 189     assert( !output->obj.head );
 190
 191     if ((fd_in = dup(fd)) == -1)
 192     {
 193         file_set_error();
 194         release_object( input );
 195         release_object( output );
 196         return 0;
 197     }
 198     if ((fd_out = dup(fd)) == -1)
 199     {
 200         file_set_error();
 201         close( fd_in );
 202         release_object( input );
 203         release_object( output );
 204         return 0;
 205     }
 206     unregister_select_user( &input->select );
 207     unregister_select_user( &output->select );
 208     close( input->select.fd );
 209     close( output->select.fd );
 210     input->select.fd  = fd_in;
 211     output->select.fd = fd_out;
 212     output->pid       = pid;
 213     register_select_user( &input->select );
 214     register_select_user( &output->select );
 215     release_object( input );
 216     release_object( output );
 217     return 1;
 218 }
 219
 220 static int get_console_mode( int handle, int *mode )
 221 {
 222     struct object *obj;
 223     int ret = 0;
 224
 225     if (!(obj = get_handle_obj( current->process, handle, GENERIC_READ, NULL )))
 226         return 0;
 227     if (obj->ops == &console_input_ops)
 228     {
 229         *mode = ((struct console_input *)obj)->mode;
 230         ret = 1;
 231     }
 232     else if (obj->ops == &screen_buffer_ops)
 233     {
 234         *mode = ((struct screen_buffer *)obj)->mode;
 235         ret = 1;
 236     }
 237     else SET_ERROR( ERROR_INVALID_HANDLE );
 238     release_object( obj );
 239     return ret;
 240 }
 241
 242 static int set_console_mode( int handle, int mode )
 243 {
 244     struct object *obj;
 245     int ret = 0;
 246
 247     if (!(obj = get_handle_obj( current->process, handle, GENERIC_READ, NULL )))
 248         return 0;
 249     if (obj->ops == &console_input_ops)
 250     {
 251         ((struct console_input *)obj)->mode = mode;
 252         ret = 1;
 253     }
 254     else if (obj->ops == &screen_buffer_ops)
 255     {
 256         ((struct screen_buffer *)obj)->mode = mode;
 257         ret = 1;
 258     }
 259     else SET_ERROR( ERROR_INVALID_HANDLE );
 260     release_object( obj );
 261     return ret;
 262 }
 263
 264 /* set misc console information (output handle only) */
 265 static int set_console_info( int handle, struct set_console_info_request *req, const char *title )
 266 {
 267     struct screen_buffer *console;
 268     if (!(console = (struct screen_buffer *)get_handle_obj( current->process, handle,
 269                                                             GENERIC_WRITE, &screen_buffer_ops )))
 270         return 0;
 271     if (req->mask & SET_CONSOLE_INFO_CURSOR)
 272     {
 273         console->cursor_size    = req->cursor_size;
 274         console->cursor_visible = req->cursor_visible;
 275     }
 276     if (req->mask & SET_CONSOLE_INFO_TITLE)
 277     {
 278         if (console->title) free( console->title );
 279         console->title = strdup( title );
 280     }
 281     release_object( console );
 282     return 1;
 283 }
 284
 285 /* get misc console information (output handle only) */
 286 static int get_console_info( int handle, struct get_console_info_reply *reply, const char **title )
 287 {
 288     struct screen_buffer *console;
 289     if (!(console = (struct screen_buffer *)get_handle_obj( current->process, handle,
 290                                                             GENERIC_READ, &screen_buffer_ops )))
 291         return 0;
 292     reply->cursor_size    = console->cursor_size;
 293     reply->cursor_visible = console->cursor_visible;
 294     reply->pid            = console->pid;
 295     *title                = console->title;
 296     release_object( console );
 297     return 1;
 298 }
 299
 300 /* add input events to a console input queue */
 301 static int write_console_input( int handle, int count, INPUT_RECORD *records )
 302 {
 303     INPUT_RECORD *new_rec;
 304     struct console_input *console;
 305
 306     if (!(console = (struct console_input *)get_handle_obj( current->process, handle,
 307                                                             GENERIC_WRITE, &console_input_ops )))
 308         return -1;
 309     if (!(new_rec = realloc( console->records,
 310                              (console->recnum + count) * sizeof(INPUT_RECORD) )))
 311     {
 312         SET_ERROR( ERROR_NOT_ENOUGH_MEMORY );
 313         release_object( console );
 314         return -1;
 315     }
 316     console->records = new_rec;
 317     memcpy( new_rec + console->recnum, records, count * sizeof(INPUT_RECORD) );
 318     console->recnum += count;
 319     release_object( console );
 320     return count;
 321 }
 322
 323 /* retrieve a pointer to the console input records */
 324 static int read_console_input( int handle, int count, int flush )
 325 {
 326     struct console_input *console;
 327
 328     if (!(console = (struct console_input *)get_handle_obj( current->process, handle,
 329                                                             GENERIC_READ, &console_input_ops )))
 330         return -1;
 331     if ((count < 0) || (count > console->recnum)) count = console->recnum;
 332     send_reply( current, -1, 1, console->records, count * sizeof(INPUT_RECORD) );
 333     if (flush)
 334     {
 335         int i;
 336         for (i = count; i < console->recnum; i++)
 337             console->records[i-count] = console->records[i];
 338         if ((console->recnum -= count) > 0)
 339         {
 340             INPUT_RECORD *new_rec = realloc( console->records,
 341                                              console->recnum * sizeof(INPUT_RECORD) );
 342             if (new_rec) console->records = new_rec;
 343         }
 344         else
 345         {
 346             free( console->records );
 347             console->records = NULL;
 348         }
 349     }
 350     release_object( console );
 351     return count;
 352 }
 353
 354 static void console_input_dump( struct object *obj, int verbose )
 355 {
 356     struct console_input *console = (struct console_input *)obj;
 357     assert( obj->ops == &console_input_ops );
 358     fprintf( stderr, "Console input fd=%d\n", console->select.fd );
 359 }
 360
 361 static int console_input_add_queue( struct object *obj, struct wait_queue_entry *entry )
 362 {
 363     struct console_input *console = (struct console_input *)obj;
 364     assert( obj->ops == &console_input_ops );
 365     if (!obj->head)  /* first on the queue */
 366         set_select_events( &console->select, READ_EVENT );
 367     add_queue( obj, entry );
 368     return 1;
 369 }
 370
 371 static void console_input_remove_queue( struct object *obj, struct wait_queue_entry *entry )
 372 {
 373     struct console_input *console = (struct console_input *)grab_object(obj);
 374     assert( obj->ops == &console_input_ops );
 375
 376     remove_queue( obj, entry );
 377     if (!obj->head)  /* last on the queue is gone */
 378         set_select_events( &console->select, 0 );
 379     release_object( obj );
 380 }
 381
 382 static int console_input_signaled( struct object *obj, struct thread *thread )
 383 {
 384     struct console_input *console = (struct console_input *)obj;
 385     assert( obj->ops == &console_input_ops );
 386
 387     if (check_select_events( &console->select, READ_EVENT ))
 388     {
 389         /* stop waiting on select() if we are signaled */
 390         set_select_events( &console->select, 0 );
 391         return 1;
 392     }
 393     else
 394     {
 395         /* restart waiting on select() if we are no longer signaled */
 396         if (obj->head) set_select_events( &console->select, READ_EVENT );
 397         return 0;
 398     }
 399 }
 400
 401 static int console_input_get_read_fd( struct object *obj )
 402 {
 403     struct console_input *console = (struct console_input *)obj;
 404     assert( obj->ops == &console_input_ops );
 405     return dup( console->select.fd );
 406 }
 407
 408 static int console_get_info( struct object *obj, struct get_file_info_reply *reply )
 409 {
 410     memset( reply, 0, sizeof(*reply) );
 411     reply->type = FILE_TYPE_CHAR;
 412     return 1;
 413 }
 414
 415 static void console_input_destroy( struct object *obj )
 416 {
 417     struct console_input *console = (struct console_input *)obj;
 418     assert( obj->ops == &console_input_ops );
 419     unregister_select_user( &console->select );
 420     close( console->select.fd );
 421     if (console->output) console->output->input = NULL;
 422     free( console );
 423 }
 424
 425 static void screen_buffer_dump( struct object *obj, int verbose )
 426 {
 427     struct screen_buffer *console = (struct screen_buffer *)obj;
 428     assert( obj->ops == &screen_buffer_ops );
 429     fprintf( stderr, "Console screen buffer fd=%d\n", console->select.fd );
 430 }
 431
 432 static int screen_buffer_add_queue( struct object *obj, struct wait_queue_entry *entry )
 433 {
 434     struct screen_buffer *console = (struct screen_buffer *)obj;
 435     assert( obj->ops == &screen_buffer_ops );
 436     if (!obj->head)  /* first on the queue */
 437         set_select_events( &console->select, WRITE_EVENT );
 438     add_queue( obj, entry );
 439     return 1;
 440 }
 441
 442 static void screen_buffer_remove_queue( struct object *obj, struct wait_queue_entry *entry )
 443 {
 444     struct screen_buffer *console = (struct screen_buffer *)grab_object(obj);
 445     assert( obj->ops == &screen_buffer_ops );
 446
 447     remove_queue( obj, entry );
 448     if (!obj->head)  /* last on the queue is gone */
 449         set_select_events( &console->select, 0 );
 450     release_object( obj );
 451 }
 452
 453 static int screen_buffer_signaled( struct object *obj, struct thread *thread )
 454 {
 455     struct screen_buffer *console = (struct screen_buffer *)obj;
 456     assert( obj->ops == &screen_buffer_ops );
 457
 458     if (check_select_events( &console->select, WRITE_EVENT ))
 459     {
 460         /* stop waiting on select() if we are signaled */
 461         set_select_events( &console->select, 0 );
 462         return 1;
 463     }
 464     else
 465     {
 466         /* restart waiting on select() if we are no longer signaled */
 467         if (obj->head) set_select_events( &console->select, WRITE_EVENT );
 468         return 0;
 469     }
 470 }
 471
 472 static int screen_buffer_get_write_fd( struct object *obj )
 473 {
 474     struct screen_buffer *console = (struct screen_buffer *)obj;
 475     assert( obj->ops == &screen_buffer_ops );
 476     return dup( console->select.fd );
 477 }
 478
 479 static void screen_buffer_destroy( struct object *obj )
 480 {
 481     struct screen_buffer *console = (struct screen_buffer *)obj;
 482     assert( obj->ops == &screen_buffer_ops );
 483     unregister_select_user( &console->select );
 484     close( console->select.fd );
 485     if (console->input) console->input->output = NULL;
 486     if (console->pid) kill( console->pid, SIGTERM );
 487     if (console->title) free( console->title );
 488     free( console );
 489 }
 490
 491 /* allocate a console for the current process */
 492 DECL_HANDLER(alloc_console)
 493 {
 494     alloc_console( current->process );
 495     send_reply( current, -1, 0 );
 496 }
 497
 498 /* free the console of the current process */
 499 DECL_HANDLER(free_console)
 500 {
 501     free_console( current->process );
 502     send_reply( current, -1, 0 );
 503 }
 504
 505 /* open a handle to the process console */
 506 DECL_HANDLER(open_console)
 507 {
 508     struct object *obj;
 509     struct open_console_reply reply = { -1 };
 510     if ((obj = get_console( current->process, req->output )))
 511     {
 512         reply.handle = alloc_handle( current->process, obj, req->access, req->inherit );
 513         release_object( obj );
 514     }
 515     send_reply( current, -1, 1, &reply, sizeof(reply) );
 516 }
 517
 518 /* set info about a console (output only) */
 519 DECL_HANDLER(set_console_info)
 520 {
 521     char *name = (char *)data;
 522     if (!len) name = NULL;
 523     else CHECK_STRING( "set_console_info", name, len );
 524     set_console_info( req->handle, req, name );
 525     send_reply( current, -1, 0 );
 526 }
 527
 528 /* get info about a console (output only) */
 529 DECL_HANDLER(get_console_info)
 530 {
 531     struct get_console_info_reply reply;
 532     const char *title;
 533     get_console_info( req->handle, &reply, &title );
 534     send_reply( current, -1, 2, &reply, sizeof(reply),
 535                 title, title ? strlen(title)+1 : 0 );
 536 }
 537
 538 /* set a console fd */
 539 DECL_HANDLER(set_console_fd)
 540 {
 541     set_console_fd( req->handle, fd, req->pid );
 542     send_reply( current, -1, 0 );
 543 }
 544
 545 /* get a console mode (input or output) */
 546 DECL_HANDLER(get_console_mode)
 547 {
 548     struct get_console_mode_reply reply;
 549     get_console_mode( req->handle, &reply.mode );
 550     send_reply( current, -1, 1, &reply, sizeof(reply) );
 551 }
 552
 553 /* set a console mode (input or output) */
 554 DECL_HANDLER(set_console_mode)
 555 {
 556     set_console_mode( req->handle, req->mode );
 557     send_reply( current, -1, 0 );
 558 }
 559
 560 /* add input records to a console input queue */
 561 DECL_HANDLER(write_console_input)
 562 {
 563     struct write_console_input_reply reply;
 564     INPUT_RECORD *records = (INPUT_RECORD *)data;
 565
 566     if (len != req->count * sizeof(INPUT_RECORD))
 567         fatal_protocol_error( "write_console_input: bad length %d for %d records\n",
 568                               len, req->count );
 569     reply.written = write_console_input( req->handle, req->count, records );
 570     send_reply( current, -1, 1, &reply, sizeof(reply) );
 571 }
 572
 573 /* fetch input records from a console input queue */
 574 DECL_HANDLER(read_console_input)
 575 {
 576     read_console_input( req->handle, req->count, req->flush );
 577 }