← Back to branch summary

~ubuntu-branches/ubuntu/trusty/qemu/trusty

« back to all changes in this revision

Viewing changes to .pc/1.6.1.patch/qemu-char.c

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn
  • Date: 2013-10-22 22:47:07 UTC
  • mfrom: (1.8.3) (10.1.42 sid)
  • Revision ID: package-import@ubuntu.com-20131022224707-1lya34fw3k3f24tv
Tags: 1.6.0+dfsg-2ubuntu1
http://bugs.debian.org/709241
* Merge 1.6.0~rc0+dfsg-2exp from debian experimental.  Remaining changes:
  - debian/control
    * update maintainer
    * remove libiscsi, usb-redir, vde, vnc-jpeg, and libssh2-1-dev
      from build-deps
    * enable rbd
    * add qemu-system and qemu-common B/R to qemu-keymaps
    * add D:udev, R:qemu, R:qemu-common and B:qemu-common to
      qemu-system-common
    * qemu-system-arm, qemu-system-ppc, qemu-system-sparc:
      - add qemu-kvm to Provides
      - add qemu-common, qemu-kvm, kvm to B/R
      - remove openbios-sparc from qemu-system-sparc D
      - drop openbios-ppc and openhackware Depends to Suggests (for now)
    * qemu-system-x86:
      - add qemu-common to Breaks/Replaces.
      - add cpu-checker to Recommends.
    * qemu-user: add B/R:qemu-kvm
    * qemu-kvm:
      - add armhf armel powerpc sparc to Architecture
      - C/R/P: qemu-kvm-spice
    * add qemu-common package
    * drop qemu-slof which is not packaged in ubuntu
  - add qemu-system-common.links for tap ifup/down scripts and OVMF link.
  - qemu-system-x86.links:
    * remove pxe rom links which are in kvm-ipxe
    * add symlink for kvm.1 manpage
  - debian/rules
    * add kvm-spice symlink to qemu-kvm
    * call dh_installmodules for qemu-system-x86
    * update dh_installinit to install upstart script
    * run dh_installman (Closes: #709241) (cherrypicked from 1.5.0+dfsg-2)
  - Add qemu-utils.links for kvm-* symlinks.
  - Add qemu-system-x86.qemu-kvm.upstart and .default
  - Add qemu-system-x86.modprobe to set nesting=1
  - Add qemu-system-common.preinst to add kvm group
  - qemu-system-common.postinst: remove bad group acl if there, then have
    udev relabel /dev/kvm.
  - New linaro patches from qemu-linaro rebasing branch
  - Dropped patches:
    * xen-simplify-xen_enabled.patch
    * sparc-linux-user-fix-missing-symbols-in-.rel-.rela.plt-sections.patch
    * main_loop-do-not-set-nonblocking-if-xen_enabled.patch
    * xen_machine_pv-do-not-create-a-dummy-CPU-in-machine-.patch
    * virtio-rng-fix-crash
  - Kept patches:
    * expose_vms_qemu64cpu.patch - updated
    * linaro arm patches from qemu-linaro rebasing branch
  - New patches:
    * fix-pci-add: change CONFIG variable in ifdef to make sure that
      pci_add is defined.
* Add linaro patches
* Add experimental mach-virt patches for arm virtualization.
* qemu-system-common.install: add debian/tmp/usr/lib to install the
  qemu-bridge-helper

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/1.6.1.patch/qemu-char.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-common.h"
 
25
#include "monitor/monitor.h"
 
26
#include "ui/console.h"
 
27
#include "sysemu/sysemu.h"
 
28
#include "qemu/timer.h"
 
29
#include "sysemu/char.h"
 
30
#include "hw/usb.h"
 
31
#include "qmp-commands.h"
 
32
 
 
33
#include <unistd.h>
 
34
#include <fcntl.h>
 
35
#include <time.h>
 
36
#include <errno.h>
 
37
#include <sys/time.h>
 
38
#include <zlib.h>
 
39
 
 
40
#ifndef _WIN32
 
41
#include <sys/times.h>
 
42
#include <sys/wait.h>
 
43
#include <termios.h>
 
44
#include <sys/mman.h>
 
45
#include <sys/ioctl.h>
 
46
#include <sys/resource.h>
 
47
#include <sys/socket.h>
 
48
#include <netinet/in.h>
 
49
#include <net/if.h>
 
50
#include <arpa/inet.h>
 
51
#include <dirent.h>
 
52
#include <netdb.h>
 
53
#include <sys/select.h>
 
54
#ifdef CONFIG_BSD
 
55
#include <sys/stat.h>
 
56
#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
 
57
#include <dev/ppbus/ppi.h>
 
58
#include <dev/ppbus/ppbconf.h>
 
59
#elif defined(__DragonFly__)
 
60
#include <dev/misc/ppi/ppi.h>
 
61
#include <bus/ppbus/ppbconf.h>
 
62
#endif
 
63
#else
 
64
#ifdef __linux__
 
65
#include <linux/ppdev.h>
 
66
#include <linux/parport.h>
 
67
#endif
 
68
#ifdef __sun__
 
69
#include <sys/stat.h>
 
70
#include <sys/ethernet.h>
 
71
#include <sys/sockio.h>
 
72
#include <netinet/arp.h>
 
73
#include <netinet/in.h>
 
74
#include <netinet/in_systm.h>
 
75
#include <netinet/ip.h>
 
76
#include <netinet/ip_icmp.h> // must come after ip.h
 
77
#include <netinet/udp.h>
 
78
#include <netinet/tcp.h>
 
79
#endif
 
80
#endif
 
81
#endif
 
82
 
 
83
#include "qemu/sockets.h"
 
84
#include "ui/qemu-spice.h"
 
85
 
 
86
#define READ_BUF_LEN 4096
 
87
 
 
88
/***********************************************************/
 
89
/* character device */
 
90
 
 
91
static QTAILQ_HEAD(CharDriverStateHead, CharDriverState) chardevs =
 
92
    QTAILQ_HEAD_INITIALIZER(chardevs);
 
93
 
 
94
void qemu_chr_be_event(CharDriverState *s, int event)
 
95
{
 
96
    /* Keep track if the char device is open */
 
97
    switch (event) {
 
98
        case CHR_EVENT_OPENED:
 
99
            s->be_open = 1;
 
100
            break;
 
101
        case CHR_EVENT_CLOSED:
 
102
            s->be_open = 0;
 
103
            break;
 
104
    }
 
105
 
 
106
    if (!s->chr_event)
 
107
        return;
 
108
    s->chr_event(s->handler_opaque, event);
 
109
}
 
110
 
 
111
void qemu_chr_be_generic_open(CharDriverState *s)
 
112
{
 
113
    qemu_chr_be_event(s, CHR_EVENT_OPENED);
 
114
}
 
115
 
 
116
int qemu_chr_fe_write(CharDriverState *s, const uint8_t *buf, int len)
 
117
{
 
118
    return s->chr_write(s, buf, len);
 
119
}
 
120
 
 
121
int qemu_chr_fe_write_all(CharDriverState *s, const uint8_t *buf, int len)
 
122
{
 
123
    int offset = 0;
 
124
    int res;
 
125
 
 
126
    while (offset < len) {
 
127
        do {
 
128
            res = s->chr_write(s, buf + offset, len - offset);
 
129
            if (res == -1 && errno == EAGAIN) {
 
130
                g_usleep(100);
 
131
            }
 
132
        } while (res == -1 && errno == EAGAIN);
 
133
 
 
134
        if (res == 0) {
 
135
            break;
 
136
        }
 
137
 
 
138
        if (res < 0) {
 
139
            return res;
 
140
        }
 
141
 
 
142
        offset += res;
 
143
    }
 
144
 
 
145
    return offset;
 
146
}
 
147
 
 
148
int qemu_chr_fe_ioctl(CharDriverState *s, int cmd, void *arg)
 
149
{
 
150
    if (!s->chr_ioctl)
 
151
        return -ENOTSUP;
 
152
    return s->chr_ioctl(s, cmd, arg);
 
153
}
 
154
 
 
155
int qemu_chr_be_can_write(CharDriverState *s)
 
156
{
 
157
    if (!s->chr_can_read)
 
158
        return 0;
 
159
    return s->chr_can_read(s->handler_opaque);
 
160
}
 
161
 
 
162
void qemu_chr_be_write(CharDriverState *s, uint8_t *buf, int len)
 
163
{
 
164
    if (s->chr_read) {
 
165
        s->chr_read(s->handler_opaque, buf, len);
 
166
    }
 
167
}
 
168
 
 
169
int qemu_chr_fe_get_msgfd(CharDriverState *s)
 
170
{
 
171
    return s->get_msgfd ? s->get_msgfd(s) : -1;
 
172
}
 
173
 
 
174
int qemu_chr_add_client(CharDriverState *s, int fd)
 
175
{
 
176
    return s->chr_add_client ? s->chr_add_client(s, fd) : -1;
 
177
}
 
178
 
 
179
void qemu_chr_accept_input(CharDriverState *s)
 
180
{
 
181
    if (s->chr_accept_input)
 
182
        s->chr_accept_input(s);
 
183
    qemu_notify_event();
 
184
}
 
185
 
 
186
void qemu_chr_fe_printf(CharDriverState *s, const char *fmt, ...)
 
187
{
 
188
    char buf[READ_BUF_LEN];
 
189
    va_list ap;
 
190
    va_start(ap, fmt);
 
191
    vsnprintf(buf, sizeof(buf), fmt, ap);
 
192
    qemu_chr_fe_write(s, (uint8_t *)buf, strlen(buf));
 
193
    va_end(ap);
 
194
}
 
195
 
 
196
void qemu_chr_add_handlers(CharDriverState *s,
 
197
                           IOCanReadHandler *fd_can_read,
 
198
                           IOReadHandler *fd_read,
 
199
                           IOEventHandler *fd_event,
 
200
                           void *opaque)
 
201
{
 
202
    int fe_open;
 
203
 
 
204
    if (!opaque && !fd_can_read && !fd_read && !fd_event) {
 
205
        fe_open = 0;
 
206
    } else {
 
207
        fe_open = 1;
 
208
    }
 
209
    s->chr_can_read = fd_can_read;
 
210
    s->chr_read = fd_read;
 
211
    s->chr_event = fd_event;
 
212
    s->handler_opaque = opaque;
 
213
    if (s->chr_update_read_handler)
 
214
        s->chr_update_read_handler(s);
 
215
 
 
216
    if (!s->explicit_fe_open) {
 
217
        qemu_chr_fe_set_open(s, fe_open);
 
218
    }
 
219
 
 
220
    /* We're connecting to an already opened device, so let's make sure we
 
221
       also get the open event */
 
222
    if (fe_open && s->be_open) {
 
223
        qemu_chr_be_generic_open(s);
 
224
    }
 
225
}
 
226
 
 
227
static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
 
228
{
 
229
    return len;
 
230
}
 
231
 
 
232
static CharDriverState *qemu_chr_open_null(void)
 
233
{
 
234
    CharDriverState *chr;
 
235
 
 
236
    chr = g_malloc0(sizeof(CharDriverState));
 
237
    chr->chr_write = null_chr_write;
 
238
    chr->explicit_be_open = true;
 
239
    return chr;
 
240
}
 
241
 
 
242
/* MUX driver for serial I/O splitting */
 
243
#define MAX_MUX 4
 
244
#define MUX_BUFFER_SIZE 32      /* Must be a power of 2.  */
 
245
#define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)
 
246
typedef struct {
 
247
    IOCanReadHandler *chr_can_read[MAX_MUX];
 
248
    IOReadHandler *chr_read[MAX_MUX];
 
249
    IOEventHandler *chr_event[MAX_MUX];
 
250
    void *ext_opaque[MAX_MUX];
 
251
    CharDriverState *drv;
 
252
    int focus;
 
253
    int mux_cnt;
 
254
    int term_got_escape;
 
255
    int max_size;
 
256
    /* Intermediate input buffer allows to catch escape sequences even if the
 
257
       currently active device is not accepting any input - but only until it
 
258
       is full as well. */
 
259
    unsigned char buffer[MAX_MUX][MUX_BUFFER_SIZE];
 
260
    int prod[MAX_MUX];
 
261
    int cons[MAX_MUX];
 
262
    int timestamps;
 
263
    int linestart;
 
264
    int64_t timestamps_start;
 
265
} MuxDriver;
 
266
 
 
267
 
 
268
static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
 
269
{
 
270
    MuxDriver *d = chr->opaque;
 
271
    int ret;
 
272
    if (!d->timestamps) {
 
273
        ret = d->drv->chr_write(d->drv, buf, len);
 
274
    } else {
 
275
        int i;
 
276
 
 
277
        ret = 0;
 
278
        for (i = 0; i < len; i++) {
 
279
            if (d->linestart) {
 
280
                char buf1[64];
 
281
                int64_t ti;
 
282
                int secs;
 
283
 
 
284
                ti = qemu_get_clock_ms(rt_clock);
 
285
                if (d->timestamps_start == -1)
 
286
                    d->timestamps_start = ti;
 
287
                ti -= d->timestamps_start;
 
288
                secs = ti / 1000;
 
289
                snprintf(buf1, sizeof(buf1),
 
290
                         "[%02d:%02d:%02d.%03d] ",
 
291
                         secs / 3600,
 
292
                         (secs / 60) % 60,
 
293
                         secs % 60,
 
294
                         (int)(ti % 1000));
 
295
                d->drv->chr_write(d->drv, (uint8_t *)buf1, strlen(buf1));
 
296
                d->linestart = 0;
 
297
            }
 
298
            ret += d->drv->chr_write(d->drv, buf+i, 1);
 
299
            if (buf[i] == '\n') {
 
300
                d->linestart = 1;
 
301
            }
 
302
        }
 
303
    }
 
304
    return ret;
 
305
}
 
306
 
 
307
static const char * const mux_help[] = {
 
308
    "% h    print this help\n\r",
 
309
    "% x    exit emulator\n\r",
 
310
    "% s    save disk data back to file (if -snapshot)\n\r",
 
311
    "% t    toggle console timestamps\n\r"
 
312
    "% b    send break (magic sysrq)\n\r",
 
313
    "% c    switch between console and monitor\n\r",
 
314
    "% %  sends %\n\r",
 
315
    NULL
 
316
};
 
317
 
 
318
int term_escape_char = 0x01; /* ctrl-a is used for escape */
 
319
static void mux_print_help(CharDriverState *chr)
 
320
{
 
321
    int i, j;
 
322
    char ebuf[15] = "Escape-Char";
 
323
    char cbuf[50] = "\n\r";
 
324
 
 
325
    if (term_escape_char > 0 && term_escape_char < 26) {
 
326
        snprintf(cbuf, sizeof(cbuf), "\n\r");
 
327
        snprintf(ebuf, sizeof(ebuf), "C-%c", term_escape_char - 1 + 'a');
 
328
    } else {
 
329
        snprintf(cbuf, sizeof(cbuf),
 
330
                 "\n\rEscape-Char set to Ascii: 0x%02x\n\r\n\r",
 
331
                 term_escape_char);
 
332
    }
 
333
    chr->chr_write(chr, (uint8_t *)cbuf, strlen(cbuf));
 
334
    for (i = 0; mux_help[i] != NULL; i++) {
 
335
        for (j=0; mux_help[i][j] != '\0'; j++) {
 
336
            if (mux_help[i][j] == '%')
 
337
                chr->chr_write(chr, (uint8_t *)ebuf, strlen(ebuf));
 
338
            else
 
339
                chr->chr_write(chr, (uint8_t *)&mux_help[i][j], 1);
 
340
        }
 
341
    }
 
342
}
 
343
 
 
344
static void mux_chr_send_event(MuxDriver *d, int mux_nr, int event)
 
345
{
 
346
    if (d->chr_event[mux_nr])
 
347
        d->chr_event[mux_nr](d->ext_opaque[mux_nr], event);
 
348
}
 
349
 
 
350
static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch)
 
351
{
 
352
    if (d->term_got_escape) {
 
353
        d->term_got_escape = 0;
 
354
        if (ch == term_escape_char)
 
355
            goto send_char;
 
356
        switch(ch) {
 
357
        case '?':
 
358
        case 'h':
 
359
            mux_print_help(chr);
 
360
            break;
 
361
        case 'x':
 
362
            {
 
363
                 const char *term =  "QEMU: Terminated\n\r";
 
364
                 chr->chr_write(chr,(uint8_t *)term,strlen(term));
 
365
                 exit(0);
 
366
                 break;
 
367
            }
 
368
        case 's':
 
369
            bdrv_commit_all();
 
370
            break;
 
371
        case 'b':
 
372
            qemu_chr_be_event(chr, CHR_EVENT_BREAK);
 
373
            break;
 
374
        case 'c':
 
375
            /* Switch to the next registered device */
 
376
            mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_OUT);
 
377
            d->focus++;
 
378
            if (d->focus >= d->mux_cnt)
 
379
                d->focus = 0;
 
380
            mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_IN);
 
381
            break;
 
382
        case 't':
 
383
            d->timestamps = !d->timestamps;
 
384
            d->timestamps_start = -1;
 
385
            d->linestart = 0;
 
386
            break;
 
387
        }
 
388
    } else if (ch == term_escape_char) {
 
389
        d->term_got_escape = 1;
 
390
    } else {
 
391
    send_char:
 
392
        return 1;
 
393
    }
 
394
    return 0;
 
395
}
 
396
 
 
397
static void mux_chr_accept_input(CharDriverState *chr)
 
398
{
 
399
    MuxDriver *d = chr->opaque;
 
400
    int m = d->focus;
 
401
 
 
402
    while (d->prod[m] != d->cons[m] &&
 
403
           d->chr_can_read[m] &&
 
404
           d->chr_can_read[m](d->ext_opaque[m])) {
 
405
        d->chr_read[m](d->ext_opaque[m],
 
406
                       &d->buffer[m][d->cons[m]++ & MUX_BUFFER_MASK], 1);
 
407
    }
 
408
}
 
409
 
 
410
static int mux_chr_can_read(void *opaque)
 
411
{
 
412
    CharDriverState *chr = opaque;
 
413
    MuxDriver *d = chr->opaque;
 
414
    int m = d->focus;
 
415
 
 
416
    if ((d->prod[m] - d->cons[m]) < MUX_BUFFER_SIZE)
 
417
        return 1;
 
418
    if (d->chr_can_read[m])
 
419
        return d->chr_can_read[m](d->ext_opaque[m]);
 
420
    return 0;
 
421
}
 
422
 
 
423
static void mux_chr_read(void *opaque, const uint8_t *buf, int size)
 
424
{
 
425
    CharDriverState *chr = opaque;
 
426
    MuxDriver *d = chr->opaque;
 
427
    int m = d->focus;
 
428
    int i;
 
429
 
 
430
    mux_chr_accept_input (opaque);
 
431
 
 
432
    for(i = 0; i < size; i++)
 
433
        if (mux_proc_byte(chr, d, buf[i])) {
 
434
            if (d->prod[m] == d->cons[m] &&
 
435
                d->chr_can_read[m] &&
 
436
                d->chr_can_read[m](d->ext_opaque[m]))
 
437
                d->chr_read[m](d->ext_opaque[m], &buf[i], 1);
 
438
            else
 
439
                d->buffer[m][d->prod[m]++ & MUX_BUFFER_MASK] = buf[i];
 
440
        }
 
441
}
 
442
 
 
443
static void mux_chr_event(void *opaque, int event)
 
444
{
 
445
    CharDriverState *chr = opaque;
 
446
    MuxDriver *d = chr->opaque;
 
447
    int i;
 
448
 
 
449
    /* Send the event to all registered listeners */
 
450
    for (i = 0; i < d->mux_cnt; i++)
 
451
        mux_chr_send_event(d, i, event);
 
452
}
 
453
 
 
454
static void mux_chr_update_read_handler(CharDriverState *chr)
 
