← Back to branch summary

~vcs-imports/qemu/git

« back to all changes in this revision

Viewing changes to qemu-char.c

  • Committer: aliguori
  • Date: 2008-10-31 18:49:55 UTC
  • Revision ID: git-v1:6f97dba008ec434b742764596d9e28df673cf6c2
Move CharDriverState code out of vl.c

The motivating goal behind this is to allow other tools to use the CharDriver
code.  This patch is pure code motion except for the Makefile changes and the
copyright/header in qemu-char.c.

Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>



git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@5580 c046a42c-6fe2-441c-8c8c-71466251a162

Show diffs side-by-side

added added

removed removed

Lines of Context:
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 "net.h"
 
26
#include "console.h"
 
27
#include "sysemu.h"
 
28
#include "qemu-timer.h"
 
29
#include "qemu-char.h"
 
30
#include "block.h"
 
31
 
 
32
#include <unistd.h>
 
33
#include <fcntl.h>
 
34
#include <signal.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/socket.h>
 
47
#include <netinet/in.h>
 
48
#include <dirent.h>
 
49
#include <netdb.h>
 
50
#include <sys/select.h>
 
51
#include <arpa/inet.h>
 
52
#ifdef _BSD
 
53
#include <sys/stat.h>
 
54
#if !defined(__APPLE__) && !defined(__OpenBSD__)
 
55
#include <libutil.h>
 
56
#endif
 
57
#ifdef __OpenBSD__
 
58
#include <net/if.h>
 
59
#endif
 
60
#elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
 
61
#include <freebsd/stdlib.h>
 
62
#else
 
63
#ifdef __linux__
 
64
#include <linux/if.h>
 
65
#include <pty.h>
 
66
 
 
67
#include <linux/ppdev.h>
 
68
#include <linux/parport.h>
 
69
#endif
 
70
#ifdef __sun__
 
71
#include <sys/stat.h>
 
72
#include <sys/ethernet.h>
 
73
#include <sys/sockio.h>
 
74
#include <netinet/arp.h>
 
75
#include <netinet/in.h>
 
76
#include <netinet/in_systm.h>
 
77
#include <netinet/ip.h>
 
78
#include <netinet/ip_icmp.h> // must come after ip.h
 
79
#include <netinet/udp.h>
 
80
#include <netinet/tcp.h>
 
81
#include <net/if.h>
 
82
#include <syslog.h>
 
83
#include <stropts.h>
 
84
#endif
 
85
#endif
 
86
#endif
 
87
 
 
88
#include "qemu_socket.h"
 
89
 
 
90
/***********************************************************/
 
91
/* character device */
 
92
 
 
93
static void qemu_chr_event(CharDriverState *s, int event)
 
94
{
 
95
    if (!s->chr_event)
 
96
        return;
 
97
    s->chr_event(s->handler_opaque, event);
 
98
}
 
99
 
 
100
static void qemu_chr_reset_bh(void *opaque)
 
101
{
 
102
    CharDriverState *s = opaque;
 
103
    qemu_chr_event(s, CHR_EVENT_RESET);
 
104
    qemu_bh_delete(s->bh);
 
105
    s->bh = NULL;
 
106
}
 
107
 
 
108
void qemu_chr_reset(CharDriverState *s)
 
109
{
 
110
    if (s->bh == NULL) {
 
111
        s->bh = qemu_bh_new(qemu_chr_reset_bh, s);
 
112
        qemu_bh_schedule(s->bh);
 
113
    }
 
114
}
 
115
 
 
116
int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len)
 
117
{
 
118
    return s->chr_write(s, buf, len);
 
119
}
 
120
 
 
121
int qemu_chr_ioctl(CharDriverState *s, int cmd, void *arg)
 
122
{
 
123
    if (!s->chr_ioctl)
 
124
        return -ENOTSUP;
 
125
    return s->chr_ioctl(s, cmd, arg);
 
126
}
 
127
 
 
128
int qemu_chr_can_read(CharDriverState *s)
 
129
{
 
130
    if (!s->chr_can_read)
 
131
        return 0;
 
132
    return s->chr_can_read(s->handler_opaque);
 
133
}
 
134
 
 
135
void qemu_chr_read(CharDriverState *s, uint8_t *buf, int len)
 
136
{
 
137
    s->chr_read(s->handler_opaque, buf, len);
 
138
}
 
139
 
 
140
void qemu_chr_accept_input(CharDriverState *s)
 
141
{
 
142
    if (s->chr_accept_input)
 
143
        s->chr_accept_input(s);
 
144
}
 
145
 
 
146
void qemu_chr_printf(CharDriverState *s, const char *fmt, ...)
 
147
{
 
148
    char buf[4096];
 
149
    va_list ap;
 
150
    va_start(ap, fmt);
 
151
    vsnprintf(buf, sizeof(buf), fmt, ap);
 
152
    qemu_chr_write(s, (uint8_t *)buf, strlen(buf));
 
153
    va_end(ap);
 
154
}
 
155
 
 
156
void qemu_chr_send_event(CharDriverState *s, int event)
 
157
{
 
158
    if (s->chr_send_event)
 
159
        s->chr_send_event(s, event);
 
160
}
 
161
 
 
162
void qemu_chr_add_handlers(CharDriverState *s,
 
163
                           IOCanRWHandler *fd_can_read,
 
164
                           IOReadHandler *fd_read,
 
165
                           IOEventHandler *fd_event,
 
166
                           void *opaque)
 
167
{
 
168
    s->chr_can_read = fd_can_read;
 
169
    s->chr_read = fd_read;
 
170
    s->chr_event = fd_event;
 
171
    s->handler_opaque = opaque;
 
172
    if (s->chr_update_read_handler)
 
173
        s->chr_update_read_handler(s);
 
174
}
 
175
 
 
176
static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
 
177
{
 
178
    return len;
 
179
}
 
180
 
 
181
static CharDriverState *qemu_chr_open_null(void)
 
182
{
 
183
    CharDriverState *chr;
 
184
 
 
185
    chr = qemu_mallocz(sizeof(CharDriverState));
 
186
    if (!chr)
 
187
        return NULL;
 
188
    chr->chr_write = null_chr_write;
 
189
    return chr;
 
190
}
 
191
 
 
192
/* MUX driver for serial I/O splitting */
 
193
static int term_timestamps;
 
194
static int64_t term_timestamps_start;
 
195
#define MAX_MUX 4
 
196
#define MUX_BUFFER_SIZE 32      /* Must be a power of 2.  */
 
197
#define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)
 
198
typedef struct {
 
199
    IOCanRWHandler *chr_can_read[MAX_MUX];
 
200
    IOReadHandler *chr_read[MAX_MUX];
 
201
    IOEventHandler *chr_event[MAX_MUX];
 
202
    void *ext_opaque[MAX_MUX];
 
203
    CharDriverState *drv;
 
204
    unsigned char buffer[MUX_BUFFER_SIZE];
 
205
    int prod;
 
206
    int cons;
 
207
    int mux_cnt;
 
208
    int term_got_escape;
 
209
    int max_size;
 
210
} MuxDriver;
 
211
 
 
212
 
 
213
static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
 
214
{
 
215
    MuxDriver *d = chr->opaque;
 
216
    int ret;
 
217
    if (!term_timestamps) {
 
218
        ret = d->drv->chr_write(d->drv, buf, len);
 
219
    } else {
 
220
        int i;
 
221
 
 
222
        ret = 0;
 
223
        for(i = 0; i < len; i++) {
 
224
            ret += d->drv->chr_write(d->drv, buf+i, 1);
 
225
            if (buf[i] == '\n') {
 
226
                char buf1[64];
 
227
                int64_t ti;
 
228
                int secs;
 
229
 
 
230
                ti = qemu_get_clock(rt_clock);
 
231
                if (term_timestamps_start == -1)
 
232
                    term_timestamps_start = ti;
 
233
                ti -= term_timestamps_start;
 
234
                secs = ti / 1000000000;
 
235
                snprintf(buf1, sizeof(buf1),
 
236
                         "[%02d:%02d:%02d.%03d] ",
 
237
                         secs / 3600,
 
238
                         (secs / 60) % 60,
 
239
                         secs % 60,
 
240
                         (int)((ti / 1000000) % 1000));
 
241
                d->drv->chr_write(d->drv, (uint8_t *)buf1, strlen(buf1));
 
242
            }
 
243
        }
 
244
    }
 
245
    return ret;
 
246
}
 
247
 
 
248
static const char * const mux_help[] = {
 
249
    "% h    print this help\n\r",
 
250
    "% x    exit emulator\n\r",
 
251
    "% s    save disk data back to file (if -snapshot)\n\r",
 
252
    "% t    toggle console timestamps\n\r"
 
253
    "% b    send break (magic sysrq)\n\r",
 
254
    "% c    switch between console and monitor\n\r",
 
255
    "% %  sends %\n\r",
 
256
    NULL
 
257
};
 
258
 
 
259
int term_escape_char = 0x01; /* ctrl-a is used for escape */
 
260
static void mux_print_help(CharDriverState *chr)
 
261
{
 
262
    int i, j;
 
263
    char ebuf[15] = "Escape-Char";
 
264
    char cbuf[50] = "\n\r";
 
265
 
 
266
    if (term_escape_char > 0 && term_escape_char < 26) {
 
267
        snprintf(cbuf, sizeof(cbuf), "\n\r");
 
268
        snprintf(ebuf, sizeof(ebuf), "C-%c", term_escape_char - 1 + 'a');
 
269
    } else {
 
270
        snprintf(cbuf, sizeof(cbuf),
 
271
                 "\n\rEscape-Char set to Ascii: 0x%02x\n\r\n\r",
 
272
                 term_escape_char);
 
273
    }
 
274
    chr->chr_write(chr, (uint8_t *)cbuf, strlen(cbuf));
 
275
    for (i = 0; mux_help[i] != NULL; i++) {
 
276
        for (j=0; mux_help[i][j] != '\0'; j++) {
 
277
            if (mux_help[i][j] == '%')
 
278
                chr->chr_write(chr, (uint8_t *)ebuf, strlen(ebuf));
 
279
            else
 
280
                chr->chr_write(chr, (uint8_t *)&mux_help[i][j], 1);
 
281
        }
 
282
    }
 
283
}
 
284
 
 
285
static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch)
 
