server/console.c

   1 /*
   2  * Server-side console management
   3  *
   4  * Copyright (C) 1998 Alexandre Julliard
   5  *               2001 Eric Pouech
   6  * Copyright 2020 Jacek Caban for CodeWeavers
   7  *
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #include "config.h"
  25 #include "wine/port.h"
  26
  27 #include <assert.h>
  28 #include <string.h>
  29 #include <stdio.h>
  30 #include <unistd.h>
  31 #include <signal.h>
  32 #include <sys/ioctl.h>
  33 #include <termios.h>
  34
  35 #include "ntstatus.h"
  36 #define WIN32_NO_STATUS
  37 #include "handle.h"
  38 #include "process.h"
  39 #include "request.h"
  40 #include "file.h"
  41 #include "unicode.h"
  42 #include "wincon.h"
  43 #include "winternl.h"
  44 #include "wine/condrv.h"
  45
  46 struct screen_buffer;
  47
  48 struct history_line
  49 {
  50     data_size_t len;
  51     WCHAR       text[1];
  52 };
  53
  54 struct console_input
  55 {
  56     struct object                obj;           /* object header */
  57     int                          signaled;      /* is console signaled */
  58     int                          num_proc;      /* number of processes attached to this console */
  59     struct thread               *renderer;      /* console renderer thread */
  60     struct screen_buffer        *active;        /* active screen buffer */
  61     struct console_server       *server;        /* console server object */
  62     unsigned int                 last_id;       /* id of last created console buffer */
  63     struct fd                   *fd;            /* for bare console, attached input fd */
  64     struct async_queue           ioctl_q;       /* ioctl queue */
  65     struct async_queue           read_q;        /* read queue */
  66 };
  67
  68 static void console_input_dump( struct object *obj, int verbose );
  69 static void console_input_destroy( struct object *obj );
  70 static int console_input_signaled( struct object *obj, struct wait_queue_entry *entry );
  71 static struct fd *console_input_get_fd( struct object *obj );
  72 static struct object *console_input_lookup_name( struct object *obj, struct unicode_str *name, unsigned int attr );
  73 static struct object *console_input_open_file( struct object *obj, unsigned int access,
  74                                                unsigned int sharing, unsigned int options );
  75
  76 static const struct object_ops console_input_ops =
  77 {
  78     sizeof(struct console_input),     /* size */
  79     console_input_dump,               /* dump */
  80     no_get_type,                      /* get_type */
  81     add_queue,                        /* add_queue */
  82     remove_queue,                     /* remove_queue */
  83     console_input_signaled,           /* signaled */
  84     no_satisfied,                     /* satisfied */
  85     no_signal,                        /* signal */
  86     console_input_get_fd,             /* get_fd */
  87     default_fd_map_access,            /* map_access */
  88     default_get_sd,                   /* get_sd */
  89     default_set_sd,                   /* set_sd */
  90     no_get_full_name,                 /* get_full_name */
  91     console_input_lookup_name,        /* lookup_name */
  92     no_link_name,                     /* link_name */
  93     NULL,                             /* unlink_name */
  94     console_input_open_file,          /* open_file */
  95     no_kernel_obj_list,               /* get_kernel_obj_list */
  96     no_close_handle,                  /* close_handle */
  97     console_input_destroy             /* destroy */
  98 };
  99
 100 static enum server_fd_type console_get_fd_type( struct fd *fd );
 101 static void console_get_file_info( struct fd *fd, obj_handle_t handle, unsigned int info_class );
 102 static int console_input_read( struct fd *fd, struct async *async, file_pos_t pos );
 103 static int console_input_flush( struct fd *fd, struct async *async );
 104 static int console_input_ioctl( struct fd *fd, ioctl_code_t code, struct async *async );
 105
 106 static const struct fd_ops console_input_fd_ops =
 107 {
 108     default_fd_get_poll_events,   /* get_poll_events */
 109     default_poll_event,           /* poll_event */
 110     console_get_fd_type,          /* get_fd_type */
 111     console_input_read,           /* read */
 112     no_fd_write,                  /* write */
 113     console_input_flush,          /* flush */
 114     console_get_file_info,        /* get_file_info */
 115     no_fd_get_volume_info,        /* get_volume_info */
 116     console_input_ioctl,          /* ioctl */
 117     default_fd_queue_async,       /* queue_async */
 118     default_fd_reselect_async     /* reselect_async */
 119 };
 120
 121 struct console_host_ioctl
 122 {
 123     unsigned int          code;        /* ioctl code */
 124     int                   output;      /* output id for screen buffer ioctls */
 125     struct async         *async;       /* ioctl async */
 126     struct list           entry;       /* list entry */
 127 };
 128
 129 struct console_server
 130 {
 131     struct object         obj;         /* object header */
 132     struct fd            *fd;          /* pseudo-fd for ioctls */
 133     struct console_input *console;     /* attached console */
 134     struct list           queue;       /* ioctl queue */
 135     struct list           read_queue;  /* blocking read queue */
 136     int                   busy;        /* flag if server processing an ioctl */
 137     int                   term_fd;     /* UNIX terminal fd */
 138     struct termios        termios;     /* original termios */
 139 };
 140
 141 static void console_server_dump( struct object *obj, int verbose );
 142 static void console_server_destroy( struct object *obj );
 143 static int console_server_signaled( struct object *obj, struct wait_queue_entry *entry );
 144 static struct fd *console_server_get_fd( struct object *obj );
 145 static struct object *console_server_lookup_name( struct object *obj, struct unicode_str *name, unsigned int attr );
 146 static struct object *console_server_open_file( struct object *obj, unsigned int access,
 147                                                 unsigned int sharing, unsigned int options );
 148
 149 static const struct object_ops console_server_ops =
 150 {
 151     sizeof(struct console_server),    /* size */
 152     console_server_dump,              /* dump */
 153     no_get_type,                      /* get_type */
 154     add_queue,                        /* add_queue */
 155     remove_queue,                     /* remove_queue */
 156     console_server_signaled,          /* signaled */
 157     no_satisfied,                     /* satisfied */
 158     no_signal,                        /* signal */
 159     console_server_get_fd,            /* get_fd */
 160     default_fd_map_access,            /* map_access */
 161     default_get_sd,                   /* get_sd */
 162     default_set_sd,                   /* set_sd */
 163     no_get_full_name,                 /* get_full_name */
 164     console_server_lookup_name,       /* lookup_name */
 165     no_link_name,                     /* link_name */
 166     NULL,                             /* unlink_name */
 167     console_server_open_file,         /* open_file */
 168     no_kernel_obj_list,               /* get_kernel_obj_list */
 169     fd_close_handle,                  /* close_handle */
 170     console_server_destroy            /* destroy */
 171 };
 172
 173 static int console_server_ioctl( struct fd *fd, ioctl_code_t code, struct async *async );
 174
 175 static const struct fd_ops console_server_fd_ops =
 176 {
 177     default_fd_get_poll_events,   /* get_poll_events */
 178     default_poll_event,           /* poll_event */
 179     console_get_fd_type,          /* get_fd_type */
 180     no_fd_read,                   /* read */
 181     no_fd_write,                  /* write */
 182     no_fd_flush,                  /* flush */
 183     no_fd_get_file_info,          /* get_file_info */
 184     no_fd_get_volume_info,        /* get_volume_info */
 185     console_server_ioctl,         /* ioctl */
 186     default_fd_queue_async,       /* queue_async */
 187     default_fd_reselect_async     /* reselect_async */
 188 };
 189
 190 struct font_info
 191 {
 192     short int width;
 193     short int height;
 194     short int weight;
 195     short int pitch_family;
 196     WCHAR    *face_name;
 197     data_size_t face_len;
 198 };
 199
 200 struct screen_buffer
 201 {
 202     struct object         obj;           /* object header */
 203     struct list           entry;         /* entry in list of all screen buffers */
 204     struct console_input *input;         /* associated console input */
 205     unsigned int          id;            /* buffer id */
 206     struct fd            *fd;            /* for bare console, attached output fd */
 207     struct async_queue    ioctl_q;       /* ioctl queue */
 208 };
 209
 210 static void screen_buffer_dump( struct object *obj, int verbose );
 211 static void screen_buffer_destroy( struct object *obj );
 212 static int screen_buffer_add_queue( struct object *obj, struct wait_queue_entry *entry );
 213 static struct fd *screen_buffer_get_fd( struct object *obj );
 214 static struct object *screen_buffer_open_file( struct object *obj, unsigned int access,
 215                                                unsigned int sharing, unsigned int options );
 216
 217 static const struct object_ops screen_buffer_ops =
 218 {
 219     sizeof(struct screen_buffer),     /* size */
 220     screen_buffer_dump,               /* dump */
 221     no_get_type,                      /* get_type */
 222     screen_buffer_add_queue,          /* add_queue */
 223     NULL,                             /* remove_queue */
 224     NULL,                             /* signaled */
 225     NULL,                             /* satisfied */
 226     no_signal,                        /* signal */
 227     screen_buffer_get_fd,             /* get_fd */
 228     default_fd_map_access,            /* map_access */
 229     default_get_sd,                   /* get_sd */
 230     default_set_sd,                   /* set_sd */
 231     no_get_full_name,                 /* get_full_name */
 232     no_lookup_name,                   /* lookup_name */
 233     no_link_name,                     /* link_name */
 234     NULL,                             /* unlink_name */
 235     screen_buffer_open_file,          /* open_file */
 236     no_kernel_obj_list,               /* get_kernel_obj_list */
 237     no_close_handle,                  /* close_handle */
 238     screen_buffer_destroy             /* destroy */
 239 };
 240
 241 static int screen_buffer_write( struct fd *fd, struct async *async, file_pos_t pos );
 242 static int screen_buffer_ioctl( struct fd *fd, ioctl_code_t code, struct async *async );
 243
 244 static const struct fd_ops screen_buffer_fd_ops =
 245 {
 246     default_fd_get_poll_events,   /* get_poll_events */
 247     default_poll_event,           /* poll_event */
 248     console_get_fd_type,          /* get_fd_type */
 249     no_fd_read,                   /* read */
 250     screen_buffer_write,          /* write */
 251     no_fd_flush,                  /* flush */
 252     console_get_file_info,        /* get_file_info */
 253     no_fd_get_volume_info,        /* get_volume_info */
 254     screen_buffer_ioctl,          /* ioctl */
 255     default_fd_queue_async,       /* queue_async */
 256     default_fd_reselect_async     /* reselect_async */
 257 };
 258
 259 static struct object_type *console_device_get_type( struct object *obj );
 260 static void console_device_dump( struct object *obj, int verbose );
 261 static struct object *console_device_lookup_name( struct object *obj, struct unicode_str *name, unsigned int attr );
 262 static struct object *console_device_open_file( struct object *obj, unsigned int access,
 263                                                 unsigned int sharing, unsigned int options );
 264
 265 static const struct object_ops console_device_ops =
 266 {
 267     sizeof(struct object),            /* size */
 268     console_device_dump,              /* dump */
 269     console_device_get_type,          /* get_type */
 270     no_add_queue,                     /* add_queue */
 271     NULL,                             /* remove_queue */
 272     NULL,                             /* signaled */
 273     no_satisfied,                     /* satisfied */
 274     no_signal,                        /* signal */
 275     no_get_fd,                        /* get_fd */
 276     default_fd_map_access,            /* map_access */
 277     default_get_sd,                   /* get_sd */
 278     default_set_sd,                   /* set_sd */
 279     default_get_full_name,            /* get_full_name */
 280     console_device_lookup_name,       /* lookup_name */
 281     directory_link_name,              /* link_name */
 282     default_unlink_name,              /* unlink_name */
 283     console_device_open_file,         /* open_file */
 284     no_kernel_obj_list,               /* get_kernel_obj_list */
 285     no_close_handle,                  /* close_handle */
 286     no_destroy                        /* destroy */
 287 };
 288
 289 static void input_device_dump( struct object *obj, int verbose );
 290 static struct object *input_device_open_file( struct object *obj, unsigned int access,
 291                                               unsigned int sharing, unsigned int options );
 292 static int input_device_add_queue( struct object *obj, struct wait_queue_entry *entry );
 293 static struct fd *input_device_get_fd( struct object *obj );
 294
 295 static const struct object_ops input_device_ops =
 296 {
 297     sizeof(struct object),            /* size */
 298     input_device_dump,                /* dump */
 299     console_device_get_type,          /* get_type */
 300     input_device_add_queue,           /* add_queue */
 301     NULL,                             /* remove_queue */
 302     NULL,                             /* signaled */
 303     no_satisfied,                     /* satisfied */
 304     no_signal,                        /* signal */
 305     input_device_get_fd,              /* get_fd */
 306     no_map_access,                    /* map_access */
 307     default_get_sd,                   /* get_sd */
 308     default_set_sd,                   /* set_sd */
 309     no_get_full_name,                 /* get_full_name */
 310     no_lookup_name,                   /* lookup_name */
 311     directory_link_name,              /* link_name */
 312     default_unlink_name,              /* unlink_name */
 313     input_device_open_file,           /* open_file */
 314     no_kernel_obj_list,               /* get_kernel_obj_list */
 315     no_close_handle,                  /* close_handle */
 316     no_destroy                        /* destroy */
 317 };
 318
 319 static void output_device_dump( struct object *obj, int verbose );
 320 static int output_device_add_queue( struct object *obj, struct wait_queue_entry *entry );
 321 static struct fd *output_device_get_fd( struct object *obj );
 322 static struct object *output_device_open_file( struct object *obj, unsigned int access,
 323                                               unsigned int sharing, unsigned int options );
 324
 325 static const struct object_ops output_device_ops =
 326 {
 327     sizeof(struct object),            /* size */
 328     output_device_dump,               /* dump */
 329     console_device_get_type,          /* get_type */
 330     output_device_add_queue,          /* add_queue */
 331     NULL,                             /* remove_queue */
 332     NULL,                             /* signaled */
 333     no_satisfied,                     /* satisfied */
 334     no_signal,                        /* signal */
 335     output_device_get_fd,             /* get_fd */
 336     no_map_access,                    /* map_access */
 337     default_get_sd,                   /* get_sd */
 338     default_set_sd,                   /* set_sd */
 339     no_get_full_name,                 /* get_full_name */
 340     no_lookup_name,                   /* lookup_name */
 341     directory_link_name,              /* link_name */
 342     default_unlink_name,              /* unlink_name */
 343     output_device_open_file,          /* open_file */
 344     no_kernel_obj_list,               /* get_kernel_obj_list */
 345     no_close_handle,                  /* close_handle */
 346     no_destroy                        /* destroy */
 347 };
 348
 349 struct console_connection
 350 {
 351     struct object         obj;         /* object header */
 352     struct fd            *fd;          /* pseudo-fd for ioctls */
 353 };
 354
 355 static void console_connection_dump( struct object *obj, int verbose );
 356 static struct fd *console_connection_get_fd( struct object *obj );
 357 static struct object *console_connection_lookup_name( struct object *obj, struct unicode_str *name, unsigned int attr );
 358 static struct object *console_connection_open_file( struct object *obj, unsigned int access,
 359                                                     unsigned int sharing, unsigned int options );
 360 static int console_connection_close_handle( struct object *obj, struct process *process, obj_handle_t handle );
 361 static void console_connection_destroy( struct object *obj );
 362
 363 static const struct object_ops console_connection_ops =
 364 {
 365     sizeof(struct console_connection),/* size */
 366     console_connection_dump,          /* dump */
 367     console_device_get_type,          /* get_type */
 368     no_add_queue,                     /* add_queue */
 369     NULL,                             /* remove_queue */
 370     NULL,                             /* signaled */
 371     no_satisfied,                     /* satisfied */
 372     no_signal,                        /* signal */
 373     console_connection_get_fd,        /* get_fd */
 374     no_map_access,                    /* map_access */
 375     default_get_sd,                   /* get_sd */
 376     default_set_sd,                   /* set_sd */
 377     no_get_full_name,                 /* get_full_name */
 378     console_connection_lookup_name,   /* lookup_name */
 379     directory_link_name,              /* link_name */
 380     default_unlink_name,              /* unlink_name */
 381     console_connection_open_file,     /* open_file */
 382     no_kernel_obj_list,               /* get_kernel_obj_list */
 383     console_connection_close_handle,  /* close_handle */
 384     console_connection_destroy        /* destroy */
 385 };
 386
 387 static int console_connection_ioctl( struct fd *fd, ioctl_code_t code, struct async *async );
 388
 389 static const struct fd_ops console_connection_fd_ops =
 390 {
 391     default_fd_get_poll_events,   /* get_poll_events */
 392     default_poll_event,           /* poll_event */
 393     console_get_fd_type,          /* get_fd_type */
 394     no_fd_read,                   /* read */
 395     no_fd_write,                  /* write */
 396     no_fd_flush,                  /* flush */
 397     no_fd_get_file_info,          /* get_file_info */
 398     no_fd_get_volume_info,        /* get_volume_info */
 399     console_connection_ioctl,     /* ioctl */
 400     default_fd_queue_async,       /* queue_async */
 401     default_fd_reselect_async     /* reselect_async */
 402 };
 403
 404 static struct list screen_buffer_list = LIST_INIT(screen_buffer_list);
 405
 406 static int console_input_signaled( struct object *obj, struct wait_queue_entry *entry )
 407 {
 408     struct console_input *console = (struct console_input*)obj;
 409     return console->signaled;
 410 }
 411
 412 static struct fd *console_input_get_fd( struct object* obj )
 413 {
 414     struct console_input *console_input = (struct console_input*)obj;
 415     assert( obj->ops == &console_input_ops );
 416     return (struct fd *)grab_object( console_input->fd );
 417 }
 418
 419 static enum server_fd_type console_get_fd_type( struct fd *fd )
 420 {
 421     return FD_TYPE_CHAR;
 422 }
 423
 424 static void console_get_file_info( struct fd *fd, obj_handle_t handle, unsigned int info_class )
 425 {
 426     set_error( STATUS_INVALID_DEVICE_REQUEST );
 427 }
 428
 429 static struct object *create_console_input(void)
 430 {
 431     struct console_input *console_input;
 432
 433     if (!(console_input = alloc_object( &console_input_ops )))
 434         return NULL;
 435
 436     console_input->renderer      = NULL;
 437     console_input->signaled      = 0;
 438     console_input->num_proc      = 0;
 439     console_input->active        = NULL;
 440     console_input->server        = NULL;
 441     console_input->fd            = NULL;
 442     console_input->last_id       = 0;
 443     init_async_queue( &console_input->ioctl_q );
 444     init_async_queue( &console_input->read_q );
 445
 446     console_input->fd = alloc_pseudo_fd( &console_input_fd_ops, &console_input->obj,
 447                                          FILE_SYNCHRONOUS_IO_NONALERT );
 448     if (!console_input->fd)
 449     {
 450         release_object( console_input );
 451         return NULL;
 452     }
 453     allow_fd_caching( console_input->fd );
 454     return &console_input->obj;
 455 }
 456
 457 static void console_host_ioctl_terminate( struct console_host_ioctl *call, unsigned int status )
 458 {
 459     if (call->async)
 460     {
 461         async_terminate( call->async, status );
 462         release_object( call->async );
 463     }
 464     free( call );
 465 }
 466
 467 static int queue_host_ioctl( struct console_server *server, unsigned int code, unsigned int output,
 468                              struct async *async, struct async_queue *queue )
 469 {
 470     struct console_host_ioctl *ioctl;
 471
 472     if (!(ioctl = mem_alloc( sizeof(*ioctl) ))) return 0;
 473     ioctl->code   = code;
 474     ioctl->output = output;
 475     ioctl->async  = NULL;
 476     if (async)
 477     {
 478         ioctl->async = (struct async *)grab_object( async );
 479         queue_async( queue, async );
 480     }
 481     list_add_tail( &server->queue, &ioctl->entry );
 482     wake_up( &server->obj, 0 );
 483     if (async) set_error( STATUS_PENDING );
 484     return 1;
 485 }
 486
 487 static void disconnect_console_server( struct console_server *server )
 488 {
 489     while (!list_empty( &server->queue ))
 490     {
 491         struct console_host_ioctl *call = LIST_ENTRY( list_head( &server->queue ), struct console_host_ioctl, entry );
 492         list_remove( &call->entry );
 493         console_host_ioctl_terminate( call, STATUS_CANCELLED );
 494     }
 495     while (!list_empty( &server->read_queue ))
 496     {
 497         struct console_host_ioctl *call = LIST_ENTRY( list_head( &server->read_queue ), struct console_host_ioctl, entry );
 498         list_remove( &call->entry );
 499         console_host_ioctl_terminate( call, STATUS_CANCELLED );
 500     }
 501
 502     if (server->term_fd != -1)
 503     {
 504         tcsetattr( server->term_fd, TCSANOW, &server->termios );
 505         close( server->term_fd );
 506         server->term_fd = -1;
 507     }
 508
 509     if (server->console)
 510     {
 511         assert( server->console->server == server );
 512         server->console->server = NULL;
 513         server->console = NULL;
 514         wake_up( &server->obj, 0 );
 515     }
 516 }
 517
 518 static void set_active_screen_buffer( struct console_input *console_input, struct screen_buffer *screen_buffer )
 519 {
 520     if (console_input->active == screen_buffer) return;
 521     if (console_input->active) release_object( console_input->active );
 522     console_input->active = (struct screen_buffer *)grab_object( screen_buffer );
 523
 524     if (console_input->server) queue_host_ioctl( console_input->server, IOCTL_CONDRV_ACTIVATE,
 525                                                  screen_buffer->id, NULL, NULL );
 526 }
 527
 528 static struct object *create_console_output( struct console_input *console_input )
 529 {
 530     struct screen_buffer *screen_buffer;
 531
 532     if (console_input->last_id == ~0)
 533     {
 534         set_error( STATUS_NO_MEMORY );
 535         return NULL;
 536     }
 537
 538     if (!(screen_buffer = alloc_object( &screen_buffer_ops )))
 539         return NULL;
 540
 541     screen_buffer->id    = ++console_input->last_id;
 542     screen_buffer->input = console_input;
 543     init_async_queue( &screen_buffer->ioctl_q );
 544     list_add_head( &screen_buffer_list, &screen_buffer->entry );
 545
 546     screen_buffer->fd = alloc_pseudo_fd( &screen_buffer_fd_ops, &screen_buffer->obj,
 547                                          FILE_SYNCHRONOUS_IO_NONALERT );
 548     if (!screen_buffer->fd)
 549     {
 550         release_object( screen_buffer );
 551         return NULL;
 552     }
 553     allow_fd_caching(screen_buffer->fd);
 554
 555     if (console_input->server) queue_host_ioctl( console_input->server, IOCTL_CONDRV_INIT_OUTPUT,
 556                                                  screen_buffer->id, NULL, NULL );
 557     if (!console_input->active) set_active_screen_buffer( console_input, screen_buffer );
 558     return &screen_buffer->obj;
 559 }
 560
 561 /* free the console for this process */
 562 int free_console( struct process *process )
 563 {
 564     struct console_input* console = process->console;
 565
 566     if (!console) return 0;
 567
 568     process->console = NULL;
 569     console->num_proc--;
 570     release_object( console );
 571
 572     return 1;
 573 }
 574
 575 /* let process inherit the console from parent... this handle two cases :
 576  *      1/ generic console inheritance
 577  *      2/ parent is a renderer which launches process, and process should attach to the console
 578  *         rendered by parent
 579  */
 580 obj_handle_t inherit_console( struct thread *parent_thread, obj_handle_t handle, struct process *process,
 581                               obj_handle_t hconin )
 582 {
 583     struct console_input *console = NULL;
 584
 585     if (handle) return duplicate_handle( current->process, handle, process, 0, 0, DUP_HANDLE_SAME_ACCESS );
 586
 587     /* if parent is a renderer, then attach current process to its console
 588      * a bit hacky....
 589      */
 590     if (hconin && parent_thread)
 591     {
 592         /* FIXME: should we check some access rights ? */
 593         if (!(console = (struct console_input *)get_handle_obj( parent_thread->process, hconin,
 594                                                                 0, &console_input_ops )))
 595             clear_error();  /* ignore error */
 596     }
 597     if (!console) return 0;
 598
 599     process->console = console;
 600     console->num_proc++;
 601     return alloc_handle( process, process->console,
 602                          SYNCHRONIZE | GENERIC_READ | GENERIC_WRITE, 0 );
 603 }
 604
 605 struct thread *console_get_renderer( struct console_input *console )
 606 {
 607     return console->renderer;
 608 }
 609
 610 struct console_signal_info
 611 {
 612     struct console_input        *console;
 613     process_id_t                 group;
 614     int                          signal;
 615 };
 616
 617 static int propagate_console_signal_cb(struct process *process, void *user)
 618 {
 619     struct console_signal_info* csi = (struct console_signal_info*)user;
 620
 621     if (process->console == csi->console && process->running_threads &&
 622         (!csi->group || process->group_id == csi->group))
 623     {
 624         /* find a suitable thread to signal */
 625         struct thread *thread;
 626         LIST_FOR_EACH_ENTRY( thread, &process->thread_list, struct thread, proc_entry )
 627         {
 628             if (send_thread_signal( thread, csi->signal )) break;
 629         }
 630     }
 631     return FALSE;
 632 }
 633
 634 static void propagate_console_signal( struct console_input *console,
 635                                       int sig, process_id_t group_id )
 636 {
 637     struct console_signal_info csi;
 638
 639     if (!console)
 640     {
 641         set_error( STATUS_INVALID_PARAMETER );
 642         return;
 643     }
 644     /* FIXME: should support the other events (like CTRL_BREAK) */
 645     if (sig != CTRL_C_EVENT)
 646     {
 647         set_error( STATUS_NOT_IMPLEMENTED );
 648         return;
 649     }
 650     csi.console = console;
 651     csi.signal  = SIGINT;
 652     csi.group   = group_id;
 653
 654     enum_processes(propagate_console_signal_cb, &csi);
 655 }
 656
 657 /* dumb dump */
 658 static void console_input_dump( struct object *obj, int verbose )
 659 {
 660     struct console_input *console = (struct console_input *)obj;
 661     assert( obj->ops == &console_input_ops );
 662     fprintf( stderr, "Console input active=%p server=%p\n",
 663              console->active, console->server );
 664 }
 665
 666 static void console_input_destroy( struct object *obj )
 667 {
 668     struct console_input *console_in = (struct console_input *)obj;
 669     struct screen_buffer *curr;
 670
 671     assert( obj->ops == &console_input_ops );
 672
 673     if (console_in->server)
 674     {
 675         assert( console_in->server->console == console_in );
 676         disconnect_console_server( console_in->server );
 677     }
 678
 679     if (console_in->active) release_object( console_in->active );
 680     console_in->active = NULL;
 681
 682     LIST_FOR_EACH_ENTRY( curr, &screen_buffer_list, struct screen_buffer, entry )
 683     {
 684         if (curr->input == console_in) curr->input = NULL;
 685     }
 686
 687     free_async_queue( &console_in->ioctl_q );
 688     free_async_queue( &console_in->read_q );
 689     if (console_in->fd)
 690         release_object( console_in->fd );
 691 }
 692
 693 static struct object *create_console_connection( struct console_input *console )
 694 {
 695     struct console_connection *connection;
 696
 697     if (current->process->console)
 698     {
 699         set_error( STATUS_ACCESS_DENIED );
 700         return NULL;
 701     }
 702
 703     if (!(connection = alloc_object( &console_connection_ops ))) return NULL;
 704     if (!(connection->fd = alloc_pseudo_fd( &console_connection_fd_ops, &connection->obj, 0 )))
 705     {
 706         release_object( connection );
 707         return NULL;
 708     }
 709
 710     if (console)
 711     {
 712         current->process->console = (struct console_input *)grab_object( console );
 713         console->num_proc++;
 714     }
 715
 716     return &connection->obj;
 717 }
 718
 719 static struct object *console_input_lookup_name( struct object *obj, struct unicode_str *name, unsigned int attr )
 720 {
 721     struct console_input *console = (struct console_input *)obj;
 722     static const WCHAR connectionW[]    = {'C','o','n','n','e','c','t','i','o','n'};
 723     assert( obj->ops == &console_input_ops );
 724
 725     if (name->len == sizeof(connectionW) && !memcmp( name->str, connectionW, name->len ))
 726     {
 727         name->len = 0;
 728         return create_console_connection( console );
 729     }
 730
 731     return NULL;
 732 }
 733
 734 static struct object *console_input_open_file( struct object *obj, unsigned int access,
 735                                                unsigned int sharing, unsigned int options )
 736 {
 737     return grab_object( obj );
 738 }
 739
 740 static void screen_buffer_dump( struct object *obj, int verbose )
 741 {
 742     struct screen_buffer *screen_buffer = (struct screen_buffer *)obj;
 743     assert( obj->ops == &screen_buffer_ops );
 744
 745     fprintf(stderr, "Console screen buffer input=%p\n", screen_buffer->input );
 746 }
 747
 748 static void screen_buffer_destroy( struct object *obj )
 749 {
 750     struct screen_buffer *screen_buffer = (struct screen_buffer *)obj;
 751
 752     assert( obj->ops == &screen_buffer_ops );
 753
 754     list_remove( &screen_buffer->entry );
 755     if (screen_buffer->input && screen_buffer->input->server)
 756         queue_host_ioctl( screen_buffer->input->server, IOCTL_CONDRV_CLOSE_OUTPUT,
 757                           screen_buffer->id, NULL, NULL );
 758     if (screen_buffer->fd) release_object( screen_buffer->fd );
 759     free_async_queue( &screen_buffer->ioctl_q );
 760 }
 761
 762 static struct object *screen_buffer_open_file( struct object *obj, unsigned int access,
 763                                                unsigned int sharing, unsigned int options )
 764 {
 765     return grab_object( obj );
 766 }
 767
 768 static int screen_buffer_add_queue( struct object *obj, struct wait_queue_entry *entry )
 769 {
 770     struct screen_buffer *screen_buffer = (struct screen_buffer*)obj;
 771     if (!screen_buffer->input)
 772     {
 773         set_error( STATUS_ACCESS_DENIED );
 774         return 0;
 775     }
 776     return add_queue( &screen_buffer->input->obj, entry );
 777 }
 778
 779 static struct fd *screen_buffer_get_fd( struct object *obj )
 780 {
 781     struct screen_buffer *screen_buffer = (struct screen_buffer*)obj;
 782     assert( obj->ops == &screen_buffer_ops );
 783     if (screen_buffer->fd)
 784         return (struct fd*)grab_object( screen_buffer->fd );
 785     set_error( STATUS_OBJECT_TYPE_MISMATCH );
 786     return NULL;
 787 }
 788
 789 static void console_server_dump( struct object *obj, int verbose )
 790 {
 791     assert( obj->ops == &console_server_ops );
 792     fprintf( stderr, "Console server\n" );
 793 }
 794
 795 static void console_server_destroy( struct object *obj )
 796 {
 797     struct console_server *server = (struct console_server *)obj;
 798     assert( obj->ops == &console_server_ops );
 799     disconnect_console_server( server );
 800     if (server->fd) release_object( server->fd );
 801 }
 802
 803 static struct object *console_server_lookup_name( struct object *obj, struct unicode_str *name, unsigned int attr )
 804 {
 805     struct console_server *server = (struct console_server*)obj;
 806     static const WCHAR referenceW[] = {'R','e','f','e','r','e','n','c','e'};
 807     assert( obj->ops == &console_server_ops );
 808
 809     if (name->len == sizeof(referenceW) && !memcmp( name->str, referenceW, name->len ))
 810     {
 811         struct screen_buffer *screen_buffer;
 812         name->len = 0;
 813         if (server->console)
 814         {
 815             set_error( STATUS_INVALID_HANDLE );
 816             return 0;
 817         }
 818         if (!(server->console = (struct console_input *)create_console_input())) return NULL;
 819         if (!(screen_buffer = (struct screen_buffer *)create_console_output( server->console )))
 820         {
 821             release_object( server->console );
 822             server->console = NULL;
 823             return NULL;
 824         }
 825         release_object( screen_buffer );
 826         server->console->server = server;
 827
 828         return &server->console->obj;
 829     }
 830
 831     return NULL;
 832 }
 833
 834 static int console_server_signaled( struct object *obj, struct wait_queue_entry *entry )
 835 {
 836     struct console_server *server = (struct console_server*)obj;
 837     assert( obj->ops == &console_server_ops );
 838     return !server->console || !list_empty( &server->queue );
 839 }
 840
 841 static struct fd *console_server_get_fd( struct object* obj )
 842 {
 843     struct console_server *server = (struct console_server*)obj;
 844     assert( obj->ops == &console_server_ops );
 845     return (struct fd *)grab_object( server->fd );
 846 }
 847
 848 static struct object *console_server_open_file( struct object *obj, unsigned int access,
 849                                                 unsigned int sharing, unsigned int options )
 850 {
 851     return grab_object( obj );
 852 }
 853
 854 static struct object *create_console_server( void )
 855 {
 856     struct console_server *server;
 857
 858     if (!(server = alloc_object( &console_server_ops ))) return NULL;
 859     server->console = NULL;
 860     server->busy    = 0;
 861     server->term_fd = -1;
 862     list_init( &server->queue );
 863     list_init( &server->read_queue );
 864     server->fd = alloc_pseudo_fd( &console_server_fd_ops, &server->obj, FILE_SYNCHRONOUS_IO_NONALERT );
 865     if (!server->fd)
 866     {
 867         release_object( server );
 868         return NULL;
 869     }
 870     allow_fd_caching(server->fd);
 871
 872     return &server->obj;
 873 }
 874
 875 static int is_blocking_read_ioctl( unsigned int code )
 876 {
 877     switch (code)
 878     {
 879     case IOCTL_CONDRV_READ_INPUT:
 880     case IOCTL_CONDRV_READ_CONSOLE:
 881     case IOCTL_CONDRV_READ_FILE:
 882         return 1;
 883     default:
 884         return 0;
 885     }
 886 }
 887
 888 static int console_input_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
 889 {
 890     struct console_input *console = get_fd_user( fd );
 891
 892     switch (code)
 893     {
 894     case IOCTL_CONDRV_CTRL_EVENT:
 895         {
 896             const struct condrv_ctrl_event *event = get_req_data();
 897             process_id_t group;
 898             if (get_req_data_size() != sizeof(*event))
 899             {
 900                 set_error( STATUS_INVALID_PARAMETER );
 901                 return 0;
 902             }
 903             group = event->group_id ? event->group_id : current->process->group_id;
 904             if (!group)
 905             {
 906                 set_error( STATUS_INVALID_PARAMETER );
 907                 return 0;
 908             }
 909             propagate_console_signal( console, event->event, group );
 910             return !get_error();
 911         }
 912
 913     default:
 914         if (!console->server || code >> 16 != FILE_DEVICE_CONSOLE)
 915         {
 916             set_error( STATUS_INVALID_HANDLE );
 917             return 0;
 918         }
 919         return queue_host_ioctl( console->server, code, 0, async, &console->ioctl_q );
 920     }
 921 }
 922
 923 static int console_input_read( struct fd *fd, struct async *async, file_pos_t pos )
 924 {
 925     struct console_input *console = get_fd_user( fd );
 926
 927     if (!console->server)
 928     {
 929         set_error( STATUS_INVALID_HANDLE );
 930         return 0;
 931     }
 932     return queue_host_ioctl( console->server, IOCTL_CONDRV_READ_FILE, 0, async, &console->ioctl_q );
 933 }
 934
 935 static int console_input_flush( struct fd *fd, struct async *async )
 936 {
 937     struct console_input *console = get_fd_user( fd );
 938
 939     if (!console->server)
 940     {
 941         set_error( STATUS_INVALID_HANDLE );
 942         return 0;
 943     }
 944     return queue_host_ioctl( console->server, IOCTL_CONDRV_FLUSH, 0, NULL, NULL );
 945 }
 946
 947 static int screen_buffer_write( struct fd *fd, struct async *async, file_pos_t pos )
 948 {
 949     struct screen_buffer *screen_buffer = get_fd_user( fd );
 950     struct iosb *iosb;
 951
 952     if (!screen_buffer->input || !screen_buffer->input->server)
 953     {
 954         set_error( STATUS_INVALID_HANDLE );
 955         return 0;
 956     }
 957
 958     if (!queue_host_ioctl( screen_buffer->input->server, IOCTL_CONDRV_WRITE_FILE,
 959                            screen_buffer->id, async, &screen_buffer->ioctl_q ))
 960         return 0;
 961
 962     /* we can't use default async handling, because write result is not
 963      * compatible with ioctl result */
 964     iosb = async_get_iosb( async );
 965     iosb->status = STATUS_SUCCESS;
 966     iosb->result = iosb->in_size;
 967     async_terminate( async, iosb->result ? STATUS_ALERTED : STATUS_SUCCESS );
 968     release_object( iosb );
 969     return 1;
 970 }
 971
 972 static int screen_buffer_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
 973 {
 974     struct screen_buffer *screen_buffer = get_fd_user( fd );
 975
 976     switch (code)
 977     {
 978     case IOCTL_CONDRV_ACTIVATE:
 979         if (!screen_buffer->input)
 980         {
 981             set_error( STATUS_INVALID_HANDLE );
 982             return 0;
 983         }
 984
 985         set_active_screen_buffer( screen_buffer->input, screen_buffer );
 986         return 1;
 987
 988     default:
 989         if (!screen_buffer->input || !screen_buffer->input->server || code >> 16 != FILE_DEVICE_CONSOLE ||
 990             is_blocking_read_ioctl( code ))
 991         {
 992             set_error( STATUS_INVALID_HANDLE );
 993             return 0;
 994         }
 995         return queue_host_ioctl( screen_buffer->input->server, code, screen_buffer->id,
 996                                  async, &screen_buffer->ioctl_q );
 997     }
 998 }
 999