455
{
 
456
    MuxDriver *d = chr->opaque;
 
457
 
 
458
    if (d->mux_cnt >= MAX_MUX) {
 
459
        fprintf(stderr, "Cannot add I/O handlers, MUX array is full\n");
 
460
        return;
 
461
    }
 
462
    d->ext_opaque[d->mux_cnt] = chr->handler_opaque;
 
463
    d->chr_can_read[d->mux_cnt] = chr->chr_can_read;
 
464
    d->chr_read[d->mux_cnt] = chr->chr_read;
 
465
    d->chr_event[d->mux_cnt] = chr->chr_event;
 
466
    /* Fix up the real driver with mux routines */
 
467
    if (d->mux_cnt == 0) {
 
468
        qemu_chr_add_handlers(d->drv, mux_chr_can_read, mux_chr_read,
 
469
                              mux_chr_event, chr);
 
470
    }
 
471
    if (d->focus != -1) {
 
472
        mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_OUT);
 
473
    }
 
474
    d->focus = d->mux_cnt;
 
475
    d->mux_cnt++;
 
476
    mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_IN);
 
477
}
 
478
 
 
479
static bool muxes_realized;
 
480
 
 
481
/**
 
482
 * Called after processing of default and command-line-specified
 
483
 * chardevs to deliver CHR_EVENT_OPENED events to any FEs attached
 
484
 * to a mux chardev. This is done here to ensure that
 
485
 * output/prompts/banners are only displayed for the FE that has
 
486
 * focus when initial command-line processing/machine init is
 
487
 * completed.
 
488
 *
 
489
 * After this point, any new FE attached to any new or existing
 
490
 * mux will receive CHR_EVENT_OPENED notifications for the BE
 
491
 * immediately.
 
492
 */
 
493
static void muxes_realize_done(Notifier *notifier, void *unused)
 
494
{
 
495
    CharDriverState *chr;
 
496
 
 
497
    QTAILQ_FOREACH(chr, &chardevs, next) {
 
498
        if (chr->is_mux) {
 
499
            MuxDriver *d = chr->opaque;
 
500
            int i;
 
501
 
 
502
            /* send OPENED to all already-attached FEs */
 
503
            for (i = 0; i < d->mux_cnt; i++) {
 
504
                mux_chr_send_event(d, i, CHR_EVENT_OPENED);
 
505
            }
 
506
            /* mark mux as OPENED so any new FEs will immediately receive
 
507
             * OPENED event
 
508
             */
 
509
            qemu_chr_be_generic_open(chr);
 
510
        }
 
511
    }
 
512
    muxes_realized = true;
 
513
}
 
514
 
 
515
static Notifier muxes_realize_notify = {
 
516
    .notify = muxes_realize_done,
 
517
};
 
518
 
 
519
static CharDriverState *qemu_chr_open_mux(CharDriverState *drv)
 
520
{
 
521
    CharDriverState *chr;
 
522
    MuxDriver *d;
 
523
 
 
524
    chr = g_malloc0(sizeof(CharDriverState));
 
525
    d = g_malloc0(sizeof(MuxDriver));
 
526
 
 
527
    chr->opaque = d;
 
528
    d->drv = drv;
 
529
    d->focus = -1;
 
530
    chr->chr_write = mux_chr_write;
 
531
    chr->chr_update_read_handler = mux_chr_update_read_handler;
 
532
    chr->chr_accept_input = mux_chr_accept_input;
 
533
    /* Frontend guest-open / -close notification is not support with muxes */
 
534
    chr->chr_set_fe_open = NULL;
 
535
    /* only default to opened state if we've realized the initial
 
536
     * set of muxes
 
537
     */
 
538
    chr->explicit_be_open = muxes_realized ? 0 : 1;
 
539
    chr->is_mux = 1;
 
540
 
 
541
    return chr;
 
542
}
 
543
 
 
544
 
 
545
#ifdef _WIN32
 
546
int send_all(int fd, const void *buf, int len1)
 
547
{
 
548
    int ret, len;
 
549
 
 
550
    len = len1;
 
551
    while (len > 0) {
 
552
        ret = send(fd, buf, len, 0);
 
553
        if (ret < 0) {
 
554
            errno = WSAGetLastError();
 
555
            if (errno != WSAEWOULDBLOCK) {
 
556
                return -1;
 
557
            }
 
558
        } else if (ret == 0) {
 
559
            break;
 
560
        } else {
 
561
            buf += ret;
 
562
            len -= ret;
 
563
        }
 
564
    }
 
565
    return len1 - len;
 
566
}
 
567
 
 
568
#else
 
569
 
 
570
int send_all(int fd, const void *_buf, int len1)
 
571
{
 
572
    int ret, len;
 
573
    const uint8_t *buf = _buf;
 
574
 
 
575
    len = len1;
 
576
    while (len > 0) {
 
577
        ret = write(fd, buf, len);
 
578
        if (ret < 0) {
 
579
            if (errno != EINTR && errno != EAGAIN)
 
580
                return -1;
 
581
        } else if (ret == 0) {
 
582
            break;
 
583
        } else {
 
584
            buf += ret;
 
585
            len -= ret;
 
586
        }
 
587
    }
 
588
    return len1 - len;
 
589
}
 
590
 
 
591
int recv_all(int fd, void *_buf, int len1, bool single_read)
 
592
{
 
593
    int ret, len;
 
594
    uint8_t *buf = _buf;
 
595
 
 
596
    len = len1;
 
597
    while ((len > 0) && (ret = read(fd, buf, len)) != 0) {
 
598
        if (ret < 0) {
 
599
            if (errno != EINTR && errno != EAGAIN) {
 
600
                return -1;
 
601
            }
 
602
            continue;
 
603
        } else {
 
604
            if (single_read) {
 
605
                return ret;
 
606
            }
 
607
            buf += ret;
 
608
            len -= ret;
 
609
        }
 
610
    }
 
611
    return len1 - len;
 
612
}
 
613
 
 
614
#endif /* !_WIN32 */
 
615
 
 
616
typedef struct IOWatchPoll
 
617
{
 
618
    GSource parent;
 
619
 
 
620
    GIOChannel *channel;
 
621
    GSource *src;
 
622
 
 
623
    IOCanReadHandler *fd_can_read;
 
624
    GSourceFunc fd_read;
 
625
    void *opaque;
 
626
} IOWatchPoll;
 
627
 
 
628
static IOWatchPoll *io_watch_poll_from_source(GSource *source)
 
629
{
 
630
    return container_of(source, IOWatchPoll, parent);
 
631
}
 
632
 
 
633
static gboolean io_watch_poll_prepare(GSource *source, gint *timeout_)
 
634
{
 
635
    IOWatchPoll *iwp = io_watch_poll_from_source(source);
 
636
    bool now_active = iwp->fd_can_read(iwp->opaque) > 0;
 
637
    bool was_active = iwp->src != NULL;
 
638
    if (was_active == now_active) {
 
639
        return FALSE;
 
640
    }
 
641
 
 
642
    if (now_active) {
 
643
        iwp->src = g_io_create_watch(iwp->channel, G_IO_IN | G_IO_ERR | G_IO_HUP);
 
644
        g_source_set_callback(iwp->src, iwp->fd_read, iwp->opaque, NULL);
 
645
        g_source_attach(iwp->src, NULL);
 
646
    } else {
 
647
        g_source_destroy(iwp->src);
 
648
        g_source_unref(iwp->src);
 
649
        iwp->src = NULL;
 
650
    }
 
651
    return FALSE;
 
652
}
 
653
 
 
654
static gboolean io_watch_poll_check(GSource *source)
 
655
{
 
656
    return FALSE;
 
657
}
 
658
 
 
659
static gboolean io_watch_poll_dispatch(GSource *source, GSourceFunc callback,
 
660
                                       gpointer user_data)
 
661
{
 
662
    abort();
 
663
}
 
664
 
 
665
static void io_watch_poll_finalize(GSource *source)
 
666
{
 
667
    /* Due to a glib bug, removing the last reference to a source
 
668
     * inside a finalize callback causes recursive locking (and a
 
669
     * deadlock).  This is not a problem inside other callbacks,
 
670
     * including dispatch callbacks, so we call io_remove_watch_poll
 
671
     * to remove this source.  At this point, iwp->src must
 
672
     * be NULL, or we would leak it.
 
673
     *
 
674
     * This would be solved much more elegantly by child sources,
 
675
     * but we support older glib versions that do not have them.
 
676
     */
 
677
    IOWatchPoll *iwp = io_watch_poll_from_source(source);
 
678
    assert(iwp->src == NULL);
 
679
}
 
680
 
 
681
static GSourceFuncs io_watch_poll_funcs = {
 
682
    .prepare = io_watch_poll_prepare,
 
683
    .check = io_watch_poll_check,
 
684
    .dispatch = io_watch_poll_dispatch,
 
685
    .finalize = io_watch_poll_finalize,
 
686
};
 
687
 
 
688
/* Can only be used for read */
 
689
static guint io_add_watch_poll(GIOChannel *channel,
 
690
                               IOCanReadHandler *fd_can_read,
 
691
                               GIOFunc fd_read,
 
692
                               gpointer user_data)
 
693
{
 
694
    IOWatchPoll *iwp;
 
695
    int tag;
 
696
 
 
697
    iwp = (IOWatchPoll *) g_source_new(&io_watch_poll_funcs, sizeof(IOWatchPoll));
 
698
    iwp->fd_can_read = fd_can_read;
 
699
    iwp->opaque = user_data;
 
700
    iwp->channel = channel;
 
701
    iwp->fd_read = (GSourceFunc) fd_read;
 
702
    iwp->src = NULL;
 
703
 
 
704
    tag = g_source_attach(&iwp->parent, NULL);
 
705
    g_source_unref(&iwp->parent);
 
706
    return tag;
 
707
}
 
708
 
 
709
static void io_remove_watch_poll(guint tag)
 
710
{
 
711
    GSource *source;
 
712
    IOWatchPoll *iwp;
 
713
 
 
714
    g_return_if_fail (tag > 0);
 
715
 
 
716
    source = g_main_context_find_source_by_id(NULL, tag);
 
717
    g_return_if_fail (source != NULL);
 
718
 
 
719
    iwp = io_watch_poll_from_source(source);
 
720
    if (iwp->src) {
 
721
        g_source_destroy(iwp->src);
 
722
        g_source_unref(iwp->src);
 
723
        iwp->src = NULL;
 
724
    }
 
725
    g_source_destroy(&iwp->parent);
 
726
}
 
727
 
 
728
#ifndef _WIN32
 
729
static GIOChannel *io_channel_from_fd(int fd)
 
730
{
 
731
    GIOChannel *chan;
 
732
 
 
733
    if (fd == -1) {
 
734
        return NULL;
 
735
    }
 
736
 
 
737
    chan = g_io_channel_unix_new(fd);
 
738
 
 
739
    g_io_channel_set_encoding(chan, NULL, NULL);
 
740
    g_io_channel_set_buffered(chan, FALSE);
 
741
 
 
742
    return chan;
 
743
}
 
744
#endif
 
745
 
 
746
static GIOChannel *io_channel_from_socket(int fd)
 
747
{
 
748
    GIOChannel *chan;
 
749
 
 
750
    if (fd == -1) {
 
751
        return NULL;
 
752
    }
 
753
 
 
754
#ifdef _WIN32
 
755
    chan = g_io_channel_win32_new_socket(fd);
 
756
#else
 
757
    chan = g_io_channel_unix_new(fd);
 
758
#endif
 
759
 
 
760
    g_io_channel_set_encoding(chan, NULL, NULL);
 
761
    g_io_channel_set_buffered(chan, FALSE);
 
762
 
 
763
    return chan;
 
764
}
 
765
 
 
766
static int io_channel_send(GIOChannel *fd, const void *buf, size_t len)
 
767
{
 
768
    size_t offset = 0;
 
769
    GIOStatus status = G_IO_STATUS_NORMAL;
 
770
 
 
771
    while (offset < len && status == G_IO_STATUS_NORMAL) {
 
772
        gsize bytes_written = 0;
 
773
 
 
774
        status = g_io_channel_write_chars(fd, buf + offset, len - offset,
 
775
                                          &bytes_written, NULL);
 
776
        offset += bytes_written;
 
777
    }
 
778
 
 
779
    if (offset > 0) {
 
780
        return offset;
 
781
    }
 
782
    switch (status) {
 
783
    case G_IO_STATUS_NORMAL:
 
784
        g_assert(len == 0);
 
785
        return 0;
 
786
    case G_IO_STATUS_AGAIN:
 
787
        errno = EAGAIN;
 
788
        return -1;
 
789
    default:
 
790
        break;
 
791
    }
 
792
    errno = EINVAL;
 
793
    return -1;
 
794
}
 
795
 
 
796
#ifndef _WIN32
 
797
 
 
798
typedef struct FDCharDriver {
 
799
    CharDriverState *chr;
 
800
    GIOChannel *fd_in, *fd_out;
 
801
    guint fd_in_tag;
 
802
    int max_size;
 
803
    QTAILQ_ENTRY(FDCharDriver) node;
 
804
} FDCharDriver;
 
805
 
 
806
static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
 
807
{
 
808
    FDCharDriver *s = chr->opaque;
 
809
    
 
810
    return io_channel_send(s->fd_out, buf, len);
 
811
}
 
812
 
 
813
static gboolean fd_chr_read(GIOChannel *chan, GIOCondition cond, void *opaque)
 
814
{
 
815
    CharDriverState *chr = opaque;
 
816
    FDCharDriver *s = chr->opaque;
 
817
    int len;
 
818
    uint8_t buf[READ_BUF_LEN];
 
819
    GIOStatus status;
 
820
    gsize bytes_read;
 
821
 
 
822
    len = sizeof(buf);
 
823
    if (len > s->max_size) {
 
824
        len = s->max_size;
 
825
    }
 
826
    if (len == 0) {
 
827
        return TRUE;
 
828
    }
 
829
 
 
830
    status = g_io_channel_read_chars(chan, (gchar *)buf,
 
831
                                     len, &bytes_read, NULL);
 
832
    if (status == G_IO_STATUS_EOF) {
 
833
        if (s->fd_in_tag) {
 
834
            io_remove_watch_poll(s->fd_in_tag);
 
835
            s->fd_in_tag = 0;
 
836
        }
 
837
        qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
 
838
        return FALSE;
 
839
    }
 
840
    if (status == G_IO_STATUS_NORMAL) {
 
841
        qemu_chr_be_write(chr, buf, bytes_read);
 
842
    }
 
843
 
 
844
    return TRUE;
 
845
}
 
846
 
 
847
static int fd_chr_read_poll(void *opaque)
 
848
{
 
849
    CharDriverState *chr = opaque;
 
850
    FDCharDriver *s = chr->opaque;
 
851
 
 
852
    s->max_size = qemu_chr_be_can_write(chr);
 
853
    return s->max_size;
 
854
}
 
855
 
 
856
static GSource *fd_chr_add_watch(CharDriverState *chr, GIOCondition cond)
 
857
{
 
858
    FDCharDriver *s = chr->opaque;
 
859
    return g_io_create_watch(s->fd_out, cond);
 
860
}
 
861
 
 
862
static void fd_chr_update_read_handler(CharDriverState *chr)
 
863
{
 
864
    FDCharDriver *s = chr->opaque;
 
865
 
 
866
    if (s->fd_in_tag) {
 
867
        io_remove_watch_poll(s->fd_in_tag);
 
868
        s->fd_in_tag = 0;
 
869
    }
 
870
 
 
871
    if (s->fd_in) {
 
872
        s->fd_in_tag = io_add_watch_poll(s->fd_in, fd_chr_read_poll, fd_chr_read, chr);
 
873
    }
 
874
}
 
875
 
 
876
static void fd_chr_close(struct CharDriverState *chr)
 
877
{
 
878
    FDCharDriver *s = chr->opaque;
 
879
 
 
880
    if (s->fd_in_tag) {
 
881
        io_remove_watch_poll(s->fd_in_tag);
 
882
        s->fd_in_tag = 0;
 
883
    }
 
884
 
 
885
    if (s->fd_in) {
 
886
        g_io_channel_unref(s->fd_in);
 
887
    }
 
888
    if (s->fd_out) {
 
889
        g_io_channel_unref(s->fd_out);
 
890
    }
 
891
 
 
892
    g_free(s);
 
893
    qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
 
894
}
 
895
 
 
896
/* open a character device to a unix fd */
 
897
static CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out)
 
898
{
 
899
    CharDriverState *chr;
 
900
    FDCharDriver *s;
 
901
 
 
902
    chr = g_malloc0(sizeof(CharDriverState));
 
903
    s = g_malloc0(sizeof(FDCharDriver));
 
904
    s->fd_in = io_channel_from_fd(fd_in);
 
905
    s->fd_out = io_channel_from_fd(fd_out);
 
906
    fcntl(fd_out, F_SETFL, O_NONBLOCK);
 
907
    s->chr = chr;
 
908
    chr->opaque = s;
 
909
    chr->chr_add_watch = fd_chr_add_watch;
 
910
    chr->chr_write = fd_chr_write;
 
911
    chr->chr_update_read_handler = fd_chr_update_read_handler;
 
912
    chr->chr_close = fd_chr_close;
 
913
 
 
914
    return chr;
 
915
}
 
916
 
 
917
static CharDriverState *qemu_chr_open_pipe(ChardevHostdev *opts)
 
918
{
 
919
    int fd_in, fd_out;
 
920
    char filename_in[256], filename_out[256];
 
921
    const char *filename = opts->device;
 
922
 
 
923
    if (filename == NULL) {
 
924
        fprintf(stderr, "chardev: pipe: no filename given\n");
 
925
        return NULL;
 
926
    }
 
927
 
 
928
    snprintf(filename_in, 256, "%s.in", filename);
 
929
    snprintf(filename_out, 256, "%s.out", filename);
 
930
    TFR(fd_in = qemu_open(filename_in, O_RDWR | O_BINARY));
 
931
    TFR(fd_out = qemu_open(filename_out, O_RDWR | O_BINARY));
 
932
    if (fd_in < 0 || fd_out < 0) {
 
933
        if (fd_in >= 0)
 
934
            close(fd_in);
 
935
        if (fd_out >= 0)
 
936
            close(fd_out);
 
937
        TFR(fd_in = fd_out = qemu_open(filename, O_RDWR | O_BINARY));
 
938
        if (fd_in < 0) {
 
939
            return NULL;
 
940
        }
 
941
    }
 
942
    return qemu_chr_open_fd(fd_in, fd_out);
 
943
}
 
944
 
 
945
/* init terminal so that we can grab keys */
 
946
static struct termios oldtty;
 
947
static int old_fd0_flags;
 
948
static bool stdio_allow_signal;
 
949
 
 
950
static void term_exit(void)
 
951
{
 
952
    tcsetattr (0, TCSANOW, &oldtty);
 
953
    fcntl(0, F_SETFL, old_fd0_flags);
 
954
}
 
955
 
 
956
static void qemu_chr_set_echo_stdio(CharDriverState *chr, bool echo)
 
957
{
 
958
    struct termios tty;
 
959
 
 
960
    tty = oldtty;
 
961
    if (!echo) {
 
962
        tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
 
963
                          |INLCR|IGNCR|ICRNL|IXON);
 
964
        tty.c_oflag |= OPOST;
 
965
        tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
 
966
        tty.c_cflag &= ~(CSIZE|PARENB);
 
967
        tty.c_cflag |= CS8;
 
968
        tty.c_cc[VMIN] = 1;
 
969
        tty.c_cc[VTIME] = 0;
 
970
    }
 
971
    if (!stdio_allow_signal)
 
972
        tty.c_lflag &= ~ISIG;
 
973
 
 
974
    tcsetattr (0, TCSANOW, &tty);
 
975
}
 
976
 
 
977
static void qemu_chr_close_stdio(struct CharDriverState *chr)
 
978
{
 
979
    term_exit();
 
980
    fd_chr_close(chr);
 
981
}
 
982
 
 
983
static CharDriverState *qemu_chr_open_stdio(ChardevStdio *opts)
 
