1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25#include "qemu/osdep.h"
26#include "qapi/error.h"
27#include "chardev/char.h"
28#include "io/channel-file.h"
29#include "qemu/sockets.h"
30#include "qemu/error-report.h"
31#include "qemu/module.h"
32#include "qemu/qemu-print.h"
33
34#include "chardev/char-io.h"
35#include "qom/object.h"
36
37struct PtyChardev {
38 Chardev parent;
39 QIOChannel *ioc;
40 int read_bytes;
41
42 int connected;
43 GSource *timer_src;
44};
45typedef struct PtyChardev PtyChardev;
46
47DECLARE_INSTANCE_CHECKER(PtyChardev, PTY_CHARDEV,
48 TYPE_CHARDEV_PTY)
49
50static void pty_chr_state(Chardev *chr, int connected);
51
52static void pty_chr_timer_cancel(PtyChardev *s)
53{
54 if (s->timer_src) {
55 g_source_destroy(s->timer_src);
56 g_source_unref(s->timer_src);
57 s->timer_src = NULL;
58 }
59}
60
61static gboolean pty_chr_timer(gpointer opaque)
62{
63 struct Chardev *chr = CHARDEV(opaque);
64 PtyChardev *s = PTY_CHARDEV(opaque);
65
66 pty_chr_timer_cancel(s);
67 if (!s->connected) {
68
69 qemu_chr_be_update_read_handlers(chr, chr->gcontext);
70 }
71 return FALSE;
72}
73
74static void pty_chr_rearm_timer(Chardev *chr, int ms)
75{
76 PtyChardev *s = PTY_CHARDEV(chr);
77 char *name;
78
79 pty_chr_timer_cancel(s);
80 name = g_strdup_printf("pty-timer-%s", chr->label);
81 s->timer_src = qemu_chr_timeout_add_ms(chr, ms, pty_chr_timer, chr);
82 g_source_set_name(s->timer_src, name);
83 g_free(name);
84}
85
86static void pty_chr_update_read_handler(Chardev *chr)
87{
88 PtyChardev *s = PTY_CHARDEV(chr);
89 GPollFD pfd;
90 int rc;
91 QIOChannelFile *fioc = QIO_CHANNEL_FILE(s->ioc);
92
93 pfd.fd = fioc->fd;
94 pfd.events = G_IO_OUT;
95 pfd.revents = 0;
96 rc = RETRY_ON_EINTR(g_poll(&pfd, 1, 0));
97 assert(rc >= 0);
98
99 if (pfd.revents & G_IO_HUP) {
100 pty_chr_state(chr, 0);
101 } else {
102 pty_chr_state(chr, 1);
103 }
104}
105
106static int char_pty_chr_write(Chardev *chr, const uint8_t *buf, int len)
107{
108 PtyChardev *s = PTY_CHARDEV(chr);
109
110 if (!s->connected) {
111 return len;
112 }
113 return io_channel_send(s->ioc, buf, len);
114}
115
116static GSource *pty_chr_add_watch(Chardev *chr, GIOCondition cond)
117{
118 PtyChardev *s = PTY_CHARDEV(chr);
119 if (!s->connected) {
120 return NULL;
121 }
122 return qio_channel_create_watch(s->ioc, cond);
123}
124
125static int pty_chr_read_poll(void *opaque)
126{
127 Chardev *chr = CHARDEV(opaque);
128 PtyChardev *s = PTY_CHARDEV(opaque);
129
130 s->read_bytes = qemu_chr_be_can_write(chr);
131 return s->read_bytes;
132}
133
134static gboolean pty_chr_read(QIOChannel *chan, GIOCondition cond, void *opaque)
135{
136 Chardev *chr = CHARDEV(opaque);
137 PtyChardev *s = PTY_CHARDEV(opaque);
138 gsize len;
139 uint8_t buf[CHR_READ_BUF_LEN];
140 ssize_t ret;
141
142 len = sizeof(buf);
143 if (len > s->read_bytes) {
144 len = s->read_bytes;
145 }
146 if (len == 0) {
147 return TRUE;
148 }
149 ret = qio_channel_read(s->ioc, (char *)buf, len, NULL);
150 if (ret <= 0) {
151 pty_chr_state(chr, 0);
152 return FALSE;
153 } else {
154 pty_chr_state(chr, 1);
155 qemu_chr_be_write(chr, buf, ret);
156 }
157 return TRUE;
158}
159
160static void pty_chr_state(Chardev *chr, int connected)
161{
162 PtyChardev *s = PTY_CHARDEV(chr);
163
164 if (!connected) {
165 remove_fd_in_watch(chr);
166 s->connected = 0;
167
168
169
170 pty_chr_rearm_timer(chr, 1000);
171 } else {
172 pty_chr_timer_cancel(s);
173 if (!s->connected) {
174 s->connected = 1;
175 qemu_chr_be_event(chr, CHR_EVENT_OPENED);
176 }
177 if (!chr->gsource) {
178 chr->gsource = io_add_watch_poll(chr, s->ioc,
179 pty_chr_read_poll,
180 pty_chr_read,
181 chr, chr->gcontext);
182 }
183 }
184}
185
186static void char_pty_finalize(Object *obj)
187{
188 Chardev *chr = CHARDEV(obj);
189 PtyChardev *s = PTY_CHARDEV(obj);
190
191 pty_chr_state(chr, 0);
192 object_unref(OBJECT(s->ioc));
193 pty_chr_timer_cancel(s);
194 qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
195}
196
197#if defined HAVE_PTY_H
198# include <pty.h>
199#elif defined CONFIG_BSD
200# include <termios.h>
201# if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
202# include <libutil.h>
203# else
204# include <util.h>
205# endif
206#elif defined CONFIG_SOLARIS
207# include <termios.h>
208# include <stropts.h>
209#else
210# include <termios.h>
211#endif
212
213#ifdef __sun__
214
215#if !defined(HAVE_OPENPTY)
216
217static int openpty(int *amaster, int *aslave, char *name,
218 struct termios *termp, struct winsize *winp)
219{
220 const char *slave;
221 int mfd = -1, sfd = -1;
222
223 *amaster = *aslave = -1;
224
225 mfd = open("/dev/ptmx", O_RDWR | O_NOCTTY);
226 if (mfd < 0) {
227 goto err;
228 }
229
230 if (grantpt(mfd) == -1 || unlockpt(mfd) == -1) {
231 goto err;
232 }
233
234 if ((slave = ptsname(mfd)) == NULL) {
235 goto err;
236 }
237
238 if ((sfd = open(slave, O_RDONLY | O_NOCTTY)) == -1) {
239 goto err;
240 }
241
242 if (ioctl(sfd, I_PUSH, "ptem") == -1 ||
243 (termp != NULL && tcgetattr(sfd, termp) < 0)) {
244 goto err;
245 }
246
247 *amaster = mfd;
248 *aslave = sfd;
249
250 if (winp) {
251 ioctl(sfd, TIOCSWINSZ, winp);
252 }
253
254 return 0;
255
256err:
257 if (sfd != -1) {
258 close(sfd);
259 }
260 close(mfd);
261 return -1;
262}
263#endif
264
265static void cfmakeraw (struct termios *termios_p)
266{
267 termios_p->c_iflag &=
268 ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON);
269 termios_p->c_oflag &= ~OPOST;
270 termios_p->c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
271 termios_p->c_cflag &= ~(CSIZE | PARENB);
272 termios_p->c_cflag |= CS8;
273
274 termios_p->c_cc[VMIN] = 0;
275 termios_p->c_cc[VTIME] = 0;
276}
277#endif
278
279
280static int qemu_openpty_raw(int *aslave, char *pty_name)
281{
282 int amaster;
283 struct termios tty;
284#if defined(__OpenBSD__) || defined(__DragonFly__)
285 char pty_buf[PATH_MAX];
286#define q_ptsname(x) pty_buf
287#else
288 char *pty_buf = NULL;
289#define q_ptsname(x) ptsname(x)
290#endif
291
292 if (openpty(&amaster, aslave, pty_buf, NULL, NULL) < 0) {
293 return -1;
294 }
295
296
297 tcgetattr(*aslave, &tty);
298 cfmakeraw(&tty);
299 tcsetattr(*aslave, TCSAFLUSH, &tty);
300
301 if (pty_name) {
302 strcpy(pty_name, q_ptsname(amaster));
303 }
304
305 return amaster;
306}
307
308static void char_pty_open(Chardev *chr,
309 ChardevBackend *backend,
310 bool *be_opened,
311 Error **errp)
312{
313 PtyChardev *s;
314 int master_fd, slave_fd;
315 char pty_name[PATH_MAX];
316 char *name;
317
318 master_fd = qemu_openpty_raw(&slave_fd, pty_name);
319 if (master_fd < 0) {
320 error_setg_errno(errp, errno, "Failed to create PTY");
321 return;
322 }
323
324 close(slave_fd);
325 if (!g_unix_set_fd_nonblocking(master_fd, true, NULL)) {
326 error_setg_errno(errp, errno, "Failed to set FD nonblocking");
327 return;
328 }
329
330 chr->filename = g_strdup_printf("pty:%s", pty_name);
331 qemu_printf("char device redirected to %s (label %s)\n",
332 pty_name, chr->label);
333
334 s = PTY_CHARDEV(chr);
335 s->ioc = QIO_CHANNEL(qio_channel_file_new_fd(master_fd));
336 name = g_strdup_printf("chardev-pty-%s", chr->label);
337 qio_channel_set_name(s->ioc, name);
338 g_free(name);
339 s->timer_src = NULL;
340 *be_opened = false;
341}
342
343static void char_pty_class_init(ObjectClass *oc, void *data)
344{
345 ChardevClass *cc = CHARDEV_CLASS(oc);
346
347 cc->open = char_pty_open;
348 cc->chr_write = char_pty_chr_write;
349 cc->chr_update_read_handler = pty_chr_update_read_handler;
350 cc->chr_add_watch = pty_chr_add_watch;
351}
352
353static const TypeInfo char_pty_type_info = {
354 .name = TYPE_CHARDEV_PTY,
355 .parent = TYPE_CHARDEV,
356 .instance_size = sizeof(PtyChardev),
357 .instance_finalize = char_pty_finalize,
358 .class_init = char_pty_class_init,
359};
360
361static void register_types(void)
362{
363 type_register_static(&char_pty_type_info);
364}
365
366type_init(register_types);
367