286
{
 
287
    if (d->term_got_escape) {
 
288
        d->term_got_escape = 0;
 
289
        if (ch == term_escape_char)
 
290
            goto send_char;
 
291
        switch(ch) {
 
292
        case '?':
 
293
        case 'h':
 
294
            mux_print_help(chr);
 
295
            break;
 
296
        case 'x':
 
297
            {
 
298
                 const char *term =  "QEMU: Terminated\n\r";
 
299
                 chr->chr_write(chr,(uint8_t *)term,strlen(term));
 
300
                 exit(0);
 
301
                 break;
 
302
            }
 
303
        case 's':
 
304
            {
 
305
                int i;
 
306
                for (i = 0; i < nb_drives; i++) {
 
307
                        bdrv_commit(drives_table[i].bdrv);
 
308
                }
 
309
            }
 
310
            break;
 
311
        case 'b':
 
312
            qemu_chr_event(chr, CHR_EVENT_BREAK);
 
313
            break;
 
314
        case 'c':
 
315
            /* Switch to the next registered device */
 
316
            chr->focus++;
 
317
            if (chr->focus >= d->mux_cnt)
 
318
                chr->focus = 0;
 
319
            break;
 
320
       case 't':
 
321
           term_timestamps = !term_timestamps;
 
322
           term_timestamps_start = -1;
 
323
           break;
 
324
        }
 
325
    } else if (ch == term_escape_char) {
 
326
        d->term_got_escape = 1;
 
327
    } else {
 
328
    send_char:
 
329
        return 1;
 
330
    }
 
331
    return 0;
 
332
}
 
333
 
 
334
static void mux_chr_accept_input(CharDriverState *chr)
 
335
{
 
336
    int m = chr->focus;
 
337
    MuxDriver *d = chr->opaque;
 
338
 
 
339
    while (d->prod != d->cons &&
 
340
           d->chr_can_read[m] &&
 
341
           d->chr_can_read[m](d->ext_opaque[m])) {
 
342
        d->chr_read[m](d->ext_opaque[m],
 
343
                       &d->buffer[d->cons++ & MUX_BUFFER_MASK], 1);
 
344
    }
 
345
}
 
346
 
 
347
static int mux_chr_can_read(void *opaque)
 
348
{
 
349
    CharDriverState *chr = opaque;
 
350
    MuxDriver *d = chr->opaque;
 
351
 
 
352
    if ((d->prod - d->cons) < MUX_BUFFER_SIZE)
 
353
        return 1;
 
354
    if (d->chr_can_read[chr->focus])
 
355
        return d->chr_can_read[chr->focus](d->ext_opaque[chr->focus]);
 
356
    return 0;
 
357
}
 
358
 
 
359
static void mux_chr_read(void *opaque, const uint8_t *buf, int size)
 
360
{
 
361
    CharDriverState *chr = opaque;
 
362
    MuxDriver *d = chr->opaque;
 
363
    int m = chr->focus;
 
364
    int i;
 
365
 
 
366
    mux_chr_accept_input (opaque);
 
367
 
 
368
    for(i = 0; i < size; i++)
 
369
        if (mux_proc_byte(chr, d, buf[i])) {
 
370
            if (d->prod == d->cons &&
 
371
                d->chr_can_read[m] &&
 
372
                d->chr_can_read[m](d->ext_opaque[m]))
 
373
                d->chr_read[m](d->ext_opaque[m], &buf[i], 1);
 
374
            else
 
375
                d->buffer[d->prod++ & MUX_BUFFER_MASK] = buf[i];
 
376
        }
 
377
}
 
378
 
 
379
static void mux_chr_event(void *opaque, int event)
 
380
{
 
381
    CharDriverState *chr = opaque;
 
382
    MuxDriver *d = chr->opaque;
 
383
    int i;
 
384
 
 
385
    /* Send the event to all registered listeners */
 
386
    for (i = 0; i < d->mux_cnt; i++)
 
387
        if (d->chr_event[i])
 
388
            d->chr_event[i](d->ext_opaque[i], event);
 
389
}
 
390
 
 
391
static void mux_chr_update_read_handler(CharDriverState *chr)
 
392
{
 
393
    MuxDriver *d = chr->opaque;
 
394
 
 
395
    if (d->mux_cnt >= MAX_MUX) {
 
396
        fprintf(stderr, "Cannot add I/O handlers, MUX array is full\n");
 
397
        return;
 
398
    }
 
399
    d->ext_opaque[d->mux_cnt] = chr->handler_opaque;
 
400
    d->chr_can_read[d->mux_cnt] = chr->chr_can_read;
 
401
    d->chr_read[d->mux_cnt] = chr->chr_read;
 
402
    d->chr_event[d->mux_cnt] = chr->chr_event;
 
403
    /* Fix up the real driver with mux routines */
 
404
    if (d->mux_cnt == 0) {
 
405
        qemu_chr_add_handlers(d->drv, mux_chr_can_read, mux_chr_read,
 
406
                              mux_chr_event, chr);
 
407
    }
 
408
    chr->focus = d->mux_cnt;
 
409
    d->mux_cnt++;
 
410
}
 
411
 
 
412
static CharDriverState *qemu_chr_open_mux(CharDriverState *drv)
 
413
{
 
414
    CharDriverState *chr;
 
415
    MuxDriver *d;
 
416
 
 
417
    chr = qemu_mallocz(sizeof(CharDriverState));
 
418
    if (!chr)
 
419
        return NULL;
 
420
    d = qemu_mallocz(sizeof(MuxDriver));
 
421
    if (!d) {
 
422
        free(chr);
 
423
        return NULL;
 
424
    }
 
425
 
 
426
    chr->opaque = d;
 
427
    d->drv = drv;
 
428
    chr->focus = -1;
 
429
    chr->chr_write = mux_chr_write;
 
430
    chr->chr_update_read_handler = mux_chr_update_read_handler;
 
431
    chr->chr_accept_input = mux_chr_accept_input;
 
432
    return chr;
 
433
}
 
434
 
 
435
 
 
436
#ifdef _WIN32
 
437
int send_all(int fd, const uint8_t *buf, int len1)
 
438
{
 
439
    int ret, len;
 
440
 
 
441
    len = len1;
 
442
    while (len > 0) {
 
443
        ret = send(fd, buf, len, 0);
 
444
        if (ret < 0) {
 
445
            int errno;
 
446
            errno = WSAGetLastError();
 
447
            if (errno != WSAEWOULDBLOCK) {
 
448
                return -1;
 
449
            }
 
450
        } else if (ret == 0) {
 
451
            break;
 
452
        } else {
 
453
            buf += ret;
 
454
            len -= ret;
 
455
        }
 
456
    }
 
457
    return len1 - len;
 
458
}
 
459
 
 
460
#else
 
461
 
 
462
static int unix_write(int fd, const uint8_t *buf, int len1)
 
463
{
 
464
    int ret, len;
 
465
 
 
466
    len = len1;
 
467
    while (len > 0) {
 
468
        ret = write(fd, buf, len);
 
469
        if (ret < 0) {
 
470
            if (errno != EINTR && errno != EAGAIN)
 
471
                return -1;
 
472
        } else if (ret == 0) {
 
473
            break;
 
474
        } else {
 
475
            buf += ret;
 
476
            len -= ret;
 
477
        }
 
478
    }
 
479
    return len1 - len;
 
480
}
 
481
 
 
482
inline int send_all(int fd, const uint8_t *buf, int len1)
 
483
{
 
484
    return unix_write(fd, buf, len1);
 
485
}
 
486
#endif /* !_WIN32 */
 
487
 
 
488
#ifndef _WIN32
 
489
 
 
490
typedef struct {
 
491
    int fd_in, fd_out;
 
492
    int max_size;
 
493
} FDCharDriver;
 
494
 
 
495
#define STDIO_MAX_CLIENTS 1
 
496
static int stdio_nb_clients = 0;
 
497
 
 
498
static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
 
499
{
 
500
    FDCharDriver *s = chr->opaque;
 
501
    return send_all(s->fd_out, buf, len);
 
502
}
 
503
 
 
504
static int fd_chr_read_poll(void *opaque)
 
505
{
 
506
    CharDriverState *chr = opaque;
 
507
    FDCharDriver *s = chr->opaque;
 
508
 
 
509
    s->max_size = qemu_chr_can_read(chr);
 
510
    return s->max_size;
 
511
}
 
512
 
 
513
static void fd_chr_read(void *opaque)
 
514
{
 
515
    CharDriverState *chr = opaque;
 
516
    FDCharDriver *s = chr->opaque;
 
517
    int size, len;
 
518
    uint8_t buf[1024];
 
519
 
 
520
    len = sizeof(buf);
 
521
    if (len > s->max_size)
 
522
        len = s->max_size;
 
523
    if (len == 0)
 
524
        return;
 
525
    size = read(s->fd_in, buf, len);
 
526
    if (size == 0) {
 
527
        /* FD has been closed. Remove it from the active list.  */
 
528
        qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
 
529
        return;
 
530
    }
 
531
    if (size > 0) {
 
532
        qemu_chr_read(chr, buf, size);
 
533
    }
 
534
}
 
535
 
 
536
static void fd_chr_update_read_handler(CharDriverState *chr)
 
537
{
 
538
    FDCharDriver *s = chr->opaque;
 
539
 
 
540
    if (s->fd_in >= 0) {
 
541
        if (nographic && s->fd_in == 0) {
 
542
        } else {
 
543
            qemu_set_fd_handler2(s->fd_in, fd_chr_read_poll,
 
544
                                 fd_chr_read, NULL, chr);
 
545
        }
 
546
    }
 
547
}
 
548
 
 
549
static void fd_chr_close(struct CharDriverState *chr)
 
550
{
 
551
    FDCharDriver *s = chr->opaque;
 
552
 
 
553
    if (s->fd_in >= 0) {
 
554
        if (nographic && s->fd_in == 0) {
 
555
        } else {
 
556
            qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
 
557
        }
 
558
    }
 
559
 
 
560
    qemu_free(s);
 
561
}
 
562
 
 
563
/* open a character device to a unix fd */
 
564
static CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out)
 
565
{
 
566
    CharDriverState *chr;
 
567
    FDCharDriver *s;
 
568
 
 
569
    chr = qemu_mallocz(sizeof(CharDriverState));
 
570
    if (!chr)
 
571
        return NULL;
 
572
    s = qemu_mallocz(sizeof(FDCharDriver));
 
573
    if (!s) {
 
574
        free(chr);
 
575
        return NULL;
 
576
    }
 
577
    s->fd_in = fd_in;
 
578
    s->fd_out = fd_out;
 
579
    chr->opaque = s;
 
580
    chr->chr_write = fd_chr_write;
 
581
    chr->chr_update_read_handler = fd_chr_update_read_handler;
 
582
    chr->chr_close = fd_chr_close;
 
583
 
 
584
    qemu_chr_reset(chr);
 
585
 
 
586
    return chr;
 
587
}
 
588
 
 
589
static CharDriverState *qemu_chr_open_file_out(const char *file_out)
 
590
{
 
591
    int fd_out;
 
592
 
 
593
    TFR(fd_out = open(file_out, O_WRONLY | O_TRUNC | O_CREAT | O_BINARY, 0666));
 
594
    if (fd_out < 0)
 
595
        return NULL;
 
596
    return qemu_chr_open_fd(-1, fd_out);
 
597
}
 
