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