1000 static int console_connection_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
1001 {
1002     struct console_connection *console_connection = get_fd_user( fd );
1003
1004     switch (code)
1005     {
1006     case IOCTL_CONDRV_BIND_PID:
1007         {
1008             struct process *process;
1009             unsigned int pid;
1010             if (get_req_data_size() != sizeof(unsigned int))
1011             {
1012                 set_error( STATUS_INVALID_PARAMETER );
1013                 return 0;
1014             }
1015             if (current->process->console)
1016             {
1017                 set_error( STATUS_INVALID_HANDLE );
1018                 return 0;
1019             }
1020
1021             pid = *(unsigned int *)get_req_data();
1022             if (pid == ATTACH_PARENT_PROCESS) pid = current->process->parent_id;
1023             if (!(process = get_process_from_id( pid ))) return 0;
1024
1025             if (process->console)
1026             {
1027                 current->process->console = (struct console_input *)grab_object( process->console );
1028                 process->console->num_proc++;
1029             }
1030             else set_error( STATUS_ACCESS_DENIED );
1031             release_object( process );
1032             return !get_error();
1033         }
1034
1035     default:
1036         return default_fd_ioctl( console_connection->fd, code, async );
1037     }
1038 }
1039
1040 static int console_server_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
1041 {
1042     struct console_server *server = get_fd_user( fd );
1043
1044     switch (code)
1045     {
1046     case IOCTL_CONDRV_CTRL_EVENT:
1047         {
1048             const struct condrv_ctrl_event *event = get_req_data();
1049             if (get_req_data_size() != sizeof(*event))
1050             {
1051                 set_error( STATUS_INVALID_PARAMETER );
1052                 return 0;
1053             }
1054             if (!server->console)
1055             {
1056                 set_error( STATUS_INVALID_HANDLE );
1057                 return 0;
1058             }
1059             propagate_console_signal( server->console, event->event, event->group_id );
1060             return !get_error();
1061         }
1062
1063     case IOCTL_CONDRV_SETUP_INPUT:
1064         {
1065             struct termios term;
1066             obj_handle_t handle;
1067             struct file *file;
1068             int unix_fd;
1069
1070             if (get_req_data_size() != sizeof(unsigned int) || get_reply_max_size())
1071             {
1072                 set_error( STATUS_INVALID_PARAMETER );
1073                 return 0;
1074             }
1075             if (server->term_fd != -1)
1076             {
1077                 tcsetattr( server->term_fd, TCSANOW, &server->termios );
1078                 close( server->term_fd );
1079                 server->term_fd = -1;
1080             }
1081             handle = *(unsigned int *)get_req_data();
1082             if (!handle) return 1;
1083             if (!(file = get_file_obj( current->process, handle, FILE_READ_DATA  )))
1084             {
1085                 return 0;
1086             }
1087             unix_fd = get_file_unix_fd( file );
1088             release_object( file );
1089
1090             if (tcgetattr( unix_fd, &server->termios ))
1091             {
1092                 file_set_error();
1093                 return 0;
1094             }
1095             term = server->termios;
1096             term.c_lflag &= ~(ECHO | ECHONL | ICANON | IEXTEN);
1097             term.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
1098             term.c_cflag &= ~(CSIZE | PARENB);
1099             term.c_cflag |= CS8;
1100             term.c_cc[VMIN] = 1;
1101             term.c_cc[VTIME] = 0;
1102             if (tcsetattr( unix_fd, TCSANOW, &term ) || (server->term_fd = dup( unix_fd )) == -1)
1103             {
1104                 file_set_error();
1105                 return 0;
1106             }
1107             return 1;
1108         }
1109
1110     default:
1111         set_error( STATUS_INVALID_HANDLE );
1112         return 0;
1113     }
1114 }
1115
1116 static void console_connection_dump( struct object *obj, int verbose )
1117 {
1118     fputs( "console connection\n", stderr );
1119 }
1120
1121 static struct fd *console_connection_get_fd( struct object *obj )
1122 {
1123     struct console_connection *connection = (struct console_connection *)obj;
1124     return (struct fd *)grab_object( connection->fd );
1125 }
1126
1127 static struct object *console_connection_lookup_name( struct object *obj, struct unicode_str *name, unsigned int attr )
1128 {
1129     static const WCHAR referenceW[] = {'R','e','f','e','r','e','n','c','e'};
1130
1131     if (name->len == sizeof(referenceW) && !memcmp( name->str, referenceW, name->len ))
1132     {
1133         if (!current->process->console)
1134         {
1135             set_error( STATUS_INVALID_HANDLE );
1136             return NULL;
1137         }
1138         name->len = 0;
1139         return grab_object( current->process->console );
1140     }
1141
1142     return NULL;
1143 }
1144
1145 static struct object *console_connection_open_file( struct object *obj, unsigned int access,
1146                                                     unsigned int sharing, unsigned int options )
1147 {
1148     return grab_object( obj );
1149 }
1150
1151 static int console_connection_close_handle( struct object *obj, struct process *process, obj_handle_t handle )
1152 {
1153     free_console( process );
1154     return 1;
1155 }
1156
1157 static void console_connection_destroy( struct object *obj )
1158 {
1159     struct console_connection *connection = (struct console_connection *)obj;
1160     if (connection->fd) release_object( connection->fd );
1161 }
1162
1163 static struct object_type *console_device_get_type( struct object *obj )
1164 {
1165     static const WCHAR name[] = {'D','e','v','i','c','e'};
1166     static const struct unicode_str str = { name, sizeof(name) };
1167     return get_object_type( &str );
1168 }
1169
1170 static void console_device_dump( struct object *obj, int verbose )
1171 {
1172     fputs( "Console device\n", stderr );
1173 }
1174
1175 static struct object *console_device_lookup_name( struct object *obj, struct unicode_str *name, unsigned int attr )
1176 {
1177     static const WCHAR connectionW[]    = {'C','o','n','n','e','c','t','i','o','n'};
1178     static const WCHAR consoleW[]       = {'C','o','n','s','o','l','e'};
1179     static const WCHAR current_inW[]    = {'C','u','r','r','e','n','t','I','n'};
1180     static const WCHAR current_outW[]   = {'C','u','r','r','e','n','t','O','u','t'};
1181     static const WCHAR inputW[]         = {'I','n','p','u','t'};
1182     static const WCHAR outputW[]        = {'O','u','t','p','u','t'};
1183     static const WCHAR screen_bufferW[] = {'S','c','r','e','e','n','B','u','f','f','e','r'};
1184     static const WCHAR serverW[]        = {'S','e','r','v','e','r'};
1185
1186     if (name->len == sizeof(current_inW) && !memcmp( name->str, current_inW, name->len ))
1187     {
1188         if (!current->process->console)
1189         {
1190             set_error( STATUS_INVALID_HANDLE );
1191             return NULL;
1192         }
1193         name->len = 0;
1194         return grab_object( current->process->console );
1195     }
1196
1197     if (name->len == sizeof(current_outW) && !memcmp( name->str, current_outW, name->len ))
1198     {
1199         if (!current->process->console || !current->process->console->active)
1200         {
1201             set_error( STATUS_INVALID_HANDLE );
1202             return NULL;
1203         }
1204         name->len = 0;
1205         return grab_object( current->process->console->active );
1206     }
1207
1208     if (name->len == sizeof(consoleW) && !memcmp( name->str, consoleW, name->len ))
1209     {
1210         name->len = 0;
1211         return grab_object( obj );
1212     }
1213
1214     if (name->len == sizeof(inputW) && !memcmp( name->str, inputW, name->len ))
1215     {
1216         name->len = 0;
1217         return alloc_object( &input_device_ops );
1218     }
1219
1220     if (name->len == sizeof(outputW) && !memcmp( name->str, outputW, name->len ))
1221     {
1222         name->len = 0;
1223         return alloc_object( &output_device_ops );
1224     }
1225
1226     if (name->len == sizeof(screen_bufferW) && !memcmp( name->str, screen_bufferW, name->len ))
1227     {
1228         if (!current->process->console)
1229         {
1230             set_error( STATUS_INVALID_HANDLE );
1231             return NULL;
1232         }
1233         name->len = 0;
1234         return create_console_output( current->process->console );
1235     }
1236
1237     if (name->len == sizeof(serverW) && !memcmp( name->str, serverW, name->len ))
1238     {
1239         name->len = 0;
1240         return create_console_server();
1241     }
1242
1243     if (name->len == sizeof(connectionW) && !memcmp( name->str, connectionW, name->len ))
1244     {
1245         name->len = 0;
1246         return create_console_connection( NULL );
1247     }
1248
1249     return NULL;
1250 }
1251
1252 static struct object *console_device_open_file( struct object *obj, unsigned int access,
1253                                                 unsigned int sharing, unsigned int options )
1254 {
1255     int is_output;
1256     access = default_fd_map_access( obj, access );
1257     is_output = access & FILE_WRITE_DATA;
1258     if (!current->process->console || (is_output && !current->process->console))
1259     {
1260         set_error( STATUS_INVALID_HANDLE );
1261         return NULL;
1262     }
1263     if (is_output && (access & FILE_READ_DATA))
1264     {
1265         set_error( STATUS_INVALID_PARAMETER );
1266         return NULL;
1267     }
1268     return is_output ? grab_object( current->process->console->active ) : grab_object( current->process->console );
1269 }
1270
1271 static void input_device_dump( struct object *obj, int verbose )
1272 {
1273     fputs( "console Input device\n", stderr );
1274 }
1275
1276 static int input_device_add_queue( struct object *obj, struct wait_queue_entry *entry )
1277 {
1278     if (!current->process->console)
1279     {
1280         set_error( STATUS_ACCESS_DENIED );
1281         return 0;
1282     }
1283     return add_queue( &current->process->console->obj, entry );
1284 }
1285
1286 static struct fd *input_device_get_fd( struct object *obj )
1287 {
1288     if (!current->process->console)
1289     {
1290         set_error( STATUS_ACCESS_DENIED );
1291         return 0;
1292     }
1293     return get_obj_fd( &current->process->console->obj );
1294 }
1295
1296 static struct object *input_device_open_file( struct object *obj, unsigned int access,
1297                                               unsigned int sharing, unsigned int options )
1298 {
1299     return grab_object( obj );
1300 }
1301
1302 static void output_device_dump( struct object *obj, int verbose )
1303 {
1304     fputs( "console Output device\n", stderr );
1305 }
1306
1307 static int output_device_add_queue( struct object *obj, struct wait_queue_entry *entry )
1308 {
1309     if (!current->process->console || !current->process->console->active)
1310     {
1311         set_error( STATUS_ACCESS_DENIED );
1312         return 0;
1313     }
1314     return add_queue( &current->process->console->obj, entry );
1315 }
1316
1317 static struct fd *output_device_get_fd( struct object *obj )
1318 {
1319     if (!current->process->console || !current->process->console->active)
1320     {
1321         set_error( STATUS_ACCESS_DENIED );
1322         return NULL;
1323     }
1324
1325     return get_obj_fd( &current->process->console->active->obj );
1326 }
1327
1328 static struct object *output_device_open_file( struct object *obj, unsigned int access,
1329                                                unsigned int sharing, unsigned int options )
1330 {
1331     return grab_object( obj );
1332 }
1333
1334 struct object *create_console_device( struct object *root, const struct unicode_str *name,
1335                                       unsigned int attr, const struct security_descriptor *sd )
1336 {
1337     return create_named_object( root, &console_device_ops, name, attr, sd );
1338 }
1339
1340 /* retrieve the next pending console ioctl request */
1341 DECL_HANDLER(get_next_console_request)
1342 {
1343     struct console_host_ioctl *ioctl = NULL, *next;
1344     struct console_server *server;
1345     struct iosb *iosb = NULL;
1346
1347     server = (struct console_server *)get_handle_obj( current->process, req->handle, 0, &console_server_ops );
1348     if (!server) return;
1349
1350     if (!server->console)
1351     {
1352         set_error( STATUS_INVALID_HANDLE );
1353         release_object( server );
1354         return;
1355     }
1356
1357     if (!req->signal) server->console->signaled = 0;
1358     else if (!server->console->signaled)
1359     {
1360         server->console->signaled = 1;
1361         wake_up( &server->console->obj, 0 );
1362     }
1363
1364     if (req->read)
1365     {
1366         /* set result of current pending ioctl */
1367         if (list_empty( &server->read_queue ))
1368         {
1369             set_error( STATUS_INVALID_HANDLE );
1370             release_object( server );
1371             return;
1372         }
1373
1374         ioctl = LIST_ENTRY( list_head( &server->read_queue ), struct console_host_ioctl, entry );
1375         list_remove( &ioctl->entry );
1376         list_move_tail( &server->queue, &server->read_queue );
1377     }
1378     else if (server->busy)
1379     {
1380         /* set result of previous ioctl */
1381         ioctl = LIST_ENTRY( list_head( &server->queue ), struct console_host_ioctl, entry );
1382         list_remove( &ioctl->entry );
1383     }
1384
1385     if (ioctl)
1386     {
1387         unsigned int status = req->status;
1388         if (status == STATUS_PENDING) status = STATUS_INVALID_PARAMETER;
1389         if (ioctl->async)
1390         {
1391             iosb = async_get_iosb( ioctl->async );
1392             if (iosb->status == STATUS_PENDING)
1393             {
1394                 iosb->status = status;
1395                 iosb->out_size = min( iosb->out_size, get_req_data_size() );
1396                 if (iosb->out_size)
1397                 {
1398                     if ((iosb->out_data = memdup( get_req_data(), iosb->out_size )))
1399                     {
1400                         iosb->result = iosb->out_size;
1401                         status = STATUS_ALERTED;
1402                     }
1403                     else if (!status)
1404                     {
1405                         iosb->status = STATUS_NO_MEMORY;
1406                         iosb->out_size = 0;
1407                     }
1408                 }
1409             }
1410             else
1411             {
1412                 release_object( ioctl->async );
1413                 ioctl->async = NULL;
1414             }
1415         }
1416         console_host_ioctl_terminate( ioctl, status );
1417         if (iosb) release_object( iosb );
1418
1419         if (req->read)
1420         {
1421             release_object( server );
1422             return;
1423         }
1424         server->busy = 0;
1425     }
1426
1427     /* if we have a blocking read ioctl in queue head and previous blocking read is still waiting,
1428      * move it to read queue for execution after current read is complete. move all blocking
1429      * ioctl at the same time to preserve their order. */
1430     if (!list_empty( &server->queue ) && !list_empty( &server->read_queue ))
1431     {
1432         ioctl = LIST_ENTRY( list_head( &server->queue ), struct console_host_ioctl, entry );
1433         if (is_blocking_read_ioctl( ioctl->code ))
1434         {
1435             LIST_FOR_EACH_ENTRY_SAFE( ioctl, next, &server->queue, struct console_host_ioctl, entry )
1436             {
1437                 if (!is_blocking_read_ioctl( ioctl->code )) continue;
1438                 list_remove( &ioctl->entry );
1439                 list_add_tail( &server->read_queue, &ioctl->entry );
1440             }
1441         }
1442     }
1443
1444     /* return the next ioctl */
1445     if (!list_empty( &server->queue ))
1446     {
1447         ioctl = LIST_ENTRY( list_head( &server->queue ), struct console_host_ioctl, entry );
1448         iosb = ioctl->async ? async_get_iosb( ioctl->async ) : NULL;
1449
1450         if (!iosb || get_reply_max_size() >= iosb->in_size)
1451         {
1452             reply->code   = ioctl->code;
1453             reply->output = ioctl->output;
1454
1455             if (iosb)
1456             {
1457                 reply->out_size = iosb->out_size;
1458                 set_reply_data_ptr( iosb->in_data, iosb->in_size );
1459                 iosb->in_data = NULL;
1460             }
1461
1462             if (is_blocking_read_ioctl( ioctl->code ))
1463             {
1464                 list_remove( &ioctl->entry );
1465                 assert( list_empty( &server->read_queue ));
1466                 list_add_tail( &server->read_queue, &ioctl->entry );
1467             }
1468             else server->busy = 1;
1469         }
1470         else
1471         {
1472             reply->out_size = iosb->in_size;
1473             set_error( STATUS_BUFFER_OVERFLOW );
1474         }
1475         if (iosb) release_object( iosb );
1476     }
1477     else
1478     {
1479         set_error( STATUS_PENDING );
1480     }
1481
1482     release_object( server );
1483 }