598
 
 
599
static CharDriverState *qemu_chr_open_pipe(const char *filename)
 
600
{
 
601
    int fd_in, fd_out;
 
602
    char filename_in[256], filename_out[256];
 
603
 
 
604
    snprintf(filename_in, 256, "%s.in", filename);
 
605
    snprintf(filename_out, 256, "%s.out", filename);
 
606
    TFR(fd_in = open(filename_in, O_RDWR | O_BINARY));
 
607
    TFR(fd_out = open(filename_out, O_RDWR | O_BINARY));
 
608
    if (fd_in < 0 || fd_out < 0) {
 
609
        if (fd_in >= 0)
 
610
            close(fd_in);
 
611
        if (fd_out >= 0)
 
612
            close(fd_out);
 
613
        TFR(fd_in = fd_out = open(filename, O_RDWR | O_BINARY));
 
614
        if (fd_in < 0)
 
615
            return NULL;
 
616
    }
 
617
    return qemu_chr_open_fd(fd_in, fd_out);
 
618
}
 
619
 
 
620
 
 
621
/* for STDIO, we handle the case where several clients use it
 
622
   (nographic mode) */
 
623
 
 
624
#define TERM_FIFO_MAX_SIZE 1
 
625
 
 
626
static uint8_t term_fifo[TERM_FIFO_MAX_SIZE];
 
627
static int term_fifo_size;
 
628
 
 
629
static int stdio_read_poll(void *opaque)
 
630
{
 
631
    CharDriverState *chr = opaque;
 
632
 
 
633
    /* try to flush the queue if needed */
 
634
    if (term_fifo_size != 0 && qemu_chr_can_read(chr) > 0) {
 
635
        qemu_chr_read(chr, term_fifo, 1);
 
636
        term_fifo_size = 0;
 
637
    }
 
638
    /* see if we can absorb more chars */
 
639
    if (term_fifo_size == 0)
 
640
        return 1;
 
641
    else
 
642
        return 0;
 
643
}
 
644
 
 
645
static void stdio_read(void *opaque)
 
646
{
 
647
    int size;
 
648
    uint8_t buf[1];
 
649
    CharDriverState *chr = opaque;
 
650
 
 
651
    size = read(0, buf, 1);
 
652
    if (size == 0) {
 
653
        /* stdin has been closed. Remove it from the active list.  */
 
654
        qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
 
655
        return;
 
656
    }
 
657
    if (size > 0) {
 
658
        if (qemu_chr_can_read(chr) > 0) {
 
659
            qemu_chr_read(chr, buf, 1);
 
660
        } else if (term_fifo_size == 0) {
 
661
            term_fifo[term_fifo_size++] = buf[0];
 
662
        }
 
663
    }
 
664
}
 
665
 
 
666
/* init terminal so that we can grab keys */
 
667
static struct termios oldtty;
 
668
static int old_fd0_flags;
 
669
static int term_atexit_done;
 
670
 
 
671
static void term_exit(void)
 
672
{
 
673
    tcsetattr (0, TCSANOW, &oldtty);
 
674
    fcntl(0, F_SETFL, old_fd0_flags);
 
675
}
 
676
 
 
677
static void term_init(void)
 
678
{
 
679
    struct termios tty;
 
680
 
 
681
    tcgetattr (0, &tty);
 
682
    oldtty = tty;
 
683
    old_fd0_flags = fcntl(0, F_GETFL);
 
684
 
 
685
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
 
686
                          |INLCR|IGNCR|ICRNL|IXON);
 
687
    tty.c_oflag |= OPOST;
 
688
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
 
689
    /* if graphical mode, we allow Ctrl-C handling */
 
690
    if (nographic)
 
691
        tty.c_lflag &= ~ISIG;
 
692
    tty.c_cflag &= ~(CSIZE|PARENB);
 
693
    tty.c_cflag |= CS8;
 
694
    tty.c_cc[VMIN] = 1;
 
695
    tty.c_cc[VTIME] = 0;
 
696
 
 
697
    tcsetattr (0, TCSANOW, &tty);
 
698
 
 
699
    if (!term_atexit_done++)
 
700
        atexit(term_exit);
 
701
 
 
702
    fcntl(0, F_SETFL, O_NONBLOCK);
 
703
}
 
704
 
 
705
static void qemu_chr_close_stdio(struct CharDriverState *chr)
 
706
{
 
707
    term_exit();
 
708
    stdio_nb_clients--;
 
709
    qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
 
710
    fd_chr_close(chr);
 
711
}
 
712
 
 
713
static CharDriverState *qemu_chr_open_stdio(void)
 
714
{
 
715
    CharDriverState *chr;
 
716
 
 
717
    if (stdio_nb_clients >= STDIO_MAX_CLIENTS)
 
718
        return NULL;
 
719
    chr = qemu_chr_open_fd(0, 1);
 
720
    chr->chr_close = qemu_chr_close_stdio;
 
721
    qemu_set_fd_handler2(0, stdio_read_poll, stdio_read, NULL, chr);
 
722
    stdio_nb_clients++;
 
723
    term_init();
 
724
 
 
725
    return chr;
 
726
}
 
727
 
 
728
#ifdef __sun__
 
729
/* Once Solaris has openpty(), this is going to be removed. */
 
730
int openpty(int *amaster, int *aslave, char *name,
 
731
            struct termios *termp, struct winsize *winp)
 
732
{
 
733
        const char *slave;
 
734
        int mfd = -1, sfd = -1;
 
735
 
 
736
        *amaster = *aslave = -1;
 
737
 
 
738
        mfd = open("/dev/ptmx", O_RDWR | O_NOCTTY);
 
739
        if (mfd < 0)
 
740
                goto err;
 
741
 
 
742
        if (grantpt(mfd) == -1 || unlockpt(mfd) == -1)
 
743
                goto err;
 
744
 
 
745
        if ((slave = ptsname(mfd)) == NULL)
 
746
                goto err;
 
747
 
 
748
        if ((sfd = open(slave, O_RDONLY | O_NOCTTY)) == -1)
 
749
                goto err;
 
750
 
 
751
        if (ioctl(sfd, I_PUSH, "ptem") == -1 ||
 
752
            (termp != NULL && tcgetattr(sfd, termp) < 0))
 
753
                goto err;
 
754
 
 
755
        if (amaster)
 
756
                *amaster = mfd;
 
757
        if (aslave)
 
758
                *aslave = sfd;
 
759
        if (winp)
 
760
                ioctl(sfd, TIOCSWINSZ, winp);
 
761
 
 
762
        return 0;
 
763
 
 
764
err:
 
765
        if (sfd != -1)
 
766
                close(sfd);
 
767
        close(mfd);
 
768
        return -1;
 
769
}
 
770
 
 
771
void cfmakeraw (struct termios *termios_p)
 
772
{
 
773
        termios_p->c_iflag &=
 
774
                ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
 
775
        termios_p->c_oflag &= ~OPOST;
 
776
        termios_p->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
 
777
        termios_p->c_cflag &= ~(CSIZE|PARENB);
 
778
        termios_p->c_cflag |= CS8;
 
779
 
 
780
        termios_p->c_cc[VMIN] = 0;
 
781
        termios_p->c_cc[VTIME] = 0;
 
782
}
 
783
#endif
 
784
 
 
785
#if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
 
786
    || defined(__NetBSD__) || defined(__OpenBSD__)
 
787
 
 
788
typedef struct {
 
789
    int fd;
 
790
    int connected;
 
791
    int polling;
 
792
    int read_bytes;
 
793
    QEMUTimer *timer;
 
794
} PtyCharDriver;
 
795
 
 
796
static void pty_chr_update_read_handler(CharDriverState *chr);
 
797
static void pty_chr_state(CharDriverState *chr, int connected);
 
798
 
 
799
static int pty_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
 
800
{
 
801
    PtyCharDriver *s = chr->opaque;
 
802
 
 
803
    if (!s->connected) {
 
804
        /* guest sends data, check for (re-)connect */
 
805
        pty_chr_update_read_handler(chr);
 
806
        return 0;
 
807
    }
 
808
    return send_all(s->fd, buf, len);
 
809
}
 
810
 
 
811
static int pty_chr_read_poll(void *opaque)
 
812
{
 
813
    CharDriverState *chr = opaque;
 
814
    PtyCharDriver *s = chr->opaque;
 
815
 
 
816
    s->read_bytes = qemu_chr_can_read(chr);
 
817
    return s->read_bytes;
 
818
}
 
819
 
 
820
static void pty_chr_read(void *opaque)
 
821
{
 
822
    CharDriverState *chr = opaque;
 
823
    PtyCharDriver *s = chr->opaque;
 
824
    int size, len;
 
825
    uint8_t buf[1024];
 
826
 
 
827
    len = sizeof(buf);
 
828
    if (len > s->read_bytes)
 
829
        len = s->read_bytes;
 
830
    if (len == 0)
 
831
        return;
 
832
    size = read(s->fd, buf, len);
 
833
    if ((size == -1 && errno == EIO) ||
 
834
        (size == 0)) {
 
835
        pty_chr_state(chr, 0);
 
836
        return;
 
837
    }
 
838
    if (size > 0) {
 
839
        pty_chr_state(chr, 1);
 
840
        qemu_chr_read(chr, buf, size);
 
841
    }
 
842
}
 
843
 
 
844
static void pty_chr_update_read_handler(CharDriverState *chr)
 
845
{
 
846
    PtyCharDriver *s = chr->opaque;
 
847
 
 
848
    qemu_set_fd_handler2(s->fd, pty_chr_read_poll,
 
849
                         pty_chr_read, NULL, chr);
 
850
    s->polling = 1;
 
851
    /*
 
852
     * Short timeout here: just need wait long enougth that qemu makes
 
853
     * it through the poll loop once.  When reconnected we want a
 
854
     * short timeout so we notice it almost instantly.  Otherwise
 
855
     * read() gives us -EIO instantly, making pty_chr_state() reset the
 
856
     * timeout to the normal (much longer) poll interval before the
 
857
     * timer triggers.
 
858
     */
 
859
    qemu_mod_timer(s->timer, qemu_get_clock(rt_clock) + 10);
 
860
}
 
861
 
 
862
static void pty_chr_state(CharDriverState *chr, int connected)
 
863
{
 
864
    PtyCharDriver *s = chr->opaque;
 
865
 
 
866
    if (!connected) {
 
867
        qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
 
868
        s->connected = 0;
 
869
        s->polling = 0;
 
870
        /* (re-)connect poll interval for idle guests: once per second.
 
871
         * We check more frequently in case the guests sends data to
 
872
         * the virtual device linked to our pty. */
 
873
        qemu_mod_timer(s->timer, qemu_get_clock(rt_clock) + 1000);
 
874
    } else {
 
875
        if (!s->connected)
 
876
            qemu_chr_reset(chr);
 
877
        s->connected = 1;
 
878
    }
 
879
}
 
