chardev/char-win-stdio.c

   1 /*
   2  * QEMU System Emulator
   3  *
   4  * Copyright (c) 2003-2008 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24 #include "qemu/osdep.h"
  25 #include "qapi/error.h"
  26 #include "char-win.h"
  27 #include "char-win-stdio.h"
  28
  29 typedef struct {
  30     Chardev parent;
  31     HANDLE  hStdIn;
  32     HANDLE  hInputReadyEvent;
  33     HANDLE  hInputDoneEvent;
  34     HANDLE  hInputThread;
  35     uint8_t win_stdio_buf;
  36 } WinStdioChardev;
  37
  38 #define WIN_STDIO_CHARDEV(obj)                                          \
  39     OBJECT_CHECK(WinStdioChardev, (obj), TYPE_CHARDEV_WIN_STDIO)
  40
  41 static void win_stdio_wait_func(void *opaque)
  42 {
  43     Chardev *chr = CHARDEV(opaque);
  44     WinStdioChardev *stdio = WIN_STDIO_CHARDEV(opaque);
  45     INPUT_RECORD       buf[4];
  46     int                ret;
  47     DWORD              dwSize;
  48     int                i;
  49
  50     ret = ReadConsoleInput(stdio->hStdIn, buf, ARRAY_SIZE(buf), &dwSize);
  51
  52     if (!ret) {
  53         /* Avoid error storm */
  54         qemu_del_wait_object(stdio->hStdIn, NULL, NULL);
  55         return;
  56     }
  57
  58     for (i = 0; i < dwSize; i++) {
  59         KEY_EVENT_RECORD *kev = &buf[i].Event.KeyEvent;
  60
  61         if (buf[i].EventType == KEY_EVENT && kev->bKeyDown) {
  62             int j;
  63             if (kev->uChar.AsciiChar != 0) {
  64                 for (j = 0; j < kev->wRepeatCount; j++) {
  65                     if (qemu_chr_be_can_write(chr)) {
  66                         uint8_t c = kev->uChar.AsciiChar;
  67                         qemu_chr_be_write(chr, &c, 1);
  68                     }
  69                 }
  70             }
  71         }
  72     }
  73 }
  74
  75 static DWORD WINAPI win_stdio_thread(LPVOID param)
  76 {
  77     WinStdioChardev *stdio = WIN_STDIO_CHARDEV(param);
  78     int                ret;
  79     DWORD              dwSize;
  80
  81     while (1) {
  82
  83         /* Wait for one byte */
  84         ret = ReadFile(stdio->hStdIn, &stdio->win_stdio_buf, 1, &dwSize, NULL);
  85
  86         /* Exit in case of error, continue if nothing read */
  87         if (!ret) {
  88             break;
  89         }
  90         if (!dwSize) {
  91             continue;
  92         }
  93
  94         /* Some terminal emulator returns \r\n for Enter, just pass \n */
  95         if (stdio->win_stdio_buf == '\r') {
  96             continue;
  97         }
  98
  99         /* Signal the main thread and wait until the byte was eaten */
 100         if (!SetEvent(stdio->hInputReadyEvent)) {
 101             break;
 102         }
 103         if (WaitForSingleObject(stdio->hInputDoneEvent, INFINITE)
 104             != WAIT_OBJECT_0) {
 105             break;
 106         }
 107     }
 108
 109     qemu_del_wait_object(stdio->hInputReadyEvent, NULL, NULL);
 110     return 0;
 111 }
 112
 113 static void win_stdio_thread_wait_func(void *opaque)
 114 {
 115     Chardev *chr = CHARDEV(opaque);
 116     WinStdioChardev *stdio = WIN_STDIO_CHARDEV(opaque);
 117
 118     if (qemu_chr_be_can_write(chr)) {
 119         qemu_chr_be_write(chr, &stdio->win_stdio_buf, 1);
 120     }
 121
 122     SetEvent(stdio->hInputDoneEvent);
 123 }
 124
 125 static void qemu_chr_set_echo_win_stdio(Chardev *chr, bool echo)
 126 {
 127     WinStdioChardev *stdio = WIN_STDIO_CHARDEV(chr);
 128     DWORD              dwMode = 0;
 129
 130     GetConsoleMode(stdio->hStdIn, &dwMode);
 131
 132     if (echo) {
 133         SetConsoleMode(stdio->hStdIn, dwMode | ENABLE_ECHO_INPUT);
 134     } else {
 135         SetConsoleMode(stdio->hStdIn, dwMode & ~ENABLE_ECHO_INPUT);
 136     }
 137 }
 138
 139 static void qemu_chr_open_stdio(Chardev *chr,
 140                                 ChardevBackend *backend,
 141                                 bool *be_opened,
 142                                 Error **errp)
 143 {
 144     WinStdioChardev *stdio = WIN_STDIO_CHARDEV(chr);
 145     DWORD              dwMode;
 146     int                is_console = 0;
 147
 148     stdio->hStdIn = GetStdHandle(STD_INPUT_HANDLE);
 149     if (stdio->hStdIn == INVALID_HANDLE_VALUE) {
 150         error_setg(errp, "cannot open stdio: invalid handle");
 151         return;
 152     }
 153
 154     is_console = GetConsoleMode(stdio->hStdIn, &dwMode) != 0;
 155
 156     if (is_console) {
 157         if (qemu_add_wait_object(stdio->hStdIn,
 158                                  win_stdio_wait_func, chr)) {
 159             error_setg(errp, "qemu_add_wait_object: failed");
 160             goto err1;
 161         }
 162     } else {
 163         DWORD   dwId;
 164
 165         stdio->hInputReadyEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
 166         stdio->hInputDoneEvent  = CreateEvent(NULL, FALSE, FALSE, NULL);
 167         if (stdio->hInputReadyEvent == INVALID_HANDLE_VALUE
 168             || stdio->hInputDoneEvent == INVALID_HANDLE_VALUE) {
 169             error_setg(errp, "cannot create event");
 170             goto err2;
 171         }
 172         if (qemu_add_wait_object(stdio->hInputReadyEvent,
 173                                  win_stdio_thread_wait_func, chr)) {
 174             error_setg(errp, "qemu_add_wait_object: failed");
 175             goto err2;
 176         }
 177         stdio->hInputThread     = CreateThread(NULL, 0, win_stdio_thread,
 178                                                chr, 0, &dwId);
 179
 180         if (stdio->hInputThread == INVALID_HANDLE_VALUE) {
 181             error_setg(errp, "cannot create stdio thread");
 182             goto err3;
 183         }
 184     }
 185
 186     dwMode |= ENABLE_LINE_INPUT;
 187
 188     if (is_console) {
 189         /* set the terminal in raw mode */
 190         /* ENABLE_QUICK_EDIT_MODE | ENABLE_EXTENDED_FLAGS */
 191         dwMode |= ENABLE_PROCESSED_INPUT;
 192     }
 193
 194     SetConsoleMode(stdio->hStdIn, dwMode);
 195
 196     qemu_chr_set_echo_win_stdio(chr, false);
 197
 198     return;
 199
 200 err3:
 201     qemu_del_wait_object(stdio->hInputReadyEvent, NULL, NULL);
 202 err2:
 203     CloseHandle(stdio->hInputReadyEvent);
 204     CloseHandle(stdio->hInputDoneEvent);
 205 err1:
 206     qemu_del_wait_object(stdio->hStdIn, NULL, NULL);
 207 }
 208
 209 static void char_win_stdio_finalize(Object *obj)
 210 {
 211     WinStdioChardev *stdio = WIN_STDIO_CHARDEV(obj);
 212
 213     if (stdio->hInputReadyEvent != INVALID_HANDLE_VALUE) {
 214         CloseHandle(stdio->hInputReadyEvent);
 215     }
 216     if (stdio->hInputDoneEvent != INVALID_HANDLE_VALUE) {
 217         CloseHandle(stdio->hInputDoneEvent);
 218     }
 219     if (stdio->hInputThread != INVALID_HANDLE_VALUE) {
 220         TerminateThread(stdio->hInputThread, 0);
 221     }
 222 }
 223
 224 static int win_stdio_write(Chardev *chr, const uint8_t *buf, int len)
 225 {
 226     HANDLE  hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
 227     DWORD   dwSize;
 228     int     len1;
 229
 230     len1 = len;
 231
 232     while (len1 > 0) {
 233         if (!WriteFile(hStdOut, buf, len1, &dwSize, NULL)) {
 234             break;
 235         }
 236         buf  += dwSize;
 237         len1 -= dwSize;
 238     }
 239
 240     return len - len1;
 241 }
 242
 243 static void char_win_stdio_class_init(ObjectClass *oc, void *data)
 244 {
 245     ChardevClass *cc = CHARDEV_CLASS(oc);
 246
 247     cc->open = qemu_chr_open_stdio;
 248     cc->chr_write = win_stdio_write;
 249     cc->chr_set_echo = qemu_chr_set_echo_win_stdio;
 250 }
 251
 252 static const TypeInfo char_win_stdio_type_info = {
 253     .name = TYPE_CHARDEV_WIN_STDIO,
 254     .parent = TYPE_CHARDEV,
 255     .instance_size = sizeof(WinStdioChardev),
 256     .instance_finalize = char_win_stdio_finalize,
 257     .class_init = char_win_stdio_class_init,
 258     .abstract = true,
 259 };
 260
 261 static void register_types(void)
 262 {
 263     type_register_static(&char_win_stdio_type_info);
 264 }
 265
 266 type_init(register_types);