Statistics
| Branch: | Revision:

root / qemu-char.c @ afc535ac

History | View | Annotate | Download (64.8 kB)

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 "net.h"
26
#include "monitor.h"
27
#include "console.h"
28
#include "sysemu.h"
29
#include "qemu-timer.h"
30
#include "qemu-char.h"
31
#include "block.h"
32
#include "hw/usb.h"
33
#include "hw/baum.h"
34
#include "hw/msmouse.h"
35
#include "qemu-objects.h"
36

    
37
#include <unistd.h>
38
#include <fcntl.h>
39
#include <signal.h>
40
#include <time.h>
41
#include <errno.h>
42
#include <sys/time.h>
43
#include <zlib.h>
44

    
45
#ifndef _WIN32
46
#include <sys/times.h>
47
#include <sys/wait.h>
48
#include <termios.h>
49
#include <sys/mman.h>
50
#include <sys/ioctl.h>
51
#include <sys/resource.h>
52
#include <sys/socket.h>
53
#include <netinet/in.h>
54
#include <net/if.h>
55
#include <arpa/inet.h>
56
#include <dirent.h>
57
#include <netdb.h>
58
#include <sys/select.h>
59
#ifdef CONFIG_BSD
60
#include <sys/stat.h>
61
#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
62
#include <libutil.h>
63
#include <dev/ppbus/ppi.h>
64
#include <dev/ppbus/ppbconf.h>
65
#if defined(__GLIBC__)
66
#include <pty.h>
67
#endif
68
#elif defined(__DragonFly__)
69
#include <libutil.h>
70
#include <dev/misc/ppi/ppi.h>
71
#include <bus/ppbus/ppbconf.h>
72
#else
73
#include <util.h>
74
#endif
75
#else
76
#ifdef __linux__
77
#include <pty.h>
78

    
79
#include <linux/ppdev.h>
80
#include <linux/parport.h>
81
#endif
82
#ifdef __sun__
83
#include <sys/stat.h>
84
#include <sys/ethernet.h>
85
#include <sys/sockio.h>
86
#include <netinet/arp.h>
87
#include <netinet/in.h>
88
#include <netinet/in_systm.h>
89
#include <netinet/ip.h>
90
#include <netinet/ip_icmp.h> // must come after ip.h
91
#include <netinet/udp.h>
92
#include <netinet/tcp.h>
93
#include <net/if.h>
94
#include <syslog.h>
95
#include <stropts.h>
96
#endif
97
#endif
98
#endif
99

    
100
#include "qemu_socket.h"
101

    
102
#define READ_BUF_LEN 4096
103

    
104
/***********************************************************/
105
/* character device */
106

    
107
static QTAILQ_HEAD(CharDriverStateHead, CharDriverState) chardevs =
108
    QTAILQ_HEAD_INITIALIZER(chardevs);
109

    
110
static void qemu_chr_event(CharDriverState *s, int event)
111
{
112
    if (!s->chr_event)
113
        return;
114
    s->chr_event(s->handler_opaque, event);
115
}
116

    
117
static void qemu_chr_generic_open_bh(void *opaque)
118
{
119
    CharDriverState *s = opaque;
120
    qemu_chr_event(s, CHR_EVENT_OPENED);
121
    qemu_bh_delete(s->bh);
122
    s->bh = NULL;
123
}
124

    
125
void qemu_chr_generic_open(CharDriverState *s)
126
{
127
    if (s->bh == NULL) {
128
        s->bh = qemu_bh_new(qemu_chr_generic_open_bh, s);
129
        qemu_bh_schedule(s->bh);
130
    }
131
}
132

    
133
int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len)
134
{
135
    return s->chr_write(s, buf, len);
136
}
137

    
138
int qemu_chr_ioctl(CharDriverState *s, int cmd, void *arg)
139
{
140
    if (!s->chr_ioctl)
141
        return -ENOTSUP;
142
    return s->chr_ioctl(s, cmd, arg);
143
}
144

    
145
int qemu_chr_can_read(CharDriverState *s)
146
{
147
    if (!s->chr_can_read)
148
        return 0;
149
    return s->chr_can_read(s->handler_opaque);
150
}
151

    
152
void qemu_chr_read(CharDriverState *s, uint8_t *buf, int len)
153
{
154
    s->chr_read(s->handler_opaque, buf, len);
155
}
156

    
157
int qemu_chr_get_msgfd(CharDriverState *s)
158
{
159
    return s->get_msgfd ? s->get_msgfd(s) : -1;
160
}
161

    
162
void qemu_chr_accept_input(CharDriverState *s)
163
{
164
    if (s->chr_accept_input)
165
        s->chr_accept_input(s);
166
}
167

    
168
void qemu_chr_printf(CharDriverState *s, const char *fmt, ...)
169
{
170
    char buf[READ_BUF_LEN];
171
    va_list ap;
172
    va_start(ap, fmt);
173
    vsnprintf(buf, sizeof(buf), fmt, ap);
174
    qemu_chr_write(s, (uint8_t *)buf, strlen(buf));
175
    va_end(ap);
176
}
177

    
178
void qemu_chr_send_event(CharDriverState *s, int event)
179
{
180
    if (s->chr_send_event)
181
        s->chr_send_event(s, event);
182
}
183

    
184
void qemu_chr_add_handlers(CharDriverState *s,
185
                           IOCanRWHandler *fd_can_read,
186
                           IOReadHandler *fd_read,
187
                           IOEventHandler *fd_event,
188
                           void *opaque)
189
{
190
    s->chr_can_read = fd_can_read;
191
    s->chr_read = fd_read;
192
    s->chr_event = fd_event;
193
    s->handler_opaque = opaque;
194
    if (s->chr_update_read_handler)
195
        s->chr_update_read_handler(s);
196
}
197

    
198
static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
199
{
200
    return len;
201
}
202

    
203
static CharDriverState *qemu_chr_open_null(QemuOpts *opts)
204
{
205
    CharDriverState *chr;
206

    
207
    chr = qemu_mallocz(sizeof(CharDriverState));
208
    chr->chr_write = null_chr_write;
209
    return chr;
210
}
211

    
212
/* MUX driver for serial I/O splitting */
213
#define MAX_MUX 4
214
#define MUX_BUFFER_SIZE 32        /* Must be a power of 2.  */
215
#define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)
216
typedef struct {
217
    IOCanRWHandler *chr_can_read[MAX_MUX];
218
    IOReadHandler *chr_read[MAX_MUX];
219
    IOEventHandler *chr_event[MAX_MUX];
220
    void *ext_opaque[MAX_MUX];
221
    CharDriverState *drv;
222
    int focus;
223
    int mux_cnt;
224
    int term_got_escape;
225
    int max_size;
226
    /* Intermediate input buffer allows to catch escape sequences even if the
227
       currently active device is not accepting any input - but only until it
228
       is full as well. */
229
    unsigned char buffer[MAX_MUX][MUX_BUFFER_SIZE];
230
    int prod[MAX_MUX];
231
    int cons[MAX_MUX];
232
    int timestamps;
233
    int linestart;
234
    int64_t timestamps_start;
235
} MuxDriver;
236

    
237

    
238
static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
239
{
240
    MuxDriver *d = chr->opaque;
241
    int ret;
242
    if (!d->timestamps) {
243
        ret = d->drv->chr_write(d->drv, buf, len);
244
    } else {
245
        int i;
246

    
247
        ret = 0;
248
        for (i = 0; i < len; i++) {
249
            if (d->linestart) {
250
                char buf1[64];
251
                int64_t ti;
252
                int secs;
253

    
254
                ti = qemu_get_clock(rt_clock);
255
                if (d->timestamps_start == -1)
256
                    d->timestamps_start = ti;
257
                ti -= d->timestamps_start;
258
                secs = ti / 1000;
259
                snprintf(buf1, sizeof(buf1),
260
                         "[%02d:%02d:%02d.%03d] ",
261
                         secs / 3600,
262
                         (secs / 60) % 60,
263
                         secs % 60,
264
                         (int)(ti % 1000));
265
                d->drv->chr_write(d->drv, (uint8_t *)buf1, strlen(buf1));
266
                d->linestart = 0;
267
            }
268
            ret += d->drv->chr_write(d->drv, buf+i, 1);
269
            if (buf[i] == '\n') {
270
                d->linestart = 1;
271
            }
272
        }
273
    }
274
    return ret;
275
}
276

    
277
static const char * const mux_help[] = {
278
    "% h    print this help\n\r",
279
    "% x    exit emulator\n\r",
280
    "% s    save disk data back to file (if -snapshot)\n\r",
281
    "% t    toggle console timestamps\n\r"
282
    "% b    send break (magic sysrq)\n\r",
283
    "% c    switch between console and monitor\n\r",
284
    "% %  sends %\n\r",
285
    NULL
286
};
287

    
288
int term_escape_char = 0x01; /* ctrl-a is used for escape */
289
static void mux_print_help(CharDriverState *chr)
290
{
291
    int i, j;
292
    char ebuf[15] = "Escape-Char";
293
    char cbuf[50] = "\n\r";
294

    
295
    if (term_escape_char > 0 && term_escape_char < 26) {
296
        snprintf(cbuf, sizeof(cbuf), "\n\r");
297
        snprintf(ebuf, sizeof(ebuf), "C-%c", term_escape_char - 1 + 'a');
298
    } else {
299
        snprintf(cbuf, sizeof(cbuf),
300
                 "\n\rEscape-Char set to Ascii: 0x%02x\n\r\n\r",
301
                 term_escape_char);
302
    }
303
    chr->chr_write(chr, (uint8_t *)cbuf, strlen(cbuf));
304
    for (i = 0; mux_help[i] != NULL; i++) {
305
        for (j=0; mux_help[i][j] != '\0'; j++) {
306
            if (mux_help[i][j] == '%')
307
                chr->chr_write(chr, (uint8_t *)ebuf, strlen(ebuf));
308
            else
309
                chr->chr_write(chr, (uint8_t *)&mux_help[i][j], 1);
310
        }
311
    }
312
}
313

    
314
static void mux_chr_send_event(MuxDriver *d, int mux_nr, int event)
315
{
316
    if (d->chr_event[mux_nr])
317
        d->chr_event[mux_nr](d->ext_opaque[mux_nr], event);
318
}
319

    
320
static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch)
321
{
322
    if (d->term_got_escape) {
323
        d->term_got_escape = 0;
324
        if (ch == term_escape_char)
325
            goto send_char;
326
        switch(ch) {
327
        case '?':
328
        case 'h':
329
            mux_print_help(chr);
330
            break;
331
        case 'x':
332
            {
333
                 const char *term =  "QEMU: Terminated\n\r";
334
                 chr->chr_write(chr,(uint8_t *)term,strlen(term));
335
                 exit(0);
336
                 break;
337
            }
338
        case 's':
339
            {
340
                DriveInfo *dinfo;
341
                QTAILQ_FOREACH(dinfo, &drives, next) {
342
                    bdrv_commit(dinfo->bdrv);
343
                }
344
            }
345
            break;
346
        case 'b':
347
            qemu_chr_event(chr, CHR_EVENT_BREAK);
348
            break;
349
        case 'c':
350
            /* Switch to the next registered device */
351
            mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_OUT);
352
            d->focus++;
353
            if (d->focus >= d->mux_cnt)
354
                d->focus = 0;
355
            mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_IN);
356
            break;
357
        case 't':
358
            d->timestamps = !d->timestamps;
359
            d->timestamps_start = -1;
360
            d->linestart = 0;
361
            break;
362
        }