880
 
 
881
static void pty_chr_timer(void *opaque)
 
882
{
 
883
    struct CharDriverState *chr = opaque;
 
884
    PtyCharDriver *s = chr->opaque;
 
885
 
 
886
    if (s->connected)
 
887
        return;
 
888
    if (s->polling) {
 
889
        /* If we arrive here without polling being cleared due
 
890
         * read returning -EIO, then we are (re-)connected */
 
891
        pty_chr_state(chr, 1);
 
892
        return;
 
893
    }
 
894
 
 
895
    /* Next poll ... */
 
896
    pty_chr_update_read_handler(chr);
 
897
}
 
898
 
 
899
static void pty_chr_close(struct CharDriverState *chr)
 
900
{
 
901
    PtyCharDriver *s = chr->opaque;
 
902
 
 
903
    qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
 
904
    close(s->fd);
 
905
    qemu_free(s);
 
906
}
 
907
 
 
908
static CharDriverState *qemu_chr_open_pty(void)
 
909
{
 
910
    CharDriverState *chr;
 
911
    PtyCharDriver *s;
 
912
    struct termios tty;
 
913
    int slave_fd, len;
 
914
#if defined(__OpenBSD__)
 
915
    char pty_name[PATH_MAX];
 
916
#define q_ptsname(x) pty_name
 
917
#else
 
918
    char *pty_name = NULL;
 
919
#define q_ptsname(x) ptsname(x)
 
920
#endif
 
921
 
 
922
    chr = qemu_mallocz(sizeof(CharDriverState));
 
923
    if (!chr)
 
924
        return NULL;
 
925
    s = qemu_mallocz(sizeof(PtyCharDriver));
 
926
    if (!s) {
 
927
        qemu_free(chr);
 
928
        return NULL;
 
929
    }
 
930
 
 
931
    if (openpty(&s->fd, &slave_fd, pty_name, NULL, NULL) < 0) {
 
932
        return NULL;
 
933
    }
 
934
 
 
935
    /* Set raw attributes on the pty. */
 
936
    cfmakeraw(&tty);
 
937
    tcsetattr(slave_fd, TCSAFLUSH, &tty);
 
938
    close(slave_fd);
 
939
 
 
940
    len = strlen(q_ptsname(s->fd)) + 5;
 
941
    chr->filename = qemu_malloc(len);
 
942
    snprintf(chr->filename, len, "pty:%s", q_ptsname(s->fd));
 
943
    fprintf(stderr, "char device redirected to %s\n", q_ptsname(s->fd));
 
944
 
 
945
    chr->opaque = s;
 
946
    chr->chr_write = pty_chr_write;
 
947
    chr->chr_update_read_handler = pty_chr_update_read_handler;
 
948
    chr->chr_close = pty_chr_close;
 
949
 
 
950
    s->timer = qemu_new_timer(rt_clock, pty_chr_timer, chr);
 
951
 
 
952
    return chr;
 
953
}
 
954
 
 
955
static void tty_serial_init(int fd, int speed,
 
956
                            int parity, int data_bits, int stop_bits)
 
957
{
 
958
    struct termios tty;
 
959
    speed_t spd;
 
960
 
 
961
#if 0
 
962
    printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
 
963
           speed, parity, data_bits, stop_bits);
 
964
#endif
 
965
    tcgetattr (fd, &tty);
 
966
 
 
967
#define MARGIN 1.1
 
968
    if (speed <= 50 * MARGIN)
 
969
        spd = B50;
 
970
    else if (speed <= 75 * MARGIN)
 
971
        spd = B75;
 
972
    else if (speed <= 300 * MARGIN)
 
973
        spd = B300;
 
974
    else if (speed <= 600 * MARGIN)
 
975
        spd = B600;
 
976
    else if (speed <= 1200 * MARGIN)
 
977
        spd = B1200;
 
978
    else if (speed <= 2400 * MARGIN)
 
979
        spd = B2400;
 
980
    else if (speed <= 4800 * MARGIN)
 
981
        spd = B4800;
 
982
    else if (speed <= 9600 * MARGIN)
 
983
        spd = B9600;
 
984
    else if (speed <= 19200 * MARGIN)
 
985
        spd = B19200;
 
986
    else if (speed <= 38400 * MARGIN)
 
987
        spd = B38400;
 
988
    else if (speed <= 57600 * MARGIN)
 
989
        spd = B57600;
 
990
    else if (speed <= 115200 * MARGIN)
 
991
        spd = B115200;
 
992
    else
 
993
        spd = B115200;
 
994
 
 
995
    cfsetispeed(&tty, spd);
 
996
    cfsetospeed(&tty, spd);
 
997
 
 
998
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
 
999
                          |INLCR|IGNCR|ICRNL|IXON);
 
1000
    tty.c_oflag |= OPOST;
 
1001
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN|ISIG);
 
1002
    tty.c_cflag &= ~(CSIZE|PARENB|PARODD|CRTSCTS|CSTOPB);
 
1003
    switch(data_bits) {
 
1004
    default:
 
1005
    case 8:
 
1006
        tty.c_cflag |= CS8;
 
1007
        break;
 
1008
    case 7:
 
1009
        tty.c_cflag |= CS7;
 
1010
        break;
 
1011
    case 6:
 
1012
        tty.c_cflag |= CS6;
 
1013
        break;
 
1014
    case 5:
 
1015
        tty.c_cflag |= CS5;
 
1016
        break;
 
1017
    }
 
1018
    switch(parity) {
 
1019
    default:
 
1020
    case 'N':
 
1021
        break;
 
1022
    case 'E':
 
1023
        tty.c_cflag |= PARENB;
 
1024
        break;
 
1025
    case 'O':
 
1026
        tty.c_cflag |= PARENB | PARODD;
 
1027
        break;
 
1028
    }
 
1029
    if (stop_bits == 2)
 
1030
        tty.c_cflag |= CSTOPB;
 
1031
 
 
1032
    tcsetattr (fd, TCSANOW, &tty);
 
1033
}
 
1034
 
 
1035
static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)
 
1036
{
 
1037
    FDCharDriver *s = chr->opaque;
 
1038
 
 
1039
    switch(cmd) {
 
1040
    case CHR_IOCTL_SERIAL_SET_PARAMS:
 
1041
        {
 
1042
            QEMUSerialSetParams *ssp = arg;
 
1043
            tty_serial_init(s->fd_in, ssp->speed, ssp->parity,
 
1044
                            ssp->data_bits, ssp->stop_bits);
 
1045
        }
 
1046
        break;
 
1047
    case CHR_IOCTL_SERIAL_SET_BREAK:
 
1048
        {
 
1049
            int enable = *(int *)arg;
 
1050
            if (enable)
 
1051
                tcsendbreak(s->fd_in, 1);
 
1052
        }
 
1053
        break;
 
1054
    case CHR_IOCTL_SERIAL_GET_TIOCM:
 
1055
        {
 
1056
            int sarg = 0;
 
1057
            int *targ = (int *)arg;
 
1058
            ioctl(s->fd_in, TIOCMGET, &sarg);
 
1059
            *targ = 0;
 
1060
            if (sarg | TIOCM_CTS)
 
1061
                *targ |= CHR_TIOCM_CTS;
 
1062
            if (sarg | TIOCM_CAR)
 
1063
                *targ |= CHR_TIOCM_CAR;
 
1064
            if (sarg | TIOCM_DSR)
 
1065
                *targ |= CHR_TIOCM_DSR;
 
1066
            if (sarg | TIOCM_RI)
 
1067
                *targ |= CHR_TIOCM_RI;
 
1068
            if (sarg | TIOCM_DTR)
 
1069
                *targ |= CHR_TIOCM_DTR;
 
1070
            if (sarg | TIOCM_RTS)
 
1071
                *targ |= CHR_TIOCM_RTS;
 
1072
        }
 
1073
        break;
 
1074
    case CHR_IOCTL_SERIAL_SET_TIOCM:
 
1075
        {
 
1076
            int sarg = *(int *)arg;
 
1077
            int targ = 0;
 
1078
            if (sarg | CHR_TIOCM_DTR)
 
1079
                targ |= TIOCM_DTR;
 
1080
            if (sarg | CHR_TIOCM_RTS)
 
1081
                targ |= TIOCM_RTS;
 
1082
            ioctl(s->fd_in, TIOCMSET, &targ);
 
1083
        }
 
1084
        break;
 
1085
    default:
 
1086
        return -ENOTSUP;
 
1087
    }
 
1088
    return 0;
 
1089
}
 
1090
 
 
1091
static CharDriverState *qemu_chr_open_tty(const char *filename)
 
1092
{
 
1093
    CharDriverState *chr;
 
1094
    int fd;
 
1095
 
 
1096
    TFR(fd = open(filename, O_RDWR | O_NONBLOCK));
 
1097
    tty_serial_init(fd, 115200, 'N', 8, 1);
 
1098
    chr = qemu_chr_open_fd(fd, fd);
 
1099
    if (!chr) {
 
1100
        close(fd);
 
1101
        return NULL;
 
1102
    }
 
1103
    chr->chr_ioctl = tty_serial_ioctl;
 
1104
    qemu_chr_reset(chr);
 
1105
    return chr;
 
1106
}
 
1107
#else  /* ! __linux__ && ! __sun__ */
 
1108
static CharDriverState *qemu_chr_open_pty(void)
 
1109
{
 
1110
    return NULL;
 
1111
}
 
1112
#endif /* __linux__ || __sun__ */
 
1113
 
 
1114
#if defined(__linux__)
 
1115
typedef struct {
 
1116
    int fd;
 
1117
    int mode;
 
1118
} ParallelCharDriver;
 
1119
 
 
1120
static int pp_hw_mode(ParallelCharDriver *s, uint16_t mode)
 
1121
{
 
1122
    if (s->mode != mode) {
 
1123
        int m = mode;
 
1124
        if (ioctl(s->fd, PPSETMODE, &m) < 0)
 
1125
            return 0;
 
1126
        s->mode = mode;
 
1127
    }
 
1128
    return 1;
 
1129
}
 
1130
 
 
1131
static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
 
