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