363
    } else if (ch == term_escape_char) {
364
        d->term_got_escape = 1;
365
    } else {
366
    send_char:
367
        return 1;
368
    }
369
    return 0;
370
}
371

    
372
static void mux_chr_accept_input(CharDriverState *chr)
373
{
374
    MuxDriver *d = chr->opaque;
375
    int m = d->focus;
376

    
377
    while (d->prod[m] != d->cons[m] &&
378
           d->chr_can_read[m] &&
379
           d->chr_can_read[m](d->ext_opaque[m])) {
380
        d->chr_read[m](d->ext_opaque[m],
381
                       &d->buffer[m][d->cons[m]++ & MUX_BUFFER_MASK], 1);
382
    }
383
}
384

    
385
static int mux_chr_can_read(void *opaque)
386
{
387
    CharDriverState *chr = opaque;
388
    MuxDriver *d = chr->opaque;
389
    int m = d->focus;
390

    
391
    if ((d->prod[m] - d->cons[m]) < MUX_BUFFER_SIZE)
392
        return 1;
393
    if (d->chr_can_read[m])
394
        return d->chr_can_read[m](d->ext_opaque[m]);
395
    return 0;
396
}
397

    
398
static void mux_chr_read(void *opaque, const uint8_t *buf, int size)
399
{
400
    CharDriverState *chr = opaque;
401
    MuxDriver *d = chr->opaque;
402
    int m = d->focus;
403
    int i;
404

    
405
    mux_chr_accept_input (opaque);
406

    
407
    for(i = 0; i < size; i++)
408
        if (mux_proc_byte(chr, d, buf[i])) {
409
            if (d->prod[m] == d->cons[m] &&
410
                d->chr_can_read[m] &&
411
                d->chr_can_read[m](d->ext_opaque[m]))
412
                d->chr_read[m](d->ext_opaque[m], &buf[i], 1);
413
            else
414
                d->buffer[m][d->prod[m]++ & MUX_BUFFER_MASK] = buf[i];
415
        }
416
}
417

    
418
static void mux_chr_event(void *opaque, int event)
419
{
420
    CharDriverState *chr = opaque;
421
    MuxDriver *d = chr->opaque;
422
    int i;
423

    
424
    /* Send the event to all registered listeners */
425
    for (i = 0; i < d->mux_cnt; i++)
426
        mux_chr_send_event(d, i, event);
427
}
428

    
429
static void mux_chr_update_read_handler(CharDriverState *chr)
430
{
431
    MuxDriver *d = chr->opaque;
432

    
433
    if (d->mux_cnt >= MAX_MUX) {
434
        fprintf(stderr, "Cannot add I/O handlers, MUX array is full\n");
435
        return;
436
    }
437
    d->ext_opaque[d->mux_cnt] = chr->handler_opaque;
438
    d->chr_can_read[d->mux_cnt] = chr->chr_can_read;
439
    d->chr_read[d->mux_cnt] = chr->chr_read;
440
    d->chr_event[d->mux_cnt] = chr->chr_event;
441
    /* Fix up the real driver with mux routines */
442
    if (d->mux_cnt == 0) {
443
        qemu_chr_add_handlers(d->drv, mux_chr_can_read, mux_chr_read,
444
                              mux_chr_event, chr);
445
    }
446
    if (d->focus != -1) {
447
        mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_OUT);
448
    }
449
    d->focus = d->mux_cnt;
450
    d->mux_cnt++;
451
    mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_IN);
452
}
453

    
454
static CharDriverState *qemu_chr_open_mux(CharDriverState *drv)
455
{
456
    CharDriverState *chr;
457
    MuxDriver *d;
458

    
459
    chr = qemu_mallocz(sizeof(CharDriverState));
460
    d = qemu_mallocz(sizeof(MuxDriver));
461

    
462
    chr->opaque = d;
463
    d->drv = drv;
464
    d->focus = -1;
465
    chr->chr_write = mux_chr_write;
466
    chr->chr_update_read_handler = mux_chr_update_read_handler;
467
    chr->chr_accept_input = mux_chr_accept_input;
468
    return chr;
469
}
470

    
471

    
472
#ifdef _WIN32
473
int send_all(int fd, const void *buf, int len1)
474
{
475
    int ret, len;
476

    
477
    len = len1;
478
    while (len > 0) {
479
        ret = send(fd, buf, len, 0);
480
        if (ret < 0) {
481
            errno = WSAGetLastError();
482
            if (errno != WSAEWOULDBLOCK) {
483
                return -1;
484
            }
485
        } else if (ret == 0) {
486
            break;
487
        } else {
488
            buf += ret;
489
            len -= ret;
490
        }
491
    }
492
    return len1 - len;
493
}
494

    
495
#else
496

    
497
static int unix_write(int fd, const uint8_t *buf, int len1)
498
{
499
    int ret, len;
500

    
501
    len = len1;
502
    while (len > 0) {
503
        ret = write(fd, buf, len);
504
        if (ret < 0) {
505
            if (errno != EINTR && errno != EAGAIN)
506
                return -1;
507
        } else if (ret == 0) {
508
            break;
509
        } else {
510
            buf += ret;
511
            len -= ret;
512
        }
513
    }
514
    return len1 - len;
515
}
516

    
517
int send_all(int fd, const void *buf, int len1)
518
{
519
    return unix_write(fd, buf, len1);
520
}
521
#endif /* !_WIN32 */
522

    
523
#ifndef _WIN32
524

    
525
typedef struct {
526
    int fd_in, fd_out;
527
    int max_size;
528
} FDCharDriver;
529

    
530
#define STDIO_MAX_CLIENTS 1
531
static int stdio_nb_clients = 0;
532

    
533
static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
534
{
535
    FDCharDriver *s = chr->opaque;
536
    return send_all(s->fd_out, buf, len);
537
}
538

    
539
static int fd_chr_read_poll(void *opaque)
540
{
541
    CharDriverState *chr = opaque;
542
    FDCharDriver *s = chr->opaque;
543

    
544
    s->max_size = qemu_chr_can_read(chr);
545
    return s->max_size;
546
}
547

    
548
static void fd_chr_read(void *opaque)
549
{
550
    CharDriverState *chr = opaque;
551
    FDCharDriver *s = chr->opaque;
552
    int size, len;
553
    uint8_t buf[READ_BUF_LEN];
554

    
555
    len = sizeof(buf);
556
    if (len > s->max_size)
557
        len = s->max_size;
558
    if (len == 0)
559
        return;
560
    size = read(s->fd_in, buf, len);
561
    if (size == 0) {
562
        /* FD has been closed. Remove it from the active list.  */
563
        qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
564
        qemu_chr_event(chr, CHR_EVENT_CLOSED);
565
        return;
566
    }
567
    if (size > 0) {
568
        qemu_chr_read(chr, buf, size);
569
    }
570
}
571

    
572
static void fd_chr_update_read_handler(CharDriverState *chr)
573
{
574
    FDCharDriver *s = chr->opaque;
575

    
576
    if (s->fd_in >= 0) {
577
        if (display_type == DT_NOGRAPHIC && s->fd_in == 0) {
578
        } else {
579
            qemu_set_fd_handler2(s->fd_in, fd_chr_read_poll,
580
                                 fd_chr_read, NULL, chr);
581
        }
582
    }
583
}
584

    
585
static void fd_chr_close(struct CharDriverState *chr)
586
{
587
    FDCharDriver *s = chr->opaque;
588

    
589
    if (s->fd_in >= 0) {
590
        if (display_type == DT_NOGRAPHIC && s->fd_in == 0) {
591
        } else {
592
            qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
593
        }
594
    }
595

    
596
    qemu_free(s);
597
    qemu_chr_event(chr, CHR_EVENT_CLOSED);
598
}
599

    
600
/* open a character device to a unix fd */
601
static CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out)
602
{
603
    CharDriverState *chr;
604
    FDCharDriver *s;
605

    
606
    chr = qemu_mallocz(sizeof(CharDriverState));
607
    s = qemu_mallocz(sizeof(FDCharDriver));
608
    s->fd_in = fd_in;
609
    s->fd_out = fd_out;
610
    chr->opaque = s;
611
    chr->chr_write = fd_chr_write;
612
    chr->chr_update_read_handler = fd_chr_update_read_handler;
613
    chr->chr_close = fd_chr_close;
614

    
615
    qemu_chr_generic_open(chr);
616

    
617
    return chr;
618
}
619

    
620
static CharDriverState *qemu_chr_open_file_out(QemuOpts *opts)
621
{
622
    int fd_out;
623

    
624
    TFR(fd_out = qemu_open(qemu_opt_get(opts, "path"),
625
                      O_WRONLY | O_TRUNC | O_CREAT | O_BINARY, 0666));
626
    if (fd_out < 0)
627
        return NULL;
628
    return qemu_chr_open_fd(-1, fd_out);
629
}
630

    
631
static CharDriverState *qemu_chr_open_pipe(QemuOpts *opts)
632
{
633
    int fd_in, fd_out;
634
    char filename_in[256], filename_out[256];
635
    const char *filename = qemu_opt_get(opts, "path");
636

    
637
    if (filename == NULL) {
638
        fprintf(stderr, "chardev: pipe: no filename given\n");
639
        return NULL;
640
    }
641

    
642
    snprintf(filename_in, 256, "%s.in", filename);
643
    snprintf(filename_out, 256, "%s.out", filename);
644
    TFR(fd_in = qemu_open(filename_in, O_RDWR | O_BINARY));
645
    TFR(fd_out = qemu_open(filename_out, O_RDWR | O_BINARY));
646
    if (fd_in < 0 || fd_out < 0) {
647
        if (fd_in >= 0)
648
            close(fd_in);
649
        if (fd_out >= 0)
650
            close(fd_out);
651
        TFR(fd_in = fd_out = open(filename, O_RDWR | O_BINARY));
652
        if (fd_in < 0)
653
            return NULL;
654
    }
655
    return qemu_chr_open_fd(fd_in, fd_out);
656
}
657

    
658

    
659
/* for STDIO, we handle the case where several clients use it
660
   (nographic mode) */
661

    
662
#define TERM_FIFO_MAX_SIZE 1
663

    
664
static uint8_t term_fifo[TERM_FIFO_MAX_SIZE];
665
static int term_fifo_size;
666

    
667
static int stdio_read_poll(void *opaque)
668
{
669
    CharDriverState *chr = opaque;
670

    
671
    /* try to flush the queue if needed */
672
    if (term_fifo_size != 0 && qemu_chr_can_read(chr) > 0) {
673
        qemu_chr_read(chr, term_fifo, 1);
674
        term_fifo_size = 0;
675
    }
676
    /* see if we can absorb more chars */
677
    if (term_fifo_size == 0)
678
        return 1;
679
    else
680
        return 0;
681
}
682

    
683
static void stdio_read(void *opaque)
684
{
685
    int size;
686
    uint8_t buf[1];
687
    CharDriverState *chr = opaque;
688

    
689
    size = read(0, buf, 1);
690
    if (size == 0) {
691
        /* stdin has been closed. Remove it from the active list.  */
692
        qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
693
        qemu_chr_event(chr, CHR_EVENT_CLOSED);
694
        return;
695
    }
696
    if (size > 0) {
697
        if (qemu_chr_can_read(chr) > 0) {
698
            qemu_chr_read(chr, buf, 1);
699
        } else if (term_fifo_size == 0) {
700
            term_fifo[term_fifo_size++] = buf[0];
701
        }
702
    }
703
}
704

    
705
/* init terminal so that we can grab keys */
706
static struct termios oldtty;
707
static int old_fd0_flags;
708
static int term_atexit_done;
709

    
710
static void term_exit(void)
711
{
712
    tcsetattr (0, TCSANOW, &oldtty);
713
    fcntl(0, F_SETFL, old_fd0_flags);
714
}
715

    
716
static void term_init(QemuOpts *opts)
717
{
718
    struct termios tty;
719

    
720
    tcgetattr (0, &tty);
721
    oldtty = tty;
722
    old_fd0_flags = fcntl(0, F_GETFL);
723

    
724
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
725
                          |INLCR|IGNCR|ICRNL|IXON);