984
{
 
985
    CharDriverState *chr;
 
986
 
 
987
    if (is_daemonized()) {
 
988
        error_report("cannot use stdio with -daemonize");
 
989
        return NULL;
 
990
    }
 
991
    old_fd0_flags = fcntl(0, F_GETFL);
 
992
    tcgetattr (0, &oldtty);
 
993
    fcntl(0, F_SETFL, O_NONBLOCK);
 
994
    atexit(term_exit);
 
995
 
 
996
    chr = qemu_chr_open_fd(0, 1);
 
997
    chr->chr_close = qemu_chr_close_stdio;
 
998
    chr->chr_set_echo = qemu_chr_set_echo_stdio;
 
999
    if (opts->has_signal) {
 
1000
        stdio_allow_signal = opts->signal;
 
1001
    }
 
1002
    qemu_chr_fe_set_echo(chr, false);
 
1003
 
 
1004
    return chr;
 
1005
}
 
1006
 
 
1007
#if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
 
1008
    || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) \
 
1009
    || defined(__GLIBC__)
 
1010
 
 
1011
#define HAVE_CHARDEV_TTY 1
 
1012
 
 
1013
typedef struct {
 
1014
    GIOChannel *fd;
 
1015
    guint fd_tag;
 
1016
    int connected;
 
1017
    int read_bytes;
 
1018
    guint timer_tag;
 
1019
} PtyCharDriver;
 
1020
 
 
1021
static void pty_chr_update_read_handler(CharDriverState *chr);
 
1022
static void pty_chr_state(CharDriverState *chr, int connected);
 
1023
 
 
1024
static gboolean pty_chr_timer(gpointer opaque)
 
1025
{
 
1026
    struct CharDriverState *chr = opaque;
 
1027
    PtyCharDriver *s = chr->opaque;
 
1028
 
 
1029
    if (s->connected) {
 
1030
        goto out;
 
1031
    }
 
1032
 
 
1033
    /* Next poll ... */
 
1034
    pty_chr_update_read_handler(chr);
 
1035
 
 
1036
out:
 
1037
    s->timer_tag = 0;
 
1038
    return FALSE;
 
1039
}
 
1040
 
 
1041
static void pty_chr_rearm_timer(CharDriverState *chr, int ms)
 
1042
{
 
1043
    PtyCharDriver *s = chr->opaque;
 
1044
 
 
1045
    if (s->timer_tag) {
 
1046
        g_source_remove(s->timer_tag);
 
1047
        s->timer_tag = 0;
 
1048
    }
 
1049
 
 
1050
    if (ms == 1000) {
 
1051
        s->timer_tag = g_timeout_add_seconds(1, pty_chr_timer, chr);
 
1052
    } else {
 
1053
        s->timer_tag = g_timeout_add(ms, pty_chr_timer, chr);
 
1054
    }
 
1055
}
 
1056
 
 
1057
static int pty_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
 
1058
{
 
1059
    PtyCharDriver *s = chr->opaque;
 
1060
 
 
1061
    if (!s->connected) {
 
1062
        /* guest sends data, check for (re-)connect */
 
1063
        pty_chr_update_read_handler(chr);
 
1064
        return 0;
 
1065
    }
 
1066
    return io_channel_send(s->fd, buf, len);
 
1067
}
 
1068
 
 
1069
static GSource *pty_chr_add_watch(CharDriverState *chr, GIOCondition cond)
 
1070
{
 
1071
    PtyCharDriver *s = chr->opaque;
 
1072
    return g_io_create_watch(s->fd, cond);
 
1073
}
 
1074
 
 
1075
static int pty_chr_read_poll(void *opaque)
 
1076
{
 
1077
    CharDriverState *chr = opaque;
 
1078
    PtyCharDriver *s = chr->opaque;
 
1079
 
 
1080
    s->read_bytes = qemu_chr_be_can_write(chr);
 
1081
    return s->read_bytes;
 
1082
}
 
1083
 
 
1084
static gboolean pty_chr_read(GIOChannel *chan, GIOCondition cond, void *opaque)
 
1085
{
 
1086
    CharDriverState *chr = opaque;
 
1087
    PtyCharDriver *s = chr->opaque;
 
1088
    gsize size, len;
 
1089
    uint8_t buf[READ_BUF_LEN];
 
1090
    GIOStatus status;
 
1091
 
 
1092
    len = sizeof(buf);
 
1093
    if (len > s->read_bytes)
 
1094
        len = s->read_bytes;
 
1095
    if (len == 0) {
 
1096
        return TRUE;
 
1097
    }
 
1098
    status = g_io_channel_read_chars(s->fd, (gchar *)buf, len, &size, NULL);
 
1099
    if (status != G_IO_STATUS_NORMAL) {
 
1100
        pty_chr_state(chr, 0);
 
1101
        return FALSE;
 
1102
    } else {
 
1103
        pty_chr_state(chr, 1);
 
1104
        qemu_chr_be_write(chr, buf, size);
 
1105
    }
 
1106
    return TRUE;
 
1107
}
 
1108
 
 
1109
static void pty_chr_update_read_handler(CharDriverState *chr)
 
1110
{
 
1111
    PtyCharDriver *s = chr->opaque;
 
1112
    GPollFD pfd;
 
1113
 
 
1114
    pfd.fd = g_io_channel_unix_get_fd(s->fd);
 
1115
    pfd.events = G_IO_OUT;
 
1116
    pfd.revents = 0;
 
1117
    g_poll(&pfd, 1, 0);
 
1118
    if (pfd.revents & G_IO_HUP) {
 
1119
        pty_chr_state(chr, 0);
 
1120
    } else {
 
1121
        pty_chr_state(chr, 1);
 
1122
    }
 
1123
}
 
1124
 
 
1125
static void pty_chr_state(CharDriverState *chr, int connected)
 
1126
{
 
1127
    PtyCharDriver *s = chr->opaque;
 
1128
 
 
1129
    if (!connected) {
 
1130
        if (s->fd_tag) {
 
1131
            io_remove_watch_poll(s->fd_tag);
 
1132
            s->fd_tag = 0;
 
1133
        }
 
1134
        s->connected = 0;
 
1135
        /* (re-)connect poll interval for idle guests: once per second.
 
1136
         * We check more frequently in case the guests sends data to
 
1137
         * the virtual device linked to our pty. */
 
1138
        pty_chr_rearm_timer(chr, 1000);
 
1139
    } else {
 
1140
        if (s->timer_tag) {
 
1141
            g_source_remove(s->timer_tag);
 
1142
            s->timer_tag = 0;
 
1143
        }
 
1144
        if (!s->connected) {
 
1145
            s->connected = 1;
 
1146
            qemu_chr_be_generic_open(chr);
 
1147
            s->fd_tag = io_add_watch_poll(s->fd, pty_chr_read_poll, pty_chr_read, chr);
 
1148
        }
 
1149
    }
 
1150
}
 
1151
 
 
1152
 
 
1153
static void pty_chr_close(struct CharDriverState *chr)
 
1154
{
 
1155
    PtyCharDriver *s = chr->opaque;
 
1156
    int fd;
 
1157
 
 
1158
    if (s->fd_tag) {
 
1159
        io_remove_watch_poll(s->fd_tag);
 
1160
        s->fd_tag = 0;
 
1161
    }
 
1162
    fd = g_io_channel_unix_get_fd(s->fd);
 
1163
    g_io_channel_unref(s->fd);
 
1164
    close(fd);
 
1165
    if (s->timer_tag) {
 
1166
        g_source_remove(s->timer_tag);
 
1167
        s->timer_tag = 0;
 
1168
    }
 
1169
    g_free(s);
 
1170
    qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
 
1171
}
 
1172
 
 
1173
static CharDriverState *qemu_chr_open_pty(const char *id,
 
1174
                                          ChardevReturn *ret)
 
1175
{
 
1176
    CharDriverState *chr;
 
1177
    PtyCharDriver *s;
 
1178
    int master_fd, slave_fd;
 
1179
    char pty_name[PATH_MAX];
 
1180
 
 
1181
    master_fd = qemu_openpty_raw(&slave_fd, pty_name);
 
1182
    if (master_fd < 0) {
 
1183
        return NULL;
 
1184
    }
 
1185
 
 
1186
    close(slave_fd);
 
1187
 
 
1188
    chr = g_malloc0(sizeof(CharDriverState));
 
1189
 
 
1190
    chr->filename = g_strdup_printf("pty:%s", pty_name);
 
1191
    ret->pty = g_strdup(pty_name);
 
1192
    ret->has_pty = true;
 
1193
 
 
1194
    fprintf(stderr, "char device redirected to %s (label %s)\n",
 
1195
            pty_name, id);
 
1196
 
 
1197
    s = g_malloc0(sizeof(PtyCharDriver));
 
1198
    chr->opaque = s;
 
1199
    chr->chr_write = pty_chr_write;
 
1200
    chr->chr_update_read_handler = pty_chr_update_read_handler;
 
1201
    chr->chr_close = pty_chr_close;
 
1202
    chr->chr_add_watch = pty_chr_add_watch;
 
1203
    chr->explicit_be_open = true;
 
1204
 
 
1205
    s->fd = io_channel_from_fd(master_fd);
 
1206
    s->timer_tag = 0;
 
1207
 
 
1208
    return chr;
 
1209
}
 
1210
 
 
1211
static void tty_serial_init(int fd, int speed,
 
1212
                            int parity, int data_bits, int stop_bits)
 
1213
{
 
1214
    struct termios tty;
 
1215
    speed_t spd;
 
1216
 
 
1217
#if 0
 
1218
    printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
 
1219
           speed, parity, data_bits, stop_bits);
 
1220
#endif
 
1221
    tcgetattr (fd, &tty);
 
1222
 
 
1223
#define check_speed(val) if (speed <= val) { spd = B##val; break; }
 
1224
    speed = speed * 10 / 11;
 
1225
    do {
 
1226
        check_speed(50);
 
1227
        check_speed(75);
 
1228
        check_speed(110);
 
1229
        check_speed(134);
 
1230
        check_speed(150);
 
1231
        check_speed(200);
 
1232
        check_speed(300);
 
1233
        check_speed(600);
 
1234
        check_speed(1200);
 
1235
        check_speed(1800);
 
1236
        check_speed(2400);
 
1237
        check_speed(4800);
 
1238
        check_speed(9600);
 
1239
        check_speed(19200);
 
1240
        check_speed(38400);
 
1241
        /* Non-Posix values follow. They may be unsupported on some systems. */
 
1242
        check_speed(57600);
 
1243
        check_speed(115200);
 
1244
#ifdef B230400
 
1245
        check_speed(230400);
 
1246
#endif
 
1247
#ifdef B460800
 
1248
        check_speed(460800);
 
1249
#endif
 
1250
#ifdef B500000
 
1251
        check_speed(500000);
 
1252
#endif
 
1253
#ifdef B576000
 
1254
        check_speed(576000);
 
1255
#endif
 
1256
#ifdef B921600
 
1257
        check_speed(921600);
 
1258
#endif
 
1259
#ifdef B1000000
 
1260
        check_speed(1000000);
 
1261
#endif
 
1262
#ifdef B1152000
 
1263
        check_speed(1152000);
 
1264
#endif
 
1265
#ifdef B1500000
 
1266
        check_speed(1500000);
 
1267
#endif
 
1268
#ifdef B2000000
 
1269
        check_speed(2000000);
 
1270
#endif
 
1271
#ifdef B2500000
 
1272
        check_speed(2500000);
 
1273
#endif
 
1274
#ifdef B3000000
 
1275
        check_speed(3000000);
 
1276
#endif
 
1277
#ifdef B3500000
 
1278
        check_speed(3500000);
 
1279
#endif
 
1280
#ifdef B4000000
 
1281
        check_speed(4000000);
 
1282
#endif
 
1283
        spd = B115200;
 
1284
    } while (0);
 
1285
 
 
1286
    cfsetispeed(&tty, spd);
 
1287
    cfsetospeed(&tty, spd);
 
1288
 
 
1289
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
 
1290
                          |INLCR|IGNCR|ICRNL|IXON);
 
1291
    tty.c_oflag |= OPOST;
 
1292
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN|ISIG);
 
1293
    tty.c_cflag &= ~(CSIZE|PARENB|PARODD|CRTSCTS|CSTOPB);
 
1294
    switch(data_bits) {
 
1295
    default:
 
1296
    case 8:
 
1297
        tty.c_cflag |= CS8;
 
1298
        break;
 
1299
    case 7:
 
1300
        tty.c_cflag |= CS7;
 
1301
        break;
 
1302
    case 6:
 
1303
        tty.c_cflag |= CS6;
 
1304
        break;
 
1305
    case 5:
 
1306
        tty.c_cflag |= CS5;
 
1307
        break;
 
1308
    }
 
1309
    switch(parity) {
 
1310
    default:
 
1311
    case 'N':
 
1312
        break;
 
1313
    case 'E':
 
1314
        tty.c_cflag |= PARENB;
 
1315
        break;
 
1316
    case 'O':
 
1317
        tty.c_cflag |= PARENB | PARODD;
 
1318
        break;
 
1319
    }
 
1320
    if (stop_bits == 2)
 
1321
        tty.c_cflag |= CSTOPB;
 
1322
 
 
1323
    tcsetattr (fd, TCSANOW, &tty);
 
1324
}
 
1325
 
 
1326
static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)
 
1327
{
 
1328
    FDCharDriver *s = chr->opaque;
 
1329
 
 
1330
    switch(cmd) {
 
1331
    case CHR_IOCTL_SERIAL_SET_PARAMS:
 
1332
        {
 
1333
            QEMUSerialSetParams *ssp = arg;
 
1334
            tty_serial_init(g_io_channel_unix_get_fd(s->fd_in),
 
1335
                            ssp->speed, ssp->parity,
 
1336
                            ssp->data_bits, ssp->stop_bits);
 
1337
        }
 
1338
        break;
 
1339
    case CHR_IOCTL_SERIAL_SET_BREAK:
 
1340
        {
 
1341
            int enable = *(int *)arg;
 
1342
            if (enable) {
 
1343
                tcsendbreak(g_io_channel_unix_get_fd(s->fd_in), 1);
 
1344
            }
 
1345
        }
 
1346
        break;
 
1347
    case CHR_IOCTL_SERIAL_GET_TIOCM:
 
1348
        {
 
1349
            int sarg = 0;
 
1350
            int *targ = (int *)arg;
 
1351
            ioctl(g_io_channel_unix_get_fd(s->fd_in), TIOCMGET, &sarg);
 
1352
            *targ = 0;
 
1353
            if (sarg & TIOCM_CTS)
 
1354
                *targ |= CHR_TIOCM_CTS;
 
1355
            if (sarg & TIOCM_CAR)
 
1356
                *targ |= CHR_TIOCM_CAR;
 
1357
            if (sarg & TIOCM_DSR)
 
1358
                *targ |= CHR_TIOCM_DSR;
 
1359
            if (sarg & TIOCM_RI)
 
1360
                *targ |= CHR_TIOCM_RI;
 
1361
            if (sarg & TIOCM_DTR)
 
1362
                *targ |= CHR_TIOCM_DTR;
 
1363
            if (sarg & TIOCM_RTS)
 
1364
                *targ |= CHR_TIOCM_RTS;
 
1365
        }
 
1366
        break;
 
1367
    case CHR_IOCTL_SERIAL_SET_TIOCM:
 
1368
        {
 
1369
            int sarg = *(int *)arg;
 
1370
            int targ = 0;
 
1371
            ioctl(g_io_channel_unix_get_fd(s->fd_in), TIOCMGET, &targ);
 
1372
            targ &= ~(CHR_TIOCM_CTS | CHR_TIOCM_CAR | CHR_TIOCM_DSR
 
1373
                     | CHR_TIOCM_RI | CHR_TIOCM_DTR | CHR_TIOCM_RTS);
 
1374
            if (sarg & CHR_TIOCM_CTS)
 
1375
                targ |= TIOCM_CTS;
 
1376
            if (sarg & CHR_TIOCM_CAR)
 
1377
                targ |= TIOCM_CAR;
 
1378
            if (sarg & CHR_TIOCM_DSR)
 
1379
                targ |= TIOCM_DSR;
 
1380
            if (sarg & CHR_TIOCM_RI)
 
1381
                targ |= TIOCM_RI;
 
1382
            if (sarg & CHR_TIOCM_DTR)
 
1383
                targ |= TIOCM_DTR;
 
1384
            if (sarg & CHR_TIOCM_RTS)
 
1385
                targ |= TIOCM_RTS;
 
1386
            ioctl(g_io_channel_unix_get_fd(s->fd_in), TIOCMSET, &targ);
 
1387
        }
 
1388
        break;
 
1389
    default:
 
1390
        return -ENOTSUP;
 
1391
    }
 
1392
    return 0;
 
1393
}
 
1394
 
 
1395
static void qemu_chr_close_tty(CharDriverState *chr)
 
1396
{
 
1397
    FDCharDriver *s = chr->opaque;
 
1398
    int fd = -1;
 
1399
 
 
1400
    if (s) {
 
1401
        fd = g_io_channel_unix_get_fd(s->fd_in);
 
1402
    }
 
1403
 
 
1404
    fd_chr_close(chr);
 
1405
 
 
1406
    if (fd >= 0) {
 
1407
        close(fd);
 
1408
    }
 
1409
}
 
1410
 
 
1411
static CharDriverState *qemu_chr_open_tty_fd(int fd)
 
1412
{
 
1413
    CharDriverState *chr;
 
1414
 
 
1415
    tty_serial_init(fd, 115200, 'N', 8, 1);
 
1416
    chr = qemu_chr_open_fd(fd, fd);
 
1417
    chr->chr_ioctl = tty_serial_ioctl;
 
1418
    chr->chr_close = qemu_chr_close_tty;
 
1419
    return chr;
 
1420
}
 
1421
#endif /* __linux__ || __sun__ */
 
1422
 
 
1423
#if defined(__linux__)
 
1424
 
 
1425
#define HAVE_CHARDEV_PARPORT 1
 
1426
 
 
1427
typedef struct {
 
1428
    int fd;
 
1429
    int mode;
 
1430
} ParallelCharDriver;
 
1431
 
 
1432
static int pp_hw_mode(ParallelCharDriver *s, uint16_t mode)
 
1433
{
 
1434
    if (s->mode != mode) {
 
1435
        int m = mode;
 
1436
        if (ioctl(s->fd, PPSETMODE, &m) < 0)
 
1437
            return 0;
 
1438
        s->mode = mode;
 
1439
    }
 
1440
    return 1;
 
1441
}
 
1442
 
 
1443
static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
 
1444
{
 
1445
    ParallelCharDriver *drv = chr->opaque;
 
1446
    int fd = drv->fd;
 
1447
    uint8_t b;
 
1448
 
 
1449
    switch(cmd) {
 
1450
    case CHR_IOCTL_PP_READ_DATA:
 
1451
        if (ioctl(fd, PPRDATA, &b) < 0)
 
1452
            return -ENOTSUP;
 
1453
        *(uint8_t *)arg = b;
 
1454
        break;
 
1455
    case CHR_IOCTL_PP_WRITE_DATA:
 
1456
        b = *(uint8_t *)arg;
 
1457
        if (ioctl(fd, PPWDATA, &b) < 0)
 
1458
            return -ENOTSUP;
 
1459
        break;
 
1460
    case CHR_IOCTL_PP_READ_CONTROL:
 
1461
        if (ioctl(fd, PPRCONTROL, &b) < 0)
 
1462
            return -ENOTSUP;
 
1463
        /* Linux gives only the lowest bits, and no way to know data
 
1464
           direction! For better compatibility set the fixed upper
 
1465
           bits. */
 
1466
        *(uint8_t *)arg = b | 0xc0;
 
1467
        break;
 
1468
    case CHR_IOCTL_PP_WRITE_CONTROL:
 
1469
        b = *(uint8_t *)arg;
 
1470
        if (ioctl(fd, PPWCONTROL, &b) < 0)
 
1471
            return -ENOTSUP;
 
1472
        break;
 
1473
    case CHR_IOCTL_PP_READ_STATUS:
 
1474
        if (ioctl(fd, PPRSTATUS, &b) < 0)
 
1475
            return -ENOTSUP;
 
1476
        *(uint8_t *)arg = b;
 
1477
        break;
 
1478
    case CHR_IOCTL_PP_DATA_DIR:
 
1479
        if (ioctl(fd, PPDATADIR, (int *)arg) < 0)
 
1480
            return -ENOTSUP;
 
1481
        break;
 
1482
    case CHR_IOCTL_PP_EPP_READ_ADDR:
 
1483
        if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
 
1484
            struct ParallelIOArg *parg = arg;
 
1485
            int n = read(fd, parg->buffer, parg->count);
 
1486
            if (n != parg->count) {
 
1487
                return -EIO;
 
1488
            }
 
1489
        }
 
1490
        break;
 
1491
    case CHR_IOCTL_PP_EPP_READ:
 
1492
        if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
 
1493
            struct ParallelIOArg *parg = arg;
 
1494
            int n = read(fd, parg->buffer, parg->count);
 
1495
            if (n != parg->count) {
 
1496
                return -EIO;
 
1497
            }
 
1498
        }
 