1132
{
 
1133
    ParallelCharDriver *drv = chr->opaque;
 
1134
    int fd = drv->fd;
 
1135
    uint8_t b;
 
1136
 
 
1137
    switch(cmd) {
 
1138
    case CHR_IOCTL_PP_READ_DATA:
 
1139
        if (ioctl(fd, PPRDATA, &b) < 0)
 
1140
            return -ENOTSUP;
 
1141
        *(uint8_t *)arg = b;
 
1142
        break;
 
1143
    case CHR_IOCTL_PP_WRITE_DATA:
 
1144
        b = *(uint8_t *)arg;
 
1145
        if (ioctl(fd, PPWDATA, &b) < 0)
 
1146
            return -ENOTSUP;
 
1147
        break;
 
1148
    case CHR_IOCTL_PP_READ_CONTROL:
 
1149
        if (ioctl(fd, PPRCONTROL, &b) < 0)
 
1150
            return -ENOTSUP;
 
1151
        /* Linux gives only the lowest bits, and no way to know data
 
1152
           direction! For better compatibility set the fixed upper
 
1153
           bits. */
 
1154
        *(uint8_t *)arg = b | 0xc0;
 
1155
        break;
 
1156
    case CHR_IOCTL_PP_WRITE_CONTROL:
 
1157
        b = *(uint8_t *)arg;
 
1158
        if (ioctl(fd, PPWCONTROL, &b) < 0)
 
1159
            return -ENOTSUP;
 
1160
        break;
 
1161
    case CHR_IOCTL_PP_READ_STATUS:
 
1162
        if (ioctl(fd, PPRSTATUS, &b) < 0)
 
1163
            return -ENOTSUP;
 
1164
        *(uint8_t *)arg = b;
 
1165
        break;
 
1166
    case CHR_IOCTL_PP_DATA_DIR:
 
1167
        if (ioctl(fd, PPDATADIR, (int *)arg) < 0)
 
1168
            return -ENOTSUP;
 
1169
        break;
 
1170
    case CHR_IOCTL_PP_EPP_READ_ADDR:
 
1171
        if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
 
1172
            struct ParallelIOArg *parg = arg;
 
1173
            int n = read(fd, parg->buffer, parg->count);
 
1174
            if (n != parg->count) {
 
1175
                return -EIO;
 
1176
            }
 
1177
        }
 
1178
        break;
 
1179
    case CHR_IOCTL_PP_EPP_READ:
 
1180
        if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
 
1181
            struct ParallelIOArg *parg = arg;
 
1182
            int n = read(fd, parg->buffer, parg->count);
 
1183
            if (n != parg->count) {
 
1184
                return -EIO;
 
1185
            }
 
1186
        }
 
1187
        break;
 
1188
    case CHR_IOCTL_PP_EPP_WRITE_ADDR:
 
1189
        if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
 
1190
            struct ParallelIOArg *parg = arg;
 
1191
            int n = write(fd, parg->buffer, parg->count);
 
1192
            if (n != parg->count) {
 
1193
                return -EIO;
 
1194
            }
 
1195
        }
 
1196
        break;
 
1197
    case CHR_IOCTL_PP_EPP_WRITE:
 
1198
        if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
 
1199
            struct ParallelIOArg *parg = arg;
 
1200
            int n = write(fd, parg->buffer, parg->count);
 
1201
            if (n != parg->count) {
 
1202
                return -EIO;
 
1203
            }
 
1204
        }
 
1205
        break;
 
1206
    default:
 
1207
        return -ENOTSUP;
 
1208
    }
 
1209
    return 0;
 
1210
}
 
1211
 
 
1212
static void pp_close(CharDriverState *chr)
 
1213
{
 
1214
    ParallelCharDriver *drv = chr->opaque;
 
1215
    int fd = drv->fd;
 
1216
 
 
1217
    pp_hw_mode(drv, IEEE1284_MODE_COMPAT);
 
1218
    ioctl(fd, PPRELEASE);
 
1219
    close(fd);
 
1220
    qemu_free(drv);
 
1221
}
 
1222
 
 
1223
static CharDriverState *qemu_chr_open_pp(const char *filename)
 
1224
{
 
1225
    CharDriverState *chr;
 
1226
    ParallelCharDriver *drv;
 
1227
    int fd;
 
1228
 
 
1229
    TFR(fd = open(filename, O_RDWR));
 
1230
    if (fd < 0)
 
1231
        return NULL;
 
1232
 
 
1233
    if (ioctl(fd, PPCLAIM) < 0) {
 
1234
        close(fd);
 
1235
        return NULL;
 
1236
    }
 
1237
 
 
1238
    drv = qemu_mallocz(sizeof(ParallelCharDriver));
 
1239
    if (!drv) {
 
1240
        close(fd);
 
1241
        return NULL;
 
1242
    }
 
1243
    drv->fd = fd;
 
1244
    drv->mode = IEEE1284_MODE_COMPAT;
 
1245
 
 
1246
    chr = qemu_mallocz(sizeof(CharDriverState));
 
1247
    if (!chr) {
 
1248
        qemu_free(drv);
 
1249
        close(fd);
 
1250
        return NULL;
 
1251
    }
 
1252
    chr->chr_write = null_chr_write;
 
1253
    chr->chr_ioctl = pp_ioctl;
 
1254
    chr->chr_close = pp_close;
 
1255
    chr->opaque = drv;
 
1256
 
 
1257
    qemu_chr_reset(chr);
 
1258
 
 
1259
    return chr;
 
1260
}
 
1261
#endif /* __linux__ */
 
1262
 
 
1263
#else /* _WIN32 */
 
1264
 
 
1265
typedef struct {
 
1266
    int max_size;
 
1267
    HANDLE hcom, hrecv, hsend;
 
1268
    OVERLAPPED orecv, osend;
 
1269
    BOOL fpipe;
 
1270
    DWORD len;
 
1271
} WinCharState;
 
1272
 
 
1273
#define NSENDBUF 2048
 
1274
#define NRECVBUF 2048
 
1275
#define MAXCONNECT 1
 
1276
#define NTIMEOUT 5000
 
1277
 
 
1278
static int win_chr_poll(void *opaque);
 
1279
static int win_chr_pipe_poll(void *opaque);
 
1280
 
 
1281
static void win_chr_close(CharDriverState *chr)
 
1282
{
 
1283
    WinCharState *s = chr->opaque;
 
1284
 
 
1285
    if (s->hsend) {
 
1286
        CloseHandle(s->hsend);
 
1287
        s->hsend = NULL;
 
1288
    }
 
1289
    if (s->hrecv) {
 
1290
        CloseHandle(s->hrecv);
 
1291
        s->hrecv = NULL;
 
1292
    }
 
1293
    if (s->hcom) {
 
1294
        CloseHandle(s->hcom);
 
1295
        s->hcom = NULL;
 
1296
    }
 
1297
    if (s->fpipe)
 
1298
        qemu_del_polling_cb(win_chr_pipe_poll, chr);
 
1299
    else
 
1300
        qemu_del_polling_cb(win_chr_poll, chr);
 
1301
}
 
1302
 
 
1303
static int win_chr_init(CharDriverState *chr, const char *filename)
 