726
    tty.c_oflag |= OPOST;
727
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
728
    /* if graphical mode, we allow Ctrl-C handling */
729
    if (!qemu_opt_get_bool(opts, "signal", display_type != DT_NOGRAPHIC))
730
        tty.c_lflag &= ~ISIG;
731
    tty.c_cflag &= ~(CSIZE|PARENB);
732
    tty.c_cflag |= CS8;
733
    tty.c_cc[VMIN] = 1;
734
    tty.c_cc[VTIME] = 0;
735

    
736
    tcsetattr (0, TCSANOW, &tty);
737

    
738
    if (!term_atexit_done++)
739
        atexit(term_exit);
740

    
741
    fcntl(0, F_SETFL, O_NONBLOCK);
742
}
743

    
744
static void qemu_chr_close_stdio(struct CharDriverState *chr)
745
{
746
    term_exit();
747
    stdio_nb_clients--;
748
    qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
749
    fd_chr_close(chr);
750
}
751

    
752
static CharDriverState *qemu_chr_open_stdio(QemuOpts *opts)
753
{
754
    CharDriverState *chr;
755

    
756
    if (stdio_nb_clients >= STDIO_MAX_CLIENTS)
757
        return NULL;
758
    chr = qemu_chr_open_fd(0, 1);
759
    chr->chr_close = qemu_chr_close_stdio;
760
    qemu_set_fd_handler2(0, stdio_read_poll, stdio_read, NULL, chr);
761
    stdio_nb_clients++;
762
    term_init(opts);
763

    
764
    return chr;
765
}
766

    
767
#ifdef __sun__
768
/* Once Solaris has openpty(), this is going to be removed. */
769
static int openpty(int *amaster, int *aslave, char *name,
770
                   struct termios *termp, struct winsize *winp)
771
{
772
        const char *slave;
773
        int mfd = -1, sfd = -1;
774

    
775
        *amaster = *aslave = -1;
776

    
777
        mfd = open("/dev/ptmx", O_RDWR | O_NOCTTY);
778
        if (mfd < 0)
779
                goto err;
780

    
781
        if (grantpt(mfd) == -1 || unlockpt(mfd) == -1)
782
                goto err;
783

    
784
        if ((slave = ptsname(mfd)) == NULL)
785
                goto err;
786

    
787
        if ((sfd = open(slave, O_RDONLY | O_NOCTTY)) == -1)
788
                goto err;
789

    
790
        if (ioctl(sfd, I_PUSH, "ptem") == -1 ||
791
            (termp != NULL && tcgetattr(sfd, termp) < 0))
792
                goto err;
793

    
794
        if (amaster)
795
                *amaster = mfd;
796
        if (aslave)
797
                *aslave = sfd;
798
        if (winp)
799
                ioctl(sfd, TIOCSWINSZ, winp);
800

    
801
        return 0;
802

    
803
err:
804
        if (sfd != -1)
805
                close(sfd);
806
        close(mfd);
807
        return -1;
808
}
809

    
810
static void cfmakeraw (struct termios *termios_p)
811
{
812
        termios_p->c_iflag &=
813
                ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
814
        termios_p->c_oflag &= ~OPOST;
815
        termios_p->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
816
        termios_p->c_cflag &= ~(CSIZE|PARENB);
817
        termios_p->c_cflag |= CS8;
818

    
819
        termios_p->c_cc[VMIN] = 0;
820
        termios_p->c_cc[VTIME] = 0;
821
}
822
#endif
823

    
824
#if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
825
    || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) \
826
    || defined(__GLIBC__)
827

    
828
typedef struct {
829
    int fd;
830
    int connected;
831
    int polling;
832
    int read_bytes;
833
    QEMUTimer *timer;
834
} PtyCharDriver;
835

    
836
static void pty_chr_update_read_handler(CharDriverState *chr);
837
static void pty_chr_state(CharDriverState *chr, int connected);
838

    
839
static int pty_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
840
{
841
    PtyCharDriver *s = chr->opaque;
842

    
843
    if (!s->connected) {
844
        /* guest sends data, check for (re-)connect */
845
        pty_chr_update_read_handler(chr);
846
        return 0;
847
    }
848
    return send_all(s->fd, buf, len);
849
}
850

    
851
static int pty_chr_read_poll(void *opaque)
852
{
853
    CharDriverState *chr = opaque;
854
    PtyCharDriver *s = chr->opaque;
855

    
856
    s->read_bytes = qemu_chr_can_read(chr);
857
    return s->read_bytes;
858
}
859

    
860
static void pty_chr_read(void *opaque)
861
{
862
    CharDriverState *chr = opaque;
863
    PtyCharDriver *s = chr->opaque;
864
    int size, len;
865
    uint8_t buf[READ_BUF_LEN];
866

    
867
    len = sizeof(buf);
868
    if (len > s->read_bytes)
869
        len = s->read_bytes;
870
    if (len == 0)
871
        return;
872
    size = read(s->fd, buf, len);
873
    if ((size == -1 && errno == EIO) ||
874
        (size == 0)) {
875
        pty_chr_state(chr, 0);
876
        return;
877
    }
878
    if (size > 0) {
879
        pty_chr_state(chr, 1);
880
        qemu_chr_read(chr, buf, size);
881
    }
882
}
883

    
884
static void pty_chr_update_read_handler(CharDriverState *chr)
885
{
886
    PtyCharDriver *s = chr->opaque;
887

    
888
    qemu_set_fd_handler2(s->fd, pty_chr_read_poll,
889
                         pty_chr_read, NULL, chr);
890
    s->polling = 1;
891
    /*
892
     * Short timeout here: just need wait long enougth that qemu makes
893
     * it through the poll loop once.  When reconnected we want a
894
     * short timeout so we notice it almost instantly.  Otherwise
895
     * read() gives us -EIO instantly, making pty_chr_state() reset the
896
     * timeout to the normal (much longer) poll interval before the
897
     * timer triggers.
898
     */
899
    qemu_mod_timer(s->timer, qemu_get_clock(rt_clock) + 10);
900
}
901

    
902
static void pty_chr_state(CharDriverState *chr, int connected)
903
{
904
    PtyCharDriver *s = chr->opaque;
905

    
906
    if (!connected) {
907
        qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
908
        s->connected = 0;
909
        s->polling = 0;
910
        /* (re-)connect poll interval for idle guests: once per second.
911
         * We check more frequently in case the guests sends data to
912
         * the virtual device linked to our pty. */
913
        qemu_mod_timer(s->timer, qemu_get_clock(rt_clock) + 1000);
914
    } else {
915
        if (!s->connected)
916
            qemu_chr_generic_open(chr);
917
        s->connected = 1;
918
    }
919
}
920

    
921
static void pty_chr_timer(void *opaque)
922
{
923
    struct CharDriverState *chr = opaque;
924
    PtyCharDriver *s = chr->opaque;
925

    
926
    if (s->connected)
927
        return;
928
    if (s->polling) {
929
        /* If we arrive here without polling being cleared due
930
         * read returning -EIO, then we are (re-)connected */
931
        pty_chr_state(chr, 1);
932
        return;
933
    }
934

    
935
    /* Next poll ... */
936
    pty_chr_update_read_handler(chr);
937
}
938

    
939
static void pty_chr_close(struct CharDriverState *chr)
940
{
941
    PtyCharDriver *s = chr->opaque;
942

    
943
    qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
944
    close(s->fd);
945
    qemu_del_timer(s->timer);
946
    qemu_free_timer(s->timer);
947
    qemu_free(s);
948
    qemu_chr_event(chr, CHR_EVENT_CLOSED);
949
}
950

    
951
static CharDriverState *qemu_chr_open_pty(QemuOpts *opts)
952
{
953
    CharDriverState *chr;
954
    PtyCharDriver *s;
955
    struct termios tty;
956
    int slave_fd, len;
957
#if defined(__OpenBSD__) || defined(__DragonFly__)
958
    char pty_name[PATH_MAX];
959
#define q_ptsname(x) pty_name
960
#else
961
    char *pty_name = NULL;
962
#define q_ptsname(x) ptsname(x)
963
#endif
964

    
965
    chr = qemu_mallocz(sizeof(CharDriverState));
966
    s = qemu_mallocz(sizeof(PtyCharDriver));
967

    
968
    if (openpty(&s->fd, &slave_fd, pty_name, NULL, NULL) < 0) {
969
        return NULL;
970
    }
971

    
972
    /* Set raw attributes on the pty. */
973
    tcgetattr(slave_fd, &tty);
974
    cfmakeraw(&tty);
975
    tcsetattr(slave_fd, TCSAFLUSH, &tty);
976
    close(slave_fd);
977

    
978
    len = strlen(q_ptsname(s->fd)) + 5;
979
    chr->filename = qemu_malloc(len);
980
    snprintf(chr->filename, len, "pty:%s", q_ptsname(s->fd));
981
    qemu_opt_set(opts, "path", q_ptsname(s->fd));
982
    fprintf(stderr, "char device redirected to %s\n", q_ptsname(s->fd));
983

    
984
    chr->opaque = s;
985
    chr->chr_write = pty_chr_write;
986
    chr->chr_update_read_handler = pty_chr_update_read_handler;
987
    chr->chr_close = pty_chr_close;
988

    
989
    s->timer = qemu_new_timer(rt_clock, pty_chr_timer, chr);
990

    
991
    return chr;
992
}
993

    
994
static void tty_serial_init(int fd, int speed,
995
                            int parity, int data_bits, int stop_bits)
996
{
997
    struct termios tty;
998
    speed_t spd;
999

    
1000
#if 0
1001
    printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
1002
           speed, parity, data_bits, stop_bits);
1003
#endif
1004
    tcgetattr (fd, &tty);
1005

    
1006
#define check_speed(val) if (speed <= val) { spd = B##val; break; }
1007
    speed = speed * 10 / 11;
