Lines Matching refs:chr
146 CharDriverState *chr;
150 QTAILQ_FOREACH(chr, &chardevs, next) {
151 qemu_chr_reset(chr);
215 static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
222 CharDriverState *chr;
224 chr = qemu_mallocz(sizeof(CharDriverState));
225 chr->chr_write = null_chr_write;
226 return chr;
254 static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
256 MuxDriver *d = chr->opaque;
305 static void mux_print_help(CharDriverState *chr)
319 chr->chr_write(chr, (uint8_t *)cbuf, strlen(cbuf));
323 chr->chr_write(chr, (uint8_t *)ebuf, strlen(ebuf));
325 chr->chr_write(chr, (uint8_t *)&mux_help[i][j], 1);
336 static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch)
345 mux_print_help(chr);
350 chr->chr_write(chr,(uint8_t *)term,strlen(term));
363 qemu_chr_event(chr, CHR_EVENT_BREAK);
367 mux_chr_send_event(d, chr->focus, CHR_EVENT_MUX_OUT);
368 chr->focus++;
369 if (chr->focus >= d->mux_cnt)
370 chr->focus = 0;
371 mux_chr_send_event(d, chr->focus, CHR_EVENT_MUX_IN);
388 static void mux_chr_accept_input(CharDriverState *chr)
390 int m = chr->focus;
391 MuxDriver *d = chr->opaque;
403 CharDriverState *chr = opaque;
404 MuxDriver *d = chr->opaque;
405 int m = chr->focus;
416 CharDriverState *chr = opaque;
417 MuxDriver *d = chr->opaque;
418 int m = chr->focus;
424 if (mux_proc_byte(chr, d, buf[i])) {
436 CharDriverState *chr = opaque;
437 MuxDriver *d = chr->opaque;
445 static void mux_chr_update_read_handler(CharDriverState *chr)
447 MuxDriver *d = chr->opaque;
453 d->ext_opaque[d->mux_cnt] = chr->handler_opaque;
454 d->chr_can_read[d->mux_cnt] = chr->chr_can_read;
455 d->chr_read[d->mux_cnt] = chr->chr_read;
456 d->chr_event[d->mux_cnt] = chr->chr_event;
460 mux_chr_event, chr);
462 chr->focus = d->mux_cnt;
468 CharDriverState *chr;
471 chr = qemu_mallocz(sizeof(CharDriverState));
474 chr->opaque = d;
476 chr->focus = -1;
477 chr->chr_write = mux_chr_write;
478 chr->chr_update_read_handler = mux_chr_update_read_handler;
479 chr->chr_accept_input = mux_chr_accept_input;
480 return chr;
549 static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
551 FDCharDriver *s = chr->opaque;
557 CharDriverState *chr = opaque;
558 FDCharDriver *s = chr->opaque;
560 s->max_size = qemu_chr_can_read(chr);
566 CharDriverState *chr = opaque;
567 FDCharDriver *s = chr->opaque;
583 qemu_chr_read(chr, buf, size);
587 static void fd_chr_update_read_handler(CharDriverState *chr)
589 FDCharDriver *s = chr->opaque;
595 fd_chr_read, NULL, chr);
600 static void fd_chr_close(struct CharDriverState *chr)
602 FDCharDriver *s = chr->opaque;
617 CharDriverState *chr;
620 chr = qemu_mallocz(sizeof(CharDriverState));
624 chr->opaque = s;
625 chr->chr_write = fd_chr_write;
626 chr->chr_update_read_handler = fd_chr_update_read_handler;
627 chr->chr_close = fd_chr_close;
629 qemu_chr_reset(chr);
631 return chr;
696 CharDriverState *chr = opaque;
699 if (term_fifo_size != 0 && qemu_chr_can_read(chr) > 0) {
700 qemu_chr_read(chr, term_fifo, 1);
714 CharDriverState *chr = opaque;
723 if (qemu_chr_can_read(chr) > 0) {
724 qemu_chr_read(chr, buf, 1);
770 static void qemu_chr_close_stdio(struct CharDriverState *chr)
775 fd_chr_close(chr);
780 CharDriverState *chr;
784 chr = qemu_chr_open_fd(0, 1);
785 chr->chr_close = qemu_chr_close_stdio;
786 qemu_set_fd_handler2(0, stdio_read_poll, stdio_read, NULL, chr);
790 return chr;
861 static void pty_chr_update_read_handler(CharDriverState *chr);
862 static void pty_chr_state(CharDriverState *chr, int connected);
864 static int pty_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
866 PtyCharDriver *s = chr->opaque;
870 pty_chr_update_read_handler(chr);
878 CharDriverState *chr = opaque;
879 PtyCharDriver *s = chr->opaque;
881 s->read_bytes = qemu_chr_can_read(chr);
887 CharDriverState *chr = opaque;
888 PtyCharDriver *s = chr->opaque;
900 pty_chr_state(chr, 0);
904 pty_chr_state(chr, 1);
905 qemu_chr_read(chr, buf, size);
909 static void pty_chr_update_read_handler(CharDriverState *chr)
911 PtyCharDriver *s = chr->opaque;
914 pty_chr_read, NULL, chr);
927 static void pty_chr_state(CharDriverState *chr, int connected)
929 PtyCharDriver *s = chr->opaque;
941 qemu_chr_reset(chr);
948 struct CharDriverState *chr = opaque;
949 PtyCharDriver *s = chr->opaque;
956 pty_chr_state(chr, 1);
961 pty_chr_update_read_handler(chr);
964 static void pty_chr_close(struct CharDriverState *chr)
966 PtyCharDriver *s = chr->opaque;
977 CharDriverState *chr;
990 chr = qemu_mallocz(sizeof(CharDriverState));
1004 chr->filename = qemu_malloc(len);
1005 snprintf(chr->filename, len, "pty:%s", q_ptsname(s->fd));
1008 chr->opaque = s;
1009 chr->chr_write = pty_chr_write;
1010 chr->chr_update_read_handler = pty_chr_update_read_handler;
1011 chr->chr_close = pty_chr_close;
1013 s->timer = qemu_new_timer(rt_clock, pty_chr_timer, chr);
1015 return chr;
1098 static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)
1100 FDCharDriver *s = chr->opaque;
1167 CharDriverState *chr;
1172 chr = qemu_chr_open_fd(fd, fd);
1173 if (!chr) {
1177 chr->chr_ioctl = tty_serial_ioctl;
1178 qemu_chr_reset(chr);
1179 return chr;
1205 static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
1207 ParallelCharDriver *drv = chr->opaque;
1286 static void pp_close(CharDriverState *chr)
1288 ParallelCharDriver *drv = chr->opaque;
1299 CharDriverState *chr;
1316 chr = qemu_mallocz(sizeof(CharDriverState));
1317 chr->chr_write = null_chr_write;
1318 chr->chr_ioctl = pp_ioctl;
1319 chr->chr_close = pp_close;
1320 chr->opaque = drv;
1322 qemu_chr_reset(chr);
1324 return chr;
1329 static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
1331 int fd = (int)chr->opaque;
1368 CharDriverState *chr;
1375 chr = qemu_mallocz(sizeof(CharDriverState));
1376 chr->opaque = (void *)fd;
1377 chr->chr_write = null_chr_write;
1378 chr->chr_ioctl = pp_ioctl;
1379 return chr;
1401 static void win_chr_close(CharDriverState *chr)
1403 WinCharState *s = chr->opaque;
1418 qemu_del_polling_cb(win_chr_pipe_poll, chr);
1420 qemu_del_polling_cb(win_chr_poll, chr);
1423 static int win_chr_init(CharDriverState *chr, const char *filename)
1425 WinCharState *s = chr->opaque;
1482 qemu_add_polling_cb(win_chr_poll, chr);
1486 win_chr_close(chr);
1490 static int win_chr_write(CharDriverState *chr, const uint8_t *buf, int len1)
1492 WinCharState *s = chr->opaque;
1524 static int win_chr_read_poll(CharDriverState *chr)
1526 WinCharState *s = chr->opaque;
1528 s->max_size = qemu_chr_can_read(chr);
1532 static void win_chr_readfile(CharDriverState *chr)
1534 WinCharState *s = chr->opaque;
1550 qemu_chr_read(chr, buf, size);
1554 static void win_chr_read(CharDriverState *chr)
1556 WinCharState *s = chr->opaque;
1563 win_chr_readfile(chr);
1568 CharDriverState *chr = opaque;
1569 WinCharState *s = chr->opaque;
1576 win_chr_read_poll(chr);
1577 win_chr_read(chr);
1585 CharDriverState *chr;
1588 chr = qemu_mallocz(sizeof(CharDriverState));
1590 chr->opaque = s;
1591 chr->chr_write = win_chr_write;
1592 chr->chr_close = win_chr_close;
1594 if (win_chr_init(chr, filename) < 0) {
1596 free(chr);
1599 qemu_chr_reset(chr);
1600 return chr;
1605 CharDriverState *chr = opaque;
1606 WinCharState *s = chr->opaque;
1612 win_chr_read_poll(chr);
1613 win_chr_read(chr);
1619 static int win_chr_pipe_init(CharDriverState *chr, const char *filename)
1621 WinCharState *s = chr->opaque;
1673 qemu_add_polling_cb(win_chr_pipe_poll, chr);
1677 win_chr_close(chr);
1684 CharDriverState *chr;
1687 chr = qemu_mallocz(sizeof(CharDriverState));
1689 chr->opaque = s;
1690 chr->chr_write = win_chr_write;
1691 chr->chr_close = win_chr_close;
1693 if (win_chr_pipe_init(chr, filename) < 0) {
1695 free(chr);
1698 qemu_chr_reset(chr);
1699 return chr;
1704 CharDriverState *chr;
1707 chr = qemu_mallocz(sizeof(CharDriverState));
1710 chr->opaque = s;
1711 chr->chr_write = win_chr_write;
1712 qemu_chr_reset(chr);
1713 return chr;
1746 static int udp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1748 NetCharDriver *s = chr->opaque;
1755 CharDriverState *chr = opaque;
1756 NetCharDriver *s = chr->opaque;
1758 s->max_size = qemu_chr_can_read(chr);
1764 qemu_chr_read(chr, &s->buf[s->bufptr], 1);
1766 s->max_size = qemu_chr_can_read(chr);
1773 CharDriverState *chr = opaque;
1774 NetCharDriver *s = chr->opaque;
1785 qemu_chr_read(chr, &s->buf[s->bufptr], 1);
1787 s->max_size = qemu_chr_can_read(chr);
1791 static void udp_chr_update_read_handler(CharDriverState *chr)
1793 NetCharDriver *s = chr->opaque;
1797 udp_chr_read, NULL, chr);
1801 static void udp_chr_close(CharDriverState *chr)
1803 NetCharDriver *s = chr->opaque;
1813 CharDriverState *chr = NULL;
1818 chr = qemu_mallocz(sizeof(CharDriverState));
1840 chr->opaque = s;
1841 chr->chr_write = udp_chr_write;
1842 chr->chr_update_read_handler = udp_chr_update_read_handler;
1843 chr->chr_close = udp_chr_close;
1844 return chr;
1847 if (chr)
1848 free(chr);
1870 static int tcp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1872 TCPCharDriver *s = chr->opaque;
1883 CharDriverState *chr = opaque;
1884 TCPCharDriver *s = chr->opaque;
1887 s->max_size = qemu_chr_can_read(chr);
1893 static void tcp_chr_process_IAC_bytes(CharDriverState *chr,
1920 qemu_chr_event(chr, CHR_EVENT_BREAK);
1943 CharDriverState *chr = opaque;
1944 TCPCharDriver *s = chr->opaque;
1958 qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
1965 tcp_chr_process_IAC_bytes(chr, s, buf, &size);
1967 qemu_chr_read(chr, buf, size);
1973 CharDriverState *chr = opaque;
1974 TCPCharDriver *s = chr->opaque;
1978 tcp_chr_read, NULL, chr);
1979 qemu_chr_reset(chr);
1999 CharDriverState *chr = opaque;
2000 TCPCharDriver *s = chr->opaque;
2018 tcp_chr_connect(chr);
2021 static void tcp_chr_close(CharDriverState *chr)
2023 TCPCharDriver *s = chr->opaque;
2039 CharDriverState *chr = NULL;
2070 chr = qemu_mallocz(sizeof(CharDriverState));
2074 chr->filename = qemu_malloc(256);
2076 pstrcpy(chr->filename, 256, "unix:");
2078 pstrcpy(chr->filename, 256, "telnet:");
2080 pstrcpy(chr->filename, 256, "tcp:");
2082 offset = strlen(chr->filename);
2086 fd = unix_listen(host_str, chr->filename + offset, 256 - offset);
2092 fd = inet_listen(host_str, chr->filename + offset, 256 - offset,
2110 chr->opaque = s;
2111 chr->chr_write = tcp_chr_write;
2112 chr->chr_close = tcp_chr_close;
2116 qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
2123 tcp_chr_connect(chr);
2128 chr->filename ? chr->filename : host_str);
2129 tcp_chr_accept(chr);
2133 return chr;
2138 qemu_free(chr);
2145 CharDriverState *chr;
2148 chr = text_console_init(0);
2151 chr = text_console_init(p);
2154 chr = qemu_chr_open_null();
2157 chr = qemu_chr_open_tcp(p, 0, 0);
2160 chr = qemu_chr_open_tcp(p, 1, 0);
2163 chr = qemu_chr_open_udp(p);
2166 chr = qemu_chr_open(label, p, NULL);
2167 if (chr) {
2168 chr = qemu_chr_open_mux(chr);
2169 monitor_init(chr, MONITOR_USE_READLINE);
2174 chr = qemu_chr_open_msmouse();
2178 chr = qemu_chr_open_tcp(p, 0, 1);
2180 chr = qemu_chr_open_file_out(p);
2182 chr = qemu_chr_open_pipe(p);
2184 chr = qemu_chr_open_fdpair(p);
2186 chr = qemu_chr_open_pty();
2188 chr = qemu_chr_open_stdio();
2192 chr = qemu_chr_open_pp(filename);
2196 chr = qemu_chr_open_pp(filename);
2202 chr = qemu_chr_open_tty(filename);
2207 chr = qemu_chr_open_win(filename);
2210 chr = qemu_chr_open_win_pipe(p);
2213 chr = qemu_chr_open_win_con(filename);
2216 chr = qemu_chr_open_win_file_out(p);
2234 chr = chr_baum_init();
2238 chr = NULL;
2241 if (chr) {
2242 if (!chr->filename)
2243 chr->filename = qemu_strdup(filename);
2244 chr->init = init;
2245 chr->label = qemu_strdup(label);
2246 QTAILQ_INSERT_TAIL(&chardevs, chr, next);
2248 return chr;
2251 void qemu_chr_close(CharDriverState *chr)
2253 QTAILQ_REMOVE(&chardevs, chr, next);
2254 if (chr->chr_close)
2255 chr->chr_close(chr);
2256 qemu_free(chr->filename);
2257 qemu_free(chr->label);
2258 qemu_free(chr);
2263 CharDriverState *chr;
2265 QTAILQ_FOREACH(chr, &chardevs, next) {
2266 monitor_printf(mon, "%s: filename=%s\n", chr->label, chr->filename);