1499
        break;
 
1500
    case CHR_IOCTL_PP_EPP_WRITE_ADDR:
 
1501
        if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
 
1502
            struct ParallelIOArg *parg = arg;
 
1503
            int n = write(fd, parg->buffer, parg->count);
 
1504
            if (n != parg->count) {
 
1505
                return -EIO;
 
1506
            }
 
1507
        }
 
1508
        break;
 
1509
    case CHR_IOCTL_PP_EPP_WRITE:
 
1510
        if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
 
1511
            struct ParallelIOArg *parg = arg;
 
1512
            int n = write(fd, parg->buffer, parg->count);
 
1513
            if (n != parg->count) {
 
1514
                return -EIO;
 
1515
            }
 
1516
        }
 
1517
        break;
 
1518
    default:
 
1519
        return -ENOTSUP;
 
1520
    }
 
1521
    return 0;
 
1522
}
 
1523
 
 
1524
static void pp_close(CharDriverState *chr)
 
1525
{
 
1526
    ParallelCharDriver *drv = chr->opaque;
 
1527
    int fd = drv->fd;
 
1528
 
 
1529
    pp_hw_mode(drv, IEEE1284_MODE_COMPAT);
 
1530
    ioctl(fd, PPRELEASE);
 
1531
    close(fd);
 
1532
    g_free(drv);
 
1533
    qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
 
1534
}
 
1535
 
 
1536
static CharDriverState *qemu_chr_open_pp_fd(int fd)
 
1537
{
 
1538
    CharDriverState *chr;
 
1539
    ParallelCharDriver *drv;
 
1540
 
 
1541
    if (ioctl(fd, PPCLAIM) < 0) {
 
1542
        close(fd);
 
1543
        return NULL;
 
1544
    }
 
1545
 
 
1546
    drv = g_malloc0(sizeof(ParallelCharDriver));
 
1547
    drv->fd = fd;
 
1548
    drv->mode = IEEE1284_MODE_COMPAT;
 
1549
 
 
1550
    chr = g_malloc0(sizeof(CharDriverState));
 
1551
    chr->chr_write = null_chr_write;
 
1552
    chr->chr_ioctl = pp_ioctl;
 
1553
    chr->chr_close = pp_close;
 
1554
    chr->opaque = drv;
 
1555
 
 
1556
    return chr;
 
1557
}
 
1558
#endif /* __linux__ */
 
1559
 
 
1560
#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
 
1561
 
 
1562
#define HAVE_CHARDEV_PARPORT 1
 
1563
 
 
1564
static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
 
1565
{
 
1566
    int fd = (int)(intptr_t)chr->opaque;
 
1567
    uint8_t b;
 
1568
 
 
1569
    switch(cmd) {
 
1570
    case CHR_IOCTL_PP_READ_DATA:
 
1571
        if (ioctl(fd, PPIGDATA, &b) < 0)
 
1572
            return -ENOTSUP;
 
1573
        *(uint8_t *)arg = b;
 
1574
        break;
 
1575
    case CHR_IOCTL_PP_WRITE_DATA:
 
1576
        b = *(uint8_t *)arg;
 
1577
        if (ioctl(fd, PPISDATA, &b) < 0)
 
1578
            return -ENOTSUP;
 
1579
        break;
 
1580
    case CHR_IOCTL_PP_READ_CONTROL:
 
1581
        if (ioctl(fd, PPIGCTRL, &b) < 0)
 
1582
            return -ENOTSUP;
 
1583
        *(uint8_t *)arg = b;
 
1584
        break;
 
1585
    case CHR_IOCTL_PP_WRITE_CONTROL:
 
1586
        b = *(uint8_t *)arg;
 
1587
        if (ioctl(fd, PPISCTRL, &b) < 0)
 
1588
            return -ENOTSUP;
 
1589
        break;
 
1590
    case CHR_IOCTL_PP_READ_STATUS:
 
1591
        if (ioctl(fd, PPIGSTATUS, &b) < 0)
 
1592
            return -ENOTSUP;
 
1593
        *(uint8_t *)arg = b;
 
1594
        break;
 
1595
    default:
 
1596
        return -ENOTSUP;
 
1597
    }
 
1598
    return 0;
 
1599
}
 
1600
 
 
1601
static CharDriverState *qemu_chr_open_pp_fd(int fd)
 
1602
{
 
1603
    CharDriverState *chr;
 
1604
 
 
1605
    chr = g_malloc0(sizeof(CharDriverState));
 
1606
    chr->opaque = (void *)(intptr_t)fd;
 
1607
    chr->chr_write = null_chr_write;
 
1608
    chr->chr_ioctl = pp_ioctl;
 
1609
    chr->explicit_be_open = true;
 
1610
    return chr;
 
1611
}
 
1612
#endif
 
1613
 
 
1614
#else /* _WIN32 */
 
1615
 
 
1616
typedef struct {
 
1617
    int max_size;
 
1618
    HANDLE hcom, hrecv, hsend;
 
1619
    OVERLAPPED orecv, osend;
 
1620
    BOOL fpipe;
 
1621
    DWORD len;
 
1622
} WinCharState;
 
1623
 
 
1624
typedef struct {
 
1625
    HANDLE  hStdIn;
 
1626
    HANDLE  hInputReadyEvent;
 
1627
    HANDLE  hInputDoneEvent;
 
1628
    HANDLE  hInputThread;
 
1629
    uint8_t win_stdio_buf;
 
1630
} WinStdioCharState;
 
1631
 
 
1632
#define NSENDBUF 2048
 
1633
#define NRECVBUF 2048
 
1634
#define MAXCONNECT 1
 
1635
#define NTIMEOUT 5000
 
1636
 
 
1637
static int win_chr_poll(void *opaque);
 
1638
static int win_chr_pipe_poll(void *opaque);
 
1639
 
 
1640
static void win_chr_close(CharDriverState *chr)
 
1641
{
 
1642
    WinCharState *s = chr->opaque;
 
1643
 
 
1644
    if (s->hsend) {
 
1645
        CloseHandle(s->hsend);
 
1646
        s->hsend = NULL;
 
1647
    }
 
1648
    if (s->hrecv) {
 
1649
        CloseHandle(s->hrecv);
 
1650
        s->hrecv = NULL;
 
1651
    }
 
1652
    if (s->hcom) {
 
1653
        CloseHandle(s->hcom);
 
1654
        s->hcom = NULL;
 
1655
    }
 
1656
    if (s->fpipe)
 
1657
        qemu_del_polling_cb(win_chr_pipe_poll, chr);
 
1658
    else
 
1659
        qemu_del_polling_cb(win_chr_poll, chr);
 
1660
 
 
1661
    qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
 
1662
}
 
1663
 
 
1664
static int win_chr_init(CharDriverState *chr, const char *filename)
 
1665
{
 
1666
    WinCharState *s = chr->opaque;
 
1667
    COMMCONFIG comcfg;
 
1668
    COMMTIMEOUTS cto = { 0, 0, 0, 0, 0};
 
1669
    COMSTAT comstat;
 
1670
    DWORD size;
 
1671
    DWORD err;
 
1672
 
 
1673
    s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
 
1674
    if (!s->hsend) {
 
1675
        fprintf(stderr, "Failed CreateEvent\n");
 
1676
        goto fail;
 
1677
    }
 
1678
    s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
 
1679
    if (!s->hrecv) {
 
1680
        fprintf(stderr, "Failed CreateEvent\n");
 
1681
        goto fail;
 
1682
    }
 
1683
 
 
1684
    s->hcom = CreateFile(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL,
 
1685
                      OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
 
1686
    if (s->hcom == INVALID_HANDLE_VALUE) {
 
1687
        fprintf(stderr, "Failed CreateFile (%lu)\n", GetLastError());
 
1688
        s->hcom = NULL;
 
1689
        goto fail;
 
1690
    }
 
1691
 
 
1692
    if (!SetupComm(s->hcom, NRECVBUF, NSENDBUF)) {
 
1693
        fprintf(stderr, "Failed SetupComm\n");
 
1694
        goto fail;
 
1695
    }
 
1696
 
 
1697
    ZeroMemory(&comcfg, sizeof(COMMCONFIG));
 
1698
    size = sizeof(COMMCONFIG);
 
1699
    GetDefaultCommConfig(filename, &comcfg, &size);
 
1700
    comcfg.dcb.DCBlength = sizeof(DCB);
 
1701
    CommConfigDialog(filename, NULL, &comcfg);
 
1702
 
 
1703
    if (!SetCommState(s->hcom, &comcfg.dcb)) {
 
1704
        fprintf(stderr, "Failed SetCommState\n");
 
1705
        goto fail;
 
1706
    }
 
1707
 
 
1708
    if (!SetCommMask(s->hcom, EV_ERR)) {
 
1709
        fprintf(stderr, "Failed SetCommMask\n");
 
1710
        goto fail;
 
1711
    }
 
1712
 
 
1713
    cto.ReadIntervalTimeout = MAXDWORD;
 
1714
    if (!SetCommTimeouts(s->hcom, &cto)) {
 
1715
        fprintf(stderr, "Failed SetCommTimeouts\n");
 
1716
        goto fail;
 
1717
    }
 
1718
 
 
1719
    if (!ClearCommError(s->hcom, &err, &comstat)) {
 
1720
        fprintf(stderr, "Failed ClearCommError\n");
 
1721
        goto fail;
 
1722
    }
 
1723
    qemu_add_polling_cb(win_chr_poll, chr);
 
1724
    return 0;
 
1725
 
 
1726
 fail:
 
1727
    win_chr_close(chr);
 
1728
    return -1;
 
1729
}
 
1730
 
 
1731
static int win_chr_write(CharDriverState *chr, const uint8_t *buf, int len1)
 
1732
{
 
1733
    WinCharState *s = chr->opaque;
 
1734
    DWORD len, ret, size, err;
 
1735
 
 
1736
    len = len1;
 
1737
    ZeroMemory(&s->osend, sizeof(s->osend));
 
1738
    s->osend.hEvent = s->hsend;
 
1739
    while (len > 0) {
 
1740
        if (s->hsend)
 
1741
            ret = WriteFile(s->hcom, buf, len, &size, &s->osend);
 
1742
        else
 
1743
            ret = WriteFile(s->hcom, buf, len, &size, NULL);
 
1744
        if (!ret) {
 
1745
            err = GetLastError();
 
1746
            if (err == ERROR_IO_PENDING) {
 
1747
                ret = GetOverlappedResult(s->hcom, &s->osend, &size, TRUE);
 
1748
                if (ret) {
 
1749
                    buf += size;
 
1750
                    len -= size;
 
1751
                } else {
 
1752
                    break;
 
1753
                }
 
1754
            } else {
 
1755
                break;
 
1756
            }
 
1757
        } else {
 
1758
            buf += size;
 
1759
            len -= size;
 
1760
        }
 
1761
    }
 
1762
    return len1 - len;
 
1763
}
 
1764
 
 
1765
static int win_chr_read_poll(CharDriverState *chr)
 
1766
{
 
1767
    WinCharState *s = chr->opaque;
 
1768
 
 
1769
    s->max_size = qemu_chr_be_can_write(chr);
 
1770
    return s->max_size;
 
1771
}
 
1772
 
 
1773
static void win_chr_readfile(CharDriverState *chr)
 
1774
{
 
1775
    WinCharState *s = chr->opaque;
 
1776
    int ret, err;
 
1777
    uint8_t buf[READ_BUF_LEN];
 
1778
    DWORD size;
 
1779
 
 
1780
    ZeroMemory(&s->orecv, sizeof(s->orecv));
 
1781
    s->orecv.hEvent = s->hrecv;
 
1782
    ret = ReadFile(s->hcom, buf, s->len, &size, &s->orecv);
 
1783
    if (!ret) {
 
1784
        err = GetLastError();
 
1785
        if (err == ERROR_IO_PENDING) {
 
1786
            ret = GetOverlappedResult(s->hcom, &s->orecv, &size, TRUE);
 
1787
        }
 
1788
    }
 
1789
 
 
1790
    if (size > 0) {
 
1791
        qemu_chr_be_write(chr, buf, size);
 
1792
    }
 
1793
}
 
1794
 
 
1795
static void win_chr_read(CharDriverState *chr)
 
1796
{
 
1797
    WinCharState *s = chr->opaque;
 
1798
 
 
1799
    if (s->len > s->max_size)
 
1800
        s->len = s->max_size;
 
1801
    if (s->len == 0)
 
1802
        return;
 
1803
 
 
1804
    win_chr_readfile(chr);
 
1805
}
 
1806
 
 
1807
static int win_chr_poll(void *opaque)
 
1808
{
 
1809
    CharDriverState *chr = opaque;
 
1810
    WinCharState *s = chr->opaque;
 
1811
    COMSTAT status;
 
1812
    DWORD comerr;
 
1813
 
 
1814
    ClearCommError(s->hcom, &comerr, &status);
 
1815
    if (status.cbInQue > 0) {
 
1816
        s->len = status.cbInQue;
 
1817
        win_chr_read_poll(chr);
 
1818
        win_chr_read(chr);
 
1819
        return 1;
 
1820
    }
 
1821
    return 0;
 
1822
}
 
1823
 
 
1824
static CharDriverState *qemu_chr_open_win_path(const char *filename)
 
1825
{
 
1826
    CharDriverState *chr;
 
1827
    WinCharState *s;
 
1828
 
 
1829
    chr = g_malloc0(sizeof(CharDriverState));
 
1830
    s = g_malloc0(sizeof(WinCharState));
 
1831
    chr->opaque = s;
 
1832
    chr->chr_write = win_chr_write;
 
1833
    chr->chr_close = win_chr_close;
 
1834
 
 
1835
    if (win_chr_init(chr, filename) < 0) {
 
1836
        g_free(s);
 
1837
        g_free(chr);
 
1838
        return NULL;
 
1839
    }
 
1840
    return chr;
 
1841
}
 
1842
 
 
1843
static int win_chr_pipe_poll(void *opaque)
 
1844
{
 
1845
    CharDriverState *chr = opaque;
 
1846
    WinCharState *s = chr->opaque;
 
1847
    DWORD size;
 
1848
 
 
1849
    PeekNamedPipe(s->hcom, NULL, 0, NULL, &size, NULL);
 
1850
    if (size > 0) {
 
1851
        s->len = size;
 
1852
        win_chr_read_poll(chr);
 
1853
        win_chr_read(chr);
 
1854
        return 1;
 
1855
    }
 
1856
    return 0;
 
1857
}
 
1858
 
 
1859
static int win_chr_pipe_init(CharDriverState *chr, const char *filename)
 
1860
{
 
1861
    WinCharState *s = chr->opaque;
 
1862
    OVERLAPPED ov;
 
1863
    int ret;
 
1864
    DWORD size;
 
1865
    char openname[256];
 
1866
 
 
1867
    s->fpipe = TRUE;
 
1868
 
 
1869
    s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
 
1870
    if (!s->hsend) {
 
1871
        fprintf(stderr, "Failed CreateEvent\n");
 
1872
        goto fail;
 
1873
    }
 
1874
    s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
 
1875
    if (!s->hrecv) {
 
1876
        fprintf(stderr, "Failed CreateEvent\n");
 
1877
        goto fail;
 
1878
    }
 
1879
 
 
1880
    snprintf(openname, sizeof(openname), "\\\\.\\pipe\\%s", filename);
 
1881
    s->hcom = CreateNamedPipe(openname, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
 
1882
                              PIPE_TYPE_BYTE | PIPE_READMODE_BYTE |
 
1883
                              PIPE_WAIT,
 
1884
                              MAXCONNECT, NSENDBUF, NRECVBUF, NTIMEOUT, NULL);
 
1885
    if (s->hcom == INVALID_HANDLE_VALUE) {
 
1886
        fprintf(stderr, "Failed CreateNamedPipe (%lu)\n", GetLastError());
 
1887
        s->hcom = NULL;
 
1888
        goto fail;
 
1889
    }
 
1890
 
 
1891
    ZeroMemory(&ov, sizeof(ov));
 
1892
    ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
 
1893
    ret = ConnectNamedPipe(s->hcom, &ov);
 
1894
    if (ret) {
 
1895
        fprintf(stderr, "Failed ConnectNamedPipe\n");
 
1896
        goto fail;
 
1897
    }
 
1898
 
 
1899
    ret = GetOverlappedResult(s->hcom, &ov, &size, TRUE);
 
1900
    if (!ret) {
 
1901
        fprintf(stderr, "Failed GetOverlappedResult\n");
 
1902
        if (ov.hEvent) {
 
1903
            CloseHandle(ov.hEvent);
 
1904
            ov.hEvent = NULL;
 
1905
        }
 
1906
        goto fail;
 
1907
    }
 
1908
 
 
1909
    if (ov.hEvent) {
 
1910
        CloseHandle(ov.hEvent);
 
1911
        ov.hEvent = NULL;
 
1912
    }
 
1913
    qemu_add_polling_cb(win_chr_pipe_poll, chr);
 
1914
    return 0;
 
1915
 
 
1916
 fail:
 
1917
    win_chr_close(chr);
 
1918
    return -1;
 
1919
}
 
1920
 
 
1921
 
 
1922
static CharDriverState *qemu_chr_open_pipe(ChardevHostdev *opts)
 
1923
{
 
1924
    const char *filename = opts->device;
 
1925
    CharDriverState *chr;
 
1926
    WinCharState *s;
 
1927
 
 
1928
    chr = g_malloc0(sizeof(CharDriverState));
 
1929
    s = g_malloc0(sizeof(WinCharState));
 
1930
    chr->opaque = s;
 
1931
    chr->chr_write = win_chr_write;
 
1932
    chr->chr_close = win_chr_close;
 
1933
 
 
1934
    if (win_chr_pipe_init(chr, filename) < 0) {
 
1935
        g_free(s);
 
1936
        g_free(chr);
 
1937
        return NULL;
 
1938
    }
 
1939
    return chr;
 
1940
}
 
1941
 
 
1942
static CharDriverState *qemu_chr_open_win_file(HANDLE fd_out)
 
1943
{
 
1944
    CharDriverState *chr;
 
1945
    WinCharState *s;
 
1946
 
 
1947
    chr = g_malloc0(sizeof(CharDriverState));
 
1948
    s = g_malloc0(sizeof(WinCharState));
 
1949
    s->hcom = fd_out;
 
1950
    chr->opaque = s;
 
1951
    chr->chr_write = win_chr_write;
 
1952
    return chr;
 
1953
}
 
1954
 
 
1955
static CharDriverState *qemu_chr_open_win_con(void)
 
1956
{
 
1957
    return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE));
 
1958
}
 
1959
 
 
1960
static int win_stdio_write(CharDriverState *chr, const uint8_t *buf, int len)
 
1961
{
 
1962
    HANDLE  hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
 
1963
    DWORD   dwSize;
 
1964
    int     len1;
 
1965
 
 
1966
    len1 = len;
 
1967
 
 
1968
    while (len1 > 0) {
 
1969
        if (!WriteFile(hStdOut, buf, len1, &dwSize, NULL)) {
 
1970
            break;
 
1971
        }
 
1972
        buf  += dwSize;
 
1973
        len1 -= dwSize;
 
1974
    }
 
1975
 
 
1976
    return len - len1;
 
1977
}
 
1978
 
 
1979
static void win_stdio_wait_func(void *opaque)
 