1008
    do {
1009
        check_speed(50);
1010
        check_speed(75);
1011
        check_speed(110);
1012
        check_speed(134);
1013
        check_speed(150);
1014
        check_speed(200);
1015
        check_speed(300);
1016
        check_speed(600);
1017
        check_speed(1200);
1018
        check_speed(1800);
1019
        check_speed(2400);
1020
        check_speed(4800);
1021
        check_speed(9600);
1022
        check_speed(19200);
1023
        check_speed(38400);
1024
        /* Non-Posix values follow. They may be unsupported on some systems. */
1025
        check_speed(57600);
1026
        check_speed(115200);
1027
#ifdef B230400
1028
        check_speed(230400);
1029
#endif
1030
#ifdef B460800
1031
        check_speed(460800);
1032
#endif
1033
#ifdef B500000
1034
        check_speed(500000);
1035
#endif
1036
#ifdef B576000
1037
        check_speed(576000);
1038
#endif
1039
#ifdef B921600
1040
        check_speed(921600);
1041
#endif
1042
#ifdef B1000000
1043
        check_speed(1000000);
1044
#endif
1045
#ifdef B1152000
1046
        check_speed(1152000);
1047
#endif
1048
#ifdef B1500000
1049
        check_speed(1500000);
1050
#endif
1051
#ifdef B2000000
1052
        check_speed(2000000);
1053
#endif
1054
#ifdef B2500000
1055
        check_speed(2500000);
1056
#endif
1057
#ifdef B3000000
1058
        check_speed(3000000);
1059
#endif
1060
#ifdef B3500000
1061
        check_speed(3500000);
1062
#endif
1063
#ifdef B4000000
1064
        check_speed(4000000);
1065
#endif
1066
        spd = B115200;
1067
    } while (0);
1068

    
1069
    cfsetispeed(&tty, spd);
1070
    cfsetospeed(&tty, spd);
1071

    
1072
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
1073
                          |INLCR|IGNCR|ICRNL|IXON);
1074
    tty.c_oflag |= OPOST;
1075
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN|ISIG);
1076
    tty.c_cflag &= ~(CSIZE|PARENB|PARODD|CRTSCTS|CSTOPB);
1077
    switch(data_bits) {
1078
    default:
1079
    case 8:
1080
        tty.c_cflag |= CS8;
1081
        break;
1082
    case 7:
1083
        tty.c_cflag |= CS7;
1084
        break;
1085
    case 6:
1086
        tty.c_cflag |= CS6;
1087
        break;
1088
    case 5:
1089
        tty.c_cflag |= CS5;
1090
        break;
1091
    }
1092
    switch(parity) {
1093
    default:
1094
    case 'N':
1095
        break;
1096
    case 'E':
1097
        tty.c_cflag |= PARENB;
1098
        break;
1099
    case 'O':
1100
        tty.c_cflag |= PARENB | PARODD;
1101
        break;
1102
    }
1103
    if (stop_bits == 2)
1104
        tty.c_cflag |= CSTOPB;
1105

    
1106
    tcsetattr (fd, TCSANOW, &tty);
1107
}
1108

    
1109
static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)
1110
{
1111
    FDCharDriver *s = chr->opaque;
1112

    
1113
    switch(cmd) {
1114
    case CHR_IOCTL_SERIAL_SET_PARAMS:
1115
        {
1116
            QEMUSerialSetParams *ssp = arg;
1117
            tty_serial_init(s->fd_in, ssp->speed, ssp->parity,
1118
                            ssp->data_bits, ssp->stop_bits);
1119
        }
1120
        break;
1121
    case CHR_IOCTL_SERIAL_SET_BREAK:
1122
        {
1123
            int enable = *(int *)arg;
1124
            if (enable)
1125
                tcsendbreak(s->fd_in, 1);
1126
        }
1127
        break;
1128
    case CHR_IOCTL_SERIAL_GET_TIOCM:
1129
        {
1130
            int sarg = 0;
1131
            int *targ = (int *)arg;
1132
            ioctl(s->fd_in, TIOCMGET, &sarg);
1133
            *targ = 0;
1134
            if (sarg & TIOCM_CTS)
1135
                *targ |= CHR_TIOCM_CTS;
1136
            if (sarg & TIOCM_CAR)
1137
                *targ |= CHR_TIOCM_CAR;
1138
            if (sarg & TIOCM_DSR)
1139
                *targ |= CHR_TIOCM_DSR;
1140
            if (sarg & TIOCM_RI)
1141
                *targ |= CHR_TIOCM_RI;
1142
            if (sarg & TIOCM_DTR)
1143
                *targ |= CHR_TIOCM_DTR;
1144
            if (sarg & TIOCM_RTS)
1145
                *targ |= CHR_TIOCM_RTS;
1146
        }
1147
        break;
1148
    case CHR_IOCTL_SERIAL_SET_TIOCM:
1149
        {
1150
            int sarg = *(int *)arg;
1151
            int targ = 0;
1152
            ioctl(s->fd_in, TIOCMGET, &targ);
1153
            targ &= ~(CHR_TIOCM_CTS | CHR_TIOCM_CAR | CHR_TIOCM_DSR
1154
                     | CHR_TIOCM_RI | CHR_TIOCM_DTR | CHR_TIOCM_RTS);
1155
            if (sarg & CHR_TIOCM_CTS)
1156
                targ |= TIOCM_CTS;
1157
            if (sarg & CHR_TIOCM_CAR)
1158
                targ |= TIOCM_CAR;
1159
            if (sarg & CHR_TIOCM_DSR)
1160
                targ |= TIOCM_DSR;
1161
            if (sarg & CHR_TIOCM_RI)
1162
                targ |= TIOCM_RI;
1163
            if (sarg & CHR_TIOCM_DTR)
1164
                targ |= TIOCM_DTR;
1165
            if (sarg & CHR_TIOCM_RTS)
1166
                targ |= TIOCM_RTS;
1167
            ioctl(s->fd_in, TIOCMSET, &targ);
1168
        }
1169
        break;
1170
    default:
1171
        return -ENOTSUP;
1172
    }
1173
    return 0;
1174
}
1175

    
1176
static CharDriverState *qemu_chr_open_tty(QemuOpts *opts)
1177
{
1178
    const char *filename = qemu_opt_get(opts, "path");
1179
    CharDriverState *chr;
1180
    int fd;
1181

    
1182
    TFR(fd = open(filename, O_RDWR | O_NONBLOCK));
1183
    if (fd < 0) {
1184
        return NULL;
1185
    }
1186
    tty_serial_init(fd, 115200, 'N', 8, 1);
1187
    chr = qemu_chr_open_fd(fd, fd);
1188
    if (!chr) {
1189
        close(fd);
1190
        return NULL;
1191
    }
1192
    chr->chr_ioctl = tty_serial_ioctl;
1193
    return chr;
1194
}
1195
#else  /* ! __linux__ && ! __sun__ */
1196
static CharDriverState *qemu_chr_open_pty(void)
1197
{
1198
    return NULL;
1199
}
1200
#endif /* __linux__ || __sun__ */
1201

    
1202
#if defined(__linux__)
1203
typedef struct {
1204
    int fd;
1205
    int mode;
1206
} ParallelCharDriver;
1207

    
1208
static int pp_hw_mode(ParallelCharDriver *s, uint16_t mode)
1209
{
1210
    if (s->mode != mode) {
1211
        int m = mode;
1212
        if (ioctl(s->fd, PPSETMODE, &m) < 0)
1213
            return 0;
1214
        s->mode = mode;
1215
    }
1216
    return 1;
1217
}
1218

    
1219
static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
1220
{
1221
    ParallelCharDriver *drv = chr->opaque;
1222
    int fd = drv->fd;
1223
    uint8_t b;
1224

    
1225
    switch(cmd) {
1226
    case CHR_IOCTL_PP_READ_DATA:
1227
        if (ioctl(fd, PPRDATA, &b) < 0)
1228
            return -ENOTSUP;
1229
        *(uint8_t *)arg = b;
1230
        break;
1231
    case CHR_IOCTL_PP_WRITE_DATA:
1232
        b = *(uint8_t *)arg;
1233
        if (ioctl(fd, PPWDATA, &b) < 0)
1234
            return -ENOTSUP;
1235
        break;
1236
    case CHR_IOCTL_PP_READ_CONTROL:
1237
        if (ioctl(fd, PPRCONTROL, &b) < 0)
1238
            return -ENOTSUP;
1239
        /* Linux gives only the lowest bits, and no way to know data
1240
           direction! For better compatibility set the fixed upper
1241
           bits. */
1242
        *(uint8_t *)arg = b | 0xc0;
1243
        break;
1244
    case CHR_IOCTL_PP_WRITE_CONTROL:
1245
        b = *(uint8_t *)arg;
1246
        if (ioctl(fd, PPWCONTROL, &b) < 0)
1247
            return -ENOTSUP;
1248
        break;
1249
    case CHR_IOCTL_PP_READ_STATUS:
1250
        if (ioctl(fd, PPRSTATUS, &b) < 0)
1251
            return -ENOTSUP;
1252
        *(uint8_t *)arg = b;
1253
        break;
1254
    case CHR_IOCTL_PP_DATA_DIR:
1255
        if (ioctl(fd, PPDATADIR, (int *)arg) < 0)
1256
            return -ENOTSUP;
1257
        break;
1258
    case CHR_IOCTL_PP_EPP_READ_ADDR:
1259
        if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
1260
            struct ParallelIOArg *parg = arg;
1261
            int n = read(fd, parg->buffer, parg->count);
1262
            if (n != parg->count) {
1263
                return -EIO;
1264
            }
1265
        }
1266
        break;
1267
    case CHR_IOCTL_PP_EPP_READ:
1268
        if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
1269
            struct ParallelIOArg *parg = arg;
1270
            int n = read(fd, parg->buffer, parg->count);
1271
            if (n != parg->count) {
1272
                return -EIO;
1273
            }
1274
        }
1275
        break;
1276
    case CHR_IOCTL_PP_EPP_WRITE_ADDR:
1277
        if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
1278
            struct ParallelIOArg *parg = arg;
1279
            int n = write(fd, parg->buffer, parg->count);
1280
            if (n != parg->count) {
1281
                return -EIO;
1282
            }
1283
        }
1284
        break;
1285
    case CHR_IOCTL_PP_EPP_WRITE:
1286
        if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
1287
            struct ParallelIOArg *parg = arg;
1288
            int n = write(fd, parg->buffer, parg->count);
1289
            if (n != parg->count) {
1290
                return -EIO;
1291
            }
1292
        }
1293
        break;
1294
    default:
1295
        return -ENOTSUP;
1296
    }
1297
    return 0;
