text: /*
   * Server-side console management
   *
   * Copyright (C) 1998 Alexandre Julliard
   *               2001 Eric Pouech
   * Copyright 2020 Jacek Caban for CodeWeavers
   *
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
   * This library is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
   * License along with this library; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
   */
  
  #include "config.h"
  #include "wine/port.h"
  
  #include <assert.h>
  #include <string.h>
  #include <stdio.h>
  #include <unistd.h>
  #include <signal.h>
  #include <sys/ioctl.h>
  #include <termios.h>
  
  #include "ntstatus.h"
  #define WIN32_NO_STATUS
  #include "handle.h"
  #include "process.h"
  #include "request.h"
  #include "file.h"
  #include "unicode.h"
  #include "wincon.h"
  #include "winternl.h"
  #include "wine/condrv.h"
  
  struct screen_buffer;
  
  struct history_line
  {
      data_size_t len;
      WCHAR       text[1];
  };
  
  struct console
  {
      struct object                obj;           /* object header */
      int                          signaled;      /* is console signaled */
      struct thread               *renderer;      /* console renderer thread */
      struct screen_buffer        *active;        /* active screen buffer */
      struct console_server       *server;        /* console server object */
      unsigned int                 last_id;       /* id of last created console buffer */
      struct fd                   *fd;            /* for bare console, attached input fd */
      struct async_queue           ioctl_q;       /* ioctl queue */
      struct async_queue           read_q;        /* read queue */
  };
  
  static void console_dump( struct object *obj, int verbose );
  static void console_destroy( struct object *obj );
  static int console_signaled( struct object *obj, struct wait_queue_entry *entry );
  static struct fd *console_get_fd( struct object *obj );
  static struct object *console_lookup_name( struct object *obj, struct unicode_str *name,
                                             unsigned int attr, struct object *root );
  static struct object *console_open_file( struct object *obj, unsigned int access,
                                           unsigned int sharing, unsigned int options );
  
  static const struct object_ops console_ops =
  {
      sizeof(struct console),           /* size */
      console_dump,                     /* dump */
      no_get_type,                      /* get_type */
      add_queue,                        /* add_queue */
      remove_queue,                     /* remove_queue */
      console_signaled,                 /* signaled */
      no_satisfied,                     /* satisfied */
      no_signal,                        /* signal */
      console_get_fd,                   /* get_fd */
      default_fd_map_access,            /* map_access */
      default_get_sd,                   /* get_sd */
      default_set_sd,                   /* set_sd */
      no_get_full_name,                 /* get_full_name */
      console_lookup_name,              /* lookup_name */
      no_link_name,                     /* link_name */
      NULL,                             /* unlink_name */
      console_open_file,                /* open_file */
      no_kernel_obj_list,               /* get_kernel_obj_list */
      no_close_handle,                  /* close_handle */
      console_destroy                   /* destroy */
  };
  
  static enum server_fd_type console_get_fd_type( struct fd *fd );
  static void console_get_file_info( struct fd *fd, obj_handle_t handle, unsigned int info_class );
  static void console_get_volume_info( struct fd *fd, unsigned int info_class );
  static int console_read( struct fd *fd, struct async *async, file_pos_t pos );
  static int console_flush( struct fd *fd, struct async *async );
  static int console_ioctl( struct fd *fd, ioctl_code_t code, struct async *async );
  
  static const struct fd_ops console_fd_ops =
  {
      default_fd_get_poll_events,   /* get_poll_events */
      default_poll_event,           /* poll_event */
      console_get_fd_type,          /* get_fd_type */
      console_read,                 /* read */
      no_fd_write,                  /* write */
      console_flush,                /* flush */
      console_get_file_info,        /* get_file_info */
      console_get_volume_info,      /* get_volume_info */
      console_ioctl,                /* ioctl */
      default_fd_queue_async,       /* queue_async */
      default_fd_reselect_async     /* reselect_async */
  };
  
  struct console_host_ioctl
  {
      unsigned int          code;        /* ioctl code */
      int                   output;      /* output id for screen buffer ioctls */
      struct async         *async;       /* ioctl async */
      struct list           entry;       /* list entry */
  };
  
  struct console_server
  {
      struct object         obj;         /* object header */
      struct fd            *fd;          /* pseudo-fd for ioctls */
      struct console       *console;     /* attached console */
      struct list           queue;       /* ioctl queue */
      struct list           read_queue;  /* blocking read queue */
      int                   busy;        /* flag if server processing an ioctl */
      int                   term_fd;     /* UNIX terminal fd */
      struct termios        termios;     /* original termios */
  };
  
  static void console_server_dump( struct object *obj, int verbose );
  static void console_server_destroy( struct object *obj );
  static int console_server_signaled( struct object *obj, struct wait_queue_entry *entry );
  static struct fd *console_server_get_fd( struct object *obj );
  static struct object *console_server_lookup_name( struct object *obj, struct unicode_str *name,
                                                  unsigned int attr, struct object *root );
  static struct object *console_server_open_file( struct object *obj, unsigned int access,
                                                  unsigned int sharing, unsigned int options );
  
  static const struct object_ops console_server_ops =
  {
      sizeof(struct console_server),    /* size */
      console_server_dump,              /* dump */
      no_get_type,                      /* get_type */
      add_queue,                        /* add_queue */
      remove_queue,                     /* remove_queue */
      console_server_signaled,          /* signaled */
      no_satisfied,                     /* satisfied */
      no_signal,                        /* signal */
      console_server_get_fd,            /* get_fd */
      default_fd_map_access,            /* map_access */
      default_get_sd,                   /* get_sd */
      default_set_sd,                   /* set_sd */
      no_get_full_name,                 /* get_full_name */
      console_server_lookup_name,       /* lookup_name */
      no_link_name,                     /* link_name */
      NULL,                             /* unlink_name */
      console_server_open_file,         /* open_file */
      no_kernel_obj_list,               /* get_kernel_obj_list */
      fd_close_handle,                  /* close_handle */
      console_server_destroy            /* destroy */
  };
  
  static int console_server_ioctl( struct fd *fd, ioctl_code_t code, struct async *async );
  
  static const struct fd_ops console_server_fd_ops =
  {
      default_fd_get_poll_events,   /* get_poll_events */
      default_poll_event,           /* poll_event */
      console_get_fd_type,          /* get_fd_type */
      no_fd_read,                   /* read */
      no_fd_write,                  /* write */
      no_fd_flush,                  /* flush */
      no_fd_get_file_info,          /* get_file_info */
      no_fd_get_volume_info,        /* get_volume_info */
      console_server_ioctl,         /* ioctl */
      default_fd_queue_async,       /* queue_async */
      default_fd_reselect_async     /* reselect_async */
  };
  
  struct font_info
  {
      short int width;
      short int height;
      short int weight;
      short int pitch_family;
      WCHAR    *face_name;
      data_size_t face_len;
  };
  
  struct screen_buffer
  {
      struct object         obj;           /* object header */
      struct list           entry;         /* entry in list of all screen buffers */
      struct console       *input;         /* associated console input */
      unsigned int          id;            /* buffer id */
      struct fd            *fd;            /* for bare console, attached output fd */
      struct async_queue    ioctl_q;       /* ioctl queue */
  };
  
  static void screen_buffer_dump( struct object *obj, int verbose );
  static void screen_buffer_destroy( struct object *obj );
  static int screen_buffer_add_queue( struct object *obj, struct wait_queue_entry *entry );
  static struct fd *screen_buffer_get_fd( struct object *obj );
  static struct object *screen_buffer_open_file( struct object *obj, unsigned int access,
                                                 unsigned int sharing, unsigned int options );
  
  static const struct object_ops screen_buffer_ops =
  {
      sizeof(struct screen_buffer),     /* size */
      screen_buffer_dump,               /* dump */
      no_get_type,                      /* get_type */
      screen_buffer_add_queue,          /* add_queue */
      NULL,                             /* remove_queue */
      NULL,                             /* signaled */
      NULL,                             /* satisfied */
      no_signal,                        /* signal */
      screen_buffer_get_fd,             /* get_fd */
      default_fd_map_access,            /* map_access */
      default_get_sd,                   /* get_sd */
      default_set_sd,                   /* set_sd */
      no_get_full_name,                 /* get_full_name */
      no_lookup_name,                   /* lookup_name */
      no_link_name,                     /* link_name */
      NULL,                             /* unlink_name */
      screen_buffer_open_file,          /* open_file */
      no_kernel_obj_list,               /* get_kernel_obj_list */
      no_close_handle,                  /* close_handle */
      screen_buffer_destroy             /* destroy */
  };
  
  static int screen_buffer_write( struct fd *fd, struct async *async, file_pos_t pos );
  static int screen_buffer_ioctl( struct fd *fd, ioctl_code_t code, struct async *async );
  
  static const struct fd_ops screen_buffer_fd_ops =
  {
      default_fd_get_poll_events,   /* get_poll_events */
      default_poll_event,           /* poll_event */
      console_get_fd_type,          /* get_fd_type */
      no_fd_read,                   /* read */
      screen_buffer_write,          /* write */
      no_fd_flush,                  /* flush */
      console_get_file_info,        /* get_file_info */
      console_get_volume_info,      /* get_volume_info */
      screen_buffer_ioctl,          /* ioctl */
      default_fd_queue_async,       /* queue_async */
      default_fd_reselect_async     /* reselect_async */
  };
  
  static struct object_type *console_device_get_type( struct object *obj );
  static void console_device_dump( struct object *obj, int verbose );
  static struct object *console_device_lookup_name( struct object *obj, struct unicode_str *name,
                                                  unsigned int attr, struct object *root );
  static struct object *console_device_open_file( struct object *obj, unsigned int access,
                                                  unsigned int sharing, unsigned int options );
  
  static const struct object_ops console_device_ops =
  {
      sizeof(struct object),            /* size */
      console_device_dump,              /* dump */
      console_device_get_type,          /* get_type */
      no_add_queue,                     /* add_queue */
      NULL,                             /* remove_queue */
      NULL,                             /* signaled */
      no_satisfied,                     /* satisfied */
      no_signal,                        /* signal */
      no_get_fd,                        /* get_fd */
      default_fd_map_access,            /* map_access */
      default_get_sd,                   /* get_sd */
      default_set_sd,                   /* set_sd */
      default_get_full_name,            /* get_full_name */
      console_device_lookup_name,       /* lookup_name */
      directory_link_name,              /* link_name */
      default_unlink_name,              /* unlink_name */
      console_device_open_file,         /* open_file */
      no_kernel_obj_list,               /* get_kernel_obj_list */
      no_close_handle,                  /* close_handle */
      no_destroy                        /* destroy */
  };
  
  struct console_input
  {
      struct object         obj;         /* object header */
      struct fd            *fd;          /* pseudo-fd */
  };
  
  static void console_input_dump( struct object *obj, int verbose );
  static struct object *console_input_open_file( struct object *obj, unsigned int access,
                                                 unsigned int sharing, unsigned int options );
  static int console_input_add_queue( struct object *obj, struct wait_queue_entry *entry );
  static struct fd *console_input_get_fd( struct object *obj );
  static void console_input_destroy( struct object *obj );
  
  static const struct object_ops console_input_ops =
  {
      sizeof(struct console_input),     /* size */
      console_input_dump,               /* dump */
      console_device_get_type,          /* get_type */
      console_input_add_queue,          /* add_queue */
      NULL,                             /* remove_queue */
      NULL,                             /* signaled */
      no_satisfied,                     /* satisfied */
      no_signal,                        /* signal */
      console_input_get_fd,             /* get_fd */
      no_map_access,                    /* map_access */
      default_get_sd,                   /* get_sd */
      default_set_sd,                   /* set_sd */
      no_get_full_name,                 /* get_full_name */
      no_lookup_name,                   /* lookup_name */
      directory_link_name,              /* link_name */
      default_unlink_name,              /* unlink_name */
      console_input_open_file,          /* open_file */
      no_kernel_obj_list,               /* get_kernel_obj_list */
      no_close_handle,                  /* close_handle */
      console_input_destroy             /* destroy */
  };
  
  static int console_input_read( struct fd *fd, struct async *async, file_pos_t pos );
  static int console_input_flush( struct fd *fd, struct async *async );
  static int console_input_ioctl( struct fd *fd, ioctl_code_t code, struct async *async );
  
  static const struct fd_ops console_input_fd_ops =
  {
      default_fd_get_poll_events,   /* get_poll_events */
      default_poll_event,           /* poll_event */
      console_get_fd_type,          /* get_fd_type */
      console_input_read,           /* read */
      no_fd_write,                  /* write */
      console_input_flush,          /* flush */
      console_get_file_info,        /* get_file_info */
      console_get_volume_info,      /* get_volume_info */
      console_input_ioctl,          /* ioctl */
      default_fd_queue_async,       /* queue_async */
      default_fd_reselect_async     /* reselect_async */
  };
  
  struct console_output
  {
      struct object         obj;         /* object header */
      struct fd            *fd;          /* pseudo-fd */
  };
  
  static void console_output_dump( struct object *obj, int verbose );
  static int console_output_add_queue( struct object *obj, struct wait_queue_entry *entry );
  static struct fd *console_output_get_fd( struct object *obj );
  static struct object *console_output_open_file( struct object *obj, unsigned int access,
                                                  unsigned int sharing, unsigned int options );
  static void console_output_destroy( struct object *obj );
  
  static const struct object_ops console_output_ops =
  {
      sizeof(struct console_output),    /* size */
      console_output_dump,              /* dump */
      console_device_get_type,          /* get_type */
      console_output_add_queue,         /* add_queue */
      NULL,                             /* remove_queue */
      NULL,                             /* signaled */
      no_satisfied,                     /* satisfied */
      no_signal,                        /* signal */
      console_output_get_fd,            /* get_fd */
      no_map_access,                    /* map_access */
      default_get_sd,                   /* get_sd */
      default_set_sd,                   /* set_sd */
      no_get_full_name,                 /* get_full_name */
      no_lookup_name,                   /* lookup_name */
      directory_link_name,              /* link_name */
      default_unlink_name,              /* unlink_name */
      console_output_open_file,         /* open_file */
      no_kernel_obj_list,               /* get_kernel_obj_list */
      no_close_handle,                  /* close_handle */
      console_output_destroy            /* destroy */
  };
  
  static int console_output_write( struct fd *fd, struct async *async, file_pos_t pos );
  static int console_output_ioctl( struct fd *fd, ioctl_code_t code, struct async *async );
  
  static const struct fd_ops console_output_fd_ops =
  {
      default_fd_get_poll_events,   /* get_poll_events */
      default_poll_event,           /* poll_event */
      console_get_fd_type,          /* get_fd_type */
      no_fd_read,                   /* read */
      console_output_write,         /* write */
      no_fd_flush,                  /* flush */
      console_get_file_info,        /* get_file_info */
      console_get_volume_info,      /* get_volume_info */
      console_output_ioctl,         /* ioctl */
      default_fd_queue_async,       /* queue_async */
      default_fd_reselect_async     /* reselect_async */
  };
  
  struct console_connection
  {
      struct object         obj;         /* object header */
      struct fd            *fd;          /* pseudo-fd for ioctls */
  };
  
  static void console_connection_dump( struct object *obj, int verbose );
  static struct fd *console_connection_get_fd( struct object *obj );
  static struct object *console_connection_lookup_name( struct object *obj, struct unicode_str *name,
                                                      unsigned int attr, struct object *root );
  static struct object *console_connection_open_file( struct object *obj, unsigned int access,
                                                      unsigned int sharing, unsigned int options );
  static int console_connection_close_handle( struct object *obj, struct process *process, obj_handle_t handle );
  static void console_connection_destroy( struct object *obj );
  
  static const struct object_ops console_connection_ops =
  {
      sizeof(struct console_connection),/* size */
      console_connection_dump,          /* dump */
      console_device_get_type,          /* get_type */
      no_add_queue,                     /* add_queue */
      NULL,                             /* remove_queue */
      NULL,                             /* signaled */
      no_satisfied,                     /* satisfied */
      no_signal,                        /* signal */
      console_connection_get_fd,        /* get_fd */
      no_map_access,                    /* map_access */
      default_get_sd,                   /* get_sd */
      default_set_sd,                   /* set_sd */
      no_get_full_name,                 /* get_full_name */
      console_connection_lookup_name,   /* lookup_name */
      directory_link_name,              /* link_name */
      default_unlink_name,              /* unlink_name */
      console_connection_open_file,     /* open_file */
      no_kernel_obj_list,               /* get_kernel_obj_list */
      console_connection_close_handle,  /* close_handle */
      console_connection_destroy        /* destroy */
  };
  
  static int console_connection_ioctl( struct fd *fd, ioctl_code_t code, struct async *async );
  
  static const struct fd_ops console_connection_fd_ops =
  {
      default_fd_get_poll_events,   /* get_poll_events */
      default_poll_event,           /* poll_event */
      console_get_fd_type,          /* get_fd_type */
      no_fd_read,                   /* read */
      no_fd_write,                  /* write */
      no_fd_flush,                  /* flush */
      no_fd_get_file_info,          /* get_file_info */
      no_fd_get_volume_info,        /* get_volume_info */
      console_connection_ioctl,     /* ioctl */
      default_fd_queue_async,       /* queue_async */
      default_fd_reselect_async     /* reselect_async */
  };
  
  static struct list screen_buffer_list = LIST_INIT(screen_buffer_list);
  
  static int console_signaled( struct object *obj, struct wait_queue_entry *entry )
  {
      struct console *console = (struct console*)obj;
      return console->signaled;
  }
  
  static struct fd *console_get_fd( struct object *obj )
  {
      struct console *console = (struct console *)obj;
      assert( obj->ops == &console_ops );
      return (struct fd *)grab_object( console->fd );
  }
  
  static enum server_fd_type console_get_fd_type( struct fd *fd )
  {
      return FD_TYPE_CHAR;
  }
  
  static void console_get_file_info( struct fd *fd, obj_handle_t handle, unsigned int info_class )
  {
      set_error( STATUS_INVALID_DEVICE_REQUEST );
  }
  
  static void console_get_volume_info( struct fd *fd, unsigned int info_class )
  {
      switch (info_class)
      {
      case FileFsDeviceInformation:
          {
              static const FILE_FS_DEVICE_INFORMATION device_info =
              {
                  FILE_DEVICE_CONSOLE,
                  FILE_DEVICE_ALLOW_APPCONTAINER_TRAVERSAL
              };
              if (get_reply_max_size() >= sizeof(device_info))
                  set_reply_data( &device_info, sizeof(device_info) );
              else
                  set_error( STATUS_BUFFER_TOO_SMALL );
              break;
          }
      default:
          set_error( STATUS_NOT_IMPLEMENTED );
      }
  }
  
  static struct object *create_console(void)
  {
      struct console *console;
  
      if (!(console = alloc_object( &console_ops )))
          return NULL;
  
      console->renderer      = NULL;
      console->signaled      = 0;
      console->active        = NULL;
      console->server        = NULL;
      console->fd            = NULL;
      console->last_id       = 0;
      init_async_queue( &console->ioctl_q );
      init_async_queue( &console->read_q );
  
      console->fd = alloc_pseudo_fd( &console_fd_ops, &console->obj, FILE_SYNCHRONOUS_IO_NONALERT );
      if (!console->fd)
      {
          release_object( console );
          return NULL;
      }
      allow_fd_caching( console->fd );
      return &console->obj;
  }
  
  static void console_host_ioctl_terminate( struct console_host_ioctl *call, unsigned int status )
  {
      if (call->async)
      {
          async_terminate( call->async, status );
          release_object( call->async );
      }
      free( call );
  }
  
  static int queue_host_ioctl( struct console_server *server, unsigned int code, unsigned int output,
                               struct async *async, struct async_queue *queue )
  {
      struct console_host_ioctl *ioctl;
  
      if (!(ioctl = mem_alloc( sizeof(*ioctl) ))) return 0;
      ioctl->code   = code;
      ioctl->output = output;
      ioctl->async  = NULL;
      if (async)
      {
          ioctl->async = (struct async *)grab_object( async );
          queue_async( queue, async );
      }
      list_add_tail( &server->queue, &ioctl->entry );
      wake_up( &server->obj, 0 );
      if (async) set_error( STATUS_PENDING );
      return 1;
  }
  
  static void disconnect_console_server( struct console_server *server )
  {
      while (!list_empty( &server->queue ))
      {
          struct console_host_ioctl *call = LIST_ENTRY( list_head( &server->queue ), struct console_host_ioctl, entry );
          list_remove( &call->entry );
          console_host_ioctl_terminate( call, STATUS_CANCELLED );
      }
      while (!list_empty( &server->read_queue ))
      {
          struct console_host_ioctl *call = LIST_ENTRY( list_head( &server->read_queue ), struct console_host_ioctl, entry );
          list_remove( &call->entry );
          console_host_ioctl_terminate( call, STATUS_CANCELLED );
      }
  
      if (server->term_fd != -1)
      {
          tcsetattr( server->term_fd, TCSANOW, &server->termios );
          close( server->term_fd );
          server->term_fd = -1;
      }
  
      if (server->console)
      {
          assert( server->console->server == server );
          server->console->server = NULL;
          server->console = NULL;
          wake_up( &server->obj, 0 );
      }
  }
  
  static void set_active_screen_buffer( struct console *console, struct screen_buffer *screen_buffer )
  {
      if (console->active == screen_buffer) return;
      if (console->active) release_object( console->active );
      console->active = (struct screen_buffer *)grab_object( screen_buffer );
  
      if (console->server) queue_host_ioctl( console->server, IOCTL_CONDRV_ACTIVATE,
                                             screen_buffer->id, NULL, NULL );
  }
  
  static struct object *create_screen_buffer( struct console *console )
  {
      struct screen_buffer *screen_buffer;
  
      if (console->last_id == ~0)
      {
          set_error( STATUS_NO_MEMORY );
          return NULL;
      }
  
      if (!(screen_buffer = alloc_object( &screen_buffer_ops )))
          return NULL;
  
      screen_buffer->id    = ++console->last_id;
      screen_buffer->input = console;
      init_async_queue( &screen_buffer->ioctl_q );
      list_add_head( &screen_buffer_list, &screen_buffer->entry );
  
      screen_buffer->fd = alloc_pseudo_fd( &screen_buffer_fd_ops, &screen_buffer->obj,
                                           FILE_SYNCHRONOUS_IO_NONALERT );
      if (!screen_buffer->fd)
      {
          release_object( screen_buffer );
          return NULL;
      }
      allow_fd_caching(screen_buffer->fd);
  
      if (console->server) queue_host_ioctl( console->server, IOCTL_CONDRV_INIT_OUTPUT,
                                             screen_buffer->id, NULL, NULL );
      if (!console->active) set_active_screen_buffer( console, screen_buffer );
      return &screen_buffer->obj;
  }
  
  struct thread *console_get_renderer( struct console *console )
  {
      return console->renderer;
  }
  
  struct console_signal_info
  {
      struct console        *console;
      process_id_t           group;
      int                    signal;
  };
  
  static int propagate_console_signal_cb(struct process *process, void *user)
  {
      struct console_signal_info* csi = (struct console_signal_info*)user;
  
      if (process->console == csi->console && process->running_threads &&
          (!csi->group || process->group_id == csi->group))
      {
          /* find a suitable thread to signal */
          struct thread *thread;
          LIST_FOR_EACH_ENTRY( thread, &process->thread_list, struct thread, proc_entry )
          {
              if (send_thread_signal( thread, csi->signal )) break;
          }
      }
      return FALSE;
  }
  
  static void propagate_console_signal( struct console *console,
                                        int sig, process_id_t group_id )
  {
      struct console_signal_info csi;
  
      if (!console)
      {
          set_error( STATUS_INVALID_PARAMETER );
          return;
      }
      /* FIXME: should support the other events (like CTRL_BREAK) */
      if (sig != CTRL_C_EVENT)
      {
          set_error( STATUS_NOT_IMPLEMENTED );
          return;
      }
      csi.console = console;
      csi.signal  = SIGINT;
      csi.group   = group_id;
  
      enum_processes(propagate_console_signal_cb, &csi);
  }
  
  /* dumb dump */
  static void console_dump( struct object *obj, int verbose )
  {
      struct console *console = (struct console *)obj;
      assert( obj->ops == &console_ops );
      fprintf( stderr, "Console input active=%p server=%p\n",
               console->active, console->server );
  }
  
  static void console_destroy( struct object *obj )
  {
      struct console *console = (struct console *)obj;
      struct screen_buffer *curr;
  
      assert( obj->ops == &console_ops );
  
      if (console->server)
      {
          assert( console->server->console == console );
          disconnect_console_server( console->server );
      }
  
      if (console->active) release_object( console->active );
      console->active = NULL;
  
      LIST_FOR_EACH_ENTRY( curr, &screen_buffer_list, struct screen_buffer, entry )
      {
          if (curr->input == console) curr->input = NULL;
      }
  
      free_async_queue( &console->ioctl_q );
      free_async_queue( &console->read_q );
      if (console->fd)
          release_object( console->fd );
  }
  
  static struct object *create_console_connection( struct console *console )
  {
      struct console_connection *connection;
  
      if (current->process->console)
      {
          set_error( STATUS_ACCESS_DENIED );
          return NULL;
      }
  
      if (!(connection = alloc_object( &console_connection_ops ))) return NULL;
      if (!(connection->fd = alloc_pseudo_fd( &console_connection_fd_ops, &connection->obj, 0 )))
      {
          release_object( connection );
          return NULL;
      }
  
      if (console)
          current->process->console = (struct console *)grab_object( console );
  
      return &connection->obj;
  }
  
  static struct object *console_lookup_name( struct object *obj, struct unicode_str *name,
                                             unsigned int attr, struct object *root )
  {
      struct console *console = (struct console *)obj;
      static const WCHAR connectionW[]    = {'C','o','n','n','e','c','t','i','o','n'};
      assert( obj->ops == &console_ops );
  
      if (name->len == sizeof(connectionW) && !memcmp( name->str, connectionW, name->len ))
      {
          name->len = 0;
          return create_console_connection( console );
      }
  
      return NULL;
  }
  
  static struct object *console_open_file( struct object *obj, unsigned int access,
                                                 unsigned int sharing, unsigned int options )
  {
      return grab_object( obj );
  }
  
  static void screen_buffer_dump( struct object *obj, int verbose )
  {
      struct screen_buffer *screen_buffer = (struct screen_buffer *)obj;
      assert( obj->ops == &screen_buffer_ops );
  
      fprintf(stderr, "Console screen buffer input=%p\n", screen_buffer->input );
  }
  
  static void screen_buffer_destroy( struct object *obj )
  {
      struct screen_buffer *screen_buffer = (struct screen_buffer *)obj;
  
      assert( obj->ops == &screen_buffer_ops );
  
      list_remove( &screen_buffer->entry );
      if (screen_buffer->input && screen_buffer->input->server)
          queue_host_ioctl( screen_buffer->input->server, IOCTL_CONDRV_CLOSE_OUTPUT,
                            screen_buffer->id, NULL, NULL );
      if (screen_buffer->fd) release_object( screen_buffer->fd );
      free_async_queue( &screen_buffer->ioctl_q );
  }
  
  static struct object *screen_buffer_open_file( struct object *obj, unsigned int access,
                                                 unsigned int sharing, unsigned int options )
  {
      return grab_object( obj );
  }
  
  static int screen_buffer_add_queue( struct object *obj, struct wait_queue_entry *entry )
  {
      struct screen_buffer *screen_buffer = (struct screen_buffer*)obj;
      if (!screen_buffer->input)
      {
          set_error( STATUS_ACCESS_DENIED );
          return 0;
      }
      return add_queue( &screen_buffer->input->obj, entry );
  }
  
  static struct fd *screen_buffer_get_fd( struct object *obj )
  {
      struct screen_buffer *screen_buffer = (struct screen_buffer*)obj;
      assert( obj->ops == &screen_buffer_ops );
      if (screen_buffer->fd)
          return (struct fd*)grab_object( screen_buffer->fd );
      set_error( STATUS_OBJECT_TYPE_MISMATCH );
      return NULL;
  }
  
  static void console_server_dump( struct object *obj, int verbose )
  {
      assert( obj->ops == &console_server_ops );
      fprintf( stderr, "Console server\n" );
  }
  
  static void console_server_destroy( struct object *obj )
  {
      struct console_server *server = (struct console_server *)obj;
      assert( obj->ops == &console_server_ops );
      disconnect_console_server( server );
      if (server->fd) release_object( server->fd );
  }
  
  static struct object *console_server_lookup_name( struct object *obj, struct unicode_str *name,
                                                    unsigned int attr, struct object *root )
  {
      struct console_server *server = (struct console_server*)obj;
      static const WCHAR referenceW[] = {'R','e','f','e','r','e','n','c','e'};
      assert( obj->ops == &console_server_ops );
  
      if (name->len == sizeof(referenceW) && !memcmp( name->str, referenceW, name->len ))
      {
          struct screen_buffer *screen_buffer;
          name->len = 0;
          if (server->console)
          {
              set_error( STATUS_INVALID_HANDLE );
              return 0;
          }
          if (!(server->console = (struct console *)create_console())) return NULL;
          if (!(screen_buffer = (struct screen_buffer *)create_screen_buffer( server->console )))
          {
              release_object( server->console );
              server->console = NULL;
              return NULL;
          }
          release_object( screen_buffer );
          server->console->server = server;
  
          return &server->console->obj;
      }
  
      return NULL;
  }
  
  static int console_server_signaled( struct object *obj, struct wait_queue_entry *entry )
  {
      struct console_server *server = (struct console_server*)obj;
      assert( obj->ops == &console_server_ops );
      return !server->console || !list_empty( &server->queue );
  }
  
  static struct fd *console_server_get_fd( struct object* obj )
  {
      struct console_server *server = (struct console_server*)obj;
      assert( obj->ops == &console_server_ops );
      return (struct fd *)grab_object( server->fd );
  }
  
  static struct object *console_server_open_file( struct object *obj, unsigned int access,
                                                  unsigned int sharing, unsigned int options )
  {
      return grab_object( obj );
  }
  
  static struct object *create_console_server( void )
  {
      struct console_server *server;
  
      if (!(server = alloc_object( &console_server_ops ))) return NULL;
      server->console = NULL;
      server->busy    = 0;
      server->term_fd = -1;
      list_init( &server->queue );
      list_init( &server->read_queue );
      server->fd = alloc_pseudo_fd( &console_server_fd_ops, &server->obj, FILE_SYNCHRONOUS_IO_NONALERT );
      if (!server->fd)
      {
          release_object( server );
          return NULL;
      }
      allow_fd_caching(server->fd);
  
      return &server->obj;
  }
  
  static int is_blocking_read_ioctl( unsigned int code )
  {
      switch (code)
      {
      case IOCTL_CONDRV_READ_INPUT:
      case IOCTL_CONDRV_READ_CONSOLE:
      case IOCTL_CONDRV_READ_FILE:
          return 1;
      default:
          return 0;
      }
  }
  
  static int console_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
  {
      struct console *console = get_fd_user( fd );
  
      switch (code)
      {
      case IOCTL_CONDRV_CTRL_EVENT:
          {
              const struct condrv_ctrl_event *event = get_req_data();
              process_id_t group;
              if (get_req_data_size() != sizeof(*event))
              {
                  set_error( STATUS_INVALID_PARAMETER );
                  return 0;
              }
              group = event->group_id ? event->group_id : current->process->group_id;
              if (!group)
              {
                  set_error( STATUS_INVALID_PARAMETER );
                  return 0;
              }
              propagate_console_signal( console, event->event, group );
              return !get_error();
          }
  
      default:
          if (!console->server || code >> 16 != FILE_DEVICE_CONSOLE)
          {
              set_error( STATUS_INVALID_HANDLE );
              return 0;
          }
          return queue_host_ioctl( console->server, code, 0, async, &console->ioctl_q );
      }
  }
  
  static int console_read( struct fd *fd, struct async *async, file_pos_t pos )
  {
      struct console *console = get_fd_user( fd );
  
      if (!console->server)
      {
          set_error( STATUS_INVALID_HANDLE );
          return 0;
      }
      return queue_host_ioctl( console->server, IOCTL_CONDRV_READ_FILE, 0, async, &console->ioctl_q );
  }
  
  static int console_flush( struct fd *fd, struct async *async )
  {
      struct console *console = get_fd_user( fd );
  
      if (!console->server)
      {
          set_error( STATUS_INVALID_HANDLE );
          return 0;
      }
      return queue_host_ioctl( console->server, IOCTL_CONDRV_FLUSH, 0, NULL, NULL );
  }
  
  static int screen_buffer_write( struct fd *fd, struct async *async, file_pos_t pos )
  {
      struct screen_buffer *screen_buffer = get_fd_user( fd );
      struct iosb *iosb;
  
      if (!screen_buffer->input || !screen_buffer->input->server)
      {
          set_error( STATUS_INVALID_HANDLE );
          return 0;
      }
  
      if (!queue_host_ioctl( screen_buffer->input->server, IOCTL_CONDRV_WRITE_FILE,
                             screen_buffer->id, async, &screen_buffer->ioctl_q ))
          return 0;
  
      /* we can't use default async handling, because write result is not
       * compatible with ioctl result */
      iosb = async_get_iosb( async );
      iosb->result = iosb->in_size;
      release_object( iosb );
      return 1;
  }
  
  static int screen_buffer_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
  {
      struct screen_buffer *screen_buffer = get_fd_user( fd );
  
      switch (code)
      {
      case IOCTL_CONDRV_ACTIVATE:
          if (!screen_buffer->input)
          {
              set_error( STATUS_INVALID_HANDLE );
              return 0;
          }
  
          set_active_screen_buffer( screen_buffer->input, screen_buffer );
          return 1;
  
      default:
          if (!screen_buffer->input || !screen_buffer->input->server || code >> 16 != FILE_DEVICE_CONSOLE ||
              is_blocking_read_ioctl( code ))
          {
              set_error( STATUS_INVALID_HANDLE );
              return 0;
          }
          return queue_host_ioctl( screen_buffer->input->server, code, screen_buffer->id,
                                   async, &screen_buffer->ioctl_q );
      }
  }
  
  static int console_connection_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
  {
      struct console_connection *console_connection = get_fd_user( fd );
  
      switch (code)
      {
      case IOCTL_CONDRV_BIND_PID:
          {
              struct process *process;
              unsigned int pid;
              if (get_req_data_size() != sizeof(unsigned int))
              {
                  set_error( STATUS_INVALID_PARAMETER );
                  return 0;
              }
              if (current->process->console)
              {
                  set_error( STATUS_INVALID_HANDLE );
                  return 0;
              }
  
              pid = *(unsigned int *)get_req_data();
              if (pid == ATTACH_PARENT_PROCESS) pid = current->process->parent_id;
              if (!(process = get_process_from_id( pid ))) return 0;
  
              if (process->console)
                  current->process->console = (struct console *)grab_object( process->console );
              else set_error( STATUS_ACCESS_DENIED );
              release_object( process );
              return !get_error();
          }
  
      default:
          return default_fd_ioctl( console_connection->fd, code, async );
      }
  }
  
  static int console_server_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
  {
      struct console_server *server = get_fd_user( fd );
  
      switch (code)
      {
      case IOCTL_CONDRV_CTRL_EVENT:
          {
              const struct condrv_ctrl_event *event = get_req_data();
              if (get_req_data_size() != sizeof(*event))
              {
                  set_error( STATUS_INVALID_PARAMETER );
                  return 0;
              }
              if (!server->console)
              {
                  set_error( STATUS_INVALID_HANDLE );
                  return 0;
              }
              propagate_console_signal( server->console, event->event, event->group_id );
              return !get_error();
          }
  
      case IOCTL_CONDRV_SETUP_INPUT:
          {
              struct termios term;
              obj_handle_t handle;
              struct file *file;
              int unix_fd;
  
              if (get_req_data_size() != sizeof(unsigned int) || get_reply_max_size())
              {
                  set_error( STATUS_INVALID_PARAMETER );
                  return 0;
              }
              if (server->term_fd != -1)
              {
                  tcsetattr( server->term_fd, TCSANOW, &server->termios );
                  close( server->term_fd );
                  server->term_fd = -1;
              }
              handle = *(unsigned int *)get_req_data();
              if (!handle) return 1;
              if (!(file = get_file_obj( current->process, handle, FILE_READ_DATA  )))
              {
                  return 0;
              }
              unix_fd = get_file_unix_fd( file );
              release_object( file );
  
              if (tcgetattr( unix_fd, &server->termios ))
              {
                  file_set_error();
                  return 0;
              }
              term = server->termios;
              term.c_lflag &= ~(ECHO | ECHONL | ICANON | IEXTEN);
              term.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
              term.c_cflag &= ~(CSIZE | PARENB);
              term.c_cflag |= CS8;
              term.c_cc[VMIN] = 1;
              term.c_cc[VTIME] = 0;
              if (tcsetattr( unix_fd, TCSANOW, &term ) || (server->term_fd = dup( unix_fd )) == -1)
              {
                  file_set_error();
                  return 0;
              }
              return 1;
          }
  
      default:
          set_error( STATUS_INVALID_HANDLE );
          return 0;
      }
  }
  
  static void console_connection_dump( struct object *obj, int verbose )
  {
      fputs( "console connection\n", stderr );
  }
  
  static struct fd *console_connection_get_fd( struct object *obj )
  {
      struct console_connection *connection = (struct console_connection *)obj;
      return (struct fd *)grab_object( connection->fd );
  }
  
  static struct object *console_connection_lookup_name( struct object *obj, struct unicode_str *name,
                                                        unsigned int attr, struct object *root )
  {
      static const WCHAR referenceW[] = {'R','e','f','e','r','e','n','c','e'};
  
      if (name->len == sizeof(referenceW) && !memcmp( name->str, referenceW, name->len ))
      {
          if (!current->process->console)
          {
              set_error( STATUS_INVALID_HANDLE );
              return NULL;
          }
          name->len = 0;
          return grab_object( current->process->console );
      }
  
      return NULL;
  }
  
  static struct object *console_connection_open_file( struct object *obj, unsigned int access,
                                                      unsigned int sharing, unsigned int options )
  {
      return grab_object( obj );
  }
  
  static int console_connection_close_handle( struct object *obj, struct process *process, obj_handle_t handle )
  {
      struct console *console = process->console;
  
      if (console)
      {
          process->console = NULL;
          release_object( console );
      }
      return 1;
  }
  
  static void console_connection_destroy( struct object *obj )
  {
      struct console_connection *connection = (struct console_connection *)obj;
      if (connection->fd) release_object( connection->fd );
  }
  
  static struct object_type *console_device_get_type( struct object *obj )
  {
      static const WCHAR name[] = {'D','e','v','i','c','e'};
      static const struct unicode_str str = { name, sizeof(name) };
      return get_object_type( &str );
  }
  
  static void console_device_dump( struct object *obj, int verbose )
  {
      fputs( "Console device\n", stderr );
  }
  
  static struct object *console_device_lookup_name( struct object *obj, struct unicode_str *name,
                                                    unsigned int attr, struct object *root )
  {
      static const WCHAR connectionW[]    = {'C','o','n','n','e','c','t','i','o','n'};
      static const WCHAR consoleW[]       = {'C','o','n','s','o','l','e'};
      static const WCHAR current_inW[]    = {'C','u','r','r','e','n','t','I','n'};
      static const WCHAR current_outW[]   = {'C','u','r','r','e','n','t','O','u','t'};
      static const WCHAR inputW[]         = {'I','n','p','u','t'};
      static const WCHAR outputW[]        = {'O','u','t','p','u','t'};
      static const WCHAR screen_bufferW[] = {'S','c','r','e','e','n','B','u','f','f','e','r'};
      static const WCHAR serverW[]        = {'S','e','r','v','e','r'};
  
      if (name->len == sizeof(current_inW) && !memcmp( name->str, current_inW, name->len ))
      {
          if (!current->process->console)
          {
              set_error( STATUS_INVALID_HANDLE );
              return NULL;
          }
          name->len = 0;
          return grab_object( current->process->console );
      }
  
      if (name->len == sizeof(current_outW) && !memcmp( name->str, current_outW, name->len ))
      {
          if (!current->process->console || !current->process->console->active)
          {
              set_error( STATUS_INVALID_HANDLE );
              return NULL;
          }
          name->len = 0;
          return grab_object( current->process->console->active );
      }
  
      if (name->len == sizeof(consoleW) && !memcmp( name->str, consoleW, name->len ))
      {
          name->len = 0;
          return grab_object( obj );
      }
  
      if (name->len == sizeof(inputW) && !memcmp( name->str, inputW, name->len ))
      {
          struct console_input *console_input;
          name->len = 0;
          if (!(console_input = alloc_object( &console_input_ops ))) return NULL;
          console_input->fd = alloc_pseudo_fd( &console_input_fd_ops, &console_input->obj,
                                               FILE_SYNCHRONOUS_IO_NONALERT );
          if (!console_input->fd)
          {
              release_object( console_input );
              return NULL;
          }
          return &console_input->obj;
      }
  
      if (name->len == sizeof(outputW) && !memcmp( name->str, outputW, name->len ))
      {
          struct console_output *console_output;
          name->len = 0;
          if (!(console_output = alloc_object( &console_output_ops ))) return NULL;
          console_output->fd = alloc_pseudo_fd( &console_output_fd_ops, &console_output->obj,
                                               FILE_SYNCHRONOUS_IO_NONALERT );
          if (!console_output->fd)
          {
              release_object( console_output );
              return NULL;
          }
          return &console_output->obj;
      }
  
      if (name->len == sizeof(screen_bufferW) && !memcmp( name->str, screen_bufferW, name->len ))
      {
          if (!current->process->console)
          {
              set_error( STATUS_INVALID_HANDLE );
              return NULL;
          }
          name->len = 0;
          return create_screen_buffer( current->process->console );
      }
  
      if (name->len == sizeof(serverW) && !memcmp( name->str, serverW, name->len ))
      {
          name->len = 0;
          return create_console_server();
      }
  
      if (name->len == sizeof(connectionW) && !memcmp( name->str, connectionW, name->len ))
      {
          name->len = 0;
          return create_console_connection( NULL );
      }
  
      return NULL;
  }
  
  static struct object *console_device_open_file( struct object *obj, unsigned int access,
                                                  unsigned int sharing, unsigned int options )
  {
      int is_output;
      access = default_fd_map_access( obj, access );
      is_output = access & FILE_WRITE_DATA;
      if (!current->process->console || (is_output && !current->process->console))
      {
          set_error( STATUS_INVALID_HANDLE );
          return NULL;
      }
      if (is_output && (access & FILE_READ_DATA))
      {
          set_error( STATUS_INVALID_PARAMETER );
          return NULL;
      }
      return is_output ? grab_object( current->process->console->active ) : grab_object( current->process->console );
  }
  
  static void console_input_dump( struct object *obj, int verbose )
  {
      fputs( "console Input device\n", stderr );
  }
  
  static int console_input_add_queue( struct object *obj, struct wait_queue_entry *entry )
  {
      if (!current->process->console)
      {
          set_error( STATUS_ACCESS_DENIED );
          return 0;
      }
      return add_queue( &current->process->console->obj, entry );
  }
  
  static struct fd *console_input_get_fd( struct object *obj )
  {
      struct console_input *console_input = (struct console_input *)obj;
      assert( obj->ops == &console_input_ops );
      return (struct fd *)grab_object( console_input->fd );
  }
  
  static struct object *console_input_open_file( struct object *obj, unsigned int access,
                                                 unsigned int sharing, unsigned int options )
  {
      return grab_object( obj );
  }
  
  static void console_input_destroy( struct object *obj )
  {
      struct console_input *console_input = (struct console_input *)obj;
  
      assert( obj->ops == &console_input_ops );
      if (console_input->fd) release_object( console_input->fd );
  }
  
  static int console_input_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
  {
      struct console *console = current->process->console;
  
      if (!console)
      {
          set_error( STATUS_INVALID_HANDLE );
          return 0;
      }
      return console_ioctl( console->fd, code, async );
  }
  
  static int console_input_read( struct fd *fd, struct async *async, file_pos_t pos )
  {
      struct console *console = current->process->console;
  
      if (!console)
      {
          set_error( STATUS_INVALID_HANDLE );
          return 0;
      }
      return console_read( console->fd, async, pos );
  }
  
  static int console_input_flush( struct fd *fd, struct async *async )
  {
      struct console *console = current->process->console;
  
      if (!console)
      {
          set_error( STATUS_INVALID_HANDLE );
          return 0;
      }
      return console_flush( console->fd, async );
  }
  
  static void console_output_dump( struct object *obj, int verbose )
  {
      fputs( "console Output device\n", stderr );
  }
  
  static int console_output_add_queue( struct object *obj, struct wait_queue_entry *entry )
  {
      if (!current->process->console || !current->process->console->active)
      {
          set_error( STATUS_ACCESS_DENIED );
          return 0;
      }
      return add_queue( &current->process->console->obj, entry );
  }
  
  static struct fd *console_output_get_fd( struct object *obj )
  {
      struct console_output *console_output = (struct console_output *)obj;
      assert( obj->ops == &console_output_ops );
      return (struct fd *)grab_object( console_output->fd );
  }
  
  static struct object *console_output_open_file( struct object *obj, unsigned int access,
                                                  unsigned int sharing, unsigned int options )
  {
      return grab_object( obj );
  }
  
  static void console_output_destroy( struct object *obj )
  {
      struct console_output *console_output = (struct console_output *)obj;
  
      assert( obj->ops == &console_output_ops );
      if (console_output->fd) release_object( console_output->fd );
  }
  
  static int console_output_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
  {
      struct console *console = current->process->console;
  
      if (!console || !console->active)
      {
          set_error( STATUS_INVALID_HANDLE );
          return 0;
      }
      return screen_buffer_ioctl( console->active->fd, code, async );
  }
  
  static int console_output_write( struct fd *fd, struct async *async, file_pos_t pos )
  {
      struct console *console = current->process->console;
  
      if (!console || !console->active)
      {
          set_error( STATUS_INVALID_HANDLE );
          return 0;
      }
      return screen_buffer_write( console->active->fd, async, pos );
  }
  
  struct object *create_console_device( struct object *root, const struct unicode_str *name,
                                        unsigned int attr, const struct security_descriptor *sd )
  {
      return create_named_object( root, &console_device_ops, name, attr, sd );
  }
  
  /* retrieve the next pending console ioctl request */
  DECL_HANDLER(get_next_console_request)
  {
      struct console_host_ioctl *ioctl = NULL, *next;
      struct console_server *server;
      struct iosb *iosb = NULL;
  
      server = (struct console_server *)get_handle_obj( current->process, req->handle, 0, &console_server_ops );
      if (!server) return;
  
      if (!server->console)
      {
          set_error( STATUS_INVALID_HANDLE );
          release_object( server );
          return;
      }
  
      if (!server->console->renderer) server->console->renderer = current;
  
      if (!req->signal) server->console->signaled = 0;
      else if (!server->console->signaled)
      {
          server->console->signaled = 1;
          wake_up( &server->console->obj, 0 );
      }
  
      if (req->read)
      {
          /* set result of current pending ioctl */
          if (list_empty( &server->read_queue ))
          {
              set_error( STATUS_INVALID_HANDLE );
              release_object( server );
              return;
          }
  
          ioctl = LIST_ENTRY( list_head( &server->read_queue ), struct console_host_ioctl, entry );
          list_remove( &ioctl->entry );
          list_move_tail( &server->queue, &server->read_queue );
      }
      else if (server->busy)
      {
          /* set result of previous ioctl */
          ioctl = LIST_ENTRY( list_head( &server->queue ), struct console_host_ioctl, entry );
          list_remove( &ioctl->entry );
      }
  
      if (ioctl)
      {
          unsigned int status = req->status;
          if (status == STATUS_PENDING) status = STATUS_INVALID_PARAMETER;
          if (ioctl->async)
          {
              iosb = async_get_iosb( ioctl->async );
              if (iosb->status == STATUS_PENDING)
              {
                  iosb->status = status;
                  iosb->out_size = min( iosb->out_size, get_req_data_size() );
                  if (iosb->out_size)
                  {
                      if ((iosb->out_data = memdup( get_req_data(), iosb->out_size )))
                      {
                          iosb->result = iosb->out_size;
                      }
                      else if (!status)
                      {
                          iosb->status = STATUS_NO_MEMORY;
                          iosb->out_size = 0;
                      }
                  }
                  if (iosb->result) status = STATUS_ALERTED;
              }
              else
              {
                  release_object( ioctl->async );
                  ioctl->async = NULL;
              }
          }
          console_host_ioctl_terminate( ioctl, status );
          if (iosb) release_object( iosb );
  
          if (req->read)
          {
              release_object( server );
              return;
          }
          server->busy = 0;
      }
  
      /* if we have a blocking read ioctl in queue head and previous blocking read is still waiting,
       * move it to read queue for execution after current read is complete. move all blocking
       * ioctl at the same time to preserve their order. */
      if (!list_empty( &server->queue ) && !list_empty( &server->read_queue ))
      {
          ioctl = LIST_ENTRY( list_head( &server->queue ), struct console_host_ioctl, entry );
          if (is_blocking_read_ioctl( ioctl->code ))
          {
              LIST_FOR_EACH_ENTRY_SAFE( ioctl, next, &server->queue, struct console_host_ioctl, entry )
              {
                  if (!is_blocking_read_ioctl( ioctl->code )) continue;
                  list_remove( &ioctl->entry );
                  list_add_tail( &server->read_queue, &ioctl->entry );
              }
          }
      }
  
      /* return the next ioctl */
      if (!list_empty( &server->queue ))
      {
          ioctl = LIST_ENTRY( list_head( &server->queue ), struct console_host_ioctl, entry );
          iosb = ioctl->async ? async_get_iosb( ioctl->async ) : NULL;
  
          if (!iosb || get_reply_max_size() >= iosb->in_size)
          {
              reply->code   = ioctl->code;
              reply->output = ioctl->output;
  
              if (iosb)
              {
                  reply->out_size = iosb->out_size;
                  set_reply_data_ptr( iosb->in_data, iosb->in_size );
                  iosb->in_data = NULL;
              }
  
              if (is_blocking_read_ioctl( ioctl->code ))
              {
                  list_remove( &ioctl->entry );
                  assert( list_empty( &server->read_queue ));
                  list_add_tail( &server->read_queue, &ioctl->entry );
              }
              else server->busy = 1;
          }
          else
          {
              reply->out_size = iosb->in_size;
              set_error( STATUS_BUFFER_OVERFLOW );
          }
          if (iosb) release_object( iosb );
      }
      else
      {
          set_error( STATUS_PENDING );
      }
  
      release_object( server );
  }
  