1304
{
 
1305
    WinCharState *s = chr->opaque;
 
1306
    COMMCONFIG comcfg;
 
1307
    COMMTIMEOUTS cto = { 0, 0, 0, 0, 0};
 
1308
    COMSTAT comstat;
 
1309
    DWORD size;
 
1310
    DWORD err;
 
1311
 
 
1312
    s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
 
1313
    if (!s->hsend) {
 
1314
        fprintf(stderr, "Failed CreateEvent\n");
 
1315
        goto fail;
 
1316
    }
 
1317
    s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
 
1318
    if (!s->hrecv) {
 
1319
        fprintf(stderr, "Failed CreateEvent\n");
 
1320
        goto fail;
 
1321
    }
 
1322
 
 
1323
    s->hcom = CreateFile(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL,
 
1324
                      OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
 
1325
    if (s->hcom == INVALID_HANDLE_VALUE) {
 
1326
        fprintf(stderr, "Failed CreateFile (%lu)\n", GetLastError());
 
1327
        s->hcom = NULL;
 
1328
        goto fail;
 
1329
    }
 
1330
 
 
1331
    if (!SetupComm(s->hcom, NRECVBUF, NSENDBUF)) {
 
1332
        fprintf(stderr, "Failed SetupComm\n");
 
1333
        goto fail;
 
1334
    }
 
1335
 
 
1336
    ZeroMemory(&comcfg, sizeof(COMMCONFIG));
 
1337
    size = sizeof(COMMCONFIG);
 
1338
    GetDefaultCommConfig(filename, &comcfg, &size);
 
1339
    comcfg.dcb.DCBlength = sizeof(DCB);
 
1340
    CommConfigDialog(filename, NULL, &comcfg);
 
1341
 
 
1342
    if (!SetCommState(s->hcom, &comcfg.dcb)) {
 
1343
        fprintf(stderr, "Failed SetCommState\n");
 
1344
        goto fail;
 
1345
    }
 
1346
 
 
1347
    if (!SetCommMask(s->hcom, EV_ERR)) {
 
1348
        fprintf(stderr, "Failed SetCommMask\n");
 
1349
        goto fail;
 
1350
    }
 
1351
 
 
1352
    cto.ReadIntervalTimeout = MAXDWORD;
 
1353
    if (!SetCommTimeouts(s->hcom, &cto)) {
 
1354
        fprintf(stderr, "Failed SetCommTimeouts\n");
 
1355
        goto fail;
 
1356
    }
 
1357
 
 
1358
    if (!ClearCommError(s->hcom, &err, &comstat)) {
 
1359
        fprintf(stderr, "Failed ClearCommError\n");
 
1360
        goto fail;
 
1361
    }
 
1362
    qemu_add_polling_cb(win_chr_poll, chr);
 
1363
    return 0;
 
1364
 
 
1365
 fail:
 
1366
    win_chr_close(chr);
 
1367
    return -1;
 
1368
}
 
1369
 
 
1370
static int win_chr_write(CharDriverState *chr, const uint8_t *buf, int len1)
 
1371
{
 
1372
    WinCharState *s = chr->opaque;
 
1373
    DWORD len, ret, size, err;
 
1374
 
 
1375
    len = len1;
 
1376
    ZeroMemory(&s->osend, sizeof(s->osend));
 
1377
    s->osend.hEvent = s->hsend;
 
1378
    while (len > 0) {
 
1379
        if (s->hsend)
 
1380
            ret = WriteFile(s->hcom, buf, len, &size, &s->osend);
 
1381
        else
 
1382
            ret = WriteFile(s->hcom, buf, len, &size, NULL);
 
1383
        if (!ret) {
 
1384
            err = GetLastError();
 
1385
            if (err == ERROR_IO_PENDING) {
 
1386
                ret = GetOverlappedResult(s->hcom, &s->osend, &size, TRUE);
 
1387
                if (ret) {
 
1388
                    buf += size;
 
1389
                    len -= size;
 
1390
                } else {
 
1391
                    break;
 
1392
                }
 
1393
            } else {
 
1394
                break;
 
1395
            }
 
1396
        } else {
 
1397
            buf += size;
 
1398
            len -= size;
 
1399
        }
 
1400
    }
 
1401
    return len1 - len;
 
1402
}
 
1403
 
 
1404
static int win_chr_read_poll(CharDriverState *chr)
 
1405
{
 
1406
    WinCharState *s = chr->opaque;
 
1407
 
 
1408
    s->max_size = qemu_chr_can_read(chr);
 
1409
    return s->max_size;
 
1410
}
 
1411
 
 
1412
static void win_chr_readfile(CharDriverState *chr)
 
1413
{
 
1414
    WinCharState *s = chr->opaque;
 
1415
    int ret, err;
 
1416
    uint8_t buf[1024];
 
1417
    DWORD size;
 
1418
 
 
1419
    ZeroMemory(&s->orecv, sizeof(s->orecv));
 
1420
    s->orecv.hEvent = s->hrecv;
 
1421
    ret = ReadFile(s->hcom, buf, s->len, &size, &s->orecv);
 
1422
    if (!ret) {
 
1423
        err = GetLastError();
 
1424
        if (err == ERROR_IO_PENDING) {
 
1425
            ret = GetOverlappedResult(s->hcom, &s->orecv, &size, TRUE);
 
1426
        }
 
1427
    }
 
1428
 
 
1429
    if (size > 0) {
 
1430
        qemu_chr_read(chr, buf, size);
 
1431
    }
 
1432
}
 
1433
 
 
1434
static void win_chr_read(CharDriverState *chr)
 
1435
{
 
1436
    WinCharState *s = chr->opaque;
 
1437
 
 
1438
    if (s->len > s->max_size)
 
1439
        s->len = s->max_size;
 
1440
    if (s->len == 0)
 
1441
        return;
 
1442
 
 
1443
    win_chr_readfile(chr);
 
1444
}
 
1445
 
 
1446
static int win_chr_poll(void *opaque)
 
1447
{
 
1448
    CharDriverState *chr = opaque;
 
1449
    WinCharState *s = chr->opaque;
 
1450
    COMSTAT status;
 
1451
    DWORD comerr;
 
1452
 
 
1453
    ClearCommError(s->hcom, &comerr, &status);
 
1454
    if (status.cbInQue > 0) {
 
1455
        s->len = status.cbInQue;
 
1456
        win_chr_read_poll(chr);
 
1457
        win_chr_read(chr);
 
1458
        return 1;
 
1459
    }
 
1460
    return 0;
 
1461
}
 
1462
 
 
1463
static CharDriverState *qemu_chr_open_win(const char *filename)
 
1464
{
 
1465
    CharDriverState *chr;
 
1466
    WinCharState *s;
 
1467
 
 
1468
    chr = qemu_mallocz(sizeof(CharDriverState));
 
1469
    if (!chr)
 
1470
        return NULL;
 
1471
    s = qemu_mallocz(sizeof(WinCharState));
 
1472
    if (!s) {
 
1473
        free(chr);
 
1474
        return NULL;
 
1475
    }
 
1476
    chr->opaque = s;
 
1477
    chr->chr_write = win_chr_write;
 
1478
    chr->chr_close = win_chr_close;
 
1479
 
 
1480
    if (win_chr_init(chr, filename) < 0) {
 
1481
        free(s);
 
1482
        free(chr);
 
1483
        return NULL;
 
1484
    }
 
1485
    qemu_chr_reset(chr);
 
1486
    return chr;
 
1487
}
 
1488
 
 
1489
static int win_chr_pipe_poll(void *opaque)
 
1490
{
 
1491
    CharDriverState *chr = opaque;
 
1492
    WinCharState *s = chr->opaque;
 
1493
    DWORD size;
 
1494
 
 
1495
    PeekNamedPipe(s->hcom, NULL, 0, NULL, &size, NULL);
 
1496
    if (size > 0) {
 
1497
        s->len = size;
 
1498
        win_chr_read_poll(chr);
 
1499
        win_chr_read(chr);
 
1500
        return 1;
 
1501
    }
 
1502
    return 0;
 
1503
}
 
1504
 
 
1505
static int win_chr_pipe_init(CharDriverState *chr, const char *filename)
 
1506
{
 
1507
    WinCharState *s = chr->opaque;
 
1508
    OVERLAPPED ov;
 
1509
    int ret;
 
1510
    DWORD size;
 
1511
    char openname[256];
 
1512
 
 
1513
    s->fpipe = TRUE;
 
1514
 
 
1515
    s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
 
1516
    if (!s->hsend) {
 
1517
        fprintf(stderr, "Failed CreateEvent\n");
 
1518
        goto fail;
 
1519
    }
 
1520
    s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
 
1521
    if (!s->hrecv) {
 
1522
        fprintf(stderr, "Failed CreateEvent\n");
 
1523
        goto fail;
 
1524
    }
 
1525
 
 
1526
    snprintf(openname, sizeof(openname), "\\\\.\\pipe\\%s", filename);
 
1527
    s->hcom = CreateNamedPipe(openname, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
 
1528
                              PIPE_TYPE_BYTE | PIPE_READMODE_BYTE |
 
1529
                              PIPE_WAIT,
 
1530
                              MAXCONNECT, NSENDBUF, NRECVBUF, NTIMEOUT, NULL);
 
1531
    if (s->hcom == INVALID_HANDLE_VALUE) {
 
1532
        fprintf(stderr, "Failed CreateNamedPipe (%lu)\n", GetLastError());
 
1533
        s->hcom = NULL;
 
1534
        goto fail;
 
1535
    }
 
1536
 
 
1537
    ZeroMemory(&ov, sizeof(ov));
 
1538
    ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
 
1539
    ret = ConnectNamedPipe(s->hcom, &ov);
 
1540
    if (ret) {
 
1541
        fprintf(stderr, "Failed ConnectNamedPipe\n");
 
1542
        goto fail;
 
1543
    }
 
1544
 
 
1545
    ret = GetOverlappedResult(s->hcom, &ov, &size, TRUE);
 
1546
    if (!ret) {
 
1547
        fprintf(stderr, "Failed GetOverlappedResult\n");
 
1548
        if (ov.hEvent) {
 
1549
            CloseHandle(ov.hEvent);
 
1550
            ov.hEvent = NULL;
 
1551
        }
 
1552
        goto fail;
 
1553
    }
 
1554
 
 
1555
    if (ov.hEvent) {
 
1556
        CloseHandle(ov.hEvent);
 
1557
        ov.hEvent = NULL;
 
1558
    }
 
1559
    qemu_add_polling_cb(win_chr_pipe_poll, chr);
 
1560
    return 0;
 
1561
 
 
1562
 fail:
 
1563
    win_chr_close(chr);
 
1564
    return -1;
 
1565
}
 
1566
 
 
1567
 
 
1568
static CharDriverState *qemu_chr_open_win_pipe(const char *filename)
 
1569
{
 
1570
    CharDriverState *chr;
 
1571
    WinCharState *s;
 
1572
 
 
1573
    chr = qemu_mallocz(sizeof(CharDriverState));
 
1574
    if (!chr)
 
1575
        return NULL;
 
1576
    s = qemu_mallocz(sizeof(WinCharState));
 
1577
    if (!s) {
 
1578
        free(chr);
 
1579
        return NULL;
 
1580
    }
 
1581
    chr->opaque = s;
 
1582
    chr->chr_write = win_chr_write;
 
1583
    chr->chr_close = win_chr_close;
 
1584
 
 
1585
    if (win_chr_pipe_init(chr, filename) < 0) {
 
1586
        free(s);
 
1587
        free(chr);
 
1588
        return NULL;
 
1589
    }
 
1590
    qemu_chr_reset(chr);
 
1591
    return chr;
 
1592
}
 
1593
 
 
1594
static CharDriverState *qemu_chr_open_win_file(HANDLE fd_out)
 
1595
{
 
1596
    CharDriverState *chr;
 
1597
    WinCharState *s;
 
1598
 
 
1599
    chr = qemu_mallocz(sizeof(CharDriverState));
 
1600
    if (!chr)
 
1601
        return NULL;
 
1602
    s = qemu_mallocz(sizeof(WinCharState));
 
1603
    if (!s) {
 
1604
        free(chr);
 
1605
        return NULL;
 
1606
    }
 
1607
    s->hcom = fd_out;
 
1608
    chr->opaque = s;
 
1609
    chr->chr_write = win_chr_write;
 
1610
    qemu_chr_reset(chr);
 
1611
    return chr;
 
1612
}
 
1613
 
 
1614
static CharDriverState *qemu_chr_open_win_con(const char *filename)
 
1615
{
 
1616
    return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE));
 
1617
}
 
1618
 
 
1619
static CharDriverState *qemu_chr_open_win_file_out(const char *file_out)
 