1298
}
1299

    
1300
static void pp_close(CharDriverState *chr)
1301
{
1302
    ParallelCharDriver *drv = chr->opaque;
1303
    int fd = drv->fd;
1304

    
1305
    pp_hw_mode(drv, IEEE1284_MODE_COMPAT);
1306
    ioctl(fd, PPRELEASE);
1307
    close(fd);
1308
    qemu_free(drv);
1309
    qemu_chr_event(chr, CHR_EVENT_CLOSED);
1310
}
1311

    
1312
static CharDriverState *qemu_chr_open_pp(QemuOpts *opts)
1313
{
1314
    const char *filename = qemu_opt_get(opts, "path");
1315
    CharDriverState *chr;
1316
    ParallelCharDriver *drv;
1317
    int fd;
1318

    
1319
    TFR(fd = open(filename, O_RDWR));
1320
    if (fd < 0)
1321
        return NULL;
1322

    
1323
    if (ioctl(fd, PPCLAIM) < 0) {
1324
        close(fd);
1325
        return NULL;
1326
    }
1327

    
1328
    drv = qemu_mallocz(sizeof(ParallelCharDriver));
1329
    drv->fd = fd;
1330
    drv->mode = IEEE1284_MODE_COMPAT;
1331

    
1332
    chr = qemu_mallocz(sizeof(CharDriverState));
1333
    chr->chr_write = null_chr_write;
1334
    chr->chr_ioctl = pp_ioctl;
1335
    chr->chr_close = pp_close;
1336
    chr->opaque = drv;
1337

    
1338
    qemu_chr_generic_open(chr);
1339

    
1340
    return chr;
1341
}
1342
#endif /* __linux__ */
1343

    
1344
#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
1345
static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
1346
{
1347
    int fd = (int)chr->opaque;
1348
    uint8_t b;
1349

    
1350
    switch(cmd) {
1351
    case CHR_IOCTL_PP_READ_DATA:
1352
        if (ioctl(fd, PPIGDATA, &b) < 0)
1353
            return -ENOTSUP;
1354
        *(uint8_t *)arg = b;
1355
        break;
1356
    case CHR_IOCTL_PP_WRITE_DATA:
1357
        b = *(uint8_t *)arg;
1358
        if (ioctl(fd, PPISDATA, &b) < 0)
1359
            return -ENOTSUP;
1360
        break;
1361
    case CHR_IOCTL_PP_READ_CONTROL:
1362
        if (ioctl(fd, PPIGCTRL, &b) < 0)
1363
            return -ENOTSUP;
1364
        *(uint8_t *)arg = b;
1365
        break;
1366
    case CHR_IOCTL_PP_WRITE_CONTROL:
1367
        b = *(uint8_t *)arg;
1368
        if (ioctl(fd, PPISCTRL, &b) < 0)
1369
            return -ENOTSUP;
1370
        break;
1371
    case CHR_IOCTL_PP_READ_STATUS:
1372
        if (ioctl(fd, PPIGSTATUS, &b) < 0)
1373
            return -ENOTSUP;
1374
        *(uint8_t *)arg = b;
1375
        break;
1376
    default:
1377
        return -ENOTSUP;
1378
    }
1379
    return 0;
1380
}
1381

    
1382
static CharDriverState *qemu_chr_open_pp(QemuOpts *opts)
1383
{
1384
    const char *filename = qemu_opt_get(opts, "path");
1385
    CharDriverState *chr;
1386
    int fd;
1387

    
1388
    fd = open(filename, O_RDWR);
1389
    if (fd < 0)
1390
        return NULL;
1391

    
1392
    chr = qemu_mallocz(sizeof(CharDriverState));
1393
    chr->opaque = (void *)fd;
1394
    chr->chr_write = null_chr_write;
1395
    chr->chr_ioctl = pp_ioctl;
1396
    return chr;
1397
}
1398
#endif
1399

    
1400
#else /* _WIN32 */
1401

    
1402
typedef struct {
1403
    int max_size;
1404
    HANDLE hcom, hrecv, hsend;
1405
    OVERLAPPED orecv, osend;
1406
    BOOL fpipe;
1407
    DWORD len;
1408
} WinCharState;
1409

    
1410
#define NSENDBUF 2048
1411
#define NRECVBUF 2048
1412
#define MAXCONNECT 1
1413
#define NTIMEOUT 5000
1414

    
1415
static int win_chr_poll(void *opaque);
1416
static int win_chr_pipe_poll(void *opaque);
1417

    
1418
static void win_chr_close(CharDriverState *chr)
1419
{
1420
    WinCharState *s = chr->opaque;
1421

    
1422
    if (s->hsend) {
1423
        CloseHandle(s->hsend);
1424
        s->hsend = NULL;
1425
    }
1426
    if (s->hrecv) {
1427
        CloseHandle(s->hrecv);
1428
        s->hrecv = NULL;
1429
    }
1430
    if (s->hcom) {
1431
        CloseHandle(s->hcom);
1432
        s->hcom = NULL;
1433
    }
1434
    if (s->fpipe)
1435
        qemu_del_polling_cb(win_chr_pipe_poll, chr);
1436
    else
1437
        qemu_del_polling_cb(win_chr_poll, chr);
1438

    
1439
    qemu_chr_event(chr, CHR_EVENT_CLOSED);
1440
}
1441

    
1442
static int win_chr_init(CharDriverState *chr, const char *filename)
1443
{
1444
    WinCharState *s = chr->opaque;
1445
    COMMCONFIG comcfg;
1446
    COMMTIMEOUTS cto = { 0, 0, 0, 0, 0};
1447
    COMSTAT comstat;
1448
    DWORD size;
1449
    DWORD err;
1450

    
1451
    s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
1452
    if (!s->hsend) {
1453
        fprintf(stderr, "Failed CreateEvent\n");
1454
        goto fail;
1455
    }
1456
    s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
1457
    if (!s->hrecv) {
1458
        fprintf(stderr, "Failed CreateEvent\n");
1459
        goto fail;
1460
    }
1461

    
1462
    s->hcom = CreateFile(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL,
1463
                      OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
1464
    if (s->hcom == INVALID_HANDLE_VALUE) {
1465
        fprintf(stderr, "Failed CreateFile (%lu)\n", GetLastError());
1466
        s->hcom = NULL;
1467
        goto fail;
1468
    }
1469

    
1470
    if (!SetupComm(s->hcom, NRECVBUF, NSENDBUF)) {
1471
        fprintf(stderr, "Failed SetupComm\n");
1472
        goto fail;
1473
    }
1474

    
1475
    ZeroMemory(&comcfg, sizeof(COMMCONFIG));
1476
    size = sizeof(COMMCONFIG);
1477
    GetDefaultCommConfig(filename, &comcfg, &size);
1478
    comcfg.dcb.DCBlength = sizeof(DCB);
1479
    CommConfigDialog(filename, NULL, &comcfg);
1480

    
1481
    if (!SetCommState(s->hcom, &comcfg.dcb)) {
1482
        fprintf(stderr, "Failed SetCommState\n");
1483
        goto fail;
1484
    }
1485

    
1486
    if (!SetCommMask(s->hcom, EV_ERR)) {
1487
        fprintf(stderr, "Failed SetCommMask\n");
1488
        goto fail;
1489
    }
1490

    
1491
    cto.ReadIntervalTimeout = MAXDWORD;
1492
    if (!SetCommTimeouts(s->hcom, &cto)) {
1493
        fprintf(stderr, "Failed SetCommTimeouts\n");
1494
        goto fail;
1495
    }
1496

    
1497
    if (!ClearCommError(s->hcom, &err, &comstat)) {
1498
        fprintf(stderr, "Failed ClearCommError\n");
1499
        goto fail;
1500
    }
1501
    qemu_add_polling_cb(win_chr_poll, chr);
1502
    return 0;
1503

    
1504
 fail:
1505
    win_chr_close(chr);
1506
    return -1;
1507
}
1508

    
1509
static int win_chr_write(CharDriverState *chr, const uint8_t *buf, int len1)
1510
{
1511
    WinCharState *s = chr->opaque;
1512
    DWORD len, ret, size, err;
1513

    
1514
    len = len1;
1515
    ZeroMemory(&s->osend, sizeof(s->osend));
1516
    s->osend.hEvent = s->hsend;
1517
    while (len > 0) {
1518
        if (s->hsend)
1519
            ret = WriteFile(s->hcom, buf, len, &size, &s->osend);
1520
        else
1521
            ret = WriteFile(s->hcom, buf, len, &size, NULL);
1522
        if (!ret) {
1523
            err = GetLastError();
1524
            if (err == ERROR_IO_PENDING) {
1525
                ret = GetOverlappedResult(s->hcom, &s->osend, &size, TRUE);
1526
                if (ret) {
1527
                    buf += size;
1528
                    len -= size;
1529
                } else {
1530
                    break;
1531
                }
1532
            } else {
1533
                break;
1534
            }
1535
        } else {
1536
            buf += size;
1537
            len -= size;
1538
        }
1539
    }
1540
    return len1 - len;
1541
}
1542

    
1543
static int win_chr_read_poll(CharDriverState *chr)
1544
{
1545
    WinCharState *s = chr->opaque;
1546

    
1547
    s->max_size = qemu_chr_can_read(chr);
1548
    return s->max_size;
1549
}
1550

    
1551
static void win_chr_readfile(CharDriverState *chr)
1552
{
1553
    WinCharState *s = chr->opaque;
1554
    int ret, err;
1555
    uint8_t buf[READ_BUF_LEN];
1556
    DWORD size;
1557

    
1558
    ZeroMemory(&s->orecv, sizeof(s->orecv));
1559
    s->orecv.hEvent = s->hrecv;
1560
    ret = ReadFile(s->hcom, buf, s->len, &size, &s->orecv);
1561
    if (!ret) {
1562
        err = GetLastError();
1563
        if (err == ERROR_IO_PENDING) {
1564
            ret = GetOverlappedResult(s->hcom, &s->orecv, &size, TRUE);
1565
        }
1566
    }
1567

    
1568
    if (size > 0) {
1569
        qemu_chr_read(chr, buf, size);
1570
    }
1571
}
1572

    
1573
static void win_chr_read(CharDriverState *chr)
1574
{
1575
    WinCharState *s = chr->opaque;
1576

    
1577
    if (s->len > s->max_size)
1578
        s->len = s->max_size;
1579
    if (s->len == 0)
1580
        return;
1581

    
1582
    win_chr_readfile(chr);
1583
}
1584

    
1585
static int win_chr_poll(void *opaque)
1586
{
1587
    CharDriverState *chr = opaque;
1588
    WinCharState *s = chr->opaque;
1589
    COMSTAT status;
1590
    DWORD comerr;
1591

    
1592
    ClearCommError(s->hcom, &comerr, &status);
1593
    if (status.cbInQue > 0) {
1594
        s->len = status.cbInQue;
1595
        win_chr_read_poll(chr);
1596
        win_chr_read(chr);
1597
        return 1;
1598
    }
1599
    return 0;
1600
}
1601

    
1602
static CharDriverState *qemu_chr_open_win(QemuOpts *opts)
1603
{
1604
    const char *filename = qemu_opt_get(opts, "path");
1605
    CharDriverState *chr;
1606
    WinCharState *s;
1607

    
1608
    chr = qemu_mallocz(sizeof(CharDriverState));
1609
    s = qemu_mallocz(sizeof(WinCharState));
1610
    chr->opaque = s;
1611
    chr->chr_write = win_chr_write;
1612
    chr->chr_close = win_chr_close;
1613

    
1614
    if (win_chr_init(chr, filename) < 0) {
1615
        free(s);
1616
        free(chr);
1617
        return NULL;
1618
    }
1619
    qemu_chr_generic_open(chr);
1620
    return chr;
1621
}
1622

    
1623
static int win_chr_pipe_poll(void *opaque)
1624
{
1625
    CharDriverState *chr = opaque;
1626
    WinCharState *s = chr->opaque;
1627
    DWORD size;
1628

    
1629
    PeekNamedPipe(s->hcom, NULL, 0, NULL, &size, NULL);
1630
    if (size > 0) {
1631
        s->len = size;
1632
        win_chr_read_poll(chr);
1633
        win_chr_read(chr);
1634
        return 1;
1635
    }
1636
    return 0;
1637
}
1638

    
1639
static int win_chr_pipe_init(CharDriverState *chr, const char *filename)
1640
{
1641
    WinCharState *s = chr->opaque;
1642
    OVERLAPPED ov;
1643
    int ret;
1644
    DWORD size;
1645
    char openname[256];
1646

    
1647
    s->fpipe = TRUE;
1648

    
1649
    s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
1650
    if (!s->hsend) {
1651
        fprintf(stderr, "Failed CreateEvent\n");
1652
        goto fail;
1653
    }
1654
    s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
1655
    if (!s->hrecv) {
1656
        fprintf(stderr, "Failed CreateEvent\n");
1657
        goto fail;
1658
    }
1659

    
1660
    snprintf(openname, sizeof(openname), "\\\\.\\pipe\\%s", filename);
1661
    s->hcom = CreateNamedPipe(openname, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
1662
                              PIPE_TYPE_BYTE | PIPE_READMODE_BYTE |
1663
                              PIPE_WAIT,
1664
                              MAXCONNECT, NSENDBUF, NRECVBUF, NTIMEOUT, NULL);
1665
    if (s->hcom == INVALID_HANDLE_VALUE) {
1666
        fprintf(stderr, "Failed CreateNamedPipe (%lu)\n", GetLastError());
1667
        s->hcom = NULL;
1668
        goto fail;
1669
    }
1670

    
1671
    ZeroMemory(&ov, sizeof(ov));
1672
    ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
1673
    ret = ConnectNamedPipe(s->hcom, &ov);
1674
    if (ret) {
1675
        fprintf(stderr, "Failed ConnectNamedPipe\n");
1676
        goto fail;
1677
    }
1678

    
1679
    ret = GetOverlappedResult(s->hcom, &ov, &size, TRUE);
1680
    if (!ret) {
1681
        fprintf(stderr, "Failed GetOverlappedResult\n");
1682
        if (ov.hEvent) {
1683
            CloseHandle(ov.hEvent);
1684
            ov.hEvent = NULL;
1685
        }
1686
        goto fail;
1687
    }
1688

    
1689
    if (ov.hEvent) {
1690
        CloseHandle(ov.hEvent);
1691
        ov.hEvent = NULL;
1692
    }
1693
    qemu_add_polling_cb(win_chr_pipe_poll, chr);
1694
    return 0;
1695

    
1696
 fail:
1697
    win_chr_close(chr);
1698
    return -1;
1699
}
1700

    
1701

    
1702
static CharDriverState *qemu_chr_open_win_pipe(QemuOpts *opts)
1703
{
1704
    const char *filename = qemu_opt_get(opts, "path");
1705
    CharDriverState *chr;
1706
    WinCharState *s;
1707

    
1708
    chr = qemu_mallocz(sizeof(CharDriverState));
1709
    s = qemu_mallocz(sizeof(WinCharState));
1710
    chr->opaque = s;
1711
    chr->chr_write = win_chr_write;
1712
    chr->chr_close = win_chr_close;
1713

    
1714
    if (win_chr_pipe_init(chr, filename) < 0) {
1715
        free(s);
1716
        free(chr);
1717
        return NULL;
1718
    }
1719
    qemu_chr_generic_open(chr);
1720
    return chr;
1721
}
1722

    
1723
static CharDriverState *qemu_chr_open_win_file(HANDLE fd_out)
1724
{
1725
    CharDriverState *chr;
1726
    WinCharState *s;
1727

    
1728
    chr = qemu_mallocz(sizeof(CharDriverState));
1729
    s = qemu_mallocz(sizeof(WinCharState));
1730
    s->hcom = fd_out;
1731
    chr->opaque = s;
1732
    chr->chr_write = win_chr_write;
1733
    qemu_chr_generic_open(chr);
1734
    return chr;
1735
}
1736

    
1737
static CharDriverState *qemu_chr_open_win_con(QemuOpts *opts)
1738
{
1739
    return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE));
