Lines Matching refs:chr
138 CharDriverState *chr;
142 QTAILQ_FOREACH(chr, &chardevs, next) {
143 qemu_chr_reset(chr);
207 static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
214 CharDriverState *chr;
216 chr = qemu_mallocz(sizeof(CharDriverState));
217 chr->chr_write = null_chr_write;
218 return chr;
246 static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
248 MuxDriver *d = chr->opaque;
297 static void mux_print_help(CharDriverState *chr)
311 chr->chr_write(chr, (uint8_t *)cbuf, strlen(cbuf));
315 chr->chr_write(chr, (uint8_t *)ebuf, strlen(ebuf));
317 chr->chr_write(chr, (uint8_t *)&mux_help[i][j], 1);
328 static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch)
337 mux_print_help(chr);
342 chr->chr_write(chr,(uint8_t *)term,strlen(term));
355 qemu_chr_event(chr, CHR_EVENT_BREAK);
359 mux_chr_send_event(d, chr->focus, CHR_EVENT_MUX_OUT);
360 chr->focus++;
361 if (chr->focus >= d->mux_cnt)
362 chr->focus = 0;
363 mux_chr_send_event(d, chr->focus, CHR_EVENT_MUX_IN);
380 static void mux_chr_accept_input(CharDriverState *chr)
382 int m = chr->focus;
383 MuxDriver *d = chr->opaque;
395 CharDriverState *chr = opaque;
396 MuxDriver *d = chr->opaque;
397 int m = chr->focus;
408 CharDriverState *chr = opaque;
409 MuxDriver *d = chr->opaque;
410 int m = chr->focus;
416 if (mux_proc_byte(chr, d, buf[i])) {
428 CharDriverState *chr = opaque;
429 MuxDriver *d = chr->opaque;
437 static void mux_chr_update_read_handler(CharDriverState *chr)
439 MuxDriver *d = chr->opaque;
445 d->ext_opaque[d->mux_cnt] = chr->handler_opaque;
446 d->chr_can_read[d->mux_cnt] = chr->chr_can_read;
447 d->chr_read[d->mux_cnt] = chr->chr_read;
448 d->chr_event[d->mux_cnt] = chr->chr_event;
452 mux_chr_event, chr);
454 chr->focus = d->mux_cnt;
460 CharDriverState *chr;
463 chr = qemu_mallocz(sizeof(CharDriverState));
466 chr->opaque = d;
468 chr->focus = -1;
469 chr->chr_write = mux_chr_write;
470 chr->chr_update_read_handler = mux_chr_update_read_handler;
471 chr->chr_accept_input = mux_chr_accept_input;
472 return chr;
537 static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
539 FDCharDriver *s = chr->opaque;
545 CharDriverState *chr = opaque;
546 FDCharDriver *s = chr->opaque;
548 s->max_size = qemu_chr_can_read(chr);
554 CharDriverState *chr = opaque;
555 FDCharDriver *s = chr->opaque;
571 qemu_chr_read(chr, buf, size);
575 static void fd_chr_update_read_handler(CharDriverState *chr)
577 FDCharDriver *s = chr->opaque;
583 fd_chr_read, NULL, chr);
588 static void fd_chr_close(struct CharDriverState *chr)
590 FDCharDriver *s = chr->opaque;
605 CharDriverState *chr;
608 chr = qemu_mallocz(sizeof(CharDriverState));
612 chr->opaque = s;
613 chr->chr_write = fd_chr_write;
614 chr->chr_update_read_handler = fd_chr_update_read_handler;
615 chr->chr_close = fd_chr_close;
617 qemu_chr_reset(chr);
619 return chr;
664 CharDriverState *chr = opaque;
667 if (term_fifo_size != 0 && qemu_chr_can_read(chr) > 0) {
668 qemu_chr_read(chr, term_fifo, 1);
682 CharDriverState *chr = opaque;
691 if (qemu_chr_can_read(chr) > 0) {
692 qemu_chr_read(chr, buf, 1);
738 static void qemu_chr_close_stdio(struct CharDriverState *chr)
743 fd_chr_close(chr);
748 CharDriverState *chr;
752 chr = qemu_chr_open_fd(0, 1);
753 chr->chr_close = qemu_chr_close_stdio;
754 qemu_set_fd_handler2(0, stdio_read_poll, stdio_read, NULL, chr);
758 return chr;
829 static void pty_chr_update_read_handler(CharDriverState *chr);
830 static void pty_chr_state(CharDriverState *chr, int connected);
832 static int pty_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
834 PtyCharDriver *s = chr->opaque;
838 pty_chr_update_read_handler(chr);
846 CharDriverState *chr = opaque;
847 PtyCharDriver *s = chr->opaque;
849 s->read_bytes = qemu_chr_can_read(chr);
855 CharDriverState *chr = opaque;
856 PtyCharDriver *s = chr->opaque;
868 pty_chr_state(chr, 0);
872 pty_chr_state(chr, 1);
873 qemu_chr_read(chr, buf, size);
877 static void pty_chr_update_read_handler(CharDriverState *chr)
879 PtyCharDriver *s = chr->opaque;
882 pty_chr_read, NULL, chr);
895 static void pty_chr_state(CharDriverState *chr, int connected)
897 PtyCharDriver *s = chr->opaque;
909 qemu_chr_reset(chr);
916 struct CharDriverState *chr = opaque;
917 PtyCharDriver *s = chr->opaque;
924 pty_chr_state(chr, 1);
929 pty_chr_update_read_handler(chr);
932 static void pty_chr_close(struct CharDriverState *chr)
934 PtyCharDriver *s = chr->opaque;
945 CharDriverState *chr;
957 chr = qemu_mallocz(sizeof(CharDriverState));
971 chr->filename = qemu_malloc(len);
972 snprintf(chr->filename, len, "pty:%s", q_ptsname(s->fd));
975 chr->opaque = s;
976 chr->chr_write = pty_chr_write;
977 chr->chr_update_read_handler = pty_chr_update_read_handler;
978 chr->chr_close = pty_chr_close;
980 s->timer = qemu_new_timer(rt_clock, pty_chr_timer, chr);
982 return chr;
1065 static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)
1067 FDCharDriver *s = chr->opaque;
1134 CharDriverState *chr;
1139 chr = qemu_chr_open_fd(fd, fd);
1140 if (!chr) {
1144 chr->chr_ioctl = tty_serial_ioctl;
1145 qemu_chr_reset(chr);
1146 return chr;
1172 static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
1174 ParallelCharDriver *drv = chr->opaque;
1253 static void pp_close(CharDriverState *chr)
1255 ParallelCharDriver *drv = chr->opaque;
1266 CharDriverState *chr;
1283 chr = qemu_mallocz(sizeof(CharDriverState));
1284 chr->chr_write = null_chr_write;
1285 chr->chr_ioctl = pp_ioctl;
1286 chr->chr_close = pp_close;
1287 chr->opaque = drv;
1289 qemu_chr_reset(chr);
1291 return chr;
1296 static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
1298 int fd = (int)chr->opaque;
1335 CharDriverState *chr;
1342 chr = qemu_mallocz(sizeof(CharDriverState));
1343 chr->opaque = (void *)fd;
1344 chr->chr_write = null_chr_write;
1345 chr->chr_ioctl = pp_ioctl;
1346 return chr;
1368 static void win_chr_close(CharDriverState *chr)
1370 WinCharState *s = chr->opaque;
1385 qemu_del_polling_cb(win_chr_pipe_poll, chr);
1387 qemu_del_polling_cb(win_chr_poll, chr);
1390 static int win_chr_init(CharDriverState *chr, const char *filename)
1392 WinCharState *s = chr->opaque;
1449 qemu_add_polling_cb(win_chr_poll, chr);
1453 win_chr_close(chr);
1457 static int win_chr_write(CharDriverState *chr, const uint8_t *buf, int len1)
1459 WinCharState *s = chr->opaque;
1491 static int win_chr_read_poll(CharDriverState *chr)
1493 WinCharState *s = chr->opaque;
1495 s->max_size = qemu_chr_can_read(chr);
1499 static void win_chr_readfile(CharDriverState *chr)
1501 WinCharState *s = chr->opaque;
1517 qemu_chr_read(chr, buf, size);
1521 static void win_chr_read(CharDriverState *chr)
1523 WinCharState *s = chr->opaque;
1530 win_chr_readfile(chr);
1535 CharDriverState *chr = opaque;
1536 WinCharState *s = chr->opaque;
1543 win_chr_read_poll(chr);
1544 win_chr_read(chr);
1552 CharDriverState *chr;
1555 chr = qemu_mallocz(sizeof(CharDriverState));
1557 chr->opaque = s;
1558 chr->chr_write = win_chr_write;
1559 chr->chr_close = win_chr_close;
1561 if (win_chr_init(chr, filename) < 0) {
1563 free(chr);
1566 qemu_chr_reset(chr);
1567 return chr;
1572 CharDriverState *chr = opaque;
1573 WinCharState *s = chr->opaque;
1579 win_chr_read_poll(chr);
1580 win_chr_read(chr);
1586 static int win_chr_pipe_init(CharDriverState *chr, const char *filename)
1588 WinCharState *s = chr->opaque;
1640 qemu_add_polling_cb(win_chr_pipe_poll, chr);
1644 win_chr_close(chr);
1651 CharDriverState *chr;
1654 chr = qemu_mallocz(sizeof(CharDriverState));
1656 chr->opaque = s;
1657 chr->chr_write = win_chr_write;
1658 chr->chr_close = win_chr_close;
1660 if (win_chr_pipe_init(chr, filename) < 0) {
1662 free(chr);
1665 qemu_chr_reset(chr);
1666 return chr;
1671 CharDriverState *chr;
1674 chr = qemu_mallocz(sizeof(CharDriverState));
1677 chr->opaque = s;
1678 chr->chr_write = win_chr_write;
1679 qemu_chr_reset(chr);
1680 return chr;
1713 static int udp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1715 NetCharDriver *s = chr->opaque;
1723 CharDriverState *chr = opaque;
1724 NetCharDriver *s = chr->opaque;
1726 s->max_size = qemu_chr_can_read(chr);
1732 qemu_chr_read(chr, &s->buf[s->bufptr], 1);
1734 s->max_size = qemu_chr_can_read(chr);
1741 CharDriverState *chr = opaque;
1742 NetCharDriver *s = chr->opaque;
1753 qemu_chr_read(chr, &s->buf[s->bufptr], 1);
1755 s->max_size = qemu_chr_can_read(chr);
1759 static void udp_chr_update_read_handler(CharDriverState *chr)
1761 NetCharDriver *s = chr->opaque;
1765 udp_chr_read, NULL, chr);
1769 static void udp_chr_close(CharDriverState *chr)
1771 NetCharDriver *s = chr->opaque;
1781 CharDriverState *chr = NULL;
1786 chr = qemu_mallocz(sizeof(CharDriverState));
1809 chr->opaque = s;
1810 chr->chr_write = udp_chr_write;
1811 chr->chr_update_read_handler = udp_chr_update_read_handler;
1812 chr->chr_close = udp_chr_close;
1813 return chr;
1816 if (chr)
1817 free(chr);
1839 static int tcp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1841 TCPCharDriver *s = chr->opaque;
1852 CharDriverState *chr = opaque;
1853 TCPCharDriver *s = chr->opaque;
1856 s->max_size = qemu_chr_can_read(chr);
1862 static void tcp_chr_process_IAC_bytes(CharDriverState *chr,
1889 qemu_chr_event(chr, CHR_EVENT_BREAK);
1912 CharDriverState *chr = opaque;
1913 TCPCharDriver *s = chr->opaque;
1927 qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
1934 chr, s, buf, &size);
1936 qemu_chr_read(chr, buf, size);
1942 CharDriverState *chr = opaque;
1943 TCPCharDriver *s = chr->opaque;
1947 tcp_chr_read, NULL, chr);
1948 qemu_chr_reset(chr);
1974 CharDriverState *chr = opaque;
1975 TCPCharDriver *s = chr->opaque;
2009 tcp_chr_connect(chr);
2012 static void tcp_chr_close(CharDriverState *chr)
2014 TCPCharDriver *s = chr->opaque;
2030 CharDriverState *chr = NULL;
2061 chr = qemu_mallocz(sizeof(CharDriverState));
2065 chr->filename = qemu_malloc(256);
2067 pstrcpy(chr->filename, 256, "unix:");
2069 pstrcpy(chr->filename, 256, "telnet:");
2071 pstrcpy(chr->filename, 256, "tcp:");
2073 offset = strlen(chr->filename);
2077 fd = unix_listen(host_str, chr->filename + offset, 256 - offset);
2083 fd = inet_listen(host_str, chr->filename + offset, 256 - offset,
2101 chr->opaque = s;
2102 chr->chr_write = tcp_chr_write;
2103 chr->chr_close = tcp_chr_close;
2107 qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
2114 tcp_chr_connect(chr);
2119 chr->filename ? chr->filename : host_str);
2120 tcp_chr_accept(chr);
2124 return chr;
2129 qemu_free(chr);
2136 CharDriverState *chr;
2139 chr = text_console_init(0);
2142 chr = text_console_init(p);
2145 chr = qemu_chr_open_null();
2148 chr = qemu_chr_open_tcp(p, 0, 0);
2151 chr = qemu_chr_open_tcp(p, 1, 0);
2154 chr = qemu_chr_open_udp(p);
2157 chr = qemu_chr_open(label, p, NULL);
2158 if (chr) {
2159 chr = qemu_chr_open_mux(chr);
2160 monitor_init(chr, MONITOR_USE_READLINE);
2165 chr = qemu_chr_open_msmouse();
2169 chr = qemu_chr_open_tcp(p, 0, 1);
2171 chr = qemu_chr_open_file_out(p);
2173 chr = qemu_chr_open_pipe(p);
2175 chr = qemu_chr_open_pty();
2177 chr = qemu_chr_open_stdio();
2181 chr = qemu_chr_open_pp(filename);
2185 chr = qemu_chr_open_pp(filename);
2191 chr = qemu_chr_open_tty(filename);
2196 chr = qemu_chr_open_win(filename);
2199 chr = qemu_chr_open_win_pipe(p);
2202 chr = qemu_chr_open_win_con(filename);
2205 chr = qemu_chr_open_win_file_out(p);
2210 chr = chr_baum_init();
2214 chr = NULL;
2217 if (chr) {
2218 if (!chr->filename)
2219 chr->filename = qemu_strdup(filename);
2220 chr->init = init;
2221 chr->label = qemu_strdup(label);
2222 TAILQ_INSERT_TAIL(&chardevs, chr, next);
2224 return chr;
2227 void qemu_chr_close(CharDriverState *chr)
2229 TAILQ_REMOVE(&chardevs, chr, next);
2230 if (chr->chr_close)
2231 chr->chr_close(chr);
2232 qemu_free(chr->filename);
2233 qemu_free(chr->label);
2234 qemu_free(chr);
2239 CharDriverState *chr;
2241 QTAILQ_FOREACH(chr, &chardevs, next) {
2242 monitor_printf(mon, "%s: filename=%s\n", chr->label, chr->filename);