1620
{
 
1621
    HANDLE fd_out;
 
1622
 
 
1623
    fd_out = CreateFile(file_out, GENERIC_WRITE, FILE_SHARE_READ, NULL,
 
1624
                        OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 
1625
    if (fd_out == INVALID_HANDLE_VALUE)
 
1626
        return NULL;
 
1627
 
 
1628
    return qemu_chr_open_win_file(fd_out);
 
1629
}
 
1630
#endif /* !_WIN32 */
 
1631
 
 
1632
/***********************************************************/
 
1633
/* UDP Net console */
 
1634
 
 
1635
typedef struct {
 
1636
    int fd;
 
1637
    struct sockaddr_in daddr;
 
1638
    uint8_t buf[1024];
 
1639
    int bufcnt;
 
1640
    int bufptr;
 
1641
    int max_size;
 
1642
} NetCharDriver;
 
1643
 
 
1644
static int udp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
 
1645
{
 
1646
    NetCharDriver *s = chr->opaque;
 
1647
 
 
1648
    return sendto(s->fd, buf, len, 0,
 
1649
                  (struct sockaddr *)&s->daddr, sizeof(struct sockaddr_in));
 
1650
}
 
1651
 
 
1652
static int udp_chr_read_poll(void *opaque)
 
1653
{
 
1654
    CharDriverState *chr = opaque;
 
1655
    NetCharDriver *s = chr->opaque;
 
1656
 
 
1657
    s->max_size = qemu_chr_can_read(chr);
 
1658
 
 
1659
    /* If there were any stray characters in the queue process them
 
1660
     * first
 
1661
     */
 
1662
    while (s->max_size > 0 && s->bufptr < s->bufcnt) {
 
1663
        qemu_chr_read(chr, &s->buf[s->bufptr], 1);
 
1664
        s->bufptr++;
 
1665
        s->max_size = qemu_chr_can_read(chr);
 
1666
    }
 
1667
    return s->max_size;
 
1668
}
 
1669
 
 
1670
static void udp_chr_read(void *opaque)
 
1671
{
 
1672
    CharDriverState *chr = opaque;
 
1673
    NetCharDriver *s = chr->opaque;
 
1674
 
 
1675
    if (s->max_size == 0)
 
1676
        return;
 
1677
    s->bufcnt = recv(s->fd, s->buf, sizeof(s->buf), 0);
 
1678
    s->bufptr = s->bufcnt;
 
1679
    if (s->bufcnt <= 0)
 
1680
        return;
 
1681
 
 
1682
    s->bufptr = 0;
 
1683
    while (s->max_size > 0 && s->bufptr < s->bufcnt) {
 
1684
        qemu_chr_read(chr, &s->buf[s->bufptr], 1);
 
1685
        s->bufptr++;
 
1686
        s->max_size = qemu_chr_can_read(chr);
 
1687
    }
 
1688
}
 
1689
 
 
1690
static void udp_chr_update_read_handler(CharDriverState *chr)
 
1691
{
 
1692
    NetCharDriver *s = chr->opaque;
 
1693
 
 
1694
    if (s->fd >= 0) {
 
1695
        qemu_set_fd_handler2(s->fd, udp_chr_read_poll,
 
1696
                             udp_chr_read, NULL, chr);
 
1697
    }
 
1698
}
 
1699
 
 
1700
static CharDriverState *qemu_chr_open_udp(const char *def)
 
1701
{
 
1702
    CharDriverState *chr = NULL;
 
1703
    NetCharDriver *s = NULL;
 
1704
    int fd = -1;
 
1705
    struct sockaddr_in saddr;
 
1706
 
 
1707
    chr = qemu_mallocz(sizeof(CharDriverState));
 
1708
    if (!chr)
 
1709
        goto return_err;
 
1710
    s = qemu_mallocz(sizeof(NetCharDriver));
 
1711
    if (!s)
 
1712
        goto return_err;
 
1713
 
 
1714
    fd = socket(PF_INET, SOCK_DGRAM, 0);
 
1715
    if (fd < 0) {
 
1716
        perror("socket(PF_INET, SOCK_DGRAM)");
 
1717
        goto return_err;
 
1718
    }
 
1719
 
 
1720
    if (parse_host_src_port(&s->daddr, &saddr, def) < 0) {
 
1721
        printf("Could not parse: %s\n", def);
 
1722
        goto return_err;
 
1723
    }
 
1724
 
 
1725
    if (bind(fd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
 
1726
    {
 
1727
        perror("bind");
 
1728
        goto return_err;
 
1729
    }
 
1730
 
 
1731
    s->fd = fd;
 
1732
    s->bufcnt = 0;
 
1733
    s->bufptr = 0;
 
1734
    chr->opaque = s;
 
1735
    chr->chr_write = udp_chr_write;
 
1736
    chr->chr_update_read_handler = udp_chr_update_read_handler;
 
1737
    return chr;
 
1738
 
 
1739
return_err:
 
1740
    if (chr)
 
1741
        free(chr);
 
1742
    if (s)
 
1743
        free(s);
 
1744
    if (fd >= 0)
 
1745
        closesocket(fd);
 
1746
    return NULL;
 
1747
}
 
1748
 
 
1749
/***********************************************************/
 
1750
/* TCP Net console */
 
1751
 
 
1752
typedef struct {
 
1753
    int fd, listen_fd;
 
1754
    int connected;
 
1755
    int max_size;
 
1756
    int do_telnetopt;
 
1757
    int do_nodelay;
 
1758
    int is_unix;
 
1759
} TCPCharDriver;
 
1760
 
 
1761
static void tcp_chr_accept(void *opaque);
 
1762
 
 
1763
static int tcp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
 
1764
{
 
1765
    TCPCharDriver *s = chr->opaque;
 
1766
    if (s->connected) {
 
1767
        return send_all(s->fd, buf, len);
 
1768
    } else {
 
1769
        /* XXX: indicate an error ? */
 
1770
        return len;
 
1771
    }
 
1772
}
 
1773
 
 
1774
static int tcp_chr_read_poll(void *opaque)
 
1775
{
 
1776
    CharDriverState *chr = opaque;
 
1777
    TCPCharDriver *s = chr->opaque;
 
1778
    if (!s->connected)
 
1779
        return 0;
 
1780
    s->max_size = qemu_chr_can_read(chr);
 
1781
    return s->max_size;
 
1782
}
 
1783
 
 
1784
#define IAC 255
 
1785
#define IAC_BREAK 243
 
1786
static void tcp_chr_process_IAC_bytes(CharDriverState *chr,
 
1787
                                      TCPCharDriver *s,
 
1788
                                      uint8_t *buf, int *size)
 
1789
{
 
1790
    /* Handle any telnet client's basic IAC options to satisfy char by
 
1791
     * char mode with no echo.  All IAC options will be removed from
 
1792
     * the buf and the do_telnetopt variable will be used to track the
 
1793
     * state of the width of the IAC information.
 
1794
     *
 
1795
     * IAC commands come in sets of 3 bytes with the exception of the
 
1796
     * "IAC BREAK" command and the double IAC.
 
1797
     */
 
1798
 
 
1799
    int i;
 
1800
    int j = 0;
 
1801
 
 
1802
    for (i = 0; i < *size; i++) {
 
1803
        if (s->do_telnetopt > 1) {
 
1804
            if ((unsigned char)buf[i] == IAC && s->do_telnetopt == 2) {
 
1805
                /* Double IAC means send an IAC */
 
1806
                if (j != i)
 
1807
                    buf[j] = buf[i];
 
1808
                j++;
 
1809
                s->do_telnetopt = 1;
 
1810
            } else {
 
1811
                if ((unsigned char)buf[i] == IAC_BREAK && s->do_telnetopt == 2) {
 
1812
                    /* Handle IAC break commands by sending a serial break */
 
1813
                    qemu_chr_event(chr, CHR_EVENT_BREAK);
 
1814
                    s->do_telnetopt++;
 
1815
                }
 
1816
                s->do_telnetopt++;
 
1817
            }
 
1818
            if (s->do_telnetopt >= 4) {
 
1819
                s->do_telnetopt = 1;
 
1820
            }
 
1821
        } else {
 
1822
            if ((unsigned char)buf[i] == IAC) {
 
1823
                s->do_telnetopt = 2;
 
1824
            } else {
 
1825
                if (j != i)
 
1826
                    buf[j] = buf[i];
 
1827
                j++;
 
1828
            }
 
1829
        }
 
1830
    }
 
1831
    *size = j;
 
1832
}
 
1833
 
 
1834
static void tcp_chr_read(void *opaque)
 
1835
{
 
1836
    CharDriverState *chr = opaque;
 
1837
    TCPCharDriver *s = chr->opaque;
 
1838
    uint8_t buf[1024];
 
1839
    int len, size;
 
1840
 
 
1841
    if (!s->connected || s->max_size <= 0)
 
1842
        return;
 
1843
    len = sizeof(buf);
 
1844
    if (len > s->max_size)
 
1845
        len = s->max_size;
 
1846
    size = recv(s->fd, buf, len, 0);
 
1847
    if (size == 0) {
 
1848
        /* connection closed */
 
1849
        s->connected = 0;
 
1850
        if (s->listen_fd >= 0) {
 
1851
            qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
 
1852
        }
 
1853
        qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
 
1854
        closesocket(s->fd);
 
1855
        s->fd = -1;
 
1856
    } else if (size > 0) {
 
1857
        if (s->do_telnetopt)
 
1858
            tcp_chr_process_IAC_bytes(chr, s, buf, &size);
 
1859
        if (size > 0)
 
1860
            qemu_chr_read(chr, buf, size);
 
1861
    }
 
1862
}
 
1863
 
 
1864
static void tcp_chr_connect(void *opaque)
 
1865
{
 
1866
    CharDriverState *chr = opaque;
 
1867
    TCPCharDriver *s = chr->opaque;
 
1868
 
 
1869
    s->connected = 1;
 
1870
    qemu_set_fd_handler2(s->fd, tcp_chr_read_poll,
 
1871
                         tcp_chr_read, NULL, chr);
 
1872
    qemu_chr_reset(chr);
 
1873
}
 
1874
 
 
1875
#define IACSET(x,a,b,c) x[0] = a; x[1] = b; x[2] = c;
 
1876
static void tcp_chr_telnet_init(int fd)
 
1877
{
 
1878
    char buf[3];
 
1879
    /* Send the telnet negotion to put telnet in binary, no echo, single char mode */
 
1880
    IACSET(buf, 0xff, 0xfb, 0x01);  /* IAC WILL ECHO */
 
1881
    send(fd, (char *)buf, 3, 0);
 
1882
    IACSET(buf, 0xff, 0xfb, 0x03);  /* IAC WILL Suppress go ahead */
 
1883
    send(fd, (char *)buf, 3, 0);
 
1884
    IACSET(buf, 0xff, 0xfb, 0x00);  /* IAC WILL Binary */
 
1885
    send(fd, (char *)buf, 3, 0);
 
1886
    IACSET(buf, 0xff, 0xfd, 0x00);  /* IAC DO Binary */
 
1887
    send(fd, (char *)buf, 3, 0);
 
1888
}
 
1889
 
 
1890
static void socket_set_nodelay(int fd)
 
1891
{
 
1892
    int val = 1;
 
1893
    setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
 
1894
}
 
1895
 
 
1896
static void tcp_chr_accept(void *opaque)
 
1897
{
 
1898
    CharDriverState *chr = opaque;
 
1899
    TCPCharDriver *s = chr->opaque;
 
1900
    struct sockaddr_in saddr;
 
1901
#ifndef _WIN32
 
1902
    struct sockaddr_un uaddr;
 
1903
#endif
 
1904
    struct sockaddr *addr;
 
1905
    socklen_t len;
 
1906
    int fd;
 
1907
 
 
1908
    for(;;) {
 
1909
#ifndef _WIN32
 
1910
        if (s->is_unix) {
 
1911
            len = sizeof(uaddr);
 
1912
            addr = (struct sockaddr *)&uaddr;
 
1913
        } else
 
1914
#endif
 
1915
        {
 
1916
            len = sizeof(saddr);
 
1917
            addr = (struct sockaddr *)&saddr;
 
1918
        }
 
1919
        fd = accept(s->listen_fd, addr, &len);
 
1920
        if (fd < 0 && errno != EINTR) {
 
1921
            return;
 
1922
        } else if (fd >= 0) {
 
1923
            if (s->do_telnetopt)
 
1924
                tcp_chr_telnet_init(fd);
 
1925
            break;
 
1926
        }
 
1927
    }
 
1928
    socket_set_nonblock(fd);
 
1929
    if (s->do_nodelay)
 
1930
        socket_set_nodelay(fd);
 
1931
    s->fd = fd;
 
1932
    qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
 
1933
    tcp_chr_connect(chr);
 
1934
}
 
1935
 
 
1936
static void tcp_chr_close(CharDriverState *chr)
 
1937
{
 
1938
    TCPCharDriver *s = chr->opaque;
 
1939
    if (s->fd >= 0)
 
1940
        closesocket(s->fd);
 
1941
    if (s->listen_fd >= 0)
 
1942
        closesocket(s->listen_fd);
 
1943
    qemu_free(s);
 
1944
}
 
1945
 
 
1946
static CharDriverState *qemu_chr_open_tcp(const char *host_str,
 
1947
                                          int is_telnet,
 
1948
                                          int is_unix)
 
1949
{
 
1950
    CharDriverState *chr = NULL;
 
1951
    TCPCharDriver *s = NULL;
 
1952
    int fd = -1, ret, err, val;
 
1953
    int is_listen = 0;
 
1954
    int is_waitconnect = 1;
 
1955
    int do_nodelay = 0;
 
1956
    const char *ptr;
 
1957
    struct sockaddr_in saddr;
 
1958
#ifndef _WIN32
 
1959
    struct sockaddr_un uaddr;
 
1960
#endif
 
1961
    struct sockaddr *addr;
 
1962
    socklen_t addrlen;
 
1963
 
 
1964
#ifndef _WIN32
 
1965
    if (is_unix) {
 
1966
        addr = (struct sockaddr *)&uaddr;
 
1967
        addrlen = sizeof(uaddr);
 
1968
        if (parse_unix_path(&uaddr, host_str) < 0)
 
1969
            goto fail;
 
1970
    } else
 
1971
#endif
 
1972
    {
 
1973
        addr = (struct sockaddr *)&saddr;
 
1974
        addrlen = sizeof(saddr);
 
1975
        if (parse_host_port(&saddr, host_str) < 0)
 
1976
            goto fail;
 
1977
    }
 
1978
 
 
1979
    ptr = host_str;
 
1980
    while((ptr = strchr(ptr,','))) {
 
1981
        ptr++;
 
1982
        if (!strncmp(ptr,"server",6)) {
 
1983
            is_listen = 1;
 
1984
        } else if (!strncmp(ptr,"nowait",6)) {
 
1985
            is_waitconnect = 0;
 
1986
        } else if (!strncmp(ptr,"nodelay",6)) {
 
1987
            do_nodelay = 1;
 
1988
        } else {
 
1989
            printf("Unknown option: %s\n", ptr);
 
1990
            goto fail;
 
1991
        }
 
1992
    }
 
1993
    if (!is_listen)
 
1994
        is_waitconnect = 0;
 
1995
 
 
1996
    chr = qemu_mallocz(sizeof(CharDriverState));
 
1997
    if (!chr)
 
1998
        goto fail;
 
1999
    s = qemu_mallocz(sizeof(TCPCharDriver));
 
2000
    if (!s)
 
2001
        goto fail;
 
2002
 
 
2003
#ifndef _WIN32
 
2004
    if (is_unix)
 
2005
        fd = socket(PF_UNIX, SOCK_STREAM, 0);
 
2006
    else
 
2007
#endif
 
2008
        fd = socket(PF_INET, SOCK_STREAM, 0);
 
2009
 
 
2010
    if (fd < 0)
 
2011
        goto fail;
 
2012
 
 
2013
    if (!is_waitconnect)
 
2014
        socket_set_nonblock(fd);
 
2015
 
 
2016
    s->connected = 0;
 
2017
    s->fd = -1;
 
2018
    s->listen_fd = -1;
 
2019
    s->is_unix = is_unix;
 
2020
    s->do_nodelay = do_nodelay && !is_unix;
 
2021
 
 
2022
    chr->opaque = s;
 
2023
    chr->chr_write = tcp_chr_write;
 
2024
    chr->chr_close = tcp_chr_close;
 
2025
 
 
2026
    if (is_listen) {
 
2027
        /* allow fast reuse */
 
2028
#ifndef _WIN32
 
2029
        if (is_unix) {
 
2030
            char path[109];
 
2031
            pstrcpy(path, sizeof(path), uaddr.sun_path);
 
2032
            unlink(path);
 
2033
        } else
 
2034
#endif
 
2035
        {
 
2036
            val = 1;
 
2037
            setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
 
2038
        }
 
2039
 
 
2040
        ret = bind(fd, addr, addrlen);
 
2041
        if (ret < 0)
 
2042
            goto fail;
 
2043
 
 
2044
        ret = listen(fd, 0);
 
2045
        if (ret < 0)
 
2046
            goto fail;
 
2047
 
 
2048
        s->listen_fd = fd;
 
2049
        qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
 
2050
        if (is_telnet)
 
2051
            s->do_telnetopt = 1;
 
2052
    } else {
 
2053
        for(;;) {
 
2054
            ret = connect(fd, addr, addrlen);
 
2055
            if (ret < 0) {
 
2056
                err = socket_error();
 
2057
                if (err == EINTR || err == EWOULDBLOCK) {
 
2058
                } else if (err == EINPROGRESS) {
 
2059
                    break;
 
2060
#ifdef _WIN32
 
2061
                } else if (err == WSAEALREADY) {
 
2062
                    break;
 
2063
#endif
 
2064
                } else {
 
2065
                    goto fail;
 
2066
                }
 
2067
            } else {
 
2068
                s->connected = 1;
 
2069
                break;
 
2070
            }
 
2071
        }
 
2072
        s->fd = fd;
 
2073
        socket_set_nodelay(fd);
 
2074
        if (s->connected)
 
2075
            tcp_chr_connect(chr);
 
2076
        else
 
2077
            qemu_set_fd_handler(s->fd, NULL, tcp_chr_connect, chr);
 
2078
    }
 
2079
 
 
2080
    if (is_listen && is_waitconnect) {
 
2081
        printf("QEMU waiting for connection on: %s\n", host_str);
 
2082
        tcp_chr_accept(chr);
 
2083
        socket_set_nonblock(s->listen_fd);
 
2084
    }
 
2085
 
 
2086
    return chr;
 
2087
 fail:
 
2088
    if (fd >= 0)
 
2089
        closesocket(fd);
 
2090
    qemu_free(s);
 
2091
    qemu_free(chr);
 
2092
    return NULL;
 
2093
}
 
2094
 
 
2095
static TAILQ_HEAD(CharDriverStateHead, CharDriverState) chardevs
 
2096
= TAILQ_HEAD_INITIALIZER(chardevs);
 
2097
 
 
2098
CharDriverState *qemu_chr_open(const char *label, const char *filename)
 
2099
{
 
2100
    const char *p;
 
2101
    CharDriverState *chr;
 
2102
 
 
2103
    if (!strcmp(filename, "vc")) {
 
2104
        chr = text_console_init(&display_state, 0);
 
2105
    } else
 
2106
    if (strstart(filename, "vc:", &p)) {
 
2107
        chr = text_console_init(&display_state, p);
 
2108
    } else
 
2109
    if (!strcmp(filename, "null")) {
 
2110
        chr = qemu_chr_open_null();
 
2111
    } else
 
2112
    if (strstart(filename, "tcp:", &p)) {
 
2113
        chr = qemu_chr_open_tcp(p, 0, 0);
 
2114
    } else
 
2115
    if (strstart(filename, "telnet:", &p)) {
 
2116
        chr = qemu_chr_open_tcp(p, 1, 0);
 
2117
    } else
 
2118
    if (strstart(filename, "udp:", &p)) {
 
2119
        chr = qemu_chr_open_udp(p);
 
2120
    } else
 
2121
    if (strstart(filename, "mon:", &p)) {
 
2122
        chr = qemu_chr_open(label, p);
 
2123
        if (chr) {
 
2124
            chr = qemu_chr_open_mux(chr);
 
2125
            monitor_init(chr, !nographic);
 
2126
        } else {
 
2127
            printf("Unable to open driver: %s\n", p);
 
2128
        }
 
2129
    } else
 
2130
#ifndef _WIN32
 
2131
    if (strstart(filename, "unix:", &p)) {
 
2132
        chr = qemu_chr_open_tcp(p, 0, 1);
 
2133
    } else if (strstart(filename, "file:", &p)) {
 
2134
        chr = qemu_chr_open_file_out(p);
 
2135
    } else if (strstart(filename, "pipe:", &p)) {
 
2136
        chr = qemu_chr_open_pipe(p);
 
2137
    } else if (!strcmp(filename, "pty")) {
 
2138
        chr = qemu_chr_open_pty();
 
2139
    } else if (!strcmp(filename, "stdio")) {
 
2140
        chr = qemu_chr_open_stdio();
 
2141
    } else
 
2142
#if defined(__linux__)
 
2143
    if (strstart(filename, "/dev/parport", NULL)) {
 
2144
        chr = qemu_chr_open_pp(filename);
 
2145
    } else
 
2146
#endif
 
2147
#if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
 
2148
    || defined(__NetBSD__) || defined(__OpenBSD__)
 
2149
    if (strstart(filename, "/dev/", NULL)) {
 
2150
        chr = qemu_chr_open_tty(filename);
 
2151
    } else
 
2152
#endif
 
2153
#else /* !_WIN32 */
 
2154
    if (strstart(filename, "COM", NULL)) {
 
2155
        chr = qemu_chr_open_win(filename);
 
2156
    } else
 
2157
    if (strstart(filename, "pipe:", &p)) {
 
2158
        chr = qemu_chr_open_win_pipe(p);
 
2159
    } else
 
2160
    if (strstart(filename, "con:", NULL)) {
 
2161
        chr = qemu_chr_open_win_con(filename);
 
2162
    } else
 
2163
    if (strstart(filename, "file:", &p)) {
 
2164
        chr = qemu_chr_open_win_file_out(p);
 
2165
    } else
 
2166
#endif
 
2167
#ifdef CONFIG_BRLAPI
 
2168
    if (!strcmp(filename, "braille")) {
 
2169
        chr = chr_baum_init();
 
2170
    } else
 
2171
#endif
 
2172
    {
 
2173
        chr = NULL;
 
2174
    }
 
2175
 
 
2176
    if (chr) {
 
2177
        if (!chr->filename)
 
2178
            chr->filename = qemu_strdup(filename);
 
2179
        chr->label = qemu_strdup(label);
 
2180
        TAILQ_INSERT_TAIL(&chardevs, chr, next);
 
2181
    }
 
2182
    return chr;
 
2183
}
 
2184
 
 
2185
void qemu_chr_close(CharDriverState *chr)
 
2186
{
 
2187
    TAILQ_REMOVE(&chardevs, chr, next);
 
2188
    if (chr->chr_close)
 
2189
        chr->chr_close(chr);
 
2190
    qemu_free(chr->filename);
 
2191
    qemu_free(chr->label);
 
2192
    qemu_free(chr);
 
2193
}
 
2194
 
 
2195
void qemu_chr_info(void)
 
2196
{
 
2197
    CharDriverState *chr;
 
2198
 
 
2199
    TAILQ_FOREACH(chr, &chardevs, next) {
 
2200
        term_printf("%s: filename=%s\n", chr->label, chr->filename);
 
2201
    }
 
2202
}