1740
}
1741

    
1742
static CharDriverState *qemu_chr_open_win_file_out(QemuOpts *opts)
1743
{
1744
    const char *file_out = qemu_opt_get(opts, "path");
1745
    HANDLE fd_out;
1746

    
1747
    fd_out = CreateFile(file_out, GENERIC_WRITE, FILE_SHARE_READ, NULL,
1748
                        OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
1749
    if (fd_out == INVALID_HANDLE_VALUE)
1750
        return NULL;
1751

    
1752
    return qemu_chr_open_win_file(fd_out);
1753
}
1754
#endif /* !_WIN32 */
1755

    
1756
/***********************************************************/
1757
/* UDP Net console */
1758

    
1759
typedef struct {
1760
    int fd;
1761
    uint8_t buf[READ_BUF_LEN];
1762
    int bufcnt;
1763
    int bufptr;
1764
    int max_size;
1765
} NetCharDriver;
1766

    
1767
static int udp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1768
{
1769
    NetCharDriver *s = chr->opaque;
1770

    
1771
    return send(s->fd, (const void *)buf, len, 0);
1772
}
1773

    
1774
static int udp_chr_read_poll(void *opaque)
1775
{
1776
    CharDriverState *chr = opaque;
1777
    NetCharDriver *s = chr->opaque;
1778

    
1779
    s->max_size = qemu_chr_can_read(chr);
1780

    
1781
    /* If there were any stray characters in the queue process them
1782
     * first
1783
     */
1784
    while (s->max_size > 0 && s->bufptr < s->bufcnt) {
1785
        qemu_chr_read(chr, &s->buf[s->bufptr], 1);
1786
        s->bufptr++;
1787
        s->max_size = qemu_chr_can_read(chr);
1788
    }
1789
    return s->max_size;
1790
}
1791

    
1792
static void udp_chr_read(void *opaque)
1793
{
1794
    CharDriverState *chr = opaque;
1795
    NetCharDriver *s = chr->opaque;
1796

    
1797
    if (s->max_size == 0)
1798
        return;
1799
    s->bufcnt = recv(s->fd, (void *)s->buf, sizeof(s->buf), 0);
1800
    s->bufptr = s->bufcnt;
1801
    if (s->bufcnt <= 0)
1802
        return;
1803

    
1804
    s->bufptr = 0;
1805
    while (s->max_size > 0 && s->bufptr < s->bufcnt) {
1806
        qemu_chr_read(chr, &s->buf[s->bufptr], 1);
1807
        s->bufptr++;
1808
        s->max_size = qemu_chr_can_read(chr);
1809
    }
1810
}
1811

    
1812
static void udp_chr_update_read_handler(CharDriverState *chr)
1813
{
1814
    NetCharDriver *s = chr->opaque;
1815

    
1816
    if (s->fd >= 0) {
1817
        qemu_set_fd_handler2(s->fd, udp_chr_read_poll,
1818
                             udp_chr_read, NULL, chr);
1819
    }
1820
}
1821

    
1822
static void udp_chr_close(CharDriverState *chr)
1823
{
1824
    NetCharDriver *s = chr->opaque;
1825
    if (s->fd >= 0) {
1826
        qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
1827
        closesocket(s->fd);
1828
    }
1829
    qemu_free(s);
1830
    qemu_chr_event(chr, CHR_EVENT_CLOSED);
1831
}
1832

    
1833
static CharDriverState *qemu_chr_open_udp(QemuOpts *opts)
1834
{
1835
    CharDriverState *chr = NULL;
1836
    NetCharDriver *s = NULL;
1837
    int fd = -1;
1838

    
1839
    chr = qemu_mallocz(sizeof(CharDriverState));
1840
    s = qemu_mallocz(sizeof(NetCharDriver));
1841

    
1842
    fd = inet_dgram_opts(opts);
1843
    if (fd < 0) {
1844
        fprintf(stderr, "inet_dgram_opts failed\n");
1845
        goto return_err;
1846
    }
1847

    
1848
    s->fd = fd;
1849
    s->bufcnt = 0;
1850
    s->bufptr = 0;
1851
    chr->opaque = s;
1852
    chr->chr_write = udp_chr_write;
1853
    chr->chr_update_read_handler = udp_chr_update_read_handler;
1854
    chr->chr_close = udp_chr_close;
1855
    return chr;
1856

    
1857
return_err:
1858
    if (chr)
1859
        free(chr);
1860
    if (s)
1861
        free(s);
1862
    if (fd >= 0)
1863
        closesocket(fd);
1864
    return NULL;
1865
}
1866

    
1867
/***********************************************************/
1868
/* TCP Net console */
1869

    
1870
typedef struct {
1871
    int fd, listen_fd;
1872
    int connected;
1873
    int max_size;
1874
    int do_telnetopt;
1875
    int do_nodelay;
1876
    int is_unix;
1877
    int msgfd;
1878
} TCPCharDriver;
1879

    
1880
static void tcp_chr_accept(void *opaque);
1881

    
1882
static int tcp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1883
{
1884
    TCPCharDriver *s = chr->opaque;
1885
    if (s->connected) {
1886
        return send_all(s->fd, buf, len);
1887
    } else {
1888
        /* XXX: indicate an error ? */
1889
        return len;
1890
    }
1891
}
1892

    
1893
static int tcp_chr_read_poll(void *opaque)
1894
{
1895
    CharDriverState *chr = opaque;
1896
    TCPCharDriver *s = chr->opaque;
1897
    if (!s->connected)
1898
        return 0;
1899
    s->max_size = qemu_chr_can_read(chr);
1900
    return s->max_size;
1901
}
1902

    
1903
#define IAC 255
1904
#define IAC_BREAK 243
1905
static void tcp_chr_process_IAC_bytes(CharDriverState *chr,
1906
                                      TCPCharDriver *s,
1907
                                      uint8_t *buf, int *size)
1908
{
1909
    /* Handle any telnet client's basic IAC options to satisfy char by
1910
     * char mode with no echo.  All IAC options will be removed from
1911
     * the buf and the do_telnetopt variable will be used to track the
1912
     * state of the width of the IAC information.
1913
     *
1914
     * IAC commands come in sets of 3 bytes with the exception of the
1915
     * "IAC BREAK" command and the double IAC.
1916
     */
1917

    
1918
    int i;
1919
    int j = 0;
1920

    
1921
    for (i = 0; i < *size; i++) {
1922
        if (s->do_telnetopt > 1) {
1923
            if ((unsigned char)buf[i] == IAC && s->do_telnetopt == 2) {
1924
                /* Double IAC means send an IAC */
1925
                if (j != i)
1926
                    buf[j] = buf[i];
1927
                j++;
1928
                s->do_telnetopt = 1;
1929
            } else {
1930
                if ((unsigned char)buf[i] == IAC_BREAK && s->do_telnetopt == 2) {
1931
                    /* Handle IAC break commands by sending a serial break */
1932
                    qemu_chr_event(chr, CHR_EVENT_BREAK);
1933
                    s->do_telnetopt++;
1934
                }
1935
                s->do_telnetopt++;
1936
            }
1937
            if (s->do_telnetopt >= 4) {
1938
                s->do_telnetopt = 1;
1939
            }
1940
        } else {
1941
            if ((unsigned char)buf[i] == IAC) {
1942
                s->do_telnetopt = 2;
1943
            } else {
1944
                if (j != i)
1945
                    buf[j] = buf[i];
1946
                j++;
1947
            }
1948
        }
1949
    }
1950
    *size = j;
1951
}
1952

    
1953
static int tcp_get_msgfd(CharDriverState *chr)
1954
{
1955
    TCPCharDriver *s = chr->opaque;
1956

    
1957
    return s->msgfd;
1958
}
1959

    
1960
#ifndef _WIN32
1961
static void unix_process_msgfd(CharDriverState *chr, struct msghdr *msg)
1962
{
1963
    TCPCharDriver *s = chr->opaque;
1964
    struct cmsghdr *cmsg;
1965

    
1966
    for (cmsg = CMSG_FIRSTHDR(msg); cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) {
1967
        int fd;
1968

    
1969
        if (cmsg->cmsg_len != CMSG_LEN(sizeof(int)) ||
1970
            cmsg->cmsg_level != SOL_SOCKET ||
1971
            cmsg->cmsg_type != SCM_RIGHTS)
1972
            continue;
1973

    
1974
        fd = *((int *)CMSG_DATA(cmsg));
1975
        if (fd < 0)
1976
            continue;
1977

    
1978
        if (s->msgfd != -1)
1979
            close(s->msgfd);
1980
        s->msgfd = fd;
1981
    }
1982
}
1983

    
1984
static ssize_t tcp_chr_recv(CharDriverState *chr, char *buf, size_t len)
1985
{
1986
    TCPCharDriver *s = chr->opaque;
1987
    struct msghdr msg = { NULL, };
1988
    struct iovec iov[1];
1989
    union {
1990
        struct cmsghdr cmsg;
1991
        char control[CMSG_SPACE(sizeof(int))];
1992
    } msg_control;
1993
    ssize_t ret;
1994

    
1995
    iov[0].iov_base = buf;
1996
    iov[0].iov_len = len;
1997

    
1998
    msg.msg_iov = iov;
1999
    msg.msg_iovlen = 1;
2000
    msg.msg_control = &msg_control;
2001
    msg.msg_controllen = sizeof(msg_control);
2002

    
2003
    ret = recvmsg(s->fd, &msg, 0);
2004
    if (ret > 0 && s->is_unix)
2005
        unix_process_msgfd(chr, &msg);
2006

    
2007
    return ret;
2008
}
2009
#else
2010
static ssize_t tcp_chr_recv(CharDriverState *chr, char *buf, size_t len)
2011
{
2012
    TCPCharDriver *s = chr->opaque;
2013
    return recv(s->fd, buf, len, 0);
2014
}
2015
#endif
2016

    
2017
static void tcp_chr_read(void *opaque)
2018
{
2019
    CharDriverState *chr = opaque;
2020
    TCPCharDriver *s = chr->opaque;
2021
    uint8_t buf[READ_BUF_LEN];
2022
    int len, size;
2023

    
2024
    if (!s->connected || s->max_size <= 0)
2025
        return;
2026
    len = sizeof(buf);
2027
    if (len > s->max_size)
2028
        len = s->max_size;
2029
    size = tcp_chr_recv(chr, (void *)buf, len);
2030
    if (size == 0) {
2031
        /* connection closed */
2032
        s->connected = 0;
2033
        if (s->listen_fd >= 0) {
2034
            qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
2035
        }
2036
        qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
2037
        closesocket(s->fd);
2038
        s->fd = -1;
2039
        qemu_chr_event(chr, CHR_EVENT_CLOSED);
2040
    } else if (size > 0) {
2041
        if (s->do_telnetopt)
2042
            tcp_chr_process_IAC_bytes(chr, s, buf, &size);
2043
        if (size > 0)
2044
            qemu_chr_read(chr, buf, size);
2045
        if (s->msgfd != -1) {
2046
            close(s->msgfd);
2047
            s->msgfd = -1;
2048
        }
2049
    }
2050
}
2051

    
2052
static void tcp_chr_connect(void *opaque)
2053
{
2054
    CharDriverState *chr = opaque;
2055
    TCPCharDriver *s = chr->opaque;
2056

    
2057
    s->connected = 1;
2058
    qemu_set_fd_handler2(s->fd, tcp_chr_read_poll,
2059
                         tcp_chr_read, NULL, chr);
2060
    qemu_chr_generic_open(chr);
2061
}
2062

    
2063
#define IACSET(x,a,b,c) x[0] = a; x[1] = b; x[2] = c;
2064
static void tcp_chr_telnet_init(int fd)
2065
{
2066
    char buf[3];
2067
    /* Send the telnet negotion to put telnet in binary, no echo, single char mode */
2068
    IACSET(buf, 0xff, 0xfb, 0x01);  /* IAC WILL ECHO */
2069
    send(fd, (char *)buf, 3, 0);
2070
    IACSET(buf, 0xff, 0xfb, 0x03);  /* IAC WILL Suppress go ahead */
2071
    send(fd, (char *)buf, 3, 0);
2072
    IACSET(buf, 0xff, 0xfb, 0x00);  /* IAC WILL Binary */
2073
    send(fd, (char *)buf, 3, 0);
2074
    IACSET(buf, 0xff, 0xfd, 0x00);  /* IAC DO Binary */
2075
    send(fd, (char *)buf, 3, 0);
2076
}
2077

    
2078
static void socket_set_nodelay(int fd)
2079
{
2080
    int val = 1;
2081
    setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
2082
}
2083

    
2084
static void tcp_chr_accept(void *opaque)
2085
{
2086
    CharDriverState *chr = opaque;
2087
    TCPCharDriver *s = chr->opaque;
2088
    struct sockaddr_in saddr;
2089
#ifndef _WIN32
2090
    struct sockaddr_un uaddr;
2091
#endif
2092
    struct sockaddr *addr;
2093
    socklen_t len;
2094
    int fd;
2095

    
2096
    for(;;) {
2097
#ifndef _WIN32
2098
        if (s->is_unix) {
2099
            len = sizeof(uaddr);
2100
            addr = (struct sockaddr *)&uaddr;
2101
        } else
2102
#endif
2103
        {
2104
            len = sizeof(saddr);
2105
            addr = (struct sockaddr *)&saddr;
2106
        }
2107
        fd = qemu_accept(s->listen_fd, addr, &len);
2108
        if (fd < 0 && errno != EINTR) {
2109
            return;
2110
        } else if (fd >= 0) {
2111
            if (s->do_telnetopt)
2112
                tcp_chr_telnet_init(fd);
2113
            break;
2114
        }
2115
    }
2116
    socket_set_nonblock(fd);
2117
    if (s->do_nodelay)
2118
        socket_set_nodelay(fd);
2119
    s->fd = fd;
2120
    qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
2121
    tcp_chr_connect(chr);
2122
}
2123

    
2124
static void tcp_chr_close(CharDriverState *chr)
2125
{
2126
    TCPCharDriver *s = chr->opaque;
2127
    if (s->fd >= 0) {
2128
        qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
2129
        closesocket(s->fd);
2130
    }
2131
    if (s->listen_fd >= 0) {
2132
        qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
2133
        closesocket(s->listen_fd);
2134
    }
2135
    qemu_free(s);
2136
    qemu_chr_event(chr, CHR_EVENT_CLOSED);
2137
}
2138

    
2139
static CharDriverState *qemu_chr_open_socket(QemuOpts *opts)
2140
{
2141
    CharDriverState *chr = NULL;
2142
    TCPCharDriver *s = NULL;
2143
    int fd = -1;
2144
    int is_listen;
2145
    int is_waitconnect;
2146
    int do_nodelay;
2147
    int is_unix;
2148
    int is_telnet;
2149

    
2150
    is_listen      = qemu_opt_get_bool(opts, "server", 0);
2151
    is_waitconnect = qemu_opt_get_bool(opts, "wait", 1);
2152
    is_telnet      = qemu_opt_get_bool(opts, "telnet", 0);
2153
    do_nodelay     = !qemu_opt_get_bool(opts, "delay", 1);
2154
    is_unix        = qemu_opt_get(opts, "path") != NULL;
2155
    if (!is_listen)
2156
        is_waitconnect = 0;
2157

    
2158
    chr = qemu_mallocz(sizeof(CharDriverState));
2159
    s = qemu_mallocz(sizeof(TCPCharDriver));
2160

    
2161
    if (is_unix) {
2162
        if (is_listen) {
2163
            fd = unix_listen_opts(opts);
2164
        } else {
2165
            fd = unix_connect_opts(opts);
2166
        }
2167
    } else {
2168
        if (is_listen) {
2169
            fd = inet_listen_opts(opts, 0);
2170
        } else {
2171
            fd = inet_connect_opts(opts);
2172
        }
2173
    }
2174
    if (fd < 0)
2175
        goto fail;
2176

    
2177
    if (!is_waitconnect)
2178
        socket_set_nonblock(fd);
2179

    
2180
    s->connected = 0;
2181
    s->fd = -1;
2182
    s->listen_fd = -1;
2183
    s->msgfd = -1;
2184
    s->is_unix = is_unix;
2185
    s->do_nodelay = do_nodelay && !is_unix;
2186

    
2187
    chr->opaque = s;
2188
    chr->chr_write = tcp_chr_write;
2189
    chr->chr_close = tcp_chr_close;
2190
    chr->get_msgfd = tcp_get_msgfd;
2191

    
2192
    if (is_listen) {
2193
        s->listen_fd = fd;
2194
        qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
2195
        if (is_telnet)
2196
            s->do_telnetopt = 1;
2197

    
2198
    } else {
2199
        s->connected = 1;
2200
        s->fd = fd;
2201
        socket_set_nodelay(fd);
2202
        tcp_chr_connect(chr);
2203
    }
2204

    
2205
    /* for "info chardev" monitor command */
2206
    chr->filename = qemu_malloc(256);
2207
    if (is_unix) {
2208
        snprintf(chr->filename, 256, "unix:%s%s",
2209
                 qemu_opt_get(opts, "path"),
2210
                 qemu_opt_get_bool(opts, "server", 0) ? ",server" : "");
2211
    } else if (is_telnet) {
2212
        snprintf(chr->filename, 256, "telnet:%s:%s%s",
2213
                 qemu_opt_get(opts, "host"), qemu_opt_get(opts, "port"),
2214
                 qemu_opt_get_bool(opts, "server", 0) ? ",server" : "");
2215
    } else {
2216
        snprintf(chr->filename, 256, "tcp:%s:%s%s",
2217
                 qemu_opt_get(opts, "host"), qemu_opt_get(opts, "port"),
2218
                 qemu_opt_get_bool(opts, "server", 0) ? ",server" : "");
2219
    }
2220

    
2221
    if (is_listen && is_waitconnect) {
2222
        printf("QEMU waiting for connection on: %s\n",
2223
               chr->filename);
2224
        tcp_chr_accept(chr);
2225
        socket_set_nonblock(s->listen_fd);
2226
    }
2227
    return chr;
2228

    
2229
 fail:
2230
    if (fd >= 0)
2231
        closesocket(fd);
2232
    qemu_free(s);
2233
    qemu_free(chr);
2234
    return NULL;
2235
}
2236

    
2237
QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename)
2238
{
2239
    char host[65], port[33], width[8], height[8];
2240
    int pos;
2241
    const char *p;
2242
    QemuOpts *opts;
2243

    
2244
    opts = qemu_opts_create(&qemu_chardev_opts, label, 1);
2245
    if (NULL == opts)
2246
        return NULL;
2247

    
2248
    if (strstart(filename, "mon:", &p)) {
2249
        filename = p;
2250
        qemu_opt_set(opts, "mux", "on");
2251
    }
2252

    
2253
    if (strcmp(filename, "null")    == 0 ||
2254
        strcmp(filename, "pty")     == 0 ||
2255
        strcmp(filename, "msmouse") == 0 ||
2256
        strcmp(filename, "braille") == 0 ||
2257
        strcmp(filename, "stdio")   == 0) {
2258
        qemu_opt_set(opts, "backend", filename);
2259
        return opts;
2260
    }
2261
    if (strstart(filename, "vc", &p)) {
2262
        qemu_opt_set(opts, "backend", "vc");
2263
        if (*p == ':') {
2264
            if (sscanf(p+1, "%8[0-9]x%8[0-9]", width, height) == 2) {
2265
                /* pixels */
2266
                qemu_opt_set(opts, "width", width);
2267
                qemu_opt_set(opts, "height", height);
2268
            } else if (sscanf(p+1, "%8[0-9]Cx%8[0-9]C", width, height) == 2) {
2269
                /* chars */
2270
                qemu_opt_set(opts, "cols", width);
2271
                qemu_opt_set(opts, "rows", height);
2272
            } else {
2273
                goto fail;
2274
            }
2275
        }
2276
        return opts;
2277
    }
2278
    if (strcmp(filename, "con:") == 0) {
2279
        qemu_opt_set(opts, "backend", "console");
2280
        return opts;
2281
    }
2282
    if (strstart(filename, "COM", NULL)) {
2283
        qemu_opt_set(opts, "backend", "serial");
2284
        qemu_opt_set(opts, "path", filename);
2285
        return opts;
2286
    }
2287
    if (strstart(filename, "file:", &p)) {
2288
        qemu_opt_set(opts, "backend", "file");
2289
        qemu_opt_set(opts, "path", p);
2290
        return opts;
2291
    }
2292
    if (strstart(filename, "pipe:", &p)) {
2293
        qemu_opt_set(opts, "backend", "pipe");
2294
        qemu_opt_set(opts, "path", p);
2295
        return opts;
2296
    }
2297
    if (strstart(filename, "tcp:", &p) ||
2298
        strstart(filename, "telnet:", &p)) {
2299
        if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) {
2300
            host[0] = 0;
2301
            if (sscanf(p, ":%32[^,]%n", port, &pos) < 1)
2302
                goto fail;
2303
        }
2304
        qemu_opt_set(opts, "backend", "socket");
2305
        qemu_opt_set(opts, "host", host);
2306
        qemu_opt_set(opts, "port", port);
2307
        if (p[pos] == ',') {
2308
            if (qemu_opts_do_parse(opts, p+pos+1, NULL) != 0)
2309
                goto fail;
2310
        }
2311
        if (strstart(filename, "telnet:", &p))
2312
            qemu_opt_set(opts, "telnet", "on");
2313
        return opts;
2314
    }