1980
{
 
1981
    CharDriverState   *chr   = opaque;
 
1982
    WinStdioCharState *stdio = chr->opaque;
 
1983
    INPUT_RECORD       buf[4];
 
1984
    int                ret;
 
1985
    DWORD              dwSize;
 
1986
    int                i;
 
1987
 
 
1988
    ret = ReadConsoleInput(stdio->hStdIn, buf, sizeof(buf) / sizeof(*buf),
 
1989
                           &dwSize);
 
1990
 
 
1991
    if (!ret) {
 
1992
        /* Avoid error storm */
 
1993
        qemu_del_wait_object(stdio->hStdIn, NULL, NULL);
 
1994
        return;
 
1995
    }
 
1996
 
 
1997
    for (i = 0; i < dwSize; i++) {
 
1998
        KEY_EVENT_RECORD *kev = &buf[i].Event.KeyEvent;
 
1999
 
 
2000
        if (buf[i].EventType == KEY_EVENT && kev->bKeyDown) {
 
2001
            int j;
 
2002
            if (kev->uChar.AsciiChar != 0) {
 
2003
                for (j = 0; j < kev->wRepeatCount; j++) {
 
2004
                    if (qemu_chr_be_can_write(chr)) {
 
2005
                        uint8_t c = kev->uChar.AsciiChar;
 
2006
                        qemu_chr_be_write(chr, &c, 1);
 
2007
                    }
 
2008
                }
 
2009
            }
 
2010
        }
 
2011
    }
 
2012
}
 
2013
 
 
2014
static DWORD WINAPI win_stdio_thread(LPVOID param)
 
2015
{
 
2016
    CharDriverState   *chr   = param;
 
2017
    WinStdioCharState *stdio = chr->opaque;
 
2018
    int                ret;
 
2019
    DWORD              dwSize;
 
2020
 
 
2021
    while (1) {
 
2022
 
 
2023
        /* Wait for one byte */
 
2024
        ret = ReadFile(stdio->hStdIn, &stdio->win_stdio_buf, 1, &dwSize, NULL);
 
2025
 
 
2026
        /* Exit in case of error, continue if nothing read */
 
2027
        if (!ret) {
 
2028
            break;
 
2029
        }
 
2030
        if (!dwSize) {
 
2031
            continue;
 
2032
        }
 
2033
 
 
2034
        /* Some terminal emulator returns \r\n for Enter, just pass \n */
 
2035
        if (stdio->win_stdio_buf == '\r') {
 
2036
            continue;
 
2037
        }
 
2038
 
 
2039
        /* Signal the main thread and wait until the byte was eaten */
 
2040
        if (!SetEvent(stdio->hInputReadyEvent)) {
 
2041
            break;
 
2042
        }
 
2043
        if (WaitForSingleObject(stdio->hInputDoneEvent, INFINITE)
 
2044
            != WAIT_OBJECT_0) {
 
2045
            break;
 
2046
        }
 
2047
    }
 
2048
 
 
2049
    qemu_del_wait_object(stdio->hInputReadyEvent, NULL, NULL);
 
2050
    return 0;
 
2051
}
 
2052
 
 
2053
static void win_stdio_thread_wait_func(void *opaque)
 
2054
{
 
2055
    CharDriverState   *chr   = opaque;
 
2056
    WinStdioCharState *stdio = chr->opaque;
 
2057
 
 
2058
    if (qemu_chr_be_can_write(chr)) {
 
2059
        qemu_chr_be_write(chr, &stdio->win_stdio_buf, 1);
 
2060
    }
 
2061
 
 
2062
    SetEvent(stdio->hInputDoneEvent);
 
2063
}
 
2064
 
 
2065
static void qemu_chr_set_echo_win_stdio(CharDriverState *chr, bool echo)
 
2066
{
 
2067
    WinStdioCharState *stdio  = chr->opaque;
 
2068
    DWORD              dwMode = 0;
 
2069
 
 
2070
    GetConsoleMode(stdio->hStdIn, &dwMode);
 
2071
 
 
2072
    if (echo) {
 
2073
        SetConsoleMode(stdio->hStdIn, dwMode | ENABLE_ECHO_INPUT);
 
2074
    } else {
 
2075
        SetConsoleMode(stdio->hStdIn, dwMode & ~ENABLE_ECHO_INPUT);
 
2076
    }
 
2077
}
 
2078
 
 
2079
static void win_stdio_close(CharDriverState *chr)
 
2080
{
 
2081
    WinStdioCharState *stdio = chr->opaque;
 
2082
 
 
2083
    if (stdio->hInputReadyEvent != INVALID_HANDLE_VALUE) {
 
2084
        CloseHandle(stdio->hInputReadyEvent);
 
2085
    }
 
2086
    if (stdio->hInputDoneEvent != INVALID_HANDLE_VALUE) {
 
2087
        CloseHandle(stdio->hInputDoneEvent);
 
2088
    }
 
2089
    if (stdio->hInputThread != INVALID_HANDLE_VALUE) {
 
2090
        TerminateThread(stdio->hInputThread, 0);
 
2091
    }
 
2092
 
 
2093
    g_free(chr->opaque);
 
2094
    g_free(chr);
 
2095
}
 
2096
 
 
2097
static CharDriverState *qemu_chr_open_stdio(ChardevStdio *opts)
 
2098
{
 
2099
    CharDriverState   *chr;
 
2100
    WinStdioCharState *stdio;
 
2101
    DWORD              dwMode;
 
2102
    int                is_console = 0;
 
2103
 
 
2104
    chr   = g_malloc0(sizeof(CharDriverState));
 
2105
    stdio = g_malloc0(sizeof(WinStdioCharState));
 
2106
 
 
2107
    stdio->hStdIn = GetStdHandle(STD_INPUT_HANDLE);
 
2108
    if (stdio->hStdIn == INVALID_HANDLE_VALUE) {
 
2109
        fprintf(stderr, "cannot open stdio: invalid handle\n");
 
2110
        exit(1);
 
2111
    }
 
2112
 
 
2113
    is_console = GetConsoleMode(stdio->hStdIn, &dwMode) != 0;
 
2114
 
 
2115
    chr->opaque    = stdio;
 
2116
    chr->chr_write = win_stdio_write;
 
2117
    chr->chr_close = win_stdio_close;
 
2118
 
 
2119
    if (is_console) {
 
2120
        if (qemu_add_wait_object(stdio->hStdIn,
 
2121
                                 win_stdio_wait_func, chr)) {
 
2122
            fprintf(stderr, "qemu_add_wait_object: failed\n");
 
2123
        }
 
2124
    } else {
 
2125
        DWORD   dwId;
 
2126
            
 
2127
        stdio->hInputReadyEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
 
2128
        stdio->hInputDoneEvent  = CreateEvent(NULL, FALSE, FALSE, NULL);
 
2129
        stdio->hInputThread     = CreateThread(NULL, 0, win_stdio_thread,
 
2130
                                               chr, 0, &dwId);
 
2131
 
 
2132
        if (stdio->hInputThread == INVALID_HANDLE_VALUE
 
2133
            || stdio->hInputReadyEvent == INVALID_HANDLE_VALUE
 
2134
            || stdio->hInputDoneEvent == INVALID_HANDLE_VALUE) {
 
2135
            fprintf(stderr, "cannot create stdio thread or event\n");
 
2136
            exit(1);
 
2137
        }
 
2138
        if (qemu_add_wait_object(stdio->hInputReadyEvent,
 
2139
                                 win_stdio_thread_wait_func, chr)) {
 
2140
            fprintf(stderr, "qemu_add_wait_object: failed\n");
 
2141
        }
 
2142
    }
 
2143
 
 
2144
    dwMode |= ENABLE_LINE_INPUT;
 
2145
 
 
2146
    if (is_console) {
 
2147
        /* set the terminal in raw mode */
 
2148
        /* ENABLE_QUICK_EDIT_MODE | ENABLE_EXTENDED_FLAGS */
 
2149
        dwMode |= ENABLE_PROCESSED_INPUT;
 
2150
    }
 
2151
 
 
2152
    SetConsoleMode(stdio->hStdIn, dwMode);
 
2153
 
 
2154
    chr->chr_set_echo = qemu_chr_set_echo_win_stdio;
 
2155
    qemu_chr_fe_set_echo(chr, false);
 
2156
 
 
2157
    return chr;
 
2158
}
 
2159
#endif /* !_WIN32 */
 
2160
 
 
2161
 
 
2162
/***********************************************************/
 
2163
/* UDP Net console */
 
2164
 
 
2165
typedef struct {
 
2166
    int fd;
 
2167
    GIOChannel *chan;
 
2168
    guint tag;
 
2169
    uint8_t buf[READ_BUF_LEN];
 
2170
    int bufcnt;
 
2171
    int bufptr;
 
2172
    int max_size;
 
2173
} NetCharDriver;
 
2174
 
 
2175
static int udp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
 
2176
{
 
2177
    NetCharDriver *s = chr->opaque;
 
2178
    gsize bytes_written;
 
2179
    GIOStatus status;
 
2180
 
 
2181
    status = g_io_channel_write_chars(s->chan, (const gchar *)buf, len, &bytes_written, NULL);
 
2182
    if (status == G_IO_STATUS_EOF) {
 
2183
        return 0;
 
2184
    } else if (status != G_IO_STATUS_NORMAL) {
 
2185
        return -1;
 
2186
    }
 
2187
 
 
2188
    return bytes_written;
 
2189
}
 
2190
 
 
2191
static int udp_chr_read_poll(void *opaque)
 
2192
{
 
2193
    CharDriverState *chr = opaque;
 
2194
    NetCharDriver *s = chr->opaque;
 
2195
 
 
2196
    s->max_size = qemu_chr_be_can_write(chr);
 
2197
 
 
2198
    /* If there were any stray characters in the queue process them
 
2199
     * first
 
2200
     */
 
2201
    while (s->max_size > 0 && s->bufptr < s->bufcnt) {
 
2202
        qemu_chr_be_write(chr, &s->buf[s->bufptr], 1);
 
2203
        s->bufptr++;
 
2204
        s->max_size = qemu_chr_be_can_write(chr);
 
2205
    }
 
2206
    return s->max_size;
 
2207
}
 
2208
 
 
2209
static gboolean udp_chr_read(GIOChannel *chan, GIOCondition cond, void *opaque)
 
2210
{
 
2211
    CharDriverState *chr = opaque;
 
2212
    NetCharDriver *s = chr->opaque;
 
2213
    gsize bytes_read = 0;
 
2214
    GIOStatus status;
 
2215
 
 
2216
    if (s->max_size == 0) {
 
2217
        return TRUE;
 
2218
    }
 
2219
    status = g_io_channel_read_chars(s->chan, (gchar *)s->buf, sizeof(s->buf),
 
2220
                                     &bytes_read, NULL);
 
2221
    s->bufcnt = bytes_read;
 
2222
    s->bufptr = s->bufcnt;
 
2223
    if (status != G_IO_STATUS_NORMAL) {
 
2224
        if (s->tag) {
 
2225
            io_remove_watch_poll(s->tag);
 
2226
            s->tag = 0;
 
2227
        }
 
2228
        return FALSE;
 
2229
    }
 
2230
 
 
2231
    s->bufptr = 0;
 
2232
    while (s->max_size > 0 && s->bufptr < s->bufcnt) {
 
2233
        qemu_chr_be_write(chr, &s->buf[s->bufptr], 1);
 
2234
        s->bufptr++;
 
2235
        s->max_size = qemu_chr_be_can_write(chr);
 
2236
    }
 
2237
 
 
2238
    return TRUE;
 
2239
}
 
2240
 
 
2241
static void udp_chr_update_read_handler(CharDriverState *chr)
 
2242
{
 
2243
    NetCharDriver *s = chr->opaque;
 
2244
 
 
2245
    if (s->tag) {
 
2246
        io_remove_watch_poll(s->tag);
 
2247
        s->tag = 0;
 
2248
    }
 
2249
 
 
2250
    if (s->chan) {
 
2251
        s->tag = io_add_watch_poll(s->chan, udp_chr_read_poll, udp_chr_read, chr);
 
2252
    }
 
2253
}
 
2254
 
 
2255
static void udp_chr_close(CharDriverState *chr)
 
2256
{
 
2257
    NetCharDriver *s = chr->opaque;
 
2258
    if (s->tag) {
 
2259
        io_remove_watch_poll(s->tag);
 
2260
        s->tag = 0;
 
2261
    }
 
2262
    if (s->chan) {
 
2263
        g_io_channel_unref(s->chan);
 
2264
        closesocket(s->fd);
 
2265
    }
 
2266
    g_free(s);
 
2267
    qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
 
2268
}
 
2269
 
 
2270
static CharDriverState *qemu_chr_open_udp_fd(int fd)
 
2271
{
 
2272
    CharDriverState *chr = NULL;
 
2273
    NetCharDriver *s = NULL;
 
2274
 
 
2275
    chr = g_malloc0(sizeof(CharDriverState));
 
2276
    s = g_malloc0(sizeof(NetCharDriver));
 
2277
 
 
2278
    s->fd = fd;
 
2279
    s->chan = io_channel_from_socket(s->fd);
 
2280
    s->bufcnt = 0;
 
2281
    s->bufptr = 0;
 
2282
    chr->opaque = s;
 
2283
    chr->chr_write = udp_chr_write;
 
2284
    chr->chr_update_read_handler = udp_chr_update_read_handler;
 
2285
    chr->chr_close = udp_chr_close;
 
2286
    /* be isn't opened until we get a connection */
 
2287
    chr->explicit_be_open = true;
 
2288
    return chr;
 
2289
}
 
2290
 
 
2291
static CharDriverState *qemu_chr_open_udp(QemuOpts *opts)
 
2292
{
 
2293
    Error *local_err = NULL;
 
2294
    int fd = -1;
 
2295
 
 
2296
    fd = inet_dgram_opts(opts, &local_err);
 
2297
    if (fd < 0) {
 
2298
        qerror_report_err(local_err);
 
2299
        error_free(local_err);
 
2300
        return NULL;
 
2301
    }
 
2302
    return qemu_chr_open_udp_fd(fd);
 
2303
}
 
2304
 
 
2305
/***********************************************************/
 
2306
/* TCP Net console */
 
2307
 
 
2308
typedef struct {
 
2309
 
 
2310
    GIOChannel *chan, *listen_chan;
 
2311
    guint tag, listen_tag;
 
2312
    int fd, listen_fd;
 
2313
    int connected;
 
2314
    int max_size;
 
2315
    int do_telnetopt;
 
2316
    int do_nodelay;
 
2317
    int is_unix;
 
2318
    int msgfd;
 
2319
} TCPCharDriver;
 
2320
 
 
2321
static gboolean tcp_chr_accept(GIOChannel *chan, GIOCondition cond, void *opaque);
 
2322
 
 
2323
static int tcp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
 
2324
{
 
2325
    TCPCharDriver *s = chr->opaque;
 
2326
    if (s->connected) {
 
2327
        return io_channel_send(s->chan, buf, len);
 
2328
    } else {
 
2329
        /* XXX: indicate an error ? */
 
2330
        return len;
 
2331
    }
 
2332
}
 
2333
 
 
2334
static int tcp_chr_read_poll(void *opaque)
 
2335
{
 
2336
    CharDriverState *chr = opaque;
 
2337
    TCPCharDriver *s = chr->opaque;
 
2338
    if (!s->connected)
 
2339
        return 0;
 
2340
    s->max_size = qemu_chr_be_can_write(chr);
 
2341
    return s->max_size;
 
2342
}
 
2343
 
 
2344
#define IAC 255
 
2345
#define IAC_BREAK 243
 
2346
static void tcp_chr_process_IAC_bytes(CharDriverState *chr,
 
2347
                                      TCPCharDriver *s,
 
2348
                                      uint8_t *buf, int *size)
 
2349
{
 
2350
    /* Handle any telnet client's basic IAC options to satisfy char by
 
2351
     * char mode with no echo.  All IAC options will be removed from
 
2352
     * the buf and the do_telnetopt variable will be used to track the
 
2353
     * state of the width of the IAC information.
 
2354
     *
 
2355
     * IAC commands come in sets of 3 bytes with the exception of the
 
2356
     * "IAC BREAK" command and the double IAC.
 
2357
     */
 
2358
 
 
2359
    int i;
 
2360
    int j = 0;
 
2361
 
 
2362
    for (i = 0; i < *size; i++) {
 
2363
        if (s->do_telnetopt > 1) {
 
2364
            if ((unsigned char)buf[i] == IAC && s->do_telnetopt == 2) {
 
2365
                /* Double IAC means send an IAC */
 
2366
                if (j != i)
 
2367
                    buf[j] = buf[i];
 
2368
                j++;
 
2369
                s->do_telnetopt = 1;
 
2370
            } else {
 
2371
                if ((unsigned char)buf[i] == IAC_BREAK && s->do_telnetopt == 2) {
 
2372
                    /* Handle IAC break commands by sending a serial break */
 
2373
                    qemu_chr_be_event(chr, CHR_EVENT_BREAK);
 
2374
                    s->do_telnetopt++;
 
2375
                }
 
2376
                s->do_telnetopt++;
 
2377
            }
 
2378
            if (s->do_telnetopt >= 4) {
 
2379
                s->do_telnetopt = 1;
 
2380
            }
 
2381
        } else {
 
2382
            if ((unsigned char)buf[i] == IAC) {
 
2383
                s->do_telnetopt = 2;
 
2384
            } else {
 
2385
                if (j != i)
 
2386
                    buf[j] = buf[i];
 
2387
                j++;
 
2388
            }
 
2389
        }
 
2390
    }
 
2391
    *size = j;
 
2392
}
 
2393
 
 
2394
static int tcp_get_msgfd(CharDriverState *chr)
 
2395
{
 
2396
    TCPCharDriver *s = chr->opaque;
 
2397
    int fd = s->msgfd;
 
2398
    s->msgfd = -1;
 
2399
    return fd;
 
2400
}
 
2401
 
 
2402
#ifndef _WIN32
 
2403
static void unix_process_msgfd(CharDriverState *chr, struct msghdr *msg)
 
2404
{
 
2405
    TCPCharDriver *s = chr->opaque;
 
2406
    struct cmsghdr *cmsg;
 
2407
 
 
2408
    for (cmsg = CMSG_FIRSTHDR(msg); cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) {
 
2409
        int fd;
 
2410
 
 
2411
        if (cmsg->cmsg_len != CMSG_LEN(sizeof(int)) ||
 
2412
            cmsg->cmsg_level != SOL_SOCKET ||
 
2413
            cmsg->cmsg_type != SCM_RIGHTS)
 
2414
            continue;
 
2415
 
 
2416
        fd = *((int *)CMSG_DATA(cmsg));
 
2417
        if (fd < 0)
 
2418
            continue;
 
2419
 
 
2420
        /* O_NONBLOCK is preserved across SCM_RIGHTS so reset it */
 
2421
        qemu_set_block(fd);
 
2422
 
 
2423
#ifndef MSG_CMSG_CLOEXEC
 
2424
        qemu_set_cloexec(fd);
 
2425
#endif
 
2426
        if (s->msgfd != -1)
 
2427
            close(s->msgfd);
 
2428
        s->msgfd = fd;
 
2429
    }
 
2430
}
 
2431
 
 
2432
static ssize_t tcp_chr_recv(CharDriverState *chr, char *buf, size_t len)
 
2433
{
 
2434
    TCPCharDriver *s = chr->opaque;
 
2435
    struct msghdr msg = { NULL, };
 
2436
    struct iovec iov[1];
 
2437
    union {
 
2438
        struct cmsghdr cmsg;
 
2439
        char control[CMSG_SPACE(sizeof(int))];
 
2440
    } msg_control;
 
2441
    int flags = 0;
 
2442
    ssize_t ret;
 
2443
 
 
2444
    iov[0].iov_base = buf;
 
2445
    iov[0].iov_len = len;
 
2446
 
 
2447
    msg.msg_iov = iov;
 
2448
    msg.msg_iovlen = 1;
 
2449
    msg.msg_control = &msg_control;
 
2450
    msg.msg_controllen = sizeof(msg_control);
 
2451
 
 
2452
#ifdef MSG_CMSG_CLOEXEC
 
2453
    flags |= MSG_CMSG_CLOEXEC;
 
2454
#endif
 
2455
    ret = recvmsg(s->fd, &msg, flags);
 
2456
    if (ret > 0 && s->is_unix) {
 
2457
        unix_process_msgfd(chr, &msg);
 
2458
    }
 
2459
 
 
2460
    return ret;
 
2461
}
 
