Annotation of qemu/qemu-char.c, revision 1.1.1.1

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

unix.superglobalmegacorp.com