2315
    if (strstart(filename, "udp:", &p)) {
2316
        qemu_opt_set(opts, "backend", "udp");
2317
        if (sscanf(p, "%64[^:]:%32[^@,]%n", host, port, &pos) < 2) {
2318
            host[0] = 0;
2319
            if (sscanf(p, ":%32[^,]%n", port, &pos) < 1) {
2320
                fprintf(stderr, "udp #1\n");
2321
                goto fail;
2322
            }
2323
        }
2324
        qemu_opt_set(opts, "host", host);
2325
        qemu_opt_set(opts, "port", port);
2326
        if (p[pos] == '@') {
2327
            p += pos + 1;
2328
            if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) {
2329
                host[0] = 0;
2330
                if (sscanf(p, ":%32[^,]%n", port, &pos) < 1) {
2331
                    fprintf(stderr, "udp #2\n");
2332
                    goto fail;
2333
                }
2334
            }
2335
            qemu_opt_set(opts, "localaddr", host);
2336
            qemu_opt_set(opts, "localport", port);
2337
        }
2338
        return opts;
2339
    }
2340
    if (strstart(filename, "unix:", &p)) {
2341
        qemu_opt_set(opts, "backend", "socket");
2342
        if (qemu_opts_do_parse(opts, p, "path") != 0)
2343
            goto fail;
2344
        return opts;
2345
    }
