?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msvcr120: Add [_]strtoimax[_l] and [_]strtoumax[_l].
[wine.git] / server / console.c
blobc9db27935e635eb91fa4a4fff7418e0db0205f52
1 /*
2 * Server-side console management
3 *
4 * Copyright (C) 1998 Alexandre Julliard
5 * 2001 Eric Pouech
6 *
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <assert.h>
27 #include <string.h>
28 #include <stdio.h>
29 #include <unistd.h>
30 #include <signal.h>
31
32 #include "ntstatus.h"
33 #define WIN32_NO_STATUS
34 #include "handle.h"
35 #include "process.h"
36 #include "request.h"
37 #include "file.h"
38 #include "unicode.h"
39 #include "wincon.h"
40 #include "winternl.h"
41 #include "wine/condrv.h"
42
43 struct screen_buffer;
44 struct console_input_events;
45
46 struct history_line
47 {
48 data_size_t len;
49 WCHAR text[1];
50 };
51
52 struct console_input
53 {
54 struct object obj; /* object header */
55 int num_proc; /* number of processes attached to this console */
56 struct thread *renderer; /* console renderer thread */
57 int mode; /* input mode */
58 struct screen_buffer *active; /* active screen buffer */
59 int recnum; /* number of input records */
60 INPUT_RECORD *records; /* input records */
61 struct console_input_events *evt; /* synchronization event with renderer */
62 struct console_server *server; /* console server object */
63 WCHAR *title; /* console title */
64 data_size_t title_len; /* length of console title */
65 struct history_line **history; /* lines history */
66 int history_size; /* number of entries in history array */
67 int history_index; /* number of used entries in history array */
68 int history_mode; /* mode of history (non zero means remove doubled strings */
69 int edition_mode; /* index to edition mode flavors */
70 int input_cp; /* console input codepage */
71 int output_cp; /* console output codepage */
72 user_handle_t win; /* window handle if backend supports it */
73 unsigned int last_id; /* id of last created console buffer */
74 struct event *event; /* event to wait on for input queue */
75 struct fd *fd; /* for bare console, attached input fd */
76 struct async_queue ioctl_q; /* ioctl queue */
77 struct async_queue read_q; /* read queue */
78 };
79
80 static void console_input_dump( struct object *obj, int verbose );
81 static void console_input_destroy( struct object *obj );
82 static struct fd *console_input_get_fd( struct object *obj );
83 static struct object *console_input_open_file( struct object *obj, unsigned int access,
84 unsigned int sharing, unsigned int options );
85
86 static const struct object_ops console_input_ops =
87 {
88 sizeof(struct console_input), /* size */
89 console_input_dump, /* dump */
90 no_get_type, /* get_type */
91 no_add_queue, /* add_queue */
92 NULL, /* remove_queue */
93 NULL, /* signaled */
94 no_satisfied, /* satisfied */
95 no_signal, /* signal */
96 console_input_get_fd, /* get_fd */
97 default_fd_map_access, /* map_access */
98 default_get_sd, /* get_sd */
99 default_set_sd, /* set_sd */
100 no_lookup_name, /* lookup_name */
101 no_link_name, /* link_name */
102 NULL, /* unlink_name */
103 console_input_open_file, /* open_file */
104 no_kernel_obj_list, /* get_kernel_obj_list */
105 no_close_handle, /* close_handle */
106 console_input_destroy /* destroy */
107 };
108
109 static enum server_fd_type console_get_fd_type( struct fd *fd );
110 static int console_input_ioctl( struct fd *fd, ioctl_code_t code, struct async *async );
111
112 static const struct fd_ops console_input_fd_ops =
113 {
114 default_fd_get_poll_events, /* get_poll_events */
115 default_poll_event, /* poll_event */
116 console_get_fd_type, /* get_fd_type */
117 no_fd_read, /* read */
118 no_fd_write, /* write */
119 no_fd_flush, /* flush */
120 no_fd_get_file_info, /* get_file_info */
121 no_fd_get_volume_info, /* get_volume_info */
122 console_input_ioctl, /* ioctl */
123 default_fd_queue_async, /* queue_async */
124 default_fd_reselect_async /* reselect_async */
125 };
126
127 static void console_input_events_dump( struct object *obj, int verbose );
128 static void console_input_events_destroy( struct object *obj );
129 static struct fd *console_input_events_get_fd( struct object *obj );
130 static struct object *console_input_events_open_file( struct object *obj, unsigned int access,
131 unsigned int sharing, unsigned int options );
132
133 struct console_input_events
134 {
135 struct object obj; /* object header */
136 struct fd *fd; /* pseudo-fd for ioctls */
137 struct console_input *console; /* attached console */
138 int num_alloc; /* number of allocated events */
139 int num_used; /* number of actually used events */
140 struct condrv_renderer_event *events;
141 struct async_queue read_q; /* read queue */
142 };
143
144 static const struct object_ops console_input_events_ops =
145 {
146 sizeof(struct console_input_events), /* size */
147 console_input_events_dump, /* dump */
148 no_get_type, /* get_type */
149 add_queue, /* add_queue */
150 remove_queue, /* remove_queue */
151 NULL, /* signaled */
152 no_satisfied, /* satisfied */
153 no_signal, /* signal */
154 console_input_events_get_fd, /* get_fd */
155 default_fd_map_access, /* map_access */
156 default_get_sd, /* get_sd */
157 default_set_sd, /* set_sd */
158 no_lookup_name, /* lookup_name */
159 no_link_name, /* link_name */
160 NULL, /* unlink_name */
161 console_input_events_open_file, /* open_file */
162 no_kernel_obj_list, /* get_kernel_obj_list */
163 no_close_handle, /* close_handle */
164 console_input_events_destroy /* destroy */
165 };
166
167 static int console_input_events_ioctl( struct fd *fd, ioctl_code_t code, struct async *async );
168
169 static const struct fd_ops console_input_events_fd_ops =
170 {
171 default_fd_get_poll_events, /* get_poll_events */
172 default_poll_event, /* poll_event */
173 console_get_fd_type, /* get_fd_type */
174 no_fd_read, /* read */
175 no_fd_write, /* write */
176 no_fd_flush, /* flush */
177 no_fd_get_file_info, /* get_file_info */
178 no_fd_get_volume_info, /* get_volume_info */
179 console_input_events_ioctl, /* ioctl */
180 default_fd_queue_async, /* queue_async */
181 default_fd_reselect_async /* reselect_async */
182 };
183
184 struct console_host_ioctl
185 {
186 unsigned int code; /* ioctl code */
187 int output; /* output id for screen buffer ioctls */
188 struct async *async; /* ioctl async */
189 struct list entry; /* list entry */
190 };
191
192 struct console_server
193 {
194 struct object obj; /* object header */
195 struct fd *fd; /* pseudo-fd for ioctls */
196 struct console_input *console; /* attached console */
197 struct list queue; /* ioctl queue */
198 struct list read_queue; /* blocking read queue */
199 int busy; /* flag if server processing an ioctl */
200 };
201
202 static void console_server_dump( struct object *obj, int verbose );
203 static void console_server_destroy( struct object *obj );
204 static int console_server_signaled( struct object *obj, struct wait_queue_entry *entry );
205 static struct fd *console_server_get_fd( struct object *obj );
206 static struct object *console_server_lookup_name( struct object *obj, struct unicode_str *name, unsigned int attr );
207 static struct object *console_server_open_file( struct object *obj, unsigned int access,
208 unsigned int sharing, unsigned int options );
209
210 static const struct object_ops console_server_ops =
211 {
212 sizeof(struct console_server), /* size */
213 console_server_dump, /* dump */
214 no_get_type, /* get_type */
215 add_queue, /* add_queue */
216 remove_queue, /* remove_queue */
217 console_server_signaled, /* signaled */
218 no_satisfied, /* satisfied */
219 no_signal, /* signal */
220 console_server_get_fd, /* get_fd */
221 default_fd_map_access, /* map_access */
222 default_get_sd, /* get_sd */
223 default_set_sd, /* set_sd */
224 console_server_lookup_name, /* lookup_name */
225 no_link_name, /* link_name */
226 NULL, /* unlink_name */
227 console_server_open_file, /* open_file */
228 no_kernel_obj_list, /* get_kernel_obj_list */
229 fd_close_handle, /* close_handle */
230 console_server_destroy /* destroy */
231 };
232
233 static int console_server_ioctl( struct fd *fd, ioctl_code_t code, struct async *async );
234
235 static const struct fd_ops console_server_fd_ops =
236 {
237 default_fd_get_poll_events, /* get_poll_events */
238 default_poll_event, /* poll_event */
239 console_get_fd_type, /* get_fd_type */
240 no_fd_read, /* read */
241 no_fd_write, /* write */
242 no_fd_flush, /* flush */
243 no_fd_get_file_info, /* get_file_info */
244 no_fd_get_volume_info, /* get_volume_info */
245 console_server_ioctl, /* ioctl */
246 default_fd_queue_async, /* queue_async */
247 default_fd_reselect_async /* reselect_async */
248 };
249
250 struct font_info
251 {
252 short int width;
253 short int height;
254 short int weight;
255 short int pitch_family;
256 WCHAR *face_name;
257 data_size_t face_len;
258 };
259
260 struct screen_buffer
261 {
262 struct object obj; /* object header */
263 struct list entry; /* entry in list of all screen buffers */
264 struct console_input *input; /* associated console input */
265 unsigned int id; /* buffer id */
266 unsigned int mode; /* output mode */
267 int cursor_size; /* size of cursor (percentage filled) */
268 int cursor_visible;/* cursor visibility flag */
269 int cursor_x; /* position of cursor */
270 int cursor_y; /* position of cursor */
271 int width; /* size (w-h) of the screen buffer */
272 int height;
273 int max_width; /* size (w-h) of the window given font size */
274 int max_height;
275 char_info_t *data; /* the data for each cell - a width x height matrix */
276 unsigned short attr; /* default fill attributes (screen colors) */
277 unsigned short popup_attr; /* pop-up color attributes */
278 unsigned int color_map[16]; /* color table */
279 rectangle_t win; /* current visible window on the screen buffer *
280 * as seen in wineconsole */
281 struct font_info font; /* console font information */
282 struct fd *fd; /* for bare console, attached output fd */
283 struct async_queue ioctl_q; /* ioctl queue */
284 };
285
286 static void screen_buffer_dump( struct object *obj, int verbose );
287 static void screen_buffer_destroy( struct object *obj );
288 static struct fd *screen_buffer_get_fd( struct object *obj );
289 static struct object *screen_buffer_open_file( struct object *obj, unsigned int access,
290 unsigned int sharing, unsigned int options );
291
292 static const struct object_ops screen_buffer_ops =
293 {
294 sizeof(struct screen_buffer), /* size */
295 screen_buffer_dump, /* dump */
296 no_get_type, /* get_type */
297 no_add_queue, /* add_queue */
298 NULL, /* remove_queue */
299 NULL, /* signaled */
300 NULL, /* satisfied */
301 no_signal, /* signal */
302 screen_buffer_get_fd, /* get_fd */
303 default_fd_map_access, /* map_access */
304 default_get_sd, /* get_sd */
305 default_set_sd, /* set_sd */
306 no_lookup_name, /* lookup_name */
307 no_link_name, /* link_name */
308 NULL, /* unlink_name */
309 screen_buffer_open_file, /* open_file */
310 no_kernel_obj_list, /* get_kernel_obj_list */
311 no_close_handle, /* close_handle */
312 screen_buffer_destroy /* destroy */
313 };
314
315 static int screen_buffer_ioctl( struct fd *fd, ioctl_code_t code, struct async *async );
316
317 static const struct fd_ops screen_buffer_fd_ops =
318 {
319 default_fd_get_poll_events, /* get_poll_events */
320 default_poll_event, /* poll_event */
321 console_get_fd_type, /* get_fd_type */
322 no_fd_read, /* read */
323 no_fd_write, /* write */
324 no_fd_flush, /* flush */
325 no_fd_get_file_info, /* get_file_info */
326 no_fd_get_volume_info, /* get_volume_info */
327 screen_buffer_ioctl, /* ioctl */
328 default_fd_queue_async, /* queue_async */
329 default_fd_reselect_async /* reselect_async */
330 };
331
332 static struct object_type *console_device_get_type( struct object *obj );
333 static void console_device_dump( struct object *obj, int verbose );
334 static struct object *console_device_lookup_name( struct object *obj, struct unicode_str *name, unsigned int attr );
335 static struct object *console_device_open_file( struct object *obj, unsigned int access,
336 unsigned int sharing, unsigned int options );
337
338 static const struct object_ops console_device_ops =
339 {
340 sizeof(struct object), /* size */
341 console_device_dump, /* dump */
342 console_device_get_type, /* get_type */
343 no_add_queue, /* add_queue */
344 NULL, /* remove_queue */
345 NULL, /* signaled */
346 no_satisfied, /* satisfied */
347 no_signal, /* signal */
348 no_get_fd, /* get_fd */
349 default_fd_map_access, /* map_access */
350 default_get_sd, /* get_sd */
351 default_set_sd, /* set_sd */
352 console_device_lookup_name, /* lookup_name */
353 directory_link_name, /* link_name */
354 default_unlink_name, /* unlink_name */
355 console_device_open_file, /* open_file */
356 no_kernel_obj_list, /* get_kernel_obj_list */
357 no_close_handle, /* close_handle */
358 no_destroy /* destroy */
359 };
360
361 static struct list screen_buffer_list = LIST_INIT(screen_buffer_list);
362
363 static const char_info_t empty_char_info = { ' ', 0x000f }; /* white on black space */
364
365 static int console_input_is_bare( struct console_input* cin )
366 {
367 return cin->evt == NULL;
368 }
369
370 static struct fd *console_input_get_fd( struct object* obj )
371 {
372 struct console_input *console_input = (struct console_input*)obj;
373 assert( obj->ops == &console_input_ops );
374 return (struct fd *)grab_object( console_input->fd );
375 }
376
377 static enum server_fd_type console_get_fd_type( struct fd *fd )
378 {
379 return FD_TYPE_CHAR;
380 }
381
382 /* dumps the renderer events of a console */
383 static void console_input_events_dump( struct object *obj, int verbose )
384 {
385 struct console_input_events *evts = (struct console_input_events *)obj;
386 assert( obj->ops == &console_input_events_ops );
387 fprintf( stderr, "Console input events: %d/%d events\n",
388 evts->num_used, evts->num_alloc );
389 }
390
391 /* destroys the renderer events of a console */
392 static void console_input_events_destroy( struct object *obj )
393 {
394 struct console_input_events *evts = (struct console_input_events *)obj;
395 assert( obj->ops == &console_input_events_ops );
396 if (evts->console) evts->console->evt = NULL;
397 free_async_queue( &evts->read_q );
398 if (evts->fd) release_object( evts->fd );
399 free( evts->events );
400 }
401
402 static struct fd *console_input_events_get_fd( struct object* obj )
403 {
404 struct console_input_events *evts = (struct console_input_events*)obj;
405 assert( obj->ops == &console_input_events_ops );
406 return (struct fd*)grab_object( evts->fd );
407 }
408
409 static struct object *console_input_events_open_file( struct object *obj, unsigned int access,
410 unsigned int sharing, unsigned int options )
411 {
412 return grab_object( obj );
413 }
414
415 /* retrieves events from the console's renderer events list */
416 static int get_renderer_events( struct console_input_events* evts, struct async *async )
417 {
418 struct iosb *iosb = async_get_iosb( async );
419 data_size_t num;
420
421 num = min( iosb->out_size / sizeof(evts->events[0]), evts->num_used );
422 if (num && !(iosb->out_data = malloc( num * sizeof(evts->events[0] ))))
423 {
424 async_terminate( async, STATUS_NO_MEMORY );
425 release_object( iosb );
426 return 0;
427 }
428
429 iosb->status = STATUS_SUCCESS;
430 iosb->out_size = iosb->result = num * sizeof(evts->events[0]);
431 if (num) memcpy( iosb->out_data, evts->events, iosb->result );
432 release_object( iosb );
433 async_terminate( async, STATUS_ALERTED );
434
435 if (num && num < evts->num_used)
436 {
437 memmove( &evts->events[0], &evts->events[num],
438 (evts->num_used - num) * sizeof(evts->events[0]) );
439 }
440 evts->num_used -= num;
441 return 1;
442 }
443
444 /* add an event to the console's renderer events list */
445 static void console_input_events_append( struct console_input* console,
446 struct condrv_renderer_event* evt)
447 {
448 struct console_input_events* evts;
449 int collapsed = FALSE;
450 struct async *async;
451
452 if (!(evts = console->evt)) return;
453 /* to be done even when evt has been generated by the renderer ? */
454
455 /* try to collapse evt into current queue's events */
456 if (evts->num_used)
457 {
458 struct condrv_renderer_event* last = &evts->events[evts->num_used - 1];
459
460 if (last->event == CONSOLE_RENDERER_UPDATE_EVENT &&
461 evt->event == CONSOLE_RENDERER_UPDATE_EVENT)
462 {
463 /* if two update events overlap, collapse them into a single one */
464 if (last->u.update.bottom + 1 >= evt->u.update.top &&
465 evt->u.update.bottom + 1 >= last->u.update.top)
466 {
467 last->u.update.top = min(last->u.update.top, evt->u.update.top);
468 last->u.update.bottom = max(last->u.update.bottom, evt->u.update.bottom);
469 collapsed = TRUE;
470 }
471 }
472 }
473 if (!collapsed)
474 {
475 if (evts->num_used == evts->num_alloc)
476 {
477 evts->num_alloc += 16;
478 evts->events = realloc( evts->events, evts->num_alloc * sizeof(*evt) );
479 assert(evts->events);
480 }
481 evts->events[evts->num_used++] = *evt;
482 }
483 while (evts->num_used && (async = find_pending_async( &evts->read_q )))
484 {
485 get_renderer_events( evts, async );
486 release_object( async );
487 }
488 }
489
490 static struct object *create_console_input_events(void)
491 {
492 struct console_input_events* evt;
493
494 if (!(evt = alloc_object( &console_input_events_ops ))) return NULL;
495 evt->console = NULL;
496 evt->num_alloc = evt->num_used = 0;
497 evt->events = NULL;
498 init_async_queue( &evt->read_q );
499 if (!(evt->fd = alloc_pseudo_fd( &console_input_events_fd_ops, &evt->obj, 0 )))
500 {
501 release_object( evt );
502 return NULL;
503 }
504 return &evt->obj;
505 }
506
507 static struct object *create_console_input( int fd )
508 {
509 struct console_input *console_input;
510
511 if (!(console_input = alloc_object( &console_input_ops )))
512 {
513 if (fd != -1) close( fd );
514 return NULL;
515 }
516 console_input->renderer = NULL;
517 console_input->mode = ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT |
518 ENABLE_ECHO_INPUT | ENABLE_MOUSE_INPUT | ENABLE_INSERT_MODE |
519 ENABLE_EXTENDED_FLAGS;
520 console_input->num_proc = 0;
521 console_input->active = NULL;
522 console_input->recnum = 0;
523 console_input->records = NULL;
524 console_input->evt = NULL;
525 console_input->server = NULL;
526 console_input->title = NULL;
527 console_input->title_len = 0;
528 console_input->history_size = 50;
529 console_input->history = calloc( console_input->history_size, sizeof(*console_input->history) );
530 console_input->history_index = 0;
531 console_input->history_mode = 0;
532 console_input->edition_mode = 0;
533 console_input->input_cp = 0;
534 console_input->output_cp = 0;
535 console_input->win = 0;
536 console_input->event = create_event( NULL, NULL, 0, 1, 0, NULL );
537 console_input->fd = NULL;
538 console_input->last_id = 0;
539 init_async_queue( &console_input->ioctl_q );
540 init_async_queue( &console_input->read_q );
541
542 if (!console_input->history || !console_input->event)
543 {
544 if (fd != -1) close( fd );
545 console_input->history_size = 0;
546 release_object( console_input );
547 return NULL;
548 }
549 if (fd != -1) /* bare console */
550 {
551 console_input->fd = create_anonymous_fd( &console_input_fd_ops, fd, &console_input->obj,
552 FILE_SYNCHRONOUS_IO_NONALERT );
553 }
554 else
555 {
556 console_input->fd = alloc_pseudo_fd( &console_input_fd_ops, &console_input->obj,
557 FILE_SYNCHRONOUS_IO_NONALERT );
558 }
559 if (!console_input->fd)
560 {
561 release_object( console_input );
562 return NULL;
563 }
564 allow_fd_caching( console_input->fd );
565 return &console_input->obj;
566 }
567
568 static void console_host_ioctl_terminate( struct console_host_ioctl *call, unsigned int status )
569 {
570 if (call->async)
571 {
572 async_terminate( call->async, status );
573 release_object( call->async );
574 }
575 free( call );
576 }
577
578 static int queue_host_ioctl( struct console_server *server, unsigned int code, unsigned int output,
579 struct async *async, struct async_queue *queue )
580 {
581 struct console_host_ioctl *ioctl;
582
583 if (!(ioctl = mem_alloc( sizeof(*ioctl) ))) return 0;
584 ioctl->code = code;
585 ioctl->output = output;
586 ioctl->async = NULL;
587 if (async)
588 {
589 ioctl->async = (struct async *)grab_object( async );
590 queue_async( queue, async );
591 }
592 list_add_tail( &server->queue, &ioctl->entry );
593 wake_up( &server->obj, 0 );
594 if (async) set_error( STATUS_PENDING );
595 return 0;
596 }
597
598 static void disconnect_console_server( struct console_server *server )
599 {
600 while (!list_empty( &server->queue ))
601 {
602 struct console_host_ioctl *call = LIST_ENTRY( list_head( &server->queue ), struct console_host_ioctl, entry );
603 list_remove( &call->entry );
604 console_host_ioctl_terminate( call, STATUS_CANCELLED );
605 }
606 while (!list_empty( &server->read_queue ))
607 {
608 struct console_host_ioctl *call = LIST_ENTRY( list_head( &server->read_queue ), struct console_host_ioctl, entry );
609 list_remove( &call->entry );
610 console_host_ioctl_terminate( call, STATUS_CANCELLED );
611 }
612
613 if (server->console)
614 {
615 assert( server->console->server == server );
616 server->console->server = NULL;
617 server->console = NULL;
618 wake_up( &server->obj, 0 );
619 }
620 }
621
622 static void set_active_screen_buffer( struct console_input *console_input, struct screen_buffer *screen_buffer )
623 {
624 struct condrv_renderer_event evt;
625
626 if (console_input->active == screen_buffer) return;
627 if (console_input->active) release_object( console_input->active );
628 console_input->active = (struct screen_buffer *)grab_object( screen_buffer );
629
630 if (console_input->server) queue_host_ioctl( console_input->server, IOCTL_CONDRV_ACTIVATE,
631 screen_buffer->id, NULL, NULL );
632
633 evt.event = CONSOLE_RENDERER_SB_RESIZE_EVENT;
634 evt.u.resize.width = screen_buffer->width;
635 evt.u.resize.height = screen_buffer->height;
636 console_input_events_append( console_input, &evt );
637
638 evt.event = CONSOLE_RENDERER_DISPLAY_EVENT;
639 evt.u.display.left = screen_buffer->win.left;
640 evt.u.display.top = screen_buffer->win.top;
641 evt.u.display.width = screen_buffer->win.right - screen_buffer->win.left + 1;
642 evt.u.display.height = screen_buffer->win.bottom - screen_buffer->win.top + 1;
643 console_input_events_append( console_input, &evt );
644
645 evt.event = CONSOLE_RENDERER_UPDATE_EVENT;
646 evt.u.update.top = 0;
647 evt.u.update.bottom = screen_buffer->height - 1;
648 console_input_events_append( console_input, &evt );
649
650 evt.event = CONSOLE_RENDERER_CURSOR_GEOM_EVENT;
651 evt.u.cursor_geom.size = screen_buffer->cursor_size;
652 evt.u.cursor_geom.visible = screen_buffer->cursor_visible;
653 console_input_events_append( console_input, &evt );
654
655 evt.event = CONSOLE_RENDERER_CURSOR_POS_EVENT;
656 evt.u.cursor_pos.x = screen_buffer->cursor_x;
657 evt.u.cursor_pos.y = screen_buffer->cursor_y;
658 console_input_events_append( console_input, &evt );
659 }
660
661 static struct object *create_console_output( struct console_input *console_input, int fd )
662 {
663 struct screen_buffer *screen_buffer;
664 int i;
665
666 if (console_input->last_id == ~0)
667 {
668 set_error( STATUS_NO_MEMORY );
669 return NULL;
670 }
671
672 if (!(screen_buffer = alloc_object( &screen_buffer_ops )))
673 {
674 if (fd != -1) close( fd );
675 return NULL;
676 }
677 screen_buffer->id = ++console_input->last_id;
678 screen_buffer->mode = ENABLE_PROCESSED_OUTPUT | ENABLE_WRAP_AT_EOL_OUTPUT;
679 screen_buffer->input = console_input;
680 screen_buffer->cursor_size = 100;
681 screen_buffer->cursor_visible = 1;
682 screen_buffer->width = 80;
683 screen_buffer->height = 150;
684 screen_buffer->max_width = 80;
685 screen_buffer->max_height = 25;
686 screen_buffer->cursor_x = 0;
687 screen_buffer->cursor_y = 0;
688 screen_buffer->attr = 0x0F;
689 screen_buffer->popup_attr = 0xF5;
690 screen_buffer->win.left = 0;
691 screen_buffer->win.right = screen_buffer->max_width - 1;
692 screen_buffer->win.top = 0;
693 screen_buffer->win.bottom = screen_buffer->max_height - 1;
694 screen_buffer->data = NULL;
695 screen_buffer->font.width = 0;
696 screen_buffer->font.height = 0;
697 screen_buffer->font.weight = FW_NORMAL;
698 screen_buffer->font.pitch_family = FIXED_PITCH | FF_DONTCARE;
699 screen_buffer->font.face_name = NULL;
700 screen_buffer->font.face_len = 0;
701 memset( screen_buffer->color_map, 0, sizeof(screen_buffer->color_map) );
702 init_async_queue( &screen_buffer->ioctl_q );
703 list_add_head( &screen_buffer_list, &screen_buffer->entry );
704
705 if (fd != -1)
706 screen_buffer->fd = create_anonymous_fd( &screen_buffer_fd_ops, fd, &screen_buffer->obj,
707 FILE_SYNCHRONOUS_IO_NONALERT );
708 else
709 screen_buffer->fd = alloc_pseudo_fd( &screen_buffer_fd_ops, &screen_buffer->obj,
710 FILE_SYNCHRONOUS_IO_NONALERT );
711 if (!screen_buffer->fd)
712 {
713 release_object( screen_buffer );
714 return NULL;
715 }
716 allow_fd_caching(screen_buffer->fd);
717
718 if (!(screen_buffer->data = malloc( screen_buffer->width * screen_buffer->height *
719 sizeof(*screen_buffer->data) )))
720 {
721 release_object( screen_buffer );
722 return NULL;
723 }
724 /* clear the first row */
725 for (i = 0; i < screen_buffer->width; i++) screen_buffer->data[i] = empty_char_info;
726 /* and copy it to all other rows */
727 for (i = 1; i < screen_buffer->height; i++)
728 memcpy( &screen_buffer->data[i * screen_buffer->width], screen_buffer->data,
729 screen_buffer->width * sizeof(char_info_t) );
730
731 if (console_input->server) queue_host_ioctl( console_input->server, IOCTL_CONDRV_INIT_OUTPUT,
732 screen_buffer->id, NULL, NULL );
733 if (!console_input->active) set_active_screen_buffer( console_input, screen_buffer );
734 return &screen_buffer->obj;
735 }
736
737 /* free the console for this process */
738 int free_console( struct process *process )
739 {
740 struct console_input* console = process->console;
741
742 if (!console) return 0;
743
744 process->console = NULL;
745 if (--console->num_proc == 0 && console->renderer)
746 {
747 /* all processes have terminated... tell the renderer to terminate too */
748 struct condrv_renderer_event evt;
749 evt.event = CONSOLE_RENDERER_EXIT_EVENT;
750 memset(&evt.u, 0, sizeof(evt.u));
751 console_input_events_append( console, &evt );
752 }
753 release_object( console );
754
755 return 1;
756 }
757
758 /* let process inherit the console from parent... this handle two cases :
759 * 1/ generic console inheritance
760 * 2/ parent is a renderer which launches process, and process should attach to the console
761 * rendered by parent
762 */
763 obj_handle_t inherit_console( struct thread *parent_thread, obj_handle_t handle, struct process *process,
764 obj_handle_t hconin )
765 {
766 struct console_input *console = NULL;
767
768 if (handle && !(console = (struct console_input *)get_handle_obj( current->process, handle, 0,
769 &console_input_ops )))
770 return 0;
771
772 /* if parent is a renderer, then attach current process to its console
773 * a bit hacky....
774 */
775 if (!console && hconin && parent_thread)
776 {
777 /* FIXME: should we check some access rights ? */
778 if (!(console = (struct console_input *)get_handle_obj( parent_thread->process, hconin,
779 0, &console_input_ops )))
780 clear_error(); /* ignore error */
781 }
782 if (!console) return 0;
783
784 process->console = console;
785 console->num_proc++;
786 return alloc_handle( process, process->console,
787 SYNCHRONIZE | GENERIC_READ | GENERIC_WRITE, 0 );
788 }
789
790 struct thread *console_get_renderer( struct console_input *console )
791 {
792 return console->renderer;
793 }
794
795 static struct console_input* console_input_get( obj_handle_t handle, unsigned access )
796 {
797 struct console_input* console = NULL;
798
799 if (handle)
800 console = (struct console_input *)get_handle_obj( current->process, handle,
801 access, &console_input_ops );
802 else if (current->process->console)
803 {
804 console = (struct console_input *)grab_object( current->process->console );
805 }
806
807 if (!console && !get_error()) set_error(STATUS_INVALID_PARAMETER);
808 return console;
809 }
810
811 struct console_signal_info
812 {
813 struct console_input *console;
814 process_id_t group;
815 int signal;
816 };
817
818 static int propagate_console_signal_cb(struct process *process, void *user)
819 {
820 struct console_signal_info* csi = (struct console_signal_info*)user;
821
822 if (process->console == csi->console && process->running_threads &&
823 (!csi->group || process->group_id == csi->group))
824 {
825 /* find a suitable thread to signal */
826 struct thread *thread;
827 LIST_FOR_EACH_ENTRY( thread, &process->thread_list, struct thread, proc_entry )
828 {
829 if (send_thread_signal( thread, csi->signal )) break;
830 }
831 }
832 return FALSE;
833 }
834
835 static void propagate_console_signal( struct console_input *console,
836 int sig, process_id_t group_id )
837 {
838 struct console_signal_info csi;
839
840 if (!console)
841 {
842 set_error( STATUS_INVALID_PARAMETER );
843 return;
844 }
845 /* FIXME: should support the other events (like CTRL_BREAK) */
846 if (sig != CTRL_C_EVENT)
847 {
848 set_error( STATUS_NOT_IMPLEMENTED );
849 return;
850 }
851 csi.console = console;
852 csi.signal = SIGINT;
853 csi.group = group_id;
854
855 enum_processes(propagate_console_signal_cb, &csi);
856 }
857
858 /* retrieve a pointer to the console input records */
859 static int read_console_input( struct console_input *console, struct async *async, int flush )
860 {
861 struct iosb *iosb = async_get_iosb( async );
862 data_size_t count;
863
864 count = min( iosb->out_size / sizeof(INPUT_RECORD), console->recnum );
865 if (count)
866 {
867 if (!(iosb->out_data = malloc( count * sizeof(INPUT_RECORD) )))
868 {
869 set_error( STATUS_NO_MEMORY );
870 release_object( iosb );
871 return 0;
872 }
873 iosb->out_size = iosb->result = count * sizeof(INPUT_RECORD);
874 memcpy( iosb->out_data, console->records, iosb->result );
875 iosb->status = STATUS_SUCCESS;
876 async_terminate( async, STATUS_ALERTED );
877 }
878 else
879 {
880 async_terminate( async, STATUS_SUCCESS );
881 }
882
883 release_object( iosb );
884
885 if (flush && count)
886 {
887 if (console->recnum > count)
888 {
889 INPUT_RECORD *new_rec;
890 memmove( console->records, console->records + count, (console->recnum - count) * sizeof(*console->records) );
891 console->recnum -= count;
892 new_rec = realloc( console->records, console->recnum * sizeof(*console->records) );
893 if (new_rec) console->records = new_rec;
894 }
895 else
896 {
897 console->recnum = 0;
898 free( console->records );
899 console->records = NULL;
900 reset_event( console->event );
901 }
902 }
903
904 return 1;
905 }
906
907 /* add input events to a console input queue */
908 static int write_console_input( struct console_input* console, int count,
909 const INPUT_RECORD *records )
910 {
911 INPUT_RECORD *new_rec;
912 struct async *async;
913
914 if (!count) return 1;
915 if (!(new_rec = realloc( console->records,
916 (console->recnum + count) * sizeof(INPUT_RECORD) )))
917 {
918 set_error( STATUS_NO_MEMORY );
919 return 0;
920 }
921 console->records = new_rec;
922 memcpy( new_rec + console->recnum, records, count * sizeof(INPUT_RECORD) );
923
924 if (console->mode & ENABLE_PROCESSED_INPUT)
925 {
926 int i = 0;
927 while (i < count)
928 {
929 if (records[i].EventType == KEY_EVENT &&
930 records[i].Event.KeyEvent.uChar.UnicodeChar == 'C' - 64 &&
931 !(records[i].Event.KeyEvent.dwControlKeyState & ENHANCED_KEY))
932 {
933 if (i != count - 1)
934 memcpy( &console->records[console->recnum + i],
935 &console->records[console->recnum + i + 1],
936 (count - i - 1) * sizeof(INPUT_RECORD) );
937 count--;
938 if (records[i].Event.KeyEvent.bKeyDown)
939 {
940 /* send SIGINT to all processes attached to this console */
941 propagate_console_signal( console, CTRL_C_EVENT, 0 );
942 }
943 }
944 else i++;
945 }
946 }
947 console->recnum += count;
948 while (console->recnum && (async = find_pending_async( &console->read_q )))
949 {
950 read_console_input( console, async, 1 );
951 release_object( async );
952 }
953 if (console->recnum) set_event( console->event );
954 return 1;
955 }
956
957 /* resize a screen buffer */
958 static int change_screen_buffer_size( struct screen_buffer *screen_buffer,
959 int new_width, int new_height )
960 {
961 int i, old_width, old_height, copy_width, copy_height;
962 char_info_t *new_data;
963
964 if (!(new_data = malloc( new_width * new_height * sizeof(*new_data) )))
965 {
966 set_error( STATUS_NO_MEMORY );
967 return 0;
968 }
969 old_width = screen_buffer->width;
970 old_height = screen_buffer->height;
971 copy_width = min( old_width, new_width );
972 copy_height = min( old_height, new_height );
973
974 /* copy all the rows */
975 for (i = 0; i < copy_height; i++)
976 {
977 memcpy( &new_data[i * new_width], &screen_buffer->data[i * old_width],
978 copy_width * sizeof(char_info_t) );
979 }
980
981 /* clear the end of each row */
982 if (new_width > old_width)
983 {
984 /* fill first row */
985 for (i = old_width; i < new_width; i++) new_data[i] = empty_char_info;
986 /* and blast it to the other rows */
987 for (i = 1; i < copy_height; i++)
988 memcpy( &new_data[i * new_width + old_width], &new_data[old_width],
989 (new_width - old_width) * sizeof(char_info_t) );
990 }
991
992 /* clear remaining rows */
993 if (new_height > old_height)
994 {
995 /* fill first row */
996 for (i = 0; i < new_width; i++) new_data[old_height * new_width + i] = empty_char_info;
997 /* and blast it to the other rows */
998 for (i = old_height+1; i < new_height; i++)
999 memcpy( &new_data[i * new_width], &new_data[old_height * new_width],
1000 new_width * sizeof(char_info_t) );
1001 }
1002 free( screen_buffer->data );
1003 screen_buffer->data = new_data;
1004 screen_buffer->width = new_width;
1005 screen_buffer->height = new_height;
1006 return 1;
1007 }
1008
1009 static int set_output_info( struct screen_buffer *screen_buffer,
1010 const struct condrv_output_info_params *params, data_size_t extra_size )
1011 {
1012 const struct condrv_output_info *info = &params->info;
1013 struct condrv_renderer_event evt;
1014 WCHAR *font_name;
1015
1016 if (params->mask & SET_CONSOLE_OUTPUT_INFO_CURSOR_GEOM)
1017 {
1018 if (info->cursor_size < 1 || info->cursor_size > 100)
1019 {
1020 set_error( STATUS_INVALID_PARAMETER );
1021 return 0;
1022 }
1023 if (screen_buffer->cursor_size != info->cursor_size ||
1024 screen_buffer->cursor_visible != info->cursor_visible)
1025 {
1026 screen_buffer->cursor_size = info->cursor_size;
1027 screen_buffer->cursor_visible = info->cursor_visible;
1028 evt.event = CONSOLE_RENDERER_CURSOR_GEOM_EVENT;
1029 memset( &evt.u, 0, sizeof(evt.u) );
1030 evt.u.cursor_geom.size = info->cursor_size;
1031 evt.u.cursor_geom.visible = info->cursor_visible;
1032 console_input_events_append( screen_buffer->input, &evt );
1033 }
1034 }
1035 if (params->mask & SET_CONSOLE_OUTPUT_INFO_CURSOR_POS)
1036 {
1037 if (info->cursor_x < 0 || info->cursor_x >= screen_buffer->width ||
1038 info->cursor_y < 0 || info->cursor_y >= screen_buffer->height)
1039 {
1040 set_error( STATUS_INVALID_PARAMETER );
1041 return 0;
1042 }
1043 if (screen_buffer->cursor_x != info->cursor_x || screen_buffer->cursor_y != info->cursor_y)
1044 {
1045 screen_buffer->cursor_x = info->cursor_x;
1046 screen_buffer->cursor_y = info->cursor_y;
1047 evt.event = CONSOLE_RENDERER_CURSOR_POS_EVENT;
1048 memset( &evt.u, 0, sizeof(evt.u) );
1049 evt.u.cursor_pos.x = info->cursor_x;
1050 evt.u.cursor_pos.y = info->cursor_y;
1051 console_input_events_append( screen_buffer->input, &evt );
1052 }
1053 }
1054 if (params->mask & SET_CONSOLE_OUTPUT_INFO_SIZE)
1055 {
1056 unsigned cc;
1057
1058 /* new screen-buffer cannot be smaller than actual window */
1059 if (info->width < screen_buffer->win.right - screen_buffer->win.left + 1 ||
1060 info->height < screen_buffer->win.bottom - screen_buffer->win.top + 1)
1061 {
1062 set_error( STATUS_INVALID_PARAMETER );
1063 return 0;
1064 }
1065 /* FIXME: there are also some basic minimum and max size to deal with */
1066 if (!change_screen_buffer_size( screen_buffer, info->width, info->height )) return 0;
1067
1068 evt.event = CONSOLE_RENDERER_SB_RESIZE_EVENT;
1069 memset( &evt.u, 0, sizeof(evt.u) );
1070 evt.u.resize.width = info->width;
1071 evt.u.resize.height = info->height;
1072 console_input_events_append( screen_buffer->input, &evt );
1073
1074 evt.event = CONSOLE_RENDERER_UPDATE_EVENT;
1075 memset( &evt.u, 0, sizeof(evt.u) );
1076 evt.u.update.top = 0;
1077 evt.u.update.bottom = screen_buffer->height - 1;
1078 console_input_events_append( screen_buffer->input, &evt );
1079
1080 /* scroll window to display sb */
1081 if (screen_buffer->win.right >= info->width)
1082 {
1083 screen_buffer->win.right -= screen_buffer->win.left;
1084 screen_buffer->win.left = 0;
1085 }
1086 if (screen_buffer->win.bottom >= info->height)
1087 {
1088 screen_buffer->win.bottom -= screen_buffer->win.top;
1089 screen_buffer->win.top = 0;
1090 }
1091 /* reset cursor if needed (normally, if cursor was outside of new sb, the
1092 * window has been shifted so that the new position of the cursor will be
1093 * visible */
1094 cc = 0;
1095 if (screen_buffer->cursor_x >= info->width)
1096 {
1097 screen_buffer->cursor_x = info->width - 1;
1098 cc++;
1099 }
1100 if (screen_buffer->cursor_y >= info->height)
1101 {
1102 screen_buffer->cursor_y = info->height - 1;
1103 cc++;
1104 }
1105 if (cc)
1106 {
1107 evt.event = CONSOLE_RENDERER_CURSOR_POS_EVENT;
1108 memset( &evt.u, 0, sizeof(evt.u) );
1109 evt.u.cursor_pos.x = info->cursor_x;
1110 evt.u.cursor_pos.y = info->cursor_y;
1111 console_input_events_append( screen_buffer->input, &evt );
1112 }
1113
1114 if (screen_buffer == screen_buffer->input->active &&
1115 screen_buffer->input->mode & ENABLE_WINDOW_INPUT)
1116 {
1117 INPUT_RECORD ir;
1118 ir.EventType = WINDOW_BUFFER_SIZE_EVENT;
1119 ir.Event.WindowBufferSizeEvent.dwSize.X = info->width;
1120 ir.Event.WindowBufferSizeEvent.dwSize.Y = info->height;
1121 write_console_input( screen_buffer->input, 1, &ir );
1122 }
1123 }
1124 if (params->mask & SET_CONSOLE_OUTPUT_INFO_ATTR)
1125 {
1126 screen_buffer->attr = info->attr;
1127 }
1128 if (params->mask & SET_CONSOLE_OUTPUT_INFO_POPUP_ATTR)
1129 {
1130 screen_buffer->popup_attr = info->popup_attr;
1131 }
1132 if (params->mask & SET_CONSOLE_OUTPUT_INFO_DISPLAY_WINDOW)
1133 {
1134 if (info->win_left < 0 || info->win_left > info->win_right ||
1135 info->win_right >= screen_buffer->width ||
1136 info->win_top < 0 || info->win_top > info->win_bottom ||
1137 info->win_bottom >= screen_buffer->height)
1138 {
1139 set_error( STATUS_INVALID_PARAMETER );
1140 return 0;
1141 }
1142 if (screen_buffer->win.left != info->win_left || screen_buffer->win.top != info->win_top ||
1143 screen_buffer->win.right != info->win_right || screen_buffer->win.bottom != info->win_bottom)
1144 {
1145 screen_buffer->win.left = info->win_left;
1146 screen_buffer->win.top = info->win_top;
1147 screen_buffer->win.right = info->win_right;
1148 screen_buffer->win.bottom = info->win_bottom;
1149 evt.event = CONSOLE_RENDERER_DISPLAY_EVENT;
1150 memset( &evt.u, 0, sizeof(evt.u) );
1151 evt.u.display.left = info->win_left;
1152 evt.u.display.top = info->win_top;
1153 evt.u.display.width = info->win_right - info->win_left + 1;
1154 evt.u.display.height = info->win_bottom - info->win_top + 1;
1155 console_input_events_append( screen_buffer->input, &evt );
1156 }
1157 }
1158 if (params->mask & SET_CONSOLE_OUTPUT_INFO_MAX_SIZE)
1159 {
1160 screen_buffer->max_width = info->max_width;
1161 screen_buffer->max_height = info->max_height;
1162 }
1163 if (params->mask & SET_CONSOLE_OUTPUT_INFO_COLORTABLE)
1164 {
1165 memcpy( screen_buffer->color_map, info->color_map, sizeof(info->color_map) );
1166 }
1167 if (params->mask & SET_CONSOLE_OUTPUT_INFO_FONT)
1168 {
1169 screen_buffer->font.width = info->font_width;
1170 screen_buffer->font.height = info->font_height;
1171 screen_buffer->font.weight = info->font_weight;
1172 screen_buffer->font.pitch_family = info->font_pitch_family;
1173 if (extra_size)
1174 {
1175 extra_size = extra_size / sizeof(WCHAR) * sizeof(WCHAR);
1176 font_name = mem_alloc( extra_size );
1177 if (font_name)
1178 {
1179 memcpy( font_name, info + 1, extra_size );
1180 free( screen_buffer->font.face_name );
1181 screen_buffer->font.face_name = font_name;
1182 screen_buffer->font.face_len = extra_size;
1183 }
1184 }
1185 }
1186
1187 return 1;
1188 }
1189
1190 /* appends a new line to history (history is a fixed size array) */
1191 static void console_input_append_hist( struct console_input* console, const WCHAR* buf, data_size_t len )
1192 {
1193 struct history_line *ptr;
1194
1195 if (!console || !console->history_size)
1196 {
1197 set_error( STATUS_INVALID_PARAMETER ); /* FIXME */
1198 return;
1199 }
1200
1201 len = (len / sizeof(WCHAR)) * sizeof(WCHAR);
1202 if (console->history_mode && console->history_index &&
1203 console->history[console->history_index - 1]->len == len &&
1204 !memcmp( console->history[console->history_index - 1]->text, buf, len ))
1205 {
1206 /* don't duplicate entry */
1207 set_error( STATUS_ALIAS_EXISTS );
1208 return;
1209 }
1210 if (!(ptr = mem_alloc( offsetof( struct history_line, text[len / sizeof(WCHAR)] )))) return;
1211 ptr->len = len;
1212 memcpy( ptr->text, buf, len );
1213
1214 if (console->history_index < console->history_size)
1215 {
1216 console->history[console->history_index++] = ptr;
1217 }
1218 else
1219 {
1220 free( console->history[0]) ;
1221 memmove( &console->history[0], &console->history[1],
1222 (console->history_size - 1) * sizeof(*console->history) );
1223 console->history[console->history_size - 1] = ptr;
1224 }
1225 }
1226
1227 /* returns a line from the cache */
1228 static data_size_t console_input_get_hist( struct console_input *console, int index )
1229 {
1230 data_size_t ret = 0;
1231
1232 if (index >= console->history_index) set_error( STATUS_INVALID_PARAMETER );
1233 else
1234 {
1235 ret = console->history[index]->len;
1236 set_reply_data( console->history[index]->text, min( ret, get_reply_max_size() ));
1237 }
1238 return ret;
1239 }
1240
1241 /* dumb dump */
1242 static void console_input_dump( struct object *obj, int verbose )
1243 {
1244 struct console_input *console = (struct console_input *)obj;
1245 assert( obj->ops == &console_input_ops );
1246 fprintf( stderr, "Console input active=%p evt=%p\n",
1247 console->active, console->evt );
1248 }
1249
1250 static void console_input_destroy( struct object *obj )
1251 {
1252 struct console_input* console_in = (struct console_input *)obj;
1253 struct screen_buffer* curr;
1254 int i;
1255
1256 assert( obj->ops == &console_input_ops );
1257
1258 if (console_in->server)
1259 {
1260 assert( console_in->server->console == console_in );
1261 disconnect_console_server( console_in->server );
1262 }
1263
1264 free( console_in->title );
1265 free( console_in->records );
1266
1267 if (console_in->active) release_object( console_in->active );
1268 console_in->active = NULL;
1269
1270 LIST_FOR_EACH_ENTRY( curr, &screen_buffer_list, struct screen_buffer, entry )
1271 {
1272 if (curr->input == console_in) curr->input = NULL;
1273 }
1274
1275 free_async_queue( &console_in->ioctl_q );
1276 free_async_queue( &console_in->read_q );
1277 if (console_in->evt)
1278 console_in->evt->console = NULL;
1279 if (console_in->event)
1280 release_object( console_in->event );
1281 if (console_in->fd)
1282 release_object( console_in->fd );
1283
1284 for (i = 0; i < console_in->history_size; i++)
1285 free( console_in->history[i] );
1286 free( console_in->history );
1287 }
1288
1289 static struct object *console_input_open_file( struct object *obj, unsigned int access,
1290 unsigned int sharing, unsigned int options )
1291 {
1292 return grab_object( obj );
1293 }
1294
1295 static void screen_buffer_dump( struct object *obj, int verbose )
1296 {
1297 struct screen_buffer *screen_buffer = (struct screen_buffer *)obj;
1298 assert( obj->ops == &screen_buffer_ops );
1299
1300 fprintf(stderr, "Console screen buffer input=%p\n", screen_buffer->input );
1301 }
1302
1303 static void screen_buffer_destroy( struct object *obj )
1304 {
1305 struct screen_buffer *screen_buffer = (struct screen_buffer *)obj;
1306
1307 assert( obj->ops == &screen_buffer_ops );
1308
1309 list_remove( &screen_buffer->entry );
1310 if (screen_buffer->input && screen_buffer->input->server)
1311 queue_host_ioctl( screen_buffer->input->server, IOCTL_CONDRV_CLOSE_OUTPUT,
1312 screen_buffer->id, NULL, NULL );
1313 if (screen_buffer->fd) release_object( screen_buffer->fd );
1314 free_async_queue( &screen_buffer->ioctl_q );
1315 free( screen_buffer->data );
1316 free( screen_buffer->font.face_name );
1317 }
1318
1319 static struct object *screen_buffer_open_file( struct object *obj, unsigned int access,
1320 unsigned int sharing, unsigned int options )
1321 {
1322 return grab_object( obj );
1323 }
1324
1325 static struct fd *screen_buffer_get_fd( struct object *obj )
1326 {
1327 struct screen_buffer *screen_buffer = (struct screen_buffer*)obj;
1328 assert( obj->ops == &screen_buffer_ops );
1329 if (screen_buffer->fd)
1330 return (struct fd*)grab_object( screen_buffer->fd );
1331 set_error( STATUS_OBJECT_TYPE_MISMATCH );
1332 return NULL;
1333 }
1334
1335 /* read data from a screen buffer */
1336 static void read_console_output( struct screen_buffer *screen_buffer, unsigned int x, unsigned int y,
1337 enum char_info_mode mode, unsigned int width )
1338 {
1339 unsigned int i, count;
1340 char_info_t *src;
1341
1342 if (x >= screen_buffer->width || y >= screen_buffer->height)
1343 {
1344 if (width) set_error( STATUS_INVALID_PARAMETER );
1345 return;
1346 }
1347 src = screen_buffer->data + y * screen_buffer->width + x;
1348
1349 switch(mode)
1350 {
1351 case CHAR_INFO_MODE_TEXT:
1352 {
1353 WCHAR *data;
1354 count = min( screen_buffer->data + screen_buffer->height * screen_buffer->width - src,
1355 get_reply_max_size() / sizeof(*data) );
1356 if ((data = set_reply_data_size( count * sizeof(*data) )))
1357 {
1358 for (i = 0; i < count; i++) data[i] = src[i].ch;
1359 }
1360 }
1361 break;
1362 case CHAR_INFO_MODE_ATTR:
1363 {
1364 unsigned short *data;
1365 count = min( screen_buffer->data + screen_buffer->height * screen_buffer->width - src,
1366 get_reply_max_size() / sizeof(*data) );
1367 if ((data = set_reply_data_size( count * sizeof(*data) )))
1368 {
1369 for (i = 0; i < count; i++) data[i] = src[i].attr;
1370 }
1371 }
1372 break;
1373 case CHAR_INFO_MODE_TEXTATTR:
1374 {
1375 char_info_t *data;
1376 SMALL_RECT *region;
1377 if (!width || get_reply_max_size() < sizeof(*region))
1378 {
1379 set_error( STATUS_INVALID_PARAMETER );
1380 return;
1381 }
1382 count = min( (get_reply_max_size() - sizeof(*region)) / (width * sizeof(*data)), screen_buffer->height - y );
1383 width = min( width, screen_buffer->width - x );
1384 if (!(region = set_reply_data_size( sizeof(*region) + width * count * sizeof(*data) ))) return;
1385 region->Left = x;
1386 region->Top = y;
1387 region->Right = x + width - 1;
1388 region->Bottom = y + count - 1;
1389 data = (char_info_t *)(region + 1);
1390 for (i = 0; i < count; i++)
1391 {
1392 memcpy( &data[i * width], &src[i * screen_buffer->width], width * sizeof(*data) );
1393 }
1394 }
1395 break;
1396 default:
1397 set_error( STATUS_INVALID_PARAMETER );
1398 break;
1399 }
1400 }
1401
1402 /* write data into a screen buffer */
1403 static void write_console_output( struct screen_buffer *screen_buffer, const struct condrv_output_params *params,
1404 data_size_t size )
1405 {
1406 unsigned int i, entry_size, entry_cnt, x, y;
1407 char_info_t *dest;
1408 char *src;
1409
1410 entry_size = params->mode == CHAR_INFO_MODE_TEXTATTR ? sizeof(char_info_t) : sizeof(WCHAR);
1411 if (size % entry_size)
1412 {
1413 set_error( STATUS_INVALID_PARAMETER );
1414 return;
1415 }
1416 if (params->x >= screen_buffer->width) return;
1417 entry_cnt = size / entry_size;
1418
1419 for (i = 0, src = (char *)(params + 1); i < entry_cnt; i++, src += entry_size)
1420 {
1421 if (params->width)
1422 {
1423 x = params->x + i % params->width;
1424 y = params->y + i / params->width;
1425 if (x >= screen_buffer->width) continue;
1426 }
1427 else
1428 {
1429 x = (params->x + i) % screen_buffer->width;
1430 y = params->y + (params->x + i) / screen_buffer->width;
1431 }
1432 if (y >= screen_buffer->height) break;
1433
1434 dest = &screen_buffer->data[y * screen_buffer->width + x];
1435 switch(params->mode)
1436 {
1437 case CHAR_INFO_MODE_TEXT:
1438 dest->ch = *(const WCHAR *)src;
1439 break;
1440 case CHAR_INFO_MODE_ATTR:
1441 dest->attr = *(const unsigned short *)src;
1442 break;
1443 case CHAR_INFO_MODE_TEXTATTR:
1444 *dest = *(const char_info_t *)src;
1445 break;
1446 case CHAR_INFO_MODE_TEXTSTDATTR:
1447 dest->ch = *(const WCHAR *)src;
1448 dest->attr = screen_buffer->attr;
1449 break;
1450 default:
1451 set_error( STATUS_INVALID_PARAMETER );
1452 return;
1453 }
1454 }
1455
1456 if (i && screen_buffer == screen_buffer->input->active)
1457 {
1458 struct condrv_renderer_event evt;
1459 evt.event = CONSOLE_RENDERER_UPDATE_EVENT;
1460 memset(&evt.u, 0, sizeof(evt.u));
1461 evt.u.update.top = params->y;
1462 evt.u.update.bottom = params->width
1463 ? min( params->y + entry_cnt / params->width, screen_buffer->height ) - 1
1464 : params->y + (params->x + i - 1) / screen_buffer->width;
1465 console_input_events_append( screen_buffer->input, &evt );
1466 }
1467
1468 if (get_reply_max_size() == sizeof(SMALL_RECT))
1469 {
1470 SMALL_RECT region;
1471 region.Left = params->x;
1472 region.Top = params->y;
1473 region.Right = min( params->x + params->width, screen_buffer->width ) - 1;
1474 region.Bottom = min( params->y + entry_cnt / params->width, screen_buffer->height ) - 1;
1475 set_reply_data( &region, sizeof(region) );
1476 }
1477 else set_reply_data( &i, sizeof(i) );
1478 }
1479
1480 /* fill a screen buffer with uniform data */
1481 static int fill_console_output( struct screen_buffer *screen_buffer, char_info_t data,
1482 enum char_info_mode mode, int x, int y, int count, int wrap )
1483 {
1484 int i;
1485 char_info_t *end, *dest = screen_buffer->data + y * screen_buffer->width + x;
1486
1487 if (y >= screen_buffer->height) return 0;
1488
1489 if (wrap)
1490 end = screen_buffer->data + screen_buffer->height * screen_buffer->width;
1491 else
1492 end = screen_buffer->data + (y+1) * screen_buffer->width;
1493
1494 if (count > end - dest) count = end - dest;
1495
1496 switch(mode)
1497 {
1498 case CHAR_INFO_MODE_TEXT:
1499 for (i = 0; i < count; i++) dest[i].ch = data.ch;
1500 break;
1501 case CHAR_INFO_MODE_ATTR:
1502 for (i = 0; i < count; i++) dest[i].attr = data.attr;
1503 break;
1504 case CHAR_INFO_MODE_TEXTATTR:
1505 for (i = 0; i < count; i++) dest[i] = data;
1506 break;
1507 case CHAR_INFO_MODE_TEXTSTDATTR:
1508 for (i = 0; i < count; i++)
1509 {
1510 dest[i].ch = data.ch;
1511 dest[i].attr = screen_buffer->attr;
1512 }
1513 break;
1514 default:
1515 set_error( STATUS_INVALID_PARAMETER );
1516 return 0;
1517 }
1518
1519 if (count && screen_buffer == screen_buffer->input->active)
1520 {
1521 struct condrv_renderer_event evt;
1522 evt.event = CONSOLE_RENDERER_UPDATE_EVENT;
1523 memset(&evt.u, 0, sizeof(evt.u));
1524 evt.u.update.top = y;
1525 evt.u.update.bottom = (y * screen_buffer->width + x + count - 1) / screen_buffer->width;
1526 console_input_events_append( screen_buffer->input, &evt );
1527 }
1528 return i;
1529 }
1530
1531 /* scroll parts of a screen buffer */
1532 static void scroll_console_output( struct screen_buffer *screen_buffer, int xsrc, int ysrc, int xdst, int ydst,
1533 int w, int h, const rectangle_t *clip, char_info_t fill )
1534 {
1535 struct condrv_renderer_event evt;
1536 rectangle_t src, dst;
1537 int x, y;
1538
1539 src.left = max( xsrc, clip->left );
1540 src.top = max( ysrc, clip->top );
1541 src.right = min( xsrc + w - 1, clip->right );
1542 src.bottom = min( ysrc + h - 1, clip->bottom );
1543
1544 dst.left = xdst;
1545 dst.top = ydst;
1546 dst.right = xdst + w - 1;
1547 dst.bottom = ydst + h - 1;
1548
1549 if (dst.left < clip->left)
1550 {
1551 xsrc += clip->left - dst.left;
1552 w -= clip->left - dst.left;
1553 dst.left = clip->left;
1554 }
1555 if (dst.top < clip->top)
1556 {
1557 ysrc += clip->top - dst.top;
1558 h -= clip->top - dst.top;
1559 dst.top = clip->top;
1560 }
1561 if (dst.right > clip->right) w -= dst.right - clip->right;
1562 if (dst.bottom > clip->bottom) h -= dst.bottom - clip->bottom;
1563
1564 if (w > 0 && h > 0)
1565 {
1566 if (ysrc < ydst)
1567 {
1568 for (y = h; y > 0; y--)
1569 {
1570 memcpy( &screen_buffer->data[(dst.top + y - 1) * screen_buffer->width + dst.left],
1571 &screen_buffer->data[(ysrc + y - 1) * screen_buffer->width + xsrc],
1572 w * sizeof(screen_buffer->data[0]) );
1573 }
1574 }
1575 else
1576 {
1577 for (y = 0; y < h; y++)
1578 {
1579 /* we use memmove here because when psrc and pdst are the same,
1580 * copies are done on the same row, so the dst and src blocks
1581 * can overlap */
1582 memmove( &screen_buffer->data[(dst.top + y) * screen_buffer->width + dst.left],
1583 &screen_buffer->data[(ysrc + y) * screen_buffer->width + xsrc],
1584 w * sizeof(screen_buffer->data[0]) );
1585 }
1586 }
1587 }
1588
1589 for (y = src.top; y <= src.bottom; y++)
1590 {
1591 int left = src.left;
1592 int right = src.right;
1593 if (dst.top <= y && y <= dst.bottom)
1594 {
1595 if (dst.left <= src.left) left = max( left, dst.right + 1 );
1596 if (dst.left >= src.left) right = min( right, dst.left - 1 );
1597 }
1598 for (x = left; x <= right; x++) screen_buffer->data[y * screen_buffer->width + x] = fill;
1599 }
1600
1601 /* FIXME: this could be enhanced, by signalling scroll */
1602 evt.event = CONSOLE_RENDERER_UPDATE_EVENT;
1603 memset(&evt.u, 0, sizeof(evt.u));
1604 evt.u.update.top = min( src.top, dst.top );
1605 evt.u.update.bottom = max( src.bottom, dst.bottom );
1606 console_input_events_append( screen_buffer->input, &evt );
1607 }
1608
1609 static void console_server_dump( struct object *obj, int verbose )
1610 {
1611 assert( obj->ops == &console_server_ops );
1612 fprintf( stderr, "Console server\n" );
1613 }
1614
1615 static void console_server_destroy( struct object *obj )
1616 {
1617 struct console_server *server = (struct console_server *)obj;
1618 assert( obj->ops == &console_server_ops );
1619 disconnect_console_server( server );
1620 if (server->fd) release_object( server->fd );
1621 }
1622
1623 static struct object *console_server_lookup_name( struct object *obj, struct unicode_str *name, unsigned int attr )
1624 {
1625 struct console_server *server = (struct console_server*)obj;
1626 static const WCHAR referenceW[] = {'R','e','f','e','r','e','n','c','e'};
1627 assert( obj->ops == &console_server_ops );
1628
1629 if (name->len == sizeof(referenceW) && !memcmp( name->str, referenceW, name->len ))
1630 {
1631 struct screen_buffer *screen_buffer;
1632 name->len = 0;
1633 if (server->console)
1634 {
1635 set_error( STATUS_INVALID_HANDLE );
1636 return 0;
1637 }
1638 if (!(server->console = (struct console_input *)create_console_input( -1 ))) return NULL;
1639 if (!(screen_buffer = (struct screen_buffer *)create_console_output( server->console, -1 )))
1640 {
1641 release_object( server->console );
1642 server->console = NULL;
1643 return NULL;
1644 }
1645 release_object( screen_buffer );
1646 server->console->server = server;
1647
1648 return &server->console->obj;
1649 }
1650
1651 return NULL;
1652 }
1653
1654 static int console_server_signaled( struct object *obj, struct wait_queue_entry *entry )
1655 {
1656 struct console_server *server = (struct console_server*)obj;
1657 assert( obj->ops == &console_server_ops );
1658 return !server->console || !list_empty( &server->queue );
1659 }
1660
1661 static struct fd *console_server_get_fd( struct object* obj )
1662 {
1663 struct console_server *server = (struct console_server*)obj;
1664 assert( obj->ops == &console_server_ops );
1665 return (struct fd *)grab_object( server->fd );
1666 }
1667
1668 static struct object *console_server_open_file( struct object *obj, unsigned int access,
1669 unsigned int sharing, unsigned int options )
1670 {
1671 return grab_object( obj );
1672 }
1673
1674 static struct object *create_console_server( void )
1675 {
1676 struct console_server *server;
1677
1678 if (!(server = alloc_object( &console_server_ops ))) return NULL;
1679 server->console = NULL;
1680 server->busy = 0;
1681 list_init( &server->queue );
1682 list_init( &server->read_queue );
1683 server->fd = alloc_pseudo_fd( &console_server_fd_ops, &server->obj, FILE_SYNCHRONOUS_IO_NONALERT );
1684 if (!server->fd)
1685 {
1686 release_object( server );
1687 return NULL;
1688 }
1689 allow_fd_caching(server->fd);
1690
1691 return &server->obj;
1692 }
1693
1694 static int is_blocking_read_ioctl( unsigned int code )
1695 {
1696 return code == IOCTL_CONDRV_READ_INPUT;
1697 }
1698
1699 static int console_input_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
1700 {
1701 struct console_input *console = get_fd_user( fd );
1702
1703 switch (code)
1704 {
1705 case IOCTL_CONDRV_GET_MODE:
1706 if (console->server)
1707 return queue_host_ioctl( console->server, code, 0, async, &console->ioctl_q );
1708 if (get_reply_max_size() != sizeof(console->mode))
1709 {
1710 set_error( STATUS_INVALID_PARAMETER );
1711 return 0;
1712 }
1713 return set_reply_data( &console->mode, sizeof(console->mode) ) != NULL;
1714
1715 case IOCTL_CONDRV_SET_MODE:
1716 if (console->server)
1717 return queue_host_ioctl( console->server, code, 0, async, &console->ioctl_q );
1718 if (get_req_data_size() != sizeof(console->mode))
1719 {
1720 set_error( STATUS_INVALID_PARAMETER );
1721 return 0;
1722 }
1723 console->mode = *(unsigned int *)get_req_data();
1724 return 1;
1725
1726 case IOCTL_CONDRV_READ_INPUT:
1727 {
1728 int blocking = 0;
1729 if (console->server)
1730 return queue_host_ioctl( console->server, code, 0, async, &console->ioctl_q );
1731 if (get_reply_max_size() % sizeof(INPUT_RECORD))
1732 {
1733 set_error( STATUS_INVALID_PARAMETER );
1734 return 0;
1735 }
1736 if (get_req_data_size())
1737 {
1738 if (get_req_data_size() != sizeof(int))
1739 {
1740 set_error( STATUS_INVALID_PARAMETER );
1741 return 0;
1742 }
1743 blocking = *(int *)get_req_data();
1744 }
1745 set_error( STATUS_PENDING );
1746 if (blocking && !console->recnum)
1747 {
1748 queue_async( &console->read_q, async );
1749 return 1;
1750 }
1751 return read_console_input( console, async, 1 );
1752 }
1753
1754 case IOCTL_CONDRV_WRITE_INPUT:
1755 if (console->server)
1756 return queue_host_ioctl( console->server, code, 0, async, &console->ioctl_q );
1757 return write_console_input( console, get_req_data_size() / sizeof(INPUT_RECORD), get_req_data() );
1758
1759 case IOCTL_CONDRV_PEEK:
1760 if (console->server)
1761 return queue_host_ioctl( console->server, code, 0, async, &console->ioctl_q );
1762 if (get_reply_max_size() % sizeof(INPUT_RECORD))
1763 {
1764 set_error( STATUS_INVALID_PARAMETER );
1765 return 0;
1766 }
1767 set_error( STATUS_PENDING );
1768 return read_console_input( console, async, 0 );
1769
1770 case IOCTL_CONDRV_GET_INPUT_INFO:
1771 {
1772 struct condrv_input_info info;
1773 if (console->server)
1774 return queue_host_ioctl( console->server, code, 0, async, &console->ioctl_q );
1775 if (get_reply_max_size() != sizeof(info))
1776 {
1777 set_error( STATUS_INVALID_PARAMETER );
1778 return 0;
1779 }
1780 info.input_cp = console->input_cp;
1781 info.output_cp = console->output_cp;
1782 info.history_mode = console->history_mode;
1783 info.history_size = console->history_size;
1784 info.history_index = console->history_index;
1785 info.edition_mode = console->edition_mode;
1786 info.input_count = console->recnum;
1787 info.win = console->win;
1788 return set_reply_data( &info, sizeof(info) ) != NULL;
1789 }
1790
1791 case IOCTL_CONDRV_SET_INPUT_INFO:
1792 {
1793 const struct condrv_input_info_params *params = get_req_data();
1794 if (console->server)
1795 return queue_host_ioctl( console->server, code, 0, async, &console->ioctl_q );
1796 if (get_req_data_size() != sizeof(*params))
1797 {
1798 set_error( STATUS_INVALID_PARAMETER );
1799 return 0;
1800 }
1801 if (params->mask & SET_CONSOLE_INPUT_INFO_HISTORY_MODE)
1802 {
1803 console->history_mode = params->info.history_mode;
1804 }
1805 if ((params->mask & SET_CONSOLE_INPUT_INFO_HISTORY_SIZE) &&
1806 console->history_size != params->info.history_size)
1807 {
1808 struct history_line **mem = NULL;
1809 int i, delta;
1810
1811 if (params->info.history_size)
1812 {
1813 if (!(mem = mem_alloc( params->info.history_size * sizeof(*mem) ))) return 0;
1814 memset( mem, 0, params->info.history_size * sizeof(*mem) );
1815 }
1816
1817 delta = (console->history_index > params->info.history_size) ?
1818 (console->history_index - params->info.history_size) : 0;
1819
1820 for (i = delta; i < console->history_index; i++)
1821 {
1822 mem[i - delta] = console->history[i];
1823 console->history[i] = NULL;
1824 }
1825 console->history_index -= delta;
1826
1827 for (i = 0; i < console->history_size; i++)
1828 free( console->history[i] );
1829 free( console->history );
1830 console->history = mem;
1831 console->history_size = params->info.history_size;
1832 }
1833 if (params->mask & SET_CONSOLE_INPUT_INFO_EDITION_MODE)
1834 {
1835 console->edition_mode = params->info.edition_mode;
1836 }
1837 if (params->mask & SET_CONSOLE_INPUT_INFO_INPUT_CODEPAGE)
1838 {
1839 console->input_cp = params->info.input_cp;
1840 }
1841 if (params->mask & SET_CONSOLE_INPUT_INFO_OUTPUT_CODEPAGE)
1842 {
1843 console->output_cp = params->info.output_cp;
1844 }
1845 if (params->mask & SET_CONSOLE_INPUT_INFO_WIN)
1846 {
1847 console->win = params->info.win;
1848 }
1849 return 1;
1850 }
1851
1852 case IOCTL_CONDRV_GET_TITLE:
1853 if (console->server)
1854 return queue_host_ioctl( console->server, code, 0, async, &console->ioctl_q );
1855 if (!console->title_len) return 1;
1856 return set_reply_data( console->title, min( console->title_len, get_reply_max_size() )) != NULL;
1857
1858 case IOCTL_CONDRV_SET_TITLE:
1859 {
1860 data_size_t len = get_req_data_size();
1861 struct condrv_renderer_event evt;
1862 WCHAR *title = NULL;
1863
1864 if (console->server)
1865 return queue_host_ioctl( console->server, code, 0, async, &console->ioctl_q );
1866 if (len % sizeof(WCHAR))
1867 {
1868 set_error( STATUS_INVALID_PARAMETER );
1869 return 0;
1870 }
1871
1872 if (len && !(title = memdup( get_req_data(), len ))) return 0;
1873 free( console->title );
1874 console->title = title;
1875 console->title_len = len;
1876 evt.event = CONSOLE_RENDERER_TITLE_EVENT;
1877 console_input_events_append( console, &evt );
1878 return 1;
1879 }
1880
1881 case IOCTL_CONDRV_CTRL_EVENT:
1882 {
1883 const struct condrv_ctrl_event *event = get_req_data();
1884 process_id_t group;
1885 if (get_req_data_size() != sizeof(*event))
1886 {
1887 set_error( STATUS_INVALID_PARAMETER );
1888 return 0;
1889 }
1890 group = event->group_id ? event->group_id : current->process->group_id;
1891 if (!group)
1892 {
1893 set_error( STATUS_INVALID_PARAMETER );
1894 return 0;
1895 }
1896 propagate_console_signal( console, event->event, group );
1897 return !get_error();
1898 }
1899
1900 default:
1901 set_error( STATUS_INVALID_HANDLE );
1902 return 0;
1903 }
1904 }
1905
1906 static int screen_buffer_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
1907 {
1908 struct screen_buffer *screen_buffer = get_fd_user( fd );
1909
1910 switch (code)
1911 {
1912 case IOCTL_CONDRV_GET_MODE:
1913 if (screen_buffer->input && screen_buffer->input->server)
1914 return queue_host_ioctl( screen_buffer->input->server, code, screen_buffer->id,
1915 async, &screen_buffer->ioctl_q );
1916 if (get_reply_max_size() != sizeof(screen_buffer->mode))
1917 {
1918 set_error( STATUS_INVALID_PARAMETER );
1919 return 0;
1920 }
1921 return set_reply_data( &screen_buffer->mode, sizeof(screen_buffer->mode) ) != NULL;
1922
1923 case IOCTL_CONDRV_SET_MODE:
1924 if (screen_buffer->input && screen_buffer->input->server)
1925 return queue_host_ioctl( screen_buffer->input->server, code, screen_buffer->id,
1926 async, &screen_buffer->ioctl_q );
1927 if (get_req_data_size() != sizeof(screen_buffer->mode))
1928 {
1929 set_error( STATUS_INVALID_PARAMETER );
1930 return 0;
1931 }
1932 screen_buffer->mode = *(unsigned int *)get_req_data();
1933 return 1;
1934
1935 case IOCTL_CONDRV_READ_OUTPUT:
1936 {
1937 const struct condrv_output_params *params = get_req_data();
1938 if (screen_buffer->input && screen_buffer->input->server)
1939 return queue_host_ioctl( screen_buffer->input->server, code, screen_buffer->id,
1940 async, &screen_buffer->ioctl_q );
1941 if (get_req_data_size() != sizeof(*params))
1942 {
1943 set_error( STATUS_INVALID_PARAMETER );
1944 return 0;
1945 }
1946 if (console_input_is_bare( screen_buffer->input ))
1947 {
1948 set_error( STATUS_OBJECT_TYPE_MISMATCH );
1949 return 0;
1950 }
1951 read_console_output( screen_buffer, params->x, params->y, params->mode, params->width );
1952 return !get_error();
1953 }
1954
1955 case IOCTL_CONDRV_WRITE_OUTPUT:
1956 if (screen_buffer->input && screen_buffer->input->server)
1957 return queue_host_ioctl( screen_buffer->input->server, code, screen_buffer->id,
1958 async, &screen_buffer->ioctl_q );
1959 if (get_req_data_size() < sizeof(struct condrv_output_params) ||
1960 (get_reply_max_size() != sizeof(SMALL_RECT) && get_reply_max_size() != sizeof(unsigned int)))
1961 {
1962 set_error( STATUS_INVALID_PARAMETER );
1963 return 0;
1964 }
1965 if (console_input_is_bare( screen_buffer->input ))
1966 {
1967 set_error( STATUS_OBJECT_TYPE_MISMATCH );
1968 return 0;
1969 }
1970 write_console_output( screen_buffer, get_req_data(), get_req_data_size() - sizeof(struct condrv_output_params) );
1971 return !get_error();
1972
1973 case IOCTL_CONDRV_GET_OUTPUT_INFO:
1974 {
1975 struct condrv_output_info *info;
1976 data_size_t size;
1977
1978 if (screen_buffer->input && screen_buffer->input->server)
1979 return queue_host_ioctl( screen_buffer->input->server, code, screen_buffer->id,
1980 async, &screen_buffer->ioctl_q );
1981 size = min( sizeof(*info) + screen_buffer->font.face_len, get_reply_max_size() );
1982 if (size < sizeof(*info))
1983 {
1984 set_error( STATUS_INVALID_PARAMETER );
1985 return 0;
1986 }
1987 if (!(info = set_reply_data_size( size ))) return 0;
1988
1989 info->cursor_size = screen_buffer->cursor_size;
1990 info->cursor_visible = screen_buffer->cursor_visible;
1991 info->cursor_x = screen_buffer->cursor_x;
1992 info->cursor_y = screen_buffer->cursor_y;
1993 info->width = screen_buffer->width;
1994 info->height = screen_buffer->height;
1995 info->attr = screen_buffer->attr;
1996 info->popup_attr = screen_buffer->popup_attr;
1997 info->win_left = screen_buffer->win.left;
1998 info->win_top = screen_buffer->win.top;
1999 info->win_right = screen_buffer->win.right;
2000 info->win_bottom = screen_buffer->win.bottom;
2001 info->max_width = screen_buffer->max_width;
2002 info->max_height = screen_buffer->max_height;
2003 info->font_width = screen_buffer->font.width;
2004 info->font_height = screen_buffer->font.height;
2005 info->font_weight = screen_buffer->font.weight;
2006 info->font_pitch_family = screen_buffer->font.pitch_family;
2007 memcpy( info->color_map, screen_buffer->color_map, sizeof(info->color_map) );
2008 size -= sizeof(*info);
2009 if (size) memcpy( info + 1, screen_buffer->font.face_name, size );
2010 return 1;
2011 }
2012
2013 case IOCTL_CONDRV_SET_OUTPUT_INFO:
2014 {
2015 const struct condrv_output_info_params *params = get_req_data();
2016 if (screen_buffer->input && screen_buffer->input->server)
2017 return queue_host_ioctl( screen_buffer->input->server, code, screen_buffer->id,
2018 async, &screen_buffer->ioctl_q );
2019 if (get_req_data_size() < sizeof(*params))
2020 {
2021 set_error( STATUS_INVALID_PARAMETER );
2022 return 0;
2023 }
2024 if (!screen_buffer->input)
2025 {
2026 set_error( STATUS_INVALID_HANDLE );
2027 return 0;
2028 }
2029 return set_output_info( screen_buffer, params, get_req_data_size() - sizeof(*params) );
2030 }
2031
2032 case IOCTL_CONDRV_ACTIVATE:
2033 if (screen_buffer->input && screen_buffer->input->server)
2034 return queue_host_ioctl( screen_buffer->input->server, code, screen_buffer->id,
2035 async, &screen_buffer->ioctl_q );
2036
2037 if (!screen_buffer->input)
2038 {
2039 set_error( STATUS_INVALID_HANDLE );
2040 return 0;
2041 }
2042
2043 set_active_screen_buffer( screen_buffer->input, screen_buffer );
2044 return 1;
2045
2046 case IOCTL_CONDRV_FILL_OUTPUT:
2047 {
2048 const struct condrv_fill_output_params *params = get_req_data();
2049 char_info_t data;
2050 DWORD written;
2051 if (screen_buffer->input && screen_buffer->input->server)
2052 return queue_host_ioctl( screen_buffer->input->server, code, screen_buffer->id,
2053 async, &screen_buffer->ioctl_q );
2054 if (get_req_data_size() != sizeof(*params) ||
2055 (get_reply_max_size() && get_reply_max_size() != sizeof(written)))
2056 {
2057 set_error( STATUS_INVALID_PARAMETER );
2058 return 0;
2059 }
2060 data.ch = params->ch;
2061 data.attr = params->attr;
2062 written = fill_console_output( screen_buffer, data, params->mode,
2063 params->x, params->y, params->count, params->wrap );
2064 if (written && get_reply_max_size() == sizeof(written))
2065 set_reply_data( &written, sizeof(written) );
2066 return !get_error();
2067 }
2068
2069 case IOCTL_CONDRV_SCROLL:
2070 {
2071 const struct condrv_scroll_params *params = get_req_data();
2072 rectangle_t clip;
2073
2074 if (screen_buffer->input && screen_buffer->input->server)
2075 return queue_host_ioctl( screen_buffer->input->server, code, screen_buffer->id,
2076 async, &screen_buffer->ioctl_q );
2077
2078 if (get_req_data_size() != sizeof(*params))
2079 {
2080 set_error( STATUS_INVALID_PARAMETER );
2081 return 0;
2082 }
2083 if (console_input_is_bare( screen_buffer->input ) || !screen_buffer->input)
2084 {
2085 set_error( STATUS_OBJECT_TYPE_MISMATCH );
2086 return 0;
2087 }
2088 clip.left = max( params->clip.Left, 0 );
2089 clip.top = max( params->clip.Top, 0 );
2090 clip.right = min( params->clip.Right, screen_buffer->width - 1 );
2091 clip.bottom = min( params->clip.Bottom, screen_buffer->height - 1 );
2092 if (clip.left > clip.right || clip.top > clip.bottom || params->scroll.Left < 0 || params->scroll.Top < 0 ||
2093 params->scroll.Right >= screen_buffer->width || params->scroll.Bottom >= screen_buffer->height ||
2094 params->scroll.Right < params->scroll.Left || params->scroll.Top > params->scroll.Bottom ||
2095 params->origin.X < 0 || params->origin.X >= screen_buffer->width || params->origin.Y < 0 ||
2096 params->origin.Y >= screen_buffer->height)
2097 {
2098 set_error( STATUS_INVALID_PARAMETER );
2099 return 0;
2100 }
2101
2102 scroll_console_output( screen_buffer, params->scroll.Left, params->scroll.Top, params->origin.X, params->origin.Y,
2103 params->scroll.Right - params->scroll.Left + 1, params->scroll.Bottom - params->scroll.Top + 1,
2104 &clip, params->fill );
2105 return !get_error();
2106 }
2107
2108 default:
2109 if (!screen_buffer->input || !screen_buffer->input->server || code >> 16 != FILE_DEVICE_CONSOLE)
2110 {
2111 set_error( STATUS_INVALID_HANDLE );
2112 return 0;
2113 }
2114 return queue_host_ioctl( screen_buffer->input->server, code, screen_buffer->id,
2115 async, &screen_buffer->ioctl_q );
2116 }
2117 }
2118
2119 static int console_input_events_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
2120 {
2121 struct console_input_events *evts = get_fd_user( fd );
2122
2123 switch (code)
2124 {
2125 case IOCTL_CONDRV_GET_RENDERER_EVENTS:
2126 set_error( STATUS_PENDING );
2127 if (evts->num_used) return get_renderer_events( evts, async );
2128 queue_async( &evts->read_q, async );
2129 return 1;
2130
2131 case IOCTL_CONDRV_ATTACH_RENDERER:
2132 {
2133 struct console_input *console_input;
2134 if (get_req_data_size() != sizeof(condrv_handle_t))
2135 {
2136 set_error( STATUS_INVALID_PARAMETER );
2137 return 0;
2138 }
2139 console_input = (struct console_input *)get_handle_obj( current->process, *(condrv_handle_t *)get_req_data(),
2140 0, &console_input_ops );
2141 if (!console_input) return 0;
2142
2143 if (!console_input->evt && !evts->console)
2144 {
2145 console_input->evt = evts;
2146 console_input->renderer = current;
2147 evts->console = console_input;
2148 }
2149 else set_error( STATUS_INVALID_HANDLE );
2150
2151 release_object( console_input );
2152 return !get_error();
2153 }
2154
2155 case IOCTL_CONDRV_SCROLL:
2156 case IOCTL_CONDRV_SET_MODE:
2157 case IOCTL_CONDRV_WRITE_OUTPUT:
2158 case IOCTL_CONDRV_READ_OUTPUT:
2159 case IOCTL_CONDRV_FILL_OUTPUT:
2160 case IOCTL_CONDRV_GET_OUTPUT_INFO:
2161 case IOCTL_CONDRV_SET_OUTPUT_INFO:
2162 if (!evts->console || !evts->console->active)
2163 {
2164 set_error( STATUS_INVALID_HANDLE );
2165 return 0;
2166 }
2167 return screen_buffer_ioctl( evts->console->active->fd, code, async );
2168
2169 default:
2170 if (!evts->console)
2171 {
2172 set_error( STATUS_INVALID_HANDLE );
2173 return 0;
2174 }
2175 return console_input_ioctl( evts->console->fd, code, async );
2176 }
2177 }
2178
2179 static int console_server_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
2180 {
2181 struct console_server *server = get_fd_user( fd );
2182
2183 switch (code)
2184 {
2185 case IOCTL_CONDRV_CTRL_EVENT:
2186 {
2187 const struct condrv_ctrl_event *event = get_req_data();
2188 if (get_req_data_size() != sizeof(*event))
2189 {
2190 set_error( STATUS_INVALID_PARAMETER );
2191 return 0;
2192 }
2193 if (!server->console)
2194 {
2195 set_error( STATUS_INVALID_HANDLE );
2196 return 0;
2197 }
2198 propagate_console_signal( server->console, event->event, event->group_id );
2199 return !get_error();
2200 }
2201
2202 default:
2203 set_error( STATUS_INVALID_HANDLE );
2204 return 0;
2205 }
2206 }
2207
2208 static struct object_type *console_device_get_type( struct object *obj )
2209 {
2210 static const WCHAR name[] = {'D','e','v','i','c','e'};
2211 static const struct unicode_str str = { name, sizeof(name) };
2212 return get_object_type( &str );
2213 }
2214
2215 static void console_device_dump( struct object *obj, int verbose )
2216 {
2217 fputs( "Console device\n", stderr );
2218 }
2219
2220 static struct object *console_device_lookup_name( struct object *obj, struct unicode_str *name, unsigned int attr )
2221 {
2222 static const WCHAR consoleW[] = {'C','o','n','s','o','l','e'};
2223 static const WCHAR current_inW[] = {'C','u','r','r','e','n','t','I','n'};
2224 static const WCHAR current_outW[] = {'C','u','r','r','e','n','t','O','u','t'};
2225 static const WCHAR rendererW[] = {'R','e','n','d','e','r','e','r'};
2226 static const WCHAR screen_bufferW[] = {'S','c','r','e','e','n','B','u','f','f','e','r'};
2227 static const WCHAR serverW[] = {'S','e','r','v','e','r'};
2228
2229 if (name->len == sizeof(current_inW) && !memcmp( name->str, current_inW, name->len ))
2230 {
2231 if (!current->process->console)
2232 {
2233 set_error( STATUS_INVALID_HANDLE );
2234 return NULL;
2235 }
2236 name->len = 0;
2237 return grab_object( current->process->console );
2238 }
2239
2240 if (name->len == sizeof(current_outW) && !memcmp( name->str, current_outW, name->len ))
2241 {
2242 if (!current->process->console || !current->process->console->active)
2243 {
2244 set_error( STATUS_INVALID_HANDLE );
2245 return NULL;
2246 }
2247 name->len = 0;
2248 return grab_object( current->process->console->active );
2249 }
2250
2251 if (name->len == sizeof(consoleW) && !memcmp( name->str, consoleW, name->len ))
2252 {
2253 name->len = 0;
2254 return grab_object( obj );
2255 }
2256
2257 if (name->len == sizeof(rendererW) && !memcmp( name->str, rendererW, name->len ))
2258 {
2259 name->len = 0;
2260 return create_console_input_events();
2261 }
2262
2263 if (name->len == sizeof(screen_bufferW) && !memcmp( name->str, screen_bufferW, name->len ))
2264 {
2265 if (!current->process->console)
2266 {
2267 set_error( STATUS_INVALID_HANDLE );
2268 return NULL;
2269 }
2270 name->len = 0;
2271 return create_console_output( current->process->console, -1 );
2272 }
2273
2274 if (name->len == sizeof(serverW) && !memcmp( name->str, serverW, name->len ))
2275 {
2276 name->len = 0;
2277 return create_console_server();
2278 }
2279
2280 return NULL;
2281 }
2282
2283 static struct object *console_device_open_file( struct object *obj, unsigned int access,
2284 unsigned int sharing, unsigned int options )
2285 {
2286 int is_output;
2287 access = default_fd_map_access( obj, access );
2288 is_output = access & FILE_WRITE_DATA;
2289 if (!current->process->console || (is_output && !current->process->console))
2290 {
2291 set_error( STATUS_INVALID_HANDLE );
2292 return NULL;
2293 }
2294 if (is_output && (access & FILE_READ_DATA))
2295 {
2296 set_error( STATUS_INVALID_PARAMETER );
2297 return NULL;
2298 }
2299 return is_output ? grab_object( current->process->console->active ) : grab_object( current->process->console );
2300 }
2301
2302 struct object *create_console_device( struct object *root, const struct unicode_str *name )
2303 {
2304 return create_named_object( root, &console_device_ops, name, 0, NULL );
2305 }
2306
2307 /* allocate a console for the renderer */
2308 DECL_HANDLER(alloc_console)
2309 {
2310 struct process *process;
2311 struct console_input *console;
2312 int fd;
2313 int attach = 0;
2314
2315 if (req->input_fd != -1)
2316 {
2317 if ((fd = thread_get_inflight_fd( current, req->input_fd )) == -1)
2318 {
2319 set_error( STATUS_INVALID_PARAMETER );
2320 return;
2321 }
2322 }
2323 else fd = -1;
2324
2325 switch (req->pid)
2326 {
2327 case 0:
2328 /* console to be attached to parent process */
2329 if (!(process = get_process_from_id( current->process->parent_id )))
2330 {
2331 if (fd != -1) close( fd );
2332 set_error( STATUS_ACCESS_DENIED );
2333 return;
2334 }
2335 attach = 1;
2336 break;
2337 case 0xffffffff:
2338 /* console to be attached to current process */
2339 process = current->process;
2340 grab_object( process );
2341 attach = 1;
2342 break;
2343 default:
2344 /* console to be attached to req->pid */
2345 if (!(process = get_process_from_id( req->pid )))
2346 {
2347 if (fd != -1) close( fd );
2348 return;
2349 }
2350 }
2351
2352 if (attach && process->console)
2353 {
2354 if (fd != -1) close( fd );
2355 set_error( STATUS_ACCESS_DENIED );
2356 }
2357 else if ((console = (struct console_input*)create_console_input( fd )))
2358 {
2359 if ((reply->handle_in = alloc_handle( current->process, console, req->access,
2360 req->attributes )) && attach)
2361 {
2362 process->console = (struct console_input*)grab_object( console );
2363 console->num_proc++;
2364 }
2365 release_object( console );
2366 }
2367 release_object( process );
2368 }
2369
2370 /* free the console of the current process */
2371 DECL_HANDLER(free_console)
2372 {
2373 free_console( current->process );
2374 }
2375
2376 /* attach to a other process's console */
2377 DECL_HANDLER(attach_console)
2378 {
2379 struct process *process;
2380
2381 if (current->process->console)
2382 {
2383 set_error( STATUS_ACCESS_DENIED );
2384 return;
2385 }
2386
2387 process = get_process_from_id( req->pid == ATTACH_PARENT_PROCESS
2388 ? current->process->parent_id : req->pid );
2389 if (!process) return;
2390
2391 if (process->console && process->console->active)
2392 {
2393 current->process->console = (struct console_input *)grab_object( process->console );
2394 current->process->console->num_proc++;
2395 }
2396 else
2397 {
2398 set_error( STATUS_INVALID_HANDLE );
2399 }
2400
2401 release_object( process );
2402 return;
2403 }
2404
2405 /* appends a string to console's history */
2406 DECL_HANDLER(append_console_input_history)
2407 {
2408 struct console_input *console;
2409
2410 if (!(console = console_input_get( req->handle, FILE_WRITE_PROPERTIES ))) return;
2411 console_input_append_hist( console, get_req_data(), get_req_data_size() );
2412 release_object( console );
2413 }
2414
2415 /* appends a string to console's history */
2416 DECL_HANDLER(get_console_input_history)
2417 {
2418 struct console_input *console;
2419
2420 if (!(console = console_input_get( req->handle, FILE_READ_PROPERTIES ))) return;
2421 reply->total = console_input_get_hist( console, req->index );
2422 release_object( console );
2423 }
2424
2425 /* creates a screen buffer */
2426 DECL_HANDLER(create_console_output)
2427 {
2428 struct console_input *console;
2429 struct object *screen_buffer;
2430 int fd;
2431
2432 if (req->fd != -1)
2433 {
2434 if ((fd = thread_get_inflight_fd( current, req->fd )) == -1)
2435 {
2436 set_error( STATUS_INVALID_HANDLE );
2437 return;
2438 }
2439 }
2440 else fd = -1;
2441 if (!(console = console_input_get( req->handle_in, FILE_WRITE_PROPERTIES )))
2442 {
2443 if (fd != -1) close( fd );
2444 return;
2445 }
2446 if (console_input_is_bare( console ) ^ (fd != -1))
2447 {
2448 if (fd != -1) close( fd );
2449 release_object( console );
2450 set_error( STATUS_INVALID_HANDLE );
2451 return;
2452 }
2453
2454 screen_buffer = create_console_output( console, fd );
2455 if (screen_buffer)
2456 {
2457 /* FIXME: should store sharing and test it when opening the CONOUT$ device
2458 * see file.c on how this could be done */
2459 reply->handle_out = alloc_handle( current->process, screen_buffer, req->access, req->attributes );
2460 release_object( screen_buffer );
2461 }
2462 release_object( console );
2463 }
2464
2465 /* get console which renderer is 'current' */
2466 static int cgwe_enum( struct process* process, void* user)
2467 {
2468 if (process->console && process->console->renderer == current)
2469 {
2470 *(struct console_input**)user = (struct console_input *)grab_object( process->console );
2471 return 1;
2472 }
2473 return 0;
2474 }
2475
2476 DECL_HANDLER(get_console_wait_event)
2477 {
2478 struct console_input* console = NULL;
2479 struct object *obj;
2480
2481 if (req->handle)
2482 {
2483 if (!(obj = get_handle_obj( current->process, req->handle, FILE_READ_PROPERTIES, NULL ))) return;
2484 if (obj->ops == &console_input_ops)
2485 console = (struct console_input *)grab_object( obj );
2486 else if (obj->ops == &screen_buffer_ops)
2487 console = (struct console_input *)grab_object( ((struct screen_buffer *)obj)->input );
2488 else
2489 set_error( STATUS_OBJECT_TYPE_MISMATCH );
2490 release_object( obj );
2491 }
2492 else if (current->process->console)
2493 console = (struct console_input *)grab_object( current->process->console );
2494 else enum_processes(cgwe_enum, &console);
2495
2496 if (console)
2497 {
2498 reply->event = alloc_handle( current->process, console->event, EVENT_ALL_ACCESS, 0 );
2499 release_object( console );
2500 }
2501 else set_error( STATUS_INVALID_PARAMETER );
2502 }
2503
2504 /* retrieve the next pending console ioctl request */
2505 DECL_HANDLER(get_next_console_request)
2506 {
2507 struct console_host_ioctl *ioctl = NULL, *next;
2508 struct console_server *server;
2509 struct iosb *iosb = NULL;
2510
2511 server = (struct console_server *)get_handle_obj( current->process, req->handle, 0, &console_server_ops );
2512 if (!server) return;
2513
2514 if (!server->console)
2515 {
2516 set_error( STATUS_INVALID_HANDLE );
2517 release_object( server );
2518 return;
2519 }
2520
2521 if (req->signal) set_event( server->console->event);
2522 else reset_event( server->console->event );
2523
2524 if (req->read)
2525 {
2526 /* set result of current pending ioctl */
2527 if (list_empty( &server->read_queue ))
2528 {
2529 set_error( STATUS_INVALID_HANDLE );
2530 release_object( server );
2531 return;
2532 }
2533
2534 ioctl = LIST_ENTRY( list_head( &server->read_queue ), struct console_host_ioctl, entry );
2535 list_remove( &ioctl->entry );
2536 list_move_tail( &server->queue, &server->read_queue );
2537 }
2538 else if (server->busy)
2539 {
2540 /* set result of previous ioctl */
2541 ioctl = LIST_ENTRY( list_head( &server->queue ), struct console_host_ioctl, entry );
2542 list_remove( &ioctl->entry );
2543 }
2544
2545 if (ioctl)
2546 {
2547 unsigned int status = req->status;
2548 if (ioctl->async)
2549 {
2550 iosb = async_get_iosb( ioctl->async );
2551 iosb->status = req->status;
2552 iosb->out_size = min( iosb->out_size, get_req_data_size() );
2553 if (iosb->out_size)
2554 {
2555 if ((iosb->out_data = memdup( get_req_data(), iosb->out_size )))
2556 {
2557 iosb->result = iosb->out_size;
2558 status = STATUS_ALERTED;
2559 }
2560 else if (!status)
2561 {
2562 iosb->status = STATUS_NO_MEMORY;
2563 iosb->out_size = 0;
2564 }
2565 }
2566 }
2567 console_host_ioctl_terminate( ioctl, status );
2568 if (iosb) release_object( iosb );
2569
2570 if (req->read)
2571 {
2572 release_object( server );
2573 return;
2574 }
2575 server->busy = 0;
2576 }
2577
2578 /* if we have a blocking read ioctl in queue head and previous blocking read is still waiting,
2579 * move it to read queue for execution after current read is complete. move all blocking
2580 * ioctl at the same time to preserve their order. */
2581 if (!list_empty( &server->queue ) && !list_empty( &server->read_queue ))
2582 {
2583 ioctl = LIST_ENTRY( list_head( &server->queue ), struct console_host_ioctl, entry );
2584 if (is_blocking_read_ioctl( ioctl->code ))
2585 {
2586 LIST_FOR_EACH_ENTRY_SAFE( ioctl, next, &server->queue, struct console_host_ioctl, entry )
2587 {
2588 if (!is_blocking_read_ioctl( ioctl->code )) continue;
2589 list_remove( &ioctl->entry );
2590 list_add_tail( &server->read_queue, &ioctl->entry );
2591 }
2592 }
2593 }
2594
2595 /* return the next ioctl */
2596 if (!list_empty( &server->queue ))
2597 {
2598 ioctl = LIST_ENTRY( list_head( &server->queue ), struct console_host_ioctl, entry );
2599 iosb = ioctl->async ? async_get_iosb( ioctl->async ) : NULL;
2600
2601 if (!iosb || get_reply_max_size() >= iosb->in_size)
2602 {
2603 reply->code = ioctl->code;
2604 reply->output = ioctl->output;
2605
2606 if (iosb)
2607 {
2608 reply->out_size = iosb->out_size;
2609 set_reply_data_ptr( iosb->in_data, iosb->in_size );
2610 iosb->in_data = NULL;
2611 }
2612
2613 if (is_blocking_read_ioctl( ioctl->code ))
2614 {
2615 list_remove( &ioctl->entry );
2616 assert( list_empty( &server->read_queue ));
2617 list_add_tail( &server->read_queue, &ioctl->entry );
2618 }
2619 else server->busy = 1;
2620 }
2621 else
2622 {
2623 reply->out_size = iosb->in_size;
2624 set_error( STATUS_BUFFER_OVERFLOW );
2625 }
2626 if (iosb) release_object( iosb );
2627 }
2628 else
2629 {
2630 set_error( STATUS_PENDING );
2631 }
2632
2633 release_object( server );
2634 }
Windows API implementation