1646 lines
56 KiB
C
1646 lines
56 KiB
C
/*
|
|
* 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 <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 int console_add_queue( struct object *obj, struct wait_queue_entry *entry );
|
|
|
|
static const struct object_ops console_ops =
|
|
{
|
|
sizeof(struct console), /* size */
|
|
&file_type, /* type */
|
|
console_dump, /* dump */
|
|
console_add_queue, /* add_queue */
|
|
remove_queue, /* remove_queue */
|
|
console_signaled, /* signaled */
|
|
no_satisfied, /* satisfied */
|
|
no_signal, /* signal */
|
|
console_get_fd, /* get_fd */
|
|
default_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, struct async *async, unsigned int info_class );
|
|
static void console_read( struct fd *fd, struct async *async, file_pos_t pos );
|
|
static void console_flush( struct fd *fd, struct async *async );
|
|
static void 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_cancel_async, /* cancel_async */
|
|
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 */
|
|
unsigned int busy : 1; /* flag if server processing an ioctl */
|
|
unsigned int once_input : 1; /* flag if input thread has already been requested */
|
|
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 */
|
|
&file_type, /* type */
|
|
console_server_dump, /* dump */
|
|
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_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 */
|
|
no_close_handle, /* close_handle */
|
|
console_server_destroy /* destroy */
|
|
};
|
|
|
|
static void 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_cancel_async, /* cancel_async */
|
|
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 */
|
|
&file_type, /* type */
|
|
screen_buffer_dump, /* dump */
|
|
screen_buffer_add_queue, /* add_queue */
|
|
NULL, /* remove_queue */
|
|
NULL, /* signaled */
|
|
NULL, /* satisfied */
|
|
no_signal, /* signal */
|
|
screen_buffer_get_fd, /* get_fd */
|
|
default_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 void screen_buffer_write( struct fd *fd, struct async *async, file_pos_t pos );
|
|
static void 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_cancel_async, /* cancel_async */
|
|
default_fd_queue_async, /* queue_async */
|
|
default_fd_reselect_async /* reselect_async */
|
|
};
|
|
|
|
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 */
|
|
&device_type, /* type */
|
|
console_device_dump, /* dump */
|
|
no_add_queue, /* add_queue */
|
|
NULL, /* remove_queue */
|
|
NULL, /* signaled */
|
|
no_satisfied, /* satisfied */
|
|
no_signal, /* signal */
|
|
no_get_fd, /* get_fd */
|
|
default_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 */
|
|
&device_type, /* type */
|
|
console_input_dump, /* dump */
|
|
console_input_add_queue, /* add_queue */
|
|
NULL, /* remove_queue */
|
|
NULL, /* signaled */
|
|
no_satisfied, /* satisfied */
|
|
no_signal, /* signal */
|
|
console_input_get_fd, /* get_fd */
|
|
default_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 void console_input_read( struct fd *fd, struct async *async, file_pos_t pos );
|
|
static void console_input_flush( struct fd *fd, struct async *async );
|
|
static void 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_cancel_async, /* cancel_async */
|
|
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 */
|
|
&device_type, /* type */
|
|
console_output_dump, /* dump */
|
|
console_output_add_queue, /* add_queue */
|
|
NULL, /* remove_queue */
|
|
NULL, /* signaled */
|
|
no_satisfied, /* satisfied */
|
|
no_signal, /* signal */
|
|
console_output_get_fd, /* get_fd */
|
|
default_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 void console_output_write( struct fd *fd, struct async *async, file_pos_t pos );
|
|
static void 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_cancel_async, /* cancel_async */
|
|
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 */
|
|
&device_type, /* type */
|
|
console_connection_dump, /* dump */
|
|
no_add_queue, /* add_queue */
|
|
NULL, /* remove_queue */
|
|
NULL, /* signaled */
|
|
no_satisfied, /* satisfied */
|
|
no_signal, /* signal */
|
|
console_connection_get_fd, /* get_fd */
|
|
default_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 void 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_cancel_async, /* cancel_async */
|
|
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 queue_host_ioctl( struct console_server *server, unsigned int code, unsigned int output,
|
|
struct async *async, struct async_queue *queue );
|
|
|
|
static int console_add_queue( struct object *obj, struct wait_queue_entry *entry )
|
|
{
|
|
struct console *console = (struct console*)obj;
|
|
assert( obj->ops == &console_ops );
|
|
/* before waiting, ensure conhost's input thread has been started */
|
|
if (console->server && !console->server->once_input)
|
|
{
|
|
console->server->once_input = 1;
|
|
if (console->server->term_fd == -1)
|
|
queue_host_ioctl( console->server, IOCTL_CONDRV_PEEK, 0, NULL, NULL );
|
|
}
|
|
return add_queue( &console->obj, entry );
|
|
}
|
|
|
|
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, struct async *async, 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 && (!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);
|
|
}
|
|
|
|
struct console_process_list
|
|
{
|
|
unsigned int size;
|
|
unsigned int count;
|
|
process_id_t *processes;
|
|
struct console *console;
|
|
};
|
|
|
|
static int console_process_list_cb(struct process *process, void *user)
|
|
{
|
|
struct console_process_list *cpl = user;
|
|
|
|
if (process->console == cpl->console)
|
|
{
|
|
if (cpl->count < cpl->size) cpl->processes[cpl->count] = process->id;
|
|
cpl->count++;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* 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 console_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->once_input = 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_CONSOLE_CONTROL:
|
|
case IOCTL_CONDRV_READ_FILE:
|
|
return 1;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
static void 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;
|
|
}
|
|
group = event->group_id ? event->group_id : current->process->group_id;
|
|
if (!group)
|
|
{
|
|
set_error( STATUS_INVALID_PARAMETER );
|
|
return;
|
|
}
|
|
propagate_console_signal( console, event->event, group );
|
|
return;
|
|
}
|
|
|
|
case IOCTL_CONDRV_GET_PROCESS_LIST:
|
|
{
|
|
struct console_process_list cpl;
|
|
if (get_reply_max_size() < sizeof(unsigned int))
|
|
{
|
|
set_error( STATUS_INVALID_PARAMETER );
|
|
return;
|
|
}
|
|
|
|
cpl.count = 0;
|
|
cpl.size = 0;
|
|
cpl.console = console;
|
|
enum_processes( console_process_list_cb, &cpl );
|
|
if (cpl.count * sizeof(process_id_t) > get_reply_max_size())
|
|
{
|
|
set_reply_data( &cpl.count, sizeof(cpl.count) );
|
|
set_error( STATUS_BUFFER_TOO_SMALL );
|
|
return;
|
|
}
|
|
|
|
cpl.size = cpl.count;
|
|
cpl.count = 0;
|
|
if ((cpl.processes = set_reply_data_size( cpl.size * sizeof(process_id_t) )))
|
|
enum_processes( console_process_list_cb, &cpl );
|
|
return;
|
|
}
|
|
|
|
default:
|
|
if (!console->server || code >> 16 != FILE_DEVICE_CONSOLE)
|
|
{
|
|
set_error( STATUS_INVALID_HANDLE );
|
|
return;
|
|
}
|
|
queue_host_ioctl( console->server, code, 0, async, &console->ioctl_q );
|
|
}
|
|
}
|
|
|
|
static void 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;
|
|
}
|
|
queue_host_ioctl( console->server, IOCTL_CONDRV_READ_FILE, 0, async, &console->ioctl_q );
|
|
}
|
|
|
|
static void console_flush( struct fd *fd, struct async *async )
|
|
{
|
|
struct console *console = get_fd_user( fd );
|
|
|
|
if (!console->server)
|
|
{
|
|
set_error( STATUS_INVALID_HANDLE );
|
|
return;
|
|
}
|
|
queue_host_ioctl( console->server, IOCTL_CONDRV_FLUSH, 0, NULL, NULL );
|
|
}
|
|
|
|
static void screen_buffer_write( struct fd *fd, struct async *async, file_pos_t pos )
|
|
{
|
|
struct screen_buffer *screen_buffer = get_fd_user( fd );
|
|
|
|
if (!screen_buffer->input || !screen_buffer->input->server)
|
|
{
|
|
set_error( STATUS_INVALID_HANDLE );
|
|
return;
|
|
}
|
|
|
|
queue_host_ioctl( screen_buffer->input->server, IOCTL_CONDRV_WRITE_FILE,
|
|
screen_buffer->id, async, &screen_buffer->ioctl_q );
|
|
}
|
|
|
|
static void 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;
|
|
}
|
|
|
|
set_active_screen_buffer( screen_buffer->input, screen_buffer );
|
|
return;
|
|
|
|
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;
|
|
}
|
|
queue_host_ioctl( screen_buffer->input->server, code, screen_buffer->id,
|
|
async, &screen_buffer->ioctl_q );
|
|
}
|
|
}
|
|
|
|
static void 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;
|
|
}
|
|
if (current->process->console)
|
|
{
|
|
set_error( STATUS_INVALID_HANDLE );
|
|
return;
|
|
}
|
|
|
|
pid = *(unsigned int *)get_req_data();
|
|
if (pid == ATTACH_PARENT_PROCESS) pid = current->process->parent_id;
|
|
if (!(process = get_process_from_id( pid ))) return;
|
|
|
|
if (process->console)
|
|
current->process->console = (struct console *)grab_object( process->console );
|
|
else set_error( STATUS_ACCESS_DENIED );
|
|
release_object( process );
|
|
return;
|
|
}
|
|
|
|
default:
|
|
default_fd_ioctl( console_connection->fd, code, async );
|
|
}
|
|
}
|
|
|
|
static void 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;
|
|
}
|
|
if (!server->console)
|
|
{
|
|
set_error( STATUS_INVALID_HANDLE );
|
|
return;
|
|
}
|
|
propagate_console_signal( server->console, event->event, event->group_id );
|
|
return;
|
|
}
|
|
|
|
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;
|
|
}
|
|
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;
|
|
if (!(file = get_file_obj( current->process, handle, FILE_READ_DATA )))
|
|
{
|
|
return;
|
|
}
|
|
unix_fd = get_file_unix_fd( file );
|
|
release_object( file );
|
|
|
|
if (tcgetattr( unix_fd, &server->termios ))
|
|
{
|
|
file_set_error();
|
|
return;
|
|
}
|
|
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;
|
|
}
|
|
|
|
default:
|
|
set_error( STATUS_INVALID_HANDLE );
|
|
return;
|
|
}
|
|
}
|
|
|
|
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 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_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 console_add_queue( ¤t->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 void 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;
|
|
}
|
|
console_ioctl( console->fd, code, async );
|
|
}
|
|
|
|
static void 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;
|
|
}
|
|
console_read( console->fd, async, pos );
|
|
}
|
|
|
|
static void console_input_flush( struct fd *fd, struct async *async )
|
|
{
|
|
struct console *console = current->process->console;
|
|
|
|
if (!console)
|
|
{
|
|
set_error( STATUS_INVALID_HANDLE );
|
|
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 console_add_queue( ¤t->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 void 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;
|
|
}
|
|
screen_buffer_ioctl( console->active->fd, code, async );
|
|
}
|
|
|
|
static void 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;
|
|
}
|
|
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)
|
|
{
|
|
struct async *async = ioctl->async;
|
|
unsigned int status = req->status;
|
|
|
|
if (status == STATUS_PENDING) status = STATUS_INVALID_PARAMETER;
|
|
if (async)
|
|
{
|
|
iosb = async_get_iosb( async );
|
|
if (iosb->status == STATUS_PENDING)
|
|
{
|
|
data_size_t out_size = min( iosb->out_size, get_req_data_size() );
|
|
data_size_t result = ioctl->code == IOCTL_CONDRV_WRITE_FILE ? iosb->in_size : out_size;
|
|
async_request_complete_alloc( async, status, result, out_size, get_req_data() );
|
|
}
|
|
|
|
release_object( async );
|
|
}
|
|
free( ioctl );
|
|
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 );
|
|
}
|