2462
#else
 
2463
static ssize_t tcp_chr_recv(CharDriverState *chr, char *buf, size_t len)
 
2464
{
 
2465
    TCPCharDriver *s = chr->opaque;
 
2466
    return qemu_recv(s->fd, buf, len, 0);
 
2467
}
 
2468
#endif
 
2469
 
 
2470
static GSource *tcp_chr_add_watch(CharDriverState *chr, GIOCondition cond)
 
2471
{
 
2472
    TCPCharDriver *s = chr->opaque;
 
2473
    return g_io_create_watch(s->chan, cond);
 
2474
}
 
2475
 
 
2476
static gboolean tcp_chr_read(GIOChannel *chan, GIOCondition cond, void *opaque)
 
2477
{
 
2478
    CharDriverState *chr = opaque;
 
2479
    TCPCharDriver *s = chr->opaque;
 
2480
    uint8_t buf[READ_BUF_LEN];
 
2481
    int len, size;
 
2482
 
 
2483
    if (!s->connected || s->max_size <= 0) {
 
2484
        return TRUE;
 
2485
    }
 
2486
    len = sizeof(buf);
 
2487
    if (len > s->max_size)
 
2488
        len = s->max_size;
 
2489
    size = tcp_chr_recv(chr, (void *)buf, len);
 
2490
    if (size == 0) {
 
2491
        /* connection closed */
 
2492
        s->connected = 0;
 
2493
        if (s->listen_chan) {
 
2494
            s->listen_tag = g_io_add_watch(s->listen_chan, G_IO_IN, tcp_chr_accept, chr);
 
2495
        }
 
2496
        if (s->tag) {
 
2497
            io_remove_watch_poll(s->tag);
 
2498
            s->tag = 0;
 
2499
        }
 
2500
        g_io_channel_unref(s->chan);
 
2501
        s->chan = NULL;
 
2502
        closesocket(s->fd);
 
2503
        s->fd = -1;
 
2504
        qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
 
2505
    } else if (size > 0) {
 
2506
        if (s->do_telnetopt)
 
2507
            tcp_chr_process_IAC_bytes(chr, s, buf, &size);
 
2508
        if (size > 0)
 
2509
            qemu_chr_be_write(chr, buf, size);
 
2510
    }
 
2511
 
 
2512
    return TRUE;
 
2513
}
 
2514
 
 
2515
#ifndef _WIN32
 
2516
CharDriverState *qemu_chr_open_eventfd(int eventfd)
 
2517
{
 
2518
    return qemu_chr_open_fd(eventfd, eventfd);
 
2519
}
 
2520
#endif
 
2521
 
 
2522
static void tcp_chr_connect(void *opaque)
 
2523
{
 
2524
    CharDriverState *chr = opaque;
 
2525
    TCPCharDriver *s = chr->opaque;
 
2526
 
 
2527
    s->connected = 1;
 
2528
    if (s->chan) {
 
2529
        s->tag = io_add_watch_poll(s->chan, tcp_chr_read_poll, tcp_chr_read, chr);
 
2530
    }
 
2531
    qemu_chr_be_generic_open(chr);
 
2532
}
 
2533
 
 
2534
#define IACSET(x,a,b,c) x[0] = a; x[1] = b; x[2] = c;
 
2535
static void tcp_chr_telnet_init(int fd)
 
2536
{
 
2537
    char buf[3];
 
2538
    /* Send the telnet negotion to put telnet in binary, no echo, single char mode */
 
2539
    IACSET(buf, 0xff, 0xfb, 0x01);  /* IAC WILL ECHO */
 
2540
    send(fd, (char *)buf, 3, 0);
 
2541
    IACSET(buf, 0xff, 0xfb, 0x03);  /* IAC WILL Suppress go ahead */
 
2542
    send(fd, (char *)buf, 3, 0);
 
2543
    IACSET(buf, 0xff, 0xfb, 0x00);  /* IAC WILL Binary */
 
2544
    send(fd, (char *)buf, 3, 0);
 
2545
    IACSET(buf, 0xff, 0xfd, 0x00);  /* IAC DO Binary */
 
2546
    send(fd, (char *)buf, 3, 0);
 
2547
}
 
2548
 
 
2549
static int tcp_chr_add_client(CharDriverState *chr, int fd)
 
2550
{
 
2551
    TCPCharDriver *s = chr->opaque;
 
2552
    if (s->fd != -1)
 
2553
        return -1;
 
2554
 
 
2555
    qemu_set_nonblock(fd);
 
2556
    if (s->do_nodelay)
 
2557
        socket_set_nodelay(fd);
 
2558
    s->fd = fd;
 
2559
    s->chan = io_channel_from_socket(fd);
 
2560
    if (s->listen_tag) {
 
2561
        g_source_remove(s->listen_tag);
 
2562
        s->listen_tag = 0;
 
2563
    }
 
2564
    tcp_chr_connect(chr);
 
2565
 
 
2566
    return 0;
 
2567
}
 
2568
 
 
2569
static gboolean tcp_chr_accept(GIOChannel *channel, GIOCondition cond, void *opaque)
 
2570
{
 
2571
    CharDriverState *chr = opaque;
 
2572
    TCPCharDriver *s = chr->opaque;
 
2573
    struct sockaddr_in saddr;
 
2574
#ifndef _WIN32
 
2575
    struct sockaddr_un uaddr;
 
2576
#endif
 
2577
    struct sockaddr *addr;
 
2578
    socklen_t len;
 
2579
    int fd;
 
2580
 
 
2581
    for(;;) {
 
2582
#ifndef _WIN32
 
2583
        if (s->is_unix) {
 
2584
            len = sizeof(uaddr);
 
2585
            addr = (struct sockaddr *)&uaddr;
 
2586
        } else
 
2587
#endif
 
2588
        {
 
2589
            len = sizeof(saddr);
 
2590
            addr = (struct sockaddr *)&saddr;
 
2591
        }
 
2592
        fd = qemu_accept(s->listen_fd, addr, &len);
 
2593
        if (fd < 0 && errno != EINTR) {
 
2594
            s->listen_tag = 0;
 
2595
            return FALSE;
 
2596
        } else if (fd >= 0) {
 
2597
            if (s->do_telnetopt)
 
2598
                tcp_chr_telnet_init(fd);
 
2599
            break;
 
2600
        }
 
2601
    }
 
2602
    if (tcp_chr_add_client(chr, fd) < 0)
 
2603
        close(fd);
 
2604
 
 
2605
    return TRUE;
 
2606
}
 
2607
 
 
2608
static void tcp_chr_close(CharDriverState *chr)
 
2609
{
 
2610
    TCPCharDriver *s = chr->opaque;
 
2611
    if (s->fd >= 0) {
 
2612
        if (s->tag) {
 
2613
            io_remove_watch_poll(s->tag);
 
2614
            s->tag = 0;
 
2615
        }
 
2616
        if (s->chan) {
 
2617
            g_io_channel_unref(s->chan);
 
2618
        }
 
2619
        closesocket(s->fd);
 
2620
    }
 
2621
    if (s->listen_fd >= 0) {
 
2622
        if (s->listen_tag) {
 
2623
            g_source_remove(s->listen_tag);
 
2624
            s->listen_tag = 0;
 
2625
        }
 
2626
        if (s->listen_chan) {
 
2627
            g_io_channel_unref(s->listen_chan);
 
2628
        }
 
2629
        closesocket(s->listen_fd);
 
2630
    }
 
2631
    g_free(s);
 
2632
    qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
 
2633
}
 
2634
 
 
2635
static CharDriverState *qemu_chr_open_socket_fd(int fd, bool do_nodelay,
 
2636
                                                bool is_listen, bool is_telnet,
 
2637
                                                bool is_waitconnect,
 
2638
                                                Error **errp)
 
2639
{
 
2640
    CharDriverState *chr = NULL;
 
2641
    TCPCharDriver *s = NULL;
 
2642
    char host[NI_MAXHOST], serv[NI_MAXSERV];
 
2643
    const char *left = "", *right = "";
 
2644
    struct sockaddr_storage ss;
 
2645
    socklen_t ss_len = sizeof(ss);
 
2646
 
 
2647
    memset(&ss, 0, ss_len);
 
2648
    if (getsockname(fd, (struct sockaddr *) &ss, &ss_len) != 0) {
 
2649
        error_setg_errno(errp, errno, "getsockname");
 
2650
        return NULL;
 
2651
    }
 
2652
 
 
2653
    chr = g_malloc0(sizeof(CharDriverState));
 
2654
    s = g_malloc0(sizeof(TCPCharDriver));
 
2655
 
 
2656
    s->connected = 0;
 
2657
    s->fd = -1;
 
2658
    s->listen_fd = -1;
 
2659
    s->msgfd = -1;
 
2660
 
 
2661
    chr->filename = g_malloc(256);
 
2662
    switch (ss.ss_family) {
 
2663
#ifndef _WIN32
 
2664
    case AF_UNIX:
 
2665
        s->is_unix = 1;
 
2666
        snprintf(chr->filename, 256, "unix:%s%s",
 
2667
                 ((struct sockaddr_un *)(&ss))->sun_path,
 
2668
                 is_listen ? ",server" : "");
 
2669
        break;
 
2670
#endif
 
2671
    case AF_INET6:
 
2672
        left  = "[";
 
2673
        right = "]";
 
2674
        /* fall through */
 
2675
    case AF_INET:
 
2676
        s->do_nodelay = do_nodelay;
 
2677
        getnameinfo((struct sockaddr *) &ss, ss_len, host, sizeof(host),
 
2678
                    serv, sizeof(serv), NI_NUMERICHOST | NI_NUMERICSERV);
 
2679
        snprintf(chr->filename, 256, "%s:%s%s%s:%s%s",
 
2680
                 is_telnet ? "telnet" : "tcp",
 
2681
                 left, host, right, serv,
 
2682
                 is_listen ? ",server" : "");
 
2683
        break;
 
2684
    }
 
2685
 
 
2686
    chr->opaque = s;
 
2687
    chr->chr_write = tcp_chr_write;
 
2688
    chr->chr_close = tcp_chr_close;
 
2689
    chr->get_msgfd = tcp_get_msgfd;
 
2690
    chr->chr_add_client = tcp_chr_add_client;
 
2691
    chr->chr_add_watch = tcp_chr_add_watch;
 
2692
    /* be isn't opened until we get a connection */
 
2693
    chr->explicit_be_open = true;
 
2694
 
 
2695
    if (is_listen) {
 
2696
        s->listen_fd = fd;
 
2697
        s->listen_chan = io_channel_from_socket(s->listen_fd);
 
2698
        s->listen_tag = g_io_add_watch(s->listen_chan, G_IO_IN, tcp_chr_accept, chr);
 
2699
        if (is_telnet) {
 
2700
            s->do_telnetopt = 1;
 
2701
        }
 
2702
    } else {
 
2703
        s->connected = 1;
 
2704
        s->fd = fd;
 
2705
        socket_set_nodelay(fd);
 
2706
        s->chan = io_channel_from_socket(s->fd);
 
2707
        tcp_chr_connect(chr);
 
2708
    }
 
2709
 
 
2710
    if (is_listen && is_waitconnect) {
 
2711
        fprintf(stderr, "QEMU waiting for connection on: %s\n",
 
2712
                chr->filename);
 
2713
        tcp_chr_accept(s->listen_chan, G_IO_IN, chr);
 
2714
        qemu_set_nonblock(s->listen_fd);
 
2715
    }
 
2716
    return chr;
 
2717
}
 
2718
 
 
2719
static CharDriverState *qemu_chr_open_socket(QemuOpts *opts)
 
2720
{
 
2721
    CharDriverState *chr = NULL;
 
2722
    Error *local_err = NULL;
 
2723
    int fd = -1;
 
2724
 
 
2725
    bool is_listen      = qemu_opt_get_bool(opts, "server", false);
 
2726
    bool is_waitconnect = is_listen && qemu_opt_get_bool(opts, "wait", true);
 
2727
    bool is_telnet      = qemu_opt_get_bool(opts, "telnet", false);
 
2728
    bool do_nodelay     = !qemu_opt_get_bool(opts, "delay", true);
 
2729
    bool is_unix        = qemu_opt_get(opts, "path") != NULL;
 
2730
 
 
2731
    if (is_unix) {
 
2732
        if (is_listen) {
 
2733
            fd = unix_listen_opts(opts, &local_err);
 
2734
        } else {
 
2735
            fd = unix_connect_opts(opts, &local_err, NULL, NULL);
 
2736
        }
 
2737
    } else {
 
2738
        if (is_listen) {
 
2739
            fd = inet_listen_opts(opts, 0, &local_err);
 
2740
        } else {
 
2741
            fd = inet_connect_opts(opts, &local_err, NULL, NULL);
 
2742
        }
 
2743
    }
 
2744
    if (fd < 0) {
 
2745
        goto fail;
 
2746
    }
 
2747
 
 
2748
    if (!is_waitconnect)
 
2749
        qemu_set_nonblock(fd);
 
2750
 
 
2751
    chr = qemu_chr_open_socket_fd(fd, do_nodelay, is_listen, is_telnet,
 
2752
                                  is_waitconnect, &local_err);
 
2753
    if (error_is_set(&local_err)) {
 
2754
        goto fail;
 
2755
    }
 
2756
    return chr;
 
2757
 
 
2758
 
 
2759
 fail:
 
2760
    if (local_err) {
 
2761
        qerror_report_err(local_err);
 
2762
        error_free(local_err);
 
2763
    }
 
2764
    if (fd >= 0) {
 
2765
        closesocket(fd);
 
2766
    }
 
2767
    if (chr) {
 
2768
        g_free(chr->opaque);
 
2769
        g_free(chr);
 
2770
    }
 
2771
    return NULL;
 
2772
}
 
2773
 
 
2774
/*********************************************************/
 
2775
/* Ring buffer chardev */
 
2776
 
 
2777
typedef struct {
 
2778
    size_t size;
 
2779
    size_t prod;
 
2780
    size_t cons;
 
2781
    uint8_t *cbuf;
 
2782
} RingBufCharDriver;
 
2783
 
 
2784
static size_t ringbuf_count(const CharDriverState *chr)
 
2785
{
 
2786
    const RingBufCharDriver *d = chr->opaque;
 
2787
 
 
2788
    return d->prod - d->cons;
 
2789
}
 
2790
 
 
2791
static int ringbuf_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
 
2792
{
 
2793
    RingBufCharDriver *d = chr->opaque;
 
2794
    int i;
 
2795
 
 
2796
    if (!buf || (len < 0)) {
 
2797
        return -1;
 
2798
    }
 
2799
 
 
2800
    for (i = 0; i < len; i++ ) {
 
2801
        d->cbuf[d->prod++ & (d->size - 1)] = buf[i];
 
2802
        if (d->prod - d->cons > d->size) {
 
2803
            d->cons = d->prod - d->size;
 
2804
        }
 
2805
    }
 
2806
 
 
2807
    return 0;
 
2808
}
 
2809
 
 
2810
static int ringbuf_chr_read(CharDriverState *chr, uint8_t *buf, int len)
 
2811
{
 
2812
    RingBufCharDriver *d = chr->opaque;
 
2813
    int i;
 
2814
 
 
2815
    for (i = 0; i < len && d->cons != d->prod; i++) {
 
2816
        buf[i] = d->cbuf[d->cons++ & (d->size - 1)];
 
2817
    }
 
2818
 
 
2819
    return i;
 
2820
}
 
2821
 
 
2822
static void ringbuf_chr_close(struct CharDriverState *chr)
 
2823
{
 
2824
    RingBufCharDriver *d = chr->opaque;
 
2825
 
 
2826
    g_free(d->cbuf);
 
2827
    g_free(d);
 
2828
    chr->opaque = NULL;
 
2829
}
 
2830
 
 
2831
static CharDriverState *qemu_chr_open_ringbuf(ChardevRingbuf *opts,
 
2832
                                              Error **errp)
 
2833
{
 
2834
    CharDriverState *chr;
 
2835
    RingBufCharDriver *d;
 
2836
 
 
2837
    chr = g_malloc0(sizeof(CharDriverState));
 
2838
    d = g_malloc(sizeof(*d));
 
2839
 
 
2840
    d->size = opts->has_size ? opts->size : 65536;
 
2841
 
 
2842
    /* The size must be power of 2 */
 
2843
    if (d->size & (d->size - 1)) {
 
2844
        error_setg(errp, "size of ringbuf chardev must be power of two");
 
2845
        goto fail;
 
2846
    }
 
2847
 
 
2848
    d->prod = 0;
 
2849
    d->cons = 0;
 
2850
    d->cbuf = g_malloc0(d->size);
 
2851
 
 
2852
    chr->opaque = d;
 
2853
    chr->chr_write = ringbuf_chr_write;
 
2854
    chr->chr_close = ringbuf_chr_close;
 
2855
 
 
2856
    return chr;
 
2857
 
 
2858
fail:
 
2859
    g_free(d);
 
2860
    g_free(chr);
 
2861
    return NULL;
 
2862
}
 
2863
 
 
2864
static bool chr_is_ringbuf(const CharDriverState *chr)
 
2865
{
 
2866
    return chr->chr_write == ringbuf_chr_write;
 
2867
}
 
2868
 
 
2869
void qmp_ringbuf_write(const char *device, const char *data,
 
2870
                       bool has_format, enum DataFormat format,
 
2871
                       Error **errp)
 
2872
{
 
2873
    CharDriverState *chr;
 
2874
    const uint8_t *write_data;
 
2875
    int ret;
 
2876
    gsize write_count;
 
2877
 
 
2878
    chr = qemu_chr_find(device);
 
2879
    if (!chr) {
 
2880
        error_setg(errp, "Device '%s' not found", device);
 
2881
        return;
 
2882
    }
 
2883
 
 
2884
    if (!chr_is_ringbuf(chr)) {
 
2885
        error_setg(errp,"%s is not a ringbuf device", device);
 
2886
        return;
 
2887
    }
 
2888
 
 
2889
    if (has_format && (format == DATA_FORMAT_BASE64)) {
 
2890
        write_data = g_base64_decode(data, &write_count);
 
2891
    } else {
 
2892
        write_data = (uint8_t *)data;
 
2893
        write_count = strlen(data);
 
2894
    }
 
2895
 
 
2896
    ret = ringbuf_chr_write(chr, write_data, write_count);
 
2897
 
 
2898
    if (write_data != (uint8_t *)data) {
 
2899
        g_free((void *)write_data);
 
2900
    }
 
2901
 
 
2902
    if (ret < 0) {
 
2903
        error_setg(errp, "Failed to write to device %s", device);
 
2904
        return;
 
2905
    }
 
2906
}
 
2907
 
 
2908
char *qmp_ringbuf_read(const char *device, int64_t size,
 
2909
                       bool has_format, enum DataFormat format,
 
2910
                       Error **errp)
 
2911
{
 
2912
    CharDriverState *chr;
 
2913
    uint8_t *read_data;
 
2914
    size_t count;
 
2915
    char *data;
 
2916
 
 
2917
    chr = qemu_chr_find(device);
 
2918
    if (!chr) {
 
2919
        error_setg(errp, "Device '%s' not found", device);
 
2920
        return NULL;
 
2921
    }
 
2922
 
 
2923
    if (!chr_is_ringbuf(chr)) {
 
2924
        error_setg(errp,"%s is not a ringbuf device", device);
 
2925
        return NULL;
 
2926
    }
 
2927
 
 
2928
    if (size <= 0) {
 
2929
        error_setg(errp, "size must be greater than zero");
 
2930
        return NULL;
 
2931
    }
 
2932
 
 
2933
    count = ringbuf_count(chr);
 
2934
    size = size > count ? count : size;
 
2935
    read_data = g_malloc(size + 1);
 
2936
 
 
2937
    ringbuf_chr_read(chr, read_data, size);
 
2938
 
 
2939
    if (has_format && (format == DATA_FORMAT_BASE64)) {
 
2940
        data = g_base64_encode(read_data, size);
 
2941
        g_free(read_data);
 
2942
    } else {
 
2943
        /*
 
2944
         * FIXME should read only complete, valid UTF-8 characters up
 
2945
         * to @size bytes.  Invalid sequences should be replaced by a
 
2946
         * suitable replacement character.  Except when (and only
 
2947
         * when) ring buffer lost characters since last read, initial
 
2948
         * continuation characters should be dropped.
 
2949
         */
 
2950
        read_data[size] = 0;
 
2951
        data = (char *)read_data;
 
2952
    }
 
2953
 
 
2954
    return data;
 
2955
}
 
2956
 
 
2957
QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename)
 
2958
{
 
2959
    char host[65], port[33], width[8], height[8];
 
2960
    int pos;
 
2961
    const char *p;
 
2962
    QemuOpts *opts;
 
2963
    Error *local_err = NULL;
 
2964
 
 
2965
    opts = qemu_opts_create(qemu_find_opts("chardev"), label, 1, &local_err);
 
2966
    if (error_is_set(&local_err)) {
 
2967
        qerror_report_err(local_err);
 
2968
        error_free(local_err);
 
2969
        return NULL;
 
2970
    }
 
2971
 
 
2972
    if (strstart(filename, "mon:", &p)) {
 
2973
        filename = p;
 
2974
        qemu_opt_set(opts, "mux", "on");
 
2975
        if (strcmp(filename, "stdio") == 0) {
 
2976
            /* Monitor is muxed to stdio: do not exit on Ctrl+C by default
 
2977
             * but pass it to the guest.  Handle this only for compat syntax,
 
2978
             * for -chardev syntax we have special option for this.
 
2979
             * This is what -nographic did, redirecting+muxing serial+monitor
 
2980
             * to stdio causing Ctrl+C to be passed to guest. */
 
2981
            qemu_opt_set(opts, "signal", "off");
 
2982
        }
 
2983
    }
 
2984
 
 
2985
    if (strcmp(filename, "null")    == 0 ||
 
2986
        strcmp(filename, "pty")     == 0 ||
 
2987
        strcmp(filename, "msmouse") == 0 ||
 
2988
        strcmp(filename, "braille") == 0 ||
 
2989
        strcmp(filename, "stdio")   == 0) {
 
2990
        qemu_opt_set(opts, "backend", filename);
 
2991
        return opts;
 
2992
    }
 
2993
    if (strstart(filename, "vc", &p)) {
 
2994
        qemu_opt_set(opts, "backend", "vc");
 
2995
        if (*p == ':') {
 
2996
            if (sscanf(p+1, "%8[0-9]x%8[0-9]", width, height) == 2) {
 
2997
                /* pixels */
 
2998
                qemu_opt_set(opts, "width", width);
 
2999
                qemu_opt_set(opts, "height", height);
 
3000
            } else if (sscanf(p+1, "%8[0-9]Cx%8[0-9]C", width, height) == 2) {
 
3001
                /* chars */
 
3002
                qemu_opt_set(opts, "cols", width);
 
3003
                qemu_opt_set(opts, "rows", height);
 
3004
            } else {
 
3005
                goto fail;
 
3006
            }
 
3007
        }
 
3008
        return opts;
 
3009
    }
 
3010
    if (strcmp(filename, "con:") == 0) {
 
3011
        qemu_opt_set(opts, "backend", "console");
 
3012
        return opts;
 
3013
    }
 
3014
    if (strstart(filename, "COM", NULL)) {
 
3015
        qemu_opt_set(opts, "backend", "serial");
 
3016
        qemu_opt_set(opts, "path", filename);
 
3017
        return opts;
 
3018
    }
 
3019
    if (strstart(filename, "file:", &p)) {
 
3020
        qemu_opt_set(opts, "backend", "file");
 
3021
        qemu_opt_set(opts, "path", p);
 
3022
        return opts;
 
3023
    }
 
3024
    if (strstart(filename, "pipe:", &p)) {
 
3025
        qemu_opt_set(opts, "backend", "pipe");
 
3026
        qemu_opt_set(opts, "path", p);
 
3027
        return opts;
 
3028
    }
 
3029
    if (strstart(filename, "tcp:", &p) ||
 
3030
        strstart(filename, "telnet:", &p)) {
 
3031
        if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) {
 
3032
            host[0] = 0;
 
3033
            if (sscanf(p, ":%32[^,]%n", port, &pos) < 1)
 
3034
                goto fail;
 
3035
        }
 
3036
        qemu_opt_set(opts, "backend", "socket");
 
3037
        qemu_opt_set(opts, "host", host);
 
3038
        qemu_opt_set(opts, "port", port);
 
3039
        if (p[pos] == ',') {
 
3040
            if (qemu_opts_do_parse(opts, p+pos+1, NULL) != 0)
 
3041
                goto fail;
 
3042
        }
 
3043
        if (strstart(filename, "telnet:", &p))
 
3044
            qemu_opt_set(opts, "telnet", "on");
 
3045
        return opts;
 
3046
    }
 
3047
    if (strstart(filename, "udp:", &p)) {
 
3048
        qemu_opt_set(opts, "backend", "udp");
 
3049
        if (sscanf(p, "%64[^:]:%32[^@,]%n", host, port, &pos) < 2) {
 
3050
            host[0] = 0;
 
3051
            if (sscanf(p, ":%32[^@,]%n", port, &pos) < 1) {
 
3052
                goto fail;
 
3053
            }
 
3054
        }
 
3055
        qemu_opt_set(opts, "host", host);
 
3056
        qemu_opt_set(opts, "port", port);
 
3057
        if (p[pos] == '@') {
 
3058
            p += pos + 1;
 
3059
            if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) {
 
3060
                host[0] = 0;
 
3061
                if (sscanf(p, ":%32[^,]%n", port, &pos) < 1) {
 
3062
                    goto fail;
 
3063
                }
 
3064
            }
 
3065
            qemu_opt_set(opts, "localaddr", host);
 
3066
            qemu_opt_set(opts, "localport", port);
 
3067
        }
 
3068
        return opts;
 
3069
    }
 
3070
    if (strstart(filename, "unix:", &p)) {
 
3071
        qemu_opt_set(opts, "backend", "socket");
 
3072
        if (qemu_opts_do_parse(opts, p, "path") != 0)
 
3073
            goto fail;
 
3074
        return opts;
 
3075
    }
 
3076
    if (strstart(filename, "/dev/parport", NULL) ||
 
3077
        strstart(filename, "/dev/ppi", NULL)) {
 
3078
        qemu_opt_set(opts, "backend", "parport");
 
3079
        qemu_opt_set(opts, "path", filename);
 
3080
        return opts;
 
3081
    }
 
3082
    if (strstart(filename, "/dev/", NULL)) {
 
3083
        qemu_opt_set(opts, "backend", "tty");
 
3084
        qemu_opt_set(opts, "path", filename);
 
3085
        return opts;
 
3086
    }
 
3087
 
 
3088
fail:
 
3089
    qemu_opts_del(opts);
 
3090
    return NULL;
 
3091
}
 
3092
 
 
3093
static void qemu_chr_parse_file_out(QemuOpts *opts, ChardevBackend *backend,
 
3094
                                    Error **errp)
 
3095
{
 
3096
    const char *path = qemu_opt_get(opts, "path");
 
3097
 
 
3098
    if (path == NULL) {
 
3099
        error_setg(errp, "chardev: file: no filename given");
 
3100
        return;
 
3101
    }
 
3102
    backend->file = g_new0(ChardevFile, 1);
 
3103
    backend->file->out = g_strdup(path);
 
3104
}
 
3105
 
 
3106
static void qemu_chr_parse_stdio(QemuOpts *opts, ChardevBackend *backend,
 
3107
                                 Error **errp)
 
3108
{
 
3109
    backend->stdio = g_new0(ChardevStdio, 1);
 
3110
    backend->stdio->has_signal = true;
 
3111
    backend->stdio->signal = qemu_opt_get_bool(opts, "signal", true);
 
3112
}
 
3113
 
 
3114
static void qemu_chr_parse_serial(QemuOpts *opts, ChardevBackend *backend,
 
3115
                                  Error **errp)
 
3116
{
 
3117
    const char *device = qemu_opt_get(opts, "path");
 
3118
 
 
3119
    if (device == NULL) {
 
3120
        error_setg(errp, "chardev: serial/tty: no device path given");
 
3121
        return;
 
3122
    }
 
3123
    backend->serial = g_new0(ChardevHostdev, 1);
 
3124
    backend->serial->device = g_strdup(device);
 
3125
}
 
3126
 
 
3127
static void qemu_chr_parse_parallel(QemuOpts *opts, ChardevBackend *backend,
 
3128
                                    Error **errp)
 
3129
{
 
3130
    const char *device = qemu_opt_get(opts, "path");
 
3131
 
 
3132
    if (device == NULL) {
 
3133
        error_setg(errp, "chardev: parallel: no device path given");
 
3134
        return;
 
3135
    }
 
3136
    backend->parallel = g_new0(ChardevHostdev, 1);
 
3137
    backend->parallel->device = g_strdup(device);
 
3138
}
 
3139
 
 
3140
static void qemu_chr_parse_pipe(QemuOpts *opts, ChardevBackend *backend,
 
3141
                                Error **errp)
 
3142
{
 
3143
    const char *device = qemu_opt_get(opts, "path");
 
3144
 
 
3145
    if (device == NULL) {
 
3146
        error_setg(errp, "chardev: pipe: no device path given");
 
3147
        return;
 
3148
    }
 
3149
    backend->pipe = g_new0(ChardevHostdev, 1);
 
3150
    backend->pipe->device = g_strdup(device);
 
3151
}
 
3152
 
 
3153
static void qemu_chr_parse_ringbuf(QemuOpts *opts, ChardevBackend *backend,
 
3154
                                   Error **errp)
 
3155
{
 
3156
    int val;
 
3157
 
 
3158
    backend->ringbuf = g_new0(ChardevRingbuf, 1);
 
3159
 
 
3160
    val = qemu_opt_get_size(opts, "size", 0);
 
3161
    if (val != 0) {
 
3162
        backend->ringbuf->has_size = true;
 
3163
        backend->ringbuf->size = val;
 
3164
    }
 
3165
}
 
3166
 
 
3167
static void qemu_chr_parse_mux(QemuOpts *opts, ChardevBackend *backend,
 
3168
                               Error **errp)
 
3169
{
 
3170
    const char *chardev = qemu_opt_get(opts, "chardev");
 
3171
 
 
3172
    if (chardev == NULL) {
 
3173
        error_setg(errp, "chardev: mux: no chardev given");
 
3174
        return;
 
3175
    }
 
3176
    backend->mux = g_new0(ChardevMux, 1);
 
3177
    backend->mux->chardev = g_strdup(chardev);
 
3178
}
 
3179
 
 
3180
typedef struct CharDriver {
 
3181
    const char *name;
 
3182
    /* old, pre qapi */
 
3183
    CharDriverState *(*open)(QemuOpts *opts);
 
3184
    /* new, qapi-based */
 
3185
    ChardevBackendKind kind;
 
3186
    void (*parse)(QemuOpts *opts, ChardevBackend *backend, Error **errp);
 
3187
} CharDriver;
 
3188
 
 
3189
static GSList *backends;
 
3190
 
 
3191
void register_char_driver(const char *name, CharDriverState *(*open)(QemuOpts *))
 
3192
{
 
3193
    CharDriver *s;
 
3194
 
 
3195
    s = g_malloc0(sizeof(*s));
 
3196
    s->name = g_strdup(name);
 
3197
    s->open = open;
 
3198
 
 
3199
    backends = g_slist_append(backends, s);
 
3200
}
 
3201
 
 
3202
void register_char_driver_qapi(const char *name, ChardevBackendKind kind,
 
3203
        void (*parse)(QemuOpts *opts, ChardevBackend *backend, Error **errp))
 
3204
{
 
3205
    CharDriver *s;
 
3206
 
 
3207
    s = g_malloc0(sizeof(*s));
 
3208
    s->name = g_strdup(name);
 
3209
    s->kind = kind;
 
3210
    s->parse = parse;
 
3211
 
 
3212
    backends = g_slist_append(backends, s);
 
3213
}
 
3214
 
 
3215
CharDriverState *qemu_chr_new_from_opts(QemuOpts *opts,
 
3216
                                    void (*init)(struct CharDriverState *s),
 
3217
                                    Error **errp)
 
3218
{
 
3219
    CharDriver *cd;
 
3220
    CharDriverState *chr;
 
3221
    GSList *i;
 
3222
 
 
3223
    if (qemu_opts_id(opts) == NULL) {
 
3224
        error_setg(errp, "chardev: no id specified");
 
3225
        goto err;
 
3226
    }
 
3227
 
 
3228
    if (qemu_opt_get(opts, "backend") == NULL) {
 
3229
        error_setg(errp, "chardev: \"%s\" missing backend",
 
3230
                   qemu_opts_id(opts));
 
3231
        goto err;
 
3232
    }
 
3233
    for (i = backends; i; i = i->next) {
 
3234
        cd = i->data;
 
3235
 
 
3236
        if (strcmp(cd->name, qemu_opt_get(opts, "backend")) == 0) {
 
3237
            break;
 
3238
        }
 
3239
    }
 
3240
    if (i == NULL) {
 
3241
        error_setg(errp, "chardev: backend \"%s\" not found",
 
3242
                   qemu_opt_get(opts, "backend"));
 
3243
        goto err;
 
3244
    }
 
3245
 
 
3246
    if (!cd->open) {
 
3247
        /* using new, qapi init */
 
3248
        ChardevBackend *backend = g_new0(ChardevBackend, 1);
 
3249
        ChardevReturn *ret = NULL;
 
3250
        const char *id = qemu_opts_id(opts);
 
3251
        char *bid = NULL;
 
3252
 
 
3253
        if (qemu_opt_get_bool(opts, "mux", 0)) {
 
3254
            bid = g_strdup_printf("%s-base", id);
 
3255
        }
 
3256
 
 
3257
        chr = NULL;
 
3258
        backend->kind = cd->kind;
 
3259
        if (cd->parse) {
 
3260
            cd->parse(opts, backend, errp);
 
3261
            if (error_is_set(errp)) {
 
3262
                goto qapi_out;
 
3263
            }
 
3264
        }
 
3265
        ret = qmp_chardev_add(bid ? bid : id, backend, errp);
 
3266
        if (error_is_set(errp)) {
 
3267
            goto qapi_out;
 
3268
        }
 
3269
 
 
3270
        if (bid) {
 
3271
            qapi_free_ChardevBackend(backend);
 
3272
            qapi_free_ChardevReturn(ret);
 
3273
            backend = g_new0(ChardevBackend, 1);
 
3274
            backend->mux = g_new0(ChardevMux, 1);
 
3275
            backend->kind = CHARDEV_BACKEND_KIND_MUX;
 
3276
            backend->mux->chardev = g_strdup(bid);
 
3277
            ret = qmp_chardev_add(id, backend, errp);
 
3278
            assert(!error_is_set(errp));
 
3279
        }
 
3280
 
 
3281
        chr = qemu_chr_find(id);
 
3282
        chr->opts = opts;
 
3283
 
 
3284
    qapi_out:
 
3285
        qapi_free_ChardevBackend(backend);
 
3286
        qapi_free_ChardevReturn(ret);
 
3287
        g_free(bid);
 
3288
        return chr;
 
3289
    }
 
3290
 
 
3291
    chr = cd->open(opts);
 
3292
    if (!chr) {
 
3293
        error_setg(errp, "chardev: opening backend \"%s\" failed",
 
3294
                   qemu_opt_get(opts, "backend"));
 
3295
        goto err;
 
3296
    }
 
3297
 
 
3298
    if (!chr->filename)
 
3299
        chr->filename = g_strdup(qemu_opt_get(opts, "backend"));
 
3300
    chr->init = init;
 
3301
    /* if we didn't create the chardev via qmp_chardev_add, we
 
3302
     * need to send the OPENED event here
 
3303
     */
 
3304
    if (!chr->explicit_be_open) {
 
3305
        qemu_chr_be_event(chr, CHR_EVENT_OPENED);
 
3306
    }
 
3307
    QTAILQ_INSERT_TAIL(&chardevs, chr, next);
 
3308
 
 
3309
    if (qemu_opt_get_bool(opts, "mux", 0)) {
 
3310
        CharDriverState *base = chr;
 
3311
        int len = strlen(qemu_opts_id(opts)) + 6;
 
3312
        base->label = g_malloc(len);
 
3313
        snprintf(base->label, len, "%s-base", qemu_opts_id(opts));
 
3314
        chr = qemu_chr_open_mux(base);
 
3315
        chr->filename = base->filename;
 
3316
        chr->avail_connections = MAX_MUX;
 
3317
        QTAILQ_INSERT_TAIL(&chardevs, chr, next);
 
3318
    } else {
 
3319
        chr->avail_connections = 1;
 
3320
    }
 
3321
    chr->label = g_strdup(qemu_opts_id(opts));
 
3322
    chr->opts = opts;
 
3323
    return chr;
 
3324
 
 
3325
err:
 
3326
    qemu_opts_del(opts);
 
3327
    return NULL;
 
3328
}
 
3329
 
 
3330
CharDriverState *qemu_chr_new(const char *label, const char *filename, void (*init)(struct CharDriverState *s))
 
3331
{
 
3332
    const char *p;
 
3333
    CharDriverState *chr;
 
3334
    QemuOpts *opts;
 
3335
    Error *err = NULL;
 
3336
 
 
3337
    if (strstart(filename, "chardev:", &p)) {
 
3338
        return qemu_chr_find(p);
 
3339
    }
 
3340
 
 
3341
    opts = qemu_chr_parse_compat(label, filename);
 
3342
    if (!opts)
 
3343
        return NULL;
 
3344
 
 
3345
    chr = qemu_chr_new_from_opts(opts, init, &err);
 
3346
    if (error_is_set(&err)) {
 
3347
        fprintf(stderr, "%s\n", error_get_pretty(err));
 
3348
        error_free(err);
 
3349
    }
 
3350
    if (chr && qemu_opt_get_bool(opts, "mux", 0)) {
 
3351
        qemu_chr_fe_claim_no_fail(chr);
 
3352
        monitor_init(chr, MONITOR_USE_READLINE);
 
3353
    }
 
3354
    return chr;
 
3355
}
 
3356
 
 
3357
void qemu_chr_fe_set_echo(struct CharDriverState *chr, bool echo)
 
3358
{
 
3359
    if (chr->chr_set_echo) {
 
3360
        chr->chr_set_echo(chr, echo);
 
3361
    }
 
3362
}
 
3363
 
 
3364
void qemu_chr_fe_set_open(struct CharDriverState *chr, int fe_open)
 
3365
{
 
3366
    if (chr->fe_open == fe_open) {
 
3367
        return;
 
3368
    }
 
3369
    chr->fe_open = fe_open;
 
3370
    if (chr->chr_set_fe_open) {
 
3371
        chr->chr_set_fe_open(chr, fe_open);
 
3372
    }
 
3373
}
 
3374
 
 
3375
int qemu_chr_fe_add_watch(CharDriverState *s, GIOCondition cond,
 
3376
                          GIOFunc func, void *user_data)
 
3377
{
 
3378
    GSource *src;
 
3379
    guint tag;
 
3380
 
 
3381
    if (s->chr_add_watch == NULL) {
 
3382
        return -ENOSYS;
 
3383
    }
 
3384
 
 
3385
    src = s->chr_add_watch(s, cond);
 
3386
    g_source_set_callback(src, (GSourceFunc)func, user_data, NULL);
 
3387
    tag = g_source_attach(src, NULL);
 
3388
    g_source_unref(src);
 
3389
 
 
3390
    return tag;
 
3391
}
 
3392
 
 
3393
int qemu_chr_fe_claim(CharDriverState *s)
 
3394
{
 
3395
    if (s->avail_connections < 1) {
 
3396
        return -1;
 
3397
    }
 
3398
    s->avail_connections--;
 
3399
    return 0;
 
3400
}
 