2346
    if (strstart(filename, "/dev/parport", NULL) ||
2347
        strstart(filename, "/dev/ppi", NULL)) {
2348
        qemu_opt_set(opts, "backend", "parport");
2349
        qemu_opt_set(opts, "path", filename);
2350
        return opts;
2351
    }
2352
    if (strstart(filename, "/dev/", NULL)) {
2353
        qemu_opt_set(opts, "backend", "tty");
2354
        qemu_opt_set(opts, "path", filename);
2355
        return opts;
2356
    }
2357

    
2358
fail:
2359
    fprintf(stderr, "%s: fail on \"%s\"\n", __FUNCTION__, filename);
2360
    qemu_opts_del(opts);
2361
    return NULL;
2362
}
2363

    
2364
static const struct {
2365
    const char *name;
2366
    CharDriverState *(*open)(QemuOpts *opts);
2367
} backend_table[] = {
2368
    { .name = "null",      .open = qemu_chr_open_null },
2369
    { .name = "socket",    .open = qemu_chr_open_socket },
2370
    { .name = "udp",       .open = qemu_chr_open_udp },
2371
    { .name = "msmouse",   .open = qemu_chr_open_msmouse },
2372
    { .name = "vc",        .open = text_console_init },
2373
#ifdef _WIN32
2374
    { .name = "file",      .open = qemu_chr_open_win_file_out },
2375
    { .name = "pipe",      .open = qemu_chr_open_win_pipe },
2376
    { .name = "console",   .open = qemu_chr_open_win_con },
2377
    { .name = "serial",    .open = qemu_chr_open_win },
2378
#else
2379
    { .name = "file",      .open = qemu_chr_open_file_out },
2380
    { .name = "pipe",      .open = qemu_chr_open_pipe },
2381
    { .name = "pty",       .open = qemu_chr_open_pty },
2382
    { .name = "stdio",     .open = qemu_chr_open_stdio },
2383
#endif
2384
#ifdef CONFIG_BRLAPI
2385
    { .name = "braille",   .open = chr_baum_init },
2386
#endif
2387
#if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
2388
    || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) \
2389
    || defined(__FreeBSD_kernel__)
2390
    { .name = "tty",       .open = qemu_chr_open_tty },
2391
#endif
2392
#if defined(__linux__) || defined(__FreeBSD__) || defined(__DragonFly__) \
2393
    || defined(__FreeBSD_kernel__)
2394
    { .name = "parport",   .open = qemu_chr_open_pp },
2395
#endif
2396
};
2397

    
2398
CharDriverState *qemu_chr_open_opts(QemuOpts *opts,
2399
                                    void (*init)(struct CharDriverState *s))
2400
{
2401
    CharDriverState *chr;
2402
    int i;
2403

    
2404
    if (qemu_opts_id(opts) == NULL) {
2405
        fprintf(stderr, "chardev: no id specified\n");
2406
        return NULL;
2407
    }
2408

    
2409
    for (i = 0; i < ARRAY_SIZE(backend_table); i++) {
2410
        if (strcmp(backend_table[i].name, qemu_opt_get(opts, "backend")) == 0)
2411
            break;
2412
    }
2413
    if (i == ARRAY_SIZE(backend_table)) {
2414
        fprintf(stderr, "chardev: backend \"%s\" not found\n",
2415
                qemu_opt_get(opts, "backend"));
2416
        return NULL;
2417
    }
2418

    
2419
    chr = backend_table[i].open(opts);
2420
    if (!chr) {
2421
        fprintf(stderr, "chardev: opening backend \"%s\" failed\n",
2422
                qemu_opt_get(opts, "backend"));
2423
        return NULL;
2424
    }
2425

    
2426
    if (!chr->filename)
2427
        chr->filename = qemu_strdup(qemu_opt_get(opts, "backend"));
2428
    chr->init = init;
2429
    QTAILQ_INSERT_TAIL(&chardevs, chr, next);
2430

    
2431
    if (qemu_opt_get_bool(opts, "mux", 0)) {
2432
        CharDriverState *base = chr;
2433
        int len = strlen(qemu_opts_id(opts)) + 6;
2434
        base->label = qemu_malloc(len);
2435
        snprintf(base->label, len, "%s-base", qemu_opts_id(opts));
2436
        chr = qemu_chr_open_mux(base);
2437
        chr->filename = base->filename;
2438
        QTAILQ_INSERT_TAIL(&chardevs, chr, next);
2439
    }
2440
    chr->label = qemu_strdup(qemu_opts_id(opts));
2441
    return chr;
2442
}
2443

    
2444
CharDriverState *qemu_chr_open(const char *label, const char *filename, void (*init)(struct CharDriverState *s))
2445
{
2446
    const char *p;
2447
    CharDriverState *chr;
2448
    QemuOpts *opts;
2449

    
2450
    if (strstart(filename, "chardev:", &p)) {
2451
        return qemu_chr_find(p);
2452
    }
2453

    
2454
    opts = qemu_chr_parse_compat(label, filename);
2455
    if (!opts)
2456
        return NULL;
2457

    
2458
    chr = qemu_chr_open_opts(opts, init);
2459
    if (chr && qemu_opt_get_bool(opts, "mux", 0)) {
2460
        monitor_init(chr, MONITOR_USE_READLINE);
2461
    }
2462
    return chr;
2463
}
2464

    
2465
void qemu_chr_close(CharDriverState *chr)
2466
{
2467
    QTAILQ_REMOVE(&chardevs, chr, next);
2468
    if (chr->chr_close)
2469
        chr->chr_close(chr);
2470
    qemu_free(chr->filename);
2471
    qemu_free(chr->label);
2472
    qemu_free(chr);
2473
}
2474

    
2475
static void qemu_chr_qlist_iter(QObject *obj, void *opaque)
2476
{
2477
    QDict *chr_dict;
2478
    Monitor *mon = opaque;
2479

    
2480
    chr_dict = qobject_to_qdict(obj);
2481
    monitor_printf(mon, "%s: filename=%s\n", qdict_get_str(chr_dict, "label"),
2482
                                         qdict_get_str(chr_dict, "filename"));
2483
}
2484

    
2485
void qemu_chr_info_print(Monitor *mon, const QObject *ret_data)
2486
{
2487
    qlist_iter(qobject_to_qlist(ret_data), qemu_chr_qlist_iter, mon);
2488
}
2489

    
2490
/**
2491
 * qemu_chr_info(): Character devices information
2492
 *
2493
 * Each device is represented by a QDict. The returned QObject is a QList
2494
 * of all devices.
2495
 *
2496
 * The QDict contains the following:
2497
 *
2498
 * - "label": device's label
2499
 * - "filename": device's file
2500
 *
2501
 * Example:
2502
 *
2503
 * [ { "label": "monitor", "filename", "stdio" },
2504
 *   { "label": "serial0", "filename": "vc" } ]
2505
 */
2506
void qemu_chr_info(Monitor *mon, QObject **ret_data)
2507
{
2508
    QList *chr_list;
2509
    CharDriverState *chr;
2510

    
2511
    chr_list = qlist_new();
2512

    
2513
    QTAILQ_FOREACH(chr, &chardevs, next) {
2514
        QObject *obj = qobject_from_jsonf("{ 'label': %s, 'filename': %s }",
2515
                                          chr->label, chr->filename);
2516
        qlist_append_obj(chr_list, obj);
2517
    }
2518

    
2519
    *ret_data = QOBJECT(chr_list);
2520
}
2521

    
2522
CharDriverState *qemu_chr_find(const char *name)
2523
{
2524
    CharDriverState *chr;
2525

    
2526
    QTAILQ_FOREACH(chr, &chardevs, next) {
2527
        if (strcmp(chr->label, name) != 0)
2528
            continue;
2529
        return chr;
2530
    }
2531
    return NULL;
2532
}