3401
 
 
3402
void qemu_chr_fe_claim_no_fail(CharDriverState *s)
 
3403
{
 
3404
    if (qemu_chr_fe_claim(s) != 0) {
 
3405
        fprintf(stderr, "%s: error chardev \"%s\" already used\n",
 
3406
                __func__, s->label);
 
3407
        exit(1);
 
3408
    }
 
3409
}
 
3410
 
 
3411
void qemu_chr_fe_release(CharDriverState *s)
 
3412
{
 
3413
    s->avail_connections++;
 
3414
}
 
3415
 
 
3416
void qemu_chr_delete(CharDriverState *chr)
 
3417
{
 
3418
    QTAILQ_REMOVE(&chardevs, chr, next);
 
3419
    if (chr->chr_close) {
 
3420
        chr->chr_close(chr);
 
3421
    }
 
3422
    g_free(chr->filename);
 
3423
    g_free(chr->label);
 
3424
    if (chr->opts) {
 
3425
        qemu_opts_del(chr->opts);
 
3426
    }
 
3427
    g_free(chr);
 
3428
}
 
3429
 
 
3430
ChardevInfoList *qmp_query_chardev(Error **errp)
 
3431
{
 
3432
    ChardevInfoList *chr_list = NULL;
 
3433
    CharDriverState *chr;
 
3434
 
 
3435
    QTAILQ_FOREACH(chr, &chardevs, next) {
 
3436
        ChardevInfoList *info = g_malloc0(sizeof(*info));
 
3437
        info->value = g_malloc0(sizeof(*info->value));
 
3438
        info->value->label = g_strdup(chr->label);
 
3439
        info->value->filename = g_strdup(chr->filename);
 
3440
 
 
3441
        info->next = chr_list;
 
3442
        chr_list = info;
 
3443
    }
 
3444
 
 
3445
    return chr_list;
 
3446
}
 
3447
 
 
3448
CharDriverState *qemu_chr_find(const char *name)
 
3449
{
 
3450
    CharDriverState *chr;
 
3451
 
 
3452
    QTAILQ_FOREACH(chr, &chardevs, next) {
 
3453
        if (strcmp(chr->label, name) != 0)
 
3454
            continue;
 
3455
        return chr;
 
3456
    }
 
3457
    return NULL;
 
3458
}
 
3459
 
 
3460
/* Get a character (serial) device interface.  */
 
3461
CharDriverState *qemu_char_get_next_serial(void)
 
3462
{
 
3463
    static int next_serial;
 
3464
    CharDriverState *chr;
 
3465
 
 
3466
    /* FIXME: This function needs to go away: use chardev properties!  */
 
3467
 
 
3468
    while (next_serial < MAX_SERIAL_PORTS && serial_hds[next_serial]) {
 
3469
        chr = serial_hds[next_serial++];
 
3470
        qemu_chr_fe_claim_no_fail(chr);
 
3471
        return chr;
 
3472
    }
 
3473
    return NULL;
 
3474
}
 
3475
 
 
3476
QemuOptsList qemu_chardev_opts = {
 
3477
    .name = "chardev",
 
3478
    .implied_opt_name = "backend",
 
3479
    .head = QTAILQ_HEAD_INITIALIZER(qemu_chardev_opts.head),
 
3480
    .desc = {
 
3481
        {
 
3482
            .name = "backend",
 
3483
            .type = QEMU_OPT_STRING,
 
3484
        },{
 
3485
            .name = "path",
 
3486
            .type = QEMU_OPT_STRING,
 
3487
        },{
 
3488
            .name = "host",
 
3489
            .type = QEMU_OPT_STRING,
 
3490
        },{
 
3491
            .name = "port",
 
3492
            .type = QEMU_OPT_STRING,
 
3493
        },{
 
3494
            .name = "localaddr",
 
3495
            .type = QEMU_OPT_STRING,
 
3496
        },{
 
3497
            .name = "localport",
 
3498
            .type = QEMU_OPT_STRING,
 
3499
        },{
 
3500
            .name = "to",
 
3501
            .type = QEMU_OPT_NUMBER,
 
3502
        },{
 
3503
            .name = "ipv4",
 
3504
            .type = QEMU_OPT_BOOL,
 
3505
        },{
 
3506
            .name = "ipv6",
 
3507
            .type = QEMU_OPT_BOOL,
 
3508
        },{
 
3509
            .name = "wait",
 
3510
            .type = QEMU_OPT_BOOL,
 
3511
        },{
 
3512
            .name = "server",
 
3513
            .type = QEMU_OPT_BOOL,
 
3514
        },{
 
3515
            .name = "delay",
 
3516
            .type = QEMU_OPT_BOOL,
 
3517
        },{
 
3518
            .name = "telnet",
 
3519
            .type = QEMU_OPT_BOOL,
 
3520
        },{
 
3521
            .name = "width",
 
3522
            .type = QEMU_OPT_NUMBER,
 
3523
        },{
 
3524
            .name = "height",
 
3525
            .type = QEMU_OPT_NUMBER,
 
3526
        },{
 
3527
            .name = "cols",
 
3528
            .type = QEMU_OPT_NUMBER,
 
3529
        },{
 
3530
            .name = "rows",
 
3531
            .type = QEMU_OPT_NUMBER,
 
3532
        },{
 
3533
            .name = "mux",
 
3534
            .type = QEMU_OPT_BOOL,
 
3535
        },{
 
3536
            .name = "signal",
 
3537
            .type = QEMU_OPT_BOOL,
 
3538
        },{
 
3539
            .name = "name",
 
3540
            .type = QEMU_OPT_STRING,
 
3541
        },{
 
3542
            .name = "debug",
 
3543
            .type = QEMU_OPT_NUMBER,
 
3544
        },{
 
3545
            .name = "size",
 
3546
            .type = QEMU_OPT_SIZE,
 
3547
        },{
 
3548
            .name = "chardev",
 
3549
            .type = QEMU_OPT_STRING,
 
3550
        },
 
3551
        { /* end of list */ }
 
3552
    },
 
3553
};
 
3554
 
 
3555
#ifdef _WIN32
 
3556
 
 
3557
static CharDriverState *qmp_chardev_open_file(ChardevFile *file, Error **errp)
 
3558
{
 
3559
    HANDLE out;
 
3560
 
 
3561
    if (file->has_in) {
 
3562
        error_setg(errp, "input file not supported");
 
3563
        return NULL;
 
3564
    }
 
3565
 
 
3566
    out = CreateFile(file->out, GENERIC_WRITE, FILE_SHARE_READ, NULL,
 
3567
                     OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 
3568
    if (out == INVALID_HANDLE_VALUE) {
 
3569
        error_setg(errp, "open %s failed", file->out);
 
3570
        return NULL;
 
3571
    }
 
3572
    return qemu_chr_open_win_file(out);
 
3573
}
 
3574
 
 
3575
static CharDriverState *qmp_chardev_open_serial(ChardevHostdev *serial,
 
3576
                                                Error **errp)
 
3577
{
 
3578
    return qemu_chr_open_win_path(serial->device);
 
3579
}
 
3580
 
 
3581
static CharDriverState *qmp_chardev_open_parallel(ChardevHostdev *parallel,
 
3582
                                                  Error **errp)
 
3583
{
 
3584
    error_setg(errp, "character device backend type 'parallel' not supported");
 
3585
    return NULL;
 
3586
}
 
3587
 
 
3588
#else /* WIN32 */
 
3589
 
 
3590
static int qmp_chardev_open_file_source(char *src, int flags,
 
3591
                                        Error **errp)
 
3592
{
 
3593
    int fd = -1;
 
3594
 
 
3595
    TFR(fd = qemu_open(src, flags, 0666));
 
3596
    if (fd == -1) {
 
3597
        error_setg_file_open(errp, errno, src);
 
3598
    }
 
3599
    return fd;
 
3600
}
 
3601
 
 
3602
static CharDriverState *qmp_chardev_open_file(ChardevFile *file, Error **errp)
 
3603
{
 
3604
    int flags, in = -1, out = -1;
 
3605
 
 
3606
    flags = O_WRONLY | O_TRUNC | O_CREAT | O_BINARY;
 
3607
    out = qmp_chardev_open_file_source(file->out, flags, errp);
 
3608
    if (error_is_set(errp)) {
 
3609
        return NULL;
 
3610
    }
 
3611
 
 
3612
    if (file->has_in) {
 
3613
        flags = O_RDONLY;
 
3614
        in = qmp_chardev_open_file_source(file->in, flags, errp);
 
3615
        if (error_is_set(errp)) {
 
3616
            qemu_close(out);
 
3617
            return NULL;
 
3618
        }
 
3619
    }
 
3620
 
 
3621
    return qemu_chr_open_fd(in, out);
 
3622
}
 
3623
 
 
3624
static CharDriverState *qmp_chardev_open_serial(ChardevHostdev *serial,
 
3625
                                                Error **errp)
 
3626
{
 
3627
#ifdef HAVE_CHARDEV_TTY
 
3628
    int fd;
 
3629
 
 
3630
    fd = qmp_chardev_open_file_source(serial->device, O_RDWR, errp);
 
3631
    if (error_is_set(errp)) {
 
3632
        return NULL;
 
3633
    }
 
3634
    qemu_set_nonblock(fd);
 
3635
    return qemu_chr_open_tty_fd(fd);
 
3636
#else
 
3637
    error_setg(errp, "character device backend type 'serial' not supported");
 
3638
    return NULL;
 
3639
#endif
 
3640
}
 
3641
 
 
3642
static CharDriverState *qmp_chardev_open_parallel(ChardevHostdev *parallel,
 
3643
                                                  Error **errp)
 
3644
{
 
3645
#ifdef HAVE_CHARDEV_PARPORT
 
3646
    int fd;
 
3647
 
 
3648
    fd = qmp_chardev_open_file_source(parallel->device, O_RDWR, errp);
 
3649
    if (error_is_set(errp)) {
 
3650
        return NULL;
 
3651
    }
 
3652
    return qemu_chr_open_pp_fd(fd);
 
3653
#else
 
3654
    error_setg(errp, "character device backend type 'parallel' not supported");
 
3655
    return NULL;
 
3656
#endif
 
3657
}
 
3658
 
 
3659
#endif /* WIN32 */
 
3660
 
 
3661
static CharDriverState *qmp_chardev_open_socket(ChardevSocket *sock,
 
3662
                                                Error **errp)
 
3663
{
 
3664
    SocketAddress *addr = sock->addr;
 
3665
    bool do_nodelay     = sock->has_nodelay ? sock->nodelay : false;
 
3666
    bool is_listen      = sock->has_server  ? sock->server  : true;
 
3667
    bool is_telnet      = sock->has_telnet  ? sock->telnet  : false;
 
3668
    bool is_waitconnect = sock->has_wait    ? sock->wait    : false;
 
3669
    int fd;
 
3670
 
 
3671
    if (is_listen) {
 
3672
        fd = socket_listen(addr, errp);
 
3673
    } else {
 
3674
        fd = socket_connect(addr, errp, NULL, NULL);
 
3675
    }
 
3676
    if (error_is_set(errp)) {
 
3677
        return NULL;
 
3678
    }
 
3679
    return qemu_chr_open_socket_fd(fd, do_nodelay, is_listen,
 
3680
                                   is_telnet, is_waitconnect, errp);
 
3681
}
 
3682
 
 
3683
static CharDriverState *qmp_chardev_open_udp(ChardevUdp *udp,
 
3684
                                             Error **errp)
 
3685
{
 
3686
    int fd;
 
3687
 
 
3688
    fd = socket_dgram(udp->remote, udp->local, errp);
 
3689
    if (error_is_set(errp)) {
 
3690
        return NULL;
 
3691
    }
 
3692
    return qemu_chr_open_udp_fd(fd);
 
3693
}
 
3694
 
 
3695
ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend,
 
3696
                               Error **errp)
 
3697
{
 
3698
    ChardevReturn *ret = g_new0(ChardevReturn, 1);
 
3699
    CharDriverState *base, *chr = NULL;
 
3700
 
 
3701
    chr = qemu_chr_find(id);
 
3702
    if (chr) {
 
3703
        error_setg(errp, "Chardev '%s' already exists", id);
 
3704
        g_free(ret);
 
3705
        return NULL;
 
3706
    }
 
3707
 
 
3708
    switch (backend->kind) {
 
3709
    case CHARDEV_BACKEND_KIND_FILE:
 
3710
        chr = qmp_chardev_open_file(backend->file, errp);
 
3711
        break;
 
3712
    case CHARDEV_BACKEND_KIND_SERIAL:
 
3713
        chr = qmp_chardev_open_serial(backend->serial, errp);
 
3714
        break;
 
3715
    case CHARDEV_BACKEND_KIND_PARALLEL:
 
3716
        chr = qmp_chardev_open_parallel(backend->parallel, errp);
 
3717
        break;
 
3718
    case CHARDEV_BACKEND_KIND_PIPE:
 
3719
        chr = qemu_chr_open_pipe(backend->pipe);
 
3720
        break;
 
3721
    case CHARDEV_BACKEND_KIND_SOCKET:
 
3722
        chr = qmp_chardev_open_socket(backend->socket, errp);
 
3723
        break;
 
3724
    case CHARDEV_BACKEND_KIND_UDP:
 
3725
        chr = qmp_chardev_open_udp(backend->udp, errp);
 
3726
        break;
 
3727
#ifdef HAVE_CHARDEV_TTY
 
3728
    case CHARDEV_BACKEND_KIND_PTY:
 
3729
        chr = qemu_chr_open_pty(id, ret);
 
3730
        break;
 
3731
#endif
 
3732
    case CHARDEV_BACKEND_KIND_NULL:
 
3733
        chr = qemu_chr_open_null();
 
3734
        break;
 
3735
    case CHARDEV_BACKEND_KIND_MUX:
 
3736
        base = qemu_chr_find(backend->mux->chardev);
 
3737
        if (base == NULL) {
 
3738
            error_setg(errp, "mux: base chardev %s not found",
 
3739
                       backend->mux->chardev);
 
3740
            break;
 
3741
        }
 
3742
        chr = qemu_chr_open_mux(base);
 
3743
        break;
 
3744
    case CHARDEV_BACKEND_KIND_MSMOUSE:
 
3745
        chr = qemu_chr_open_msmouse();
 
3746
        break;
 
3747
#ifdef CONFIG_BRLAPI
 
3748
    case CHARDEV_BACKEND_KIND_BRAILLE:
 
3749
        chr = chr_baum_init();
 
3750
        break;
 
3751
#endif
 
3752
    case CHARDEV_BACKEND_KIND_STDIO:
 
3753
        chr = qemu_chr_open_stdio(backend->stdio);
 
3754
        break;
 
3755
#ifdef _WIN32
 
3756
    case CHARDEV_BACKEND_KIND_CONSOLE:
 
3757
        chr = qemu_chr_open_win_con();
 
3758
        break;
 
3759
#endif
 
3760
#ifdef CONFIG_SPICE
 
3761
    case CHARDEV_BACKEND_KIND_SPICEVMC:
 
3762
        chr = qemu_chr_open_spice_vmc(backend->spicevmc->type);
 
3763
        break;
 
3764
    case CHARDEV_BACKEND_KIND_SPICEPORT:
 
3765
        chr = qemu_chr_open_spice_port(backend->spiceport->fqdn);
 
3766
        break;
 
3767
#endif
 
3768
    case CHARDEV_BACKEND_KIND_VC:
 
3769
        chr = vc_init(backend->vc);
 
3770
        break;
 
3771
    case CHARDEV_BACKEND_KIND_RINGBUF:
 
3772
    case CHARDEV_BACKEND_KIND_MEMORY:
 
3773
        chr = qemu_chr_open_ringbuf(backend->ringbuf, errp);
 
3774
        break;
 
3775
    default:
 
3776
        error_setg(errp, "unknown chardev backend (%d)", backend->kind);
 
3777
        break;
 
3778
    }
 
3779
 
 
3780
    if (chr == NULL && !error_is_set(errp)) {
 
3781
        error_setg(errp, "Failed to create chardev");
 
3782
    }
 
3783
    if (chr) {
 
3784
        chr->label = g_strdup(id);
 
3785
        chr->avail_connections =
 
3786
            (backend->kind == CHARDEV_BACKEND_KIND_MUX) ? MAX_MUX : 1;
 
3787
        if (!chr->filename) {
 
3788
            chr->filename = g_strdup(ChardevBackendKind_lookup[backend->kind]);
 
3789
        }
 
3790
        if (!chr->explicit_be_open) {
 
3791
            qemu_chr_be_event(chr, CHR_EVENT_OPENED);
 
3792
        }
 
3793
        QTAILQ_INSERT_TAIL(&chardevs, chr, next);
 
3794
        return ret;
 
3795
    } else {
 
3796
        g_free(ret);
 
3797
        return NULL;
 
3798
    }
 
3799
}
 
3800
 
 
3801
void qmp_chardev_remove(const char *id, Error **errp)
 
3802
{
 
3803
    CharDriverState *chr;
 
3804
 
 
3805
    chr = qemu_chr_find(id);
 
3806
    if (NULL == chr) {
 
3807
        error_setg(errp, "Chardev '%s' not found", id);
 
3808
        return;
 
3809
    }
 
3810
    if (chr->chr_can_read || chr->chr_read ||
 
3811
        chr->chr_event || chr->handler_opaque) {
 
3812
        error_setg(errp, "Chardev '%s' is busy", id);
 
3813
        return;
 
3814
    }
 
3815
    qemu_chr_delete(chr);
 
3816
}
 
3817
 
 
3818
static void register_types(void)
 
3819
{
 
3820
    register_char_driver_qapi("null", CHARDEV_BACKEND_KIND_NULL, NULL);
 
3821
    register_char_driver("socket", qemu_chr_open_socket);
 
3822
    register_char_driver("udp", qemu_chr_open_udp);
 
3823
    register_char_driver_qapi("ringbuf", CHARDEV_BACKEND_KIND_RINGBUF,
 
3824
                              qemu_chr_parse_ringbuf);
 
3825
    register_char_driver_qapi("file", CHARDEV_BACKEND_KIND_FILE,
 
3826
                              qemu_chr_parse_file_out);
 
3827
    register_char_driver_qapi("stdio", CHARDEV_BACKEND_KIND_STDIO,
 
3828
                              qemu_chr_parse_stdio);
 
3829
    register_char_driver_qapi("serial", CHARDEV_BACKEND_KIND_SERIAL,
 
3830
                              qemu_chr_parse_serial);
 
3831
    register_char_driver_qapi("tty", CHARDEV_BACKEND_KIND_SERIAL,
 
3832
                              qemu_chr_parse_serial);
 
3833
    register_char_driver_qapi("parallel", CHARDEV_BACKEND_KIND_PARALLEL,
 
3834
                              qemu_chr_parse_parallel);
 
3835
    register_char_driver_qapi("parport", CHARDEV_BACKEND_KIND_PARALLEL,
 
3836
                              qemu_chr_parse_parallel);
 
3837
    register_char_driver_qapi("pty", CHARDEV_BACKEND_KIND_PTY, NULL);
 
3838
    register_char_driver_qapi("console", CHARDEV_BACKEND_KIND_CONSOLE, NULL);
 
3839
    register_char_driver_qapi("pipe", CHARDEV_BACKEND_KIND_PIPE,
 
3840
                              qemu_chr_parse_pipe);
 
3841
    register_char_driver_qapi("mux", CHARDEV_BACKEND_KIND_MUX,
 
3842
                              qemu_chr_parse_mux);
 
3843
    /* Bug-compatibility: */
 
3844
    register_char_driver_qapi("memory", CHARDEV_BACKEND_KIND_MEMORY,
 
3845
                              qemu_chr_parse_ringbuf);
 
3846
    /* this must be done after machine init, since we register FEs with muxes
 
3847
     * as part of realize functions like serial_isa_realizefn when -nographic
 
3848
     * is specified
 
3849
     */
 
3850
    qemu_add_machine_init_done_notifier(&muxes_realize_notify);
 
3851
}
 
3852
 
 
3853
type_init(register_types);