/src/qemu/chardev/char-socket.c
Line | Count | Source |
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 | | |
25 | | #include "qemu/osdep.h" |
26 | | #include "chardev/char.h" |
27 | | #include "io/channel-socket.h" |
28 | | #include "io/channel-websock.h" |
29 | | #include "qemu/error-report.h" |
30 | | #include "qemu/module.h" |
31 | | #include "qemu/option.h" |
32 | | #include "qapi/error.h" |
33 | | #include "qapi/clone-visitor.h" |
34 | | #include "qapi/qapi-visit-sockets.h" |
35 | | #include "qemu/yank.h" |
36 | | #include "trace.h" |
37 | | |
38 | | #include "chardev/char-io.h" |
39 | | #include "chardev/char-socket.h" |
40 | | |
41 | | static gboolean socket_reconnect_timeout(gpointer opaque); |
42 | | static void tcp_chr_telnet_init(Chardev *chr); |
43 | | static char *qemu_chr_compute_filename(SocketChardev *s); |
44 | | |
45 | | static void tcp_chr_change_state(SocketChardev *s, TCPChardevState state) |
46 | 0 | { |
47 | 0 | switch (state) { |
48 | 0 | case TCP_CHARDEV_STATE_DISCONNECTED: |
49 | 0 | break; |
50 | 0 | case TCP_CHARDEV_STATE_CONNECTING: |
51 | 0 | assert(s->state == TCP_CHARDEV_STATE_DISCONNECTED); |
52 | 0 | break; |
53 | 0 | case TCP_CHARDEV_STATE_CONNECTED: |
54 | 0 | assert(s->state == TCP_CHARDEV_STATE_CONNECTING); |
55 | 0 | break; |
56 | 0 | } |
57 | 0 | s->state = state; |
58 | 0 | } |
59 | | |
60 | | static void tcp_chr_reconn_timer_cancel(SocketChardev *s) |
61 | 0 | { |
62 | 0 | if (s->reconnect_timer) { |
63 | 0 | g_source_destroy(s->reconnect_timer); |
64 | 0 | g_source_unref(s->reconnect_timer); |
65 | 0 | s->reconnect_timer = NULL; |
66 | 0 | } |
67 | 0 | } |
68 | | |
69 | | static void qemu_chr_socket_restart_timer(Chardev *chr) |
70 | 0 | { |
71 | 0 | SocketChardev *s = SOCKET_CHARDEV(chr); |
72 | 0 | char *name; |
73 | |
|
74 | 0 | assert(s->state == TCP_CHARDEV_STATE_DISCONNECTED); |
75 | 0 | assert(!s->reconnect_timer); |
76 | 0 | name = g_strdup_printf("chardev-socket-reconnect-%s", chr->label); |
77 | 0 | s->reconnect_timer = qemu_chr_timeout_add_ms(chr, |
78 | 0 | s->reconnect_time_ms, |
79 | 0 | socket_reconnect_timeout, |
80 | 0 | chr); |
81 | 0 | g_source_set_name(s->reconnect_timer, name); |
82 | 0 | g_free(name); |
83 | 0 | } |
84 | | |
85 | | static void check_report_connect_error(Chardev *chr, |
86 | | Error *err) |
87 | 0 | { |
88 | 0 | SocketChardev *s = SOCKET_CHARDEV(chr); |
89 | |
|
90 | 0 | if (!s->connect_err_reported) { |
91 | 0 | error_reportf_err(err, |
92 | 0 | "Unable to connect character device %s: ", |
93 | 0 | chr->label); |
94 | 0 | s->connect_err_reported = true; |
95 | 0 | } else { |
96 | 0 | error_free(err); |
97 | 0 | } |
98 | 0 | qemu_chr_socket_restart_timer(chr); |
99 | 0 | } |
100 | | |
101 | | static void tcp_chr_accept(QIONetListener *listener, |
102 | | QIOChannelSocket *cioc, |
103 | | void *opaque); |
104 | | |
105 | | static int tcp_chr_read_poll(void *opaque); |
106 | | static void tcp_chr_disconnect_locked(Chardev *chr); |
107 | | |
108 | | /* Called with chr_write_lock held. */ |
109 | | static int tcp_chr_write(Chardev *chr, const uint8_t *buf, int len) |
110 | 0 | { |
111 | 0 | SocketChardev *s = SOCKET_CHARDEV(chr); |
112 | |
|
113 | 0 | if (s->state == TCP_CHARDEV_STATE_CONNECTED) { |
114 | 0 | int ret = io_channel_send_full(s->ioc, buf, len, |
115 | 0 | s->write_msgfds, |
116 | 0 | s->write_msgfds_num); |
117 | | |
118 | | /* free the written msgfds in any cases |
119 | | * other than ret < 0 && errno == EAGAIN |
120 | | */ |
121 | 0 | if (!(ret < 0 && EAGAIN == errno) |
122 | 0 | && s->write_msgfds_num) { |
123 | 0 | g_free(s->write_msgfds); |
124 | 0 | s->write_msgfds = 0; |
125 | 0 | s->write_msgfds_num = 0; |
126 | 0 | } |
127 | |
|
128 | 0 | if (ret < 0 && errno != EAGAIN) { |
129 | 0 | if (tcp_chr_read_poll(chr) <= 0) { |
130 | | /* Perform disconnect and return error. */ |
131 | 0 | trace_chr_socket_poll_err(chr, chr->label); |
132 | 0 | tcp_chr_disconnect_locked(chr); |
133 | 0 | } /* else let the read handler finish it properly */ |
134 | 0 | } |
135 | |
|
136 | 0 | return ret; |
137 | 0 | } else { |
138 | | /* Indicate an error. */ |
139 | 0 | errno = EIO; |
140 | 0 | return -1; |
141 | 0 | } |
142 | 0 | } |
143 | | |
144 | | static int tcp_chr_read_poll(void *opaque) |
145 | 0 | { |
146 | 0 | Chardev *chr = CHARDEV(opaque); |
147 | 0 | SocketChardev *s = SOCKET_CHARDEV(opaque); |
148 | 0 | if (s->state != TCP_CHARDEV_STATE_CONNECTED) { |
149 | 0 | return 0; |
150 | 0 | } |
151 | 0 | s->max_size = qemu_chr_be_can_write(chr); |
152 | 0 | return s->max_size; |
153 | 0 | } |
154 | | |
155 | | static void tcp_chr_process_IAC_bytes(Chardev *chr, |
156 | | SocketChardev *s, |
157 | | uint8_t *buf, int *size) |
158 | 0 | { |
159 | | /* Handle any telnet or tn3270 client's basic IAC options. |
160 | | * For telnet options, it satisfies char by char mode with no echo. |
161 | | * For tn3270 options, it satisfies binary mode with EOR. |
162 | | * All IAC options will be removed from the buf and the do_opt |
163 | | * pointer will be used to track the state of the width of the |
164 | | * IAC information. |
165 | | * |
166 | | * RFC854: "All TELNET commands consist of at least a two byte sequence. |
167 | | * The commands dealing with option negotiation are three byte sequences, |
168 | | * the third byte being the code for the option referenced." |
169 | | * "IAC BREAK", "IAC IP", "IAC NOP" and the double IAC are two bytes. |
170 | | * "IAC SB", "IAC SE" and "IAC EOR" are saved to split up data boundary |
171 | | * for tn3270. |
172 | | * NOP, Break and Interrupt Process(IP) might be encountered during a TN3270 |
173 | | * session, and NOP and IP need to be done later. |
174 | | */ |
175 | |
|
176 | 0 | int i; |
177 | 0 | int j = 0; |
178 | |
|
179 | 0 | for (i = 0; i < *size; i++) { |
180 | 0 | if (s->do_telnetopt > 1) { |
181 | 0 | if ((unsigned char)buf[i] == IAC && s->do_telnetopt == 2) { |
182 | | /* Double IAC means send an IAC */ |
183 | 0 | if (j != i) { |
184 | 0 | buf[j] = buf[i]; |
185 | 0 | } |
186 | 0 | j++; |
187 | 0 | s->do_telnetopt = 1; |
188 | 0 | } else { |
189 | 0 | if ((unsigned char)buf[i] == IAC_BREAK |
190 | 0 | && s->do_telnetopt == 2) { |
191 | | /* Handle IAC break commands by sending a serial break */ |
192 | 0 | qemu_chr_be_event(chr, CHR_EVENT_BREAK); |
193 | 0 | s->do_telnetopt++; |
194 | 0 | } else if (s->is_tn3270 && ((unsigned char)buf[i] == IAC_EOR |
195 | 0 | || (unsigned char)buf[i] == IAC_SB |
196 | 0 | || (unsigned char)buf[i] == IAC_SE) |
197 | 0 | && s->do_telnetopt == 2) { |
198 | 0 | buf[j++] = IAC; |
199 | 0 | buf[j++] = buf[i]; |
200 | 0 | s->do_telnetopt++; |
201 | 0 | } else if (s->is_tn3270 && ((unsigned char)buf[i] == IAC_IP |
202 | 0 | || (unsigned char)buf[i] == IAC_NOP) |
203 | 0 | && s->do_telnetopt == 2) { |
204 | | /* TODO: IP and NOP need to be implemented later. */ |
205 | 0 | s->do_telnetopt++; |
206 | 0 | } |
207 | 0 | s->do_telnetopt++; |
208 | 0 | } |
209 | 0 | if (s->do_telnetopt >= 4) { |
210 | 0 | s->do_telnetopt = 1; |
211 | 0 | } |
212 | 0 | } else { |
213 | 0 | if ((unsigned char)buf[i] == IAC) { |
214 | 0 | s->do_telnetopt = 2; |
215 | 0 | } else { |
216 | 0 | if (j != i) { |
217 | 0 | buf[j] = buf[i]; |
218 | 0 | } |
219 | 0 | j++; |
220 | 0 | } |
221 | 0 | } |
222 | 0 | } |
223 | 0 | *size = j; |
224 | 0 | } |
225 | | |
226 | | static int tcp_chr_get_msgfds(Chardev *chr, int *fds, int num) |
227 | 0 | { |
228 | 0 | SocketChardev *s = SOCKET_CHARDEV(chr); |
229 | |
|
230 | 0 | int to_copy = (s->read_msgfds_num < num) ? s->read_msgfds_num : num; |
231 | |
|
232 | 0 | assert(num <= TCP_MAX_FDS); |
233 | |
|
234 | 0 | if (to_copy) { |
235 | 0 | int i; |
236 | |
|
237 | 0 | memcpy(fds, s->read_msgfds, to_copy * sizeof(int)); |
238 | | |
239 | | /* Close unused fds */ |
240 | 0 | for (i = to_copy; i < s->read_msgfds_num; i++) { |
241 | 0 | close(s->read_msgfds[i]); |
242 | 0 | } |
243 | |
|
244 | 0 | g_free(s->read_msgfds); |
245 | 0 | s->read_msgfds = 0; |
246 | 0 | s->read_msgfds_num = 0; |
247 | 0 | } |
248 | |
|
249 | 0 | return to_copy; |
250 | 0 | } |
251 | | |
252 | | static int tcp_chr_set_msgfds(Chardev *chr, int *fds, int num) |
253 | 0 | { |
254 | 0 | SocketChardev *s = SOCKET_CHARDEV(chr); |
255 | | |
256 | | /* clear old pending fd array */ |
257 | 0 | g_free(s->write_msgfds); |
258 | 0 | s->write_msgfds = NULL; |
259 | 0 | s->write_msgfds_num = 0; |
260 | |
|
261 | 0 | if ((s->state != TCP_CHARDEV_STATE_CONNECTED) || |
262 | 0 | !qio_channel_has_feature(s->ioc, |
263 | 0 | QIO_CHANNEL_FEATURE_FD_PASS)) { |
264 | 0 | return -1; |
265 | 0 | } |
266 | | |
267 | 0 | if (num) { |
268 | 0 | s->write_msgfds = g_new(int, num); |
269 | 0 | memcpy(s->write_msgfds, fds, num * sizeof(int)); |
270 | 0 | } |
271 | |
|
272 | 0 | s->write_msgfds_num = num; |
273 | |
|
274 | 0 | return 0; |
275 | 0 | } |
276 | | |
277 | | static ssize_t tcp_chr_recv(Chardev *chr, char *buf, size_t len) |
278 | 0 | { |
279 | 0 | SocketChardev *s = SOCKET_CHARDEV(chr); |
280 | 0 | struct iovec iov = { .iov_base = buf, .iov_len = len }; |
281 | 0 | int ret; |
282 | 0 | size_t i; |
283 | 0 | int *msgfds = NULL; |
284 | 0 | size_t msgfds_num = 0; |
285 | 0 | Error *err = NULL; |
286 | |
|
287 | 0 | if (qio_channel_has_feature(s->ioc, QIO_CHANNEL_FEATURE_FD_PASS)) { |
288 | 0 | ret = qio_channel_readv_full(s->ioc, &iov, 1, |
289 | 0 | &msgfds, &msgfds_num, |
290 | 0 | 0, &err); |
291 | 0 | } else { |
292 | 0 | ret = qio_channel_readv_full(s->ioc, &iov, 1, |
293 | 0 | NULL, NULL, |
294 | 0 | 0, &err); |
295 | 0 | } |
296 | |
|
297 | 0 | if (msgfds_num) { |
298 | | /* |
299 | | * Close and clean previous read_msgfds, they are obsolete at |
300 | | * this point, regardless result of new call to |
301 | | * qio_channel_readv_full(). |
302 | | */ |
303 | |
|
304 | 0 | for (i = 0; i < s->read_msgfds_num; i++) { |
305 | 0 | close(s->read_msgfds[i]); |
306 | 0 | } |
307 | |
|
308 | 0 | if (s->read_msgfds_num) { |
309 | 0 | g_free(s->read_msgfds); |
310 | 0 | } |
311 | |
|
312 | 0 | s->read_msgfds = msgfds; |
313 | 0 | s->read_msgfds_num = msgfds_num; |
314 | 0 | } |
315 | |
|
316 | 0 | if (ret == QIO_CHANNEL_ERR_BLOCK) { |
317 | 0 | errno = EAGAIN; |
318 | 0 | ret = -1; |
319 | 0 | } else if (ret == -1) { |
320 | 0 | trace_chr_socket_recv_err(chr, chr->label, error_get_pretty(err)); |
321 | 0 | error_free(err); |
322 | 0 | errno = EIO; |
323 | 0 | } else if (ret == 0) { |
324 | 0 | trace_chr_socket_recv_eof(chr, chr->label); |
325 | 0 | } |
326 | |
|
327 | 0 | return ret; |
328 | 0 | } |
329 | | |
330 | | static GSource *tcp_chr_add_watch(Chardev *chr, GIOCondition cond) |
331 | 0 | { |
332 | 0 | SocketChardev *s = SOCKET_CHARDEV(chr); |
333 | 0 | if (!s->ioc) { |
334 | 0 | return NULL; |
335 | 0 | } |
336 | 0 | return qio_channel_create_watch(s->ioc, cond); |
337 | 0 | } |
338 | | |
339 | | static void remove_hup_source(SocketChardev *s) |
340 | 0 | { |
341 | 0 | if (s->hup_source != NULL) { |
342 | 0 | g_source_destroy(s->hup_source); |
343 | 0 | g_source_unref(s->hup_source); |
344 | 0 | s->hup_source = NULL; |
345 | 0 | } |
346 | 0 | } |
347 | | |
348 | | static void char_socket_yank_iochannel(void *opaque) |
349 | 0 | { |
350 | 0 | QIOChannel *ioc = QIO_CHANNEL(opaque); |
351 | |
|
352 | 0 | qio_channel_shutdown(ioc, QIO_CHANNEL_SHUTDOWN_BOTH, NULL); |
353 | 0 | } |
354 | | |
355 | | static void tcp_chr_free_connection(Chardev *chr) |
356 | 0 | { |
357 | 0 | SocketChardev *s = SOCKET_CHARDEV(chr); |
358 | 0 | int i; |
359 | |
|
360 | 0 | if (s->read_msgfds_num) { |
361 | 0 | for (i = 0; i < s->read_msgfds_num; i++) { |
362 | 0 | close(s->read_msgfds[i]); |
363 | 0 | } |
364 | 0 | g_free(s->read_msgfds); |
365 | 0 | s->read_msgfds = NULL; |
366 | 0 | s->read_msgfds_num = 0; |
367 | 0 | } |
368 | |
|
369 | 0 | remove_hup_source(s); |
370 | |
|
371 | 0 | tcp_chr_set_msgfds(chr, NULL, 0); |
372 | 0 | remove_fd_in_watch(chr); |
373 | |
|
374 | 0 | if (s->registered_yank && s->sioc && |
375 | 0 | (s->state == TCP_CHARDEV_STATE_CONNECTING |
376 | 0 | || s->state == TCP_CHARDEV_STATE_CONNECTED)) { |
377 | 0 | yank_unregister_function(CHARDEV_YANK_INSTANCE(chr->label), |
378 | 0 | char_socket_yank_iochannel, |
379 | 0 | QIO_CHANNEL(s->sioc)); |
380 | 0 | } |
381 | |
|
382 | 0 | if (s->ioc) { |
383 | 0 | qio_channel_close(s->ioc, NULL); |
384 | 0 | } |
385 | 0 | object_unref(OBJECT(s->sioc)); |
386 | 0 | s->sioc = NULL; |
387 | 0 | object_unref(OBJECT(s->ioc)); |
388 | 0 | s->ioc = NULL; |
389 | 0 | tcp_chr_change_state(s, TCP_CHARDEV_STATE_DISCONNECTED); |
390 | 0 | } |
391 | | |
392 | | static const char *qemu_chr_socket_protocol(SocketChardev *s) |
393 | 0 | { |
394 | 0 | if (s->is_telnet) { |
395 | 0 | return "telnet"; |
396 | 0 | } |
397 | 0 | return s->is_websock ? "websocket" : "tcp"; |
398 | 0 | } |
399 | | |
400 | | static char *qemu_chr_socket_address(SocketChardev *s, const char *prefix) |
401 | 0 | { |
402 | 0 | switch (s->addr->type) { |
403 | 0 | case SOCKET_ADDRESS_TYPE_INET: |
404 | 0 | return g_strdup_printf("%s%s:%s:%s%s", prefix, |
405 | 0 | qemu_chr_socket_protocol(s), |
406 | 0 | s->addr->u.inet.host, |
407 | 0 | s->addr->u.inet.port, |
408 | 0 | s->is_listen ? ",server=on" : ""); |
409 | 0 | break; |
410 | 0 | case SOCKET_ADDRESS_TYPE_UNIX: |
411 | 0 | { |
412 | 0 | const char *tight = "", *abstract = ""; |
413 | 0 | UnixSocketAddress *sa = &s->addr->u.q_unix; |
414 | |
|
415 | 0 | #ifdef CONFIG_LINUX |
416 | 0 | if (sa->has_abstract && sa->abstract) { |
417 | 0 | abstract = ",abstract=on"; |
418 | 0 | if (sa->has_tight && sa->tight) { |
419 | 0 | tight = ",tight=on"; |
420 | 0 | } |
421 | 0 | } |
422 | 0 | #endif |
423 | |
|
424 | 0 | return g_strdup_printf("%sunix:%s%s%s%s", prefix, sa->path, |
425 | 0 | abstract, tight, |
426 | 0 | s->is_listen ? ",server=on" : ""); |
427 | 0 | break; |
428 | 0 | } |
429 | 0 | case SOCKET_ADDRESS_TYPE_FD: |
430 | 0 | return g_strdup_printf("%sfd:%s%s", prefix, s->addr->u.fd.str, |
431 | 0 | s->is_listen ? ",server=on" : ""); |
432 | 0 | break; |
433 | 0 | case SOCKET_ADDRESS_TYPE_VSOCK: |
434 | 0 | return g_strdup_printf("%svsock:%s:%s", prefix, |
435 | 0 | s->addr->u.vsock.cid, |
436 | 0 | s->addr->u.vsock.port); |
437 | 0 | default: |
438 | 0 | abort(); |
439 | 0 | } |
440 | 0 | } |
441 | | |
442 | | static char *tcp_chr_get_filename(Chardev *chr) |
443 | 0 | { |
444 | 0 | SocketChardev *s = SOCKET_CHARDEV(chr); |
445 | |
|
446 | 0 | if (s->state == TCP_CHARDEV_STATE_CONNECTED) { |
447 | 0 | return qemu_chr_compute_filename(s); |
448 | 0 | } else if (s->addr) { |
449 | 0 | return qemu_chr_socket_address(s, "disconnected:"); |
450 | 0 | } |
451 | | |
452 | 0 | return g_strdup("disconnected:socket"); |
453 | 0 | } |
454 | | |
455 | | /* NB may be called even if tcp_chr_connect has not been |
456 | | * reached, due to TLS or telnet initialization failure, |
457 | | * so can *not* assume s->state == TCP_CHARDEV_STATE_CONNECTED |
458 | | * This must be called with chr->chr_write_lock held. |
459 | | */ |
460 | | static void tcp_chr_disconnect_locked(Chardev *chr) |
461 | 0 | { |
462 | 0 | SocketChardev *s = SOCKET_CHARDEV(chr); |
463 | 0 | bool emit_close = s->state == TCP_CHARDEV_STATE_CONNECTED; |
464 | |
|
465 | 0 | trace_chr_socket_disconnect(chr, chr->label); |
466 | 0 | tcp_chr_free_connection(chr); |
467 | |
|
468 | 0 | if (s->listener) { |
469 | 0 | qio_net_listener_set_client_func_full(s->listener, tcp_chr_accept, |
470 | 0 | chr, NULL, chr->gcontext); |
471 | 0 | } |
472 | 0 | if (emit_close) { |
473 | 0 | qemu_chr_be_event(chr, CHR_EVENT_CLOSED); |
474 | 0 | } |
475 | 0 | if (s->reconnect_time_ms && !s->reconnect_timer) { |
476 | 0 | qemu_chr_socket_restart_timer(chr); |
477 | 0 | } |
478 | 0 | } |
479 | | |
480 | | static void tcp_chr_disconnect(Chardev *chr) |
481 | 0 | { |
482 | 0 | qemu_mutex_lock(&chr->chr_write_lock); |
483 | 0 | tcp_chr_disconnect_locked(chr); |
484 | 0 | qemu_mutex_unlock(&chr->chr_write_lock); |
485 | 0 | } |
486 | | |
487 | | static gboolean tcp_chr_read(QIOChannel *chan, GIOCondition cond, void *opaque) |
488 | 0 | { |
489 | 0 | Chardev *chr = CHARDEV(opaque); |
490 | 0 | SocketChardev *s = SOCKET_CHARDEV(opaque); |
491 | 0 | QEMU_UNINITIALIZED uint8_t buf[CHR_READ_BUF_LEN]; |
492 | 0 | int len, size; |
493 | |
|
494 | 0 | if ((s->state != TCP_CHARDEV_STATE_CONNECTED) || |
495 | 0 | s->max_size <= 0) { |
496 | 0 | return TRUE; |
497 | 0 | } |
498 | 0 | len = sizeof(buf); |
499 | 0 | if (len > s->max_size) { |
500 | 0 | len = s->max_size; |
501 | 0 | } |
502 | 0 | size = tcp_chr_recv(chr, (void *)buf, len); |
503 | 0 | if (size == 0 || (size == -1 && errno != EAGAIN)) { |
504 | | /* connection closed */ |
505 | 0 | tcp_chr_disconnect(chr); |
506 | 0 | } else if (size > 0) { |
507 | 0 | if (s->do_telnetopt) { |
508 | 0 | tcp_chr_process_IAC_bytes(chr, s, buf, &size); |
509 | 0 | } |
510 | 0 | if (size > 0) { |
511 | 0 | qemu_chr_be_write(chr, buf, size); |
512 | 0 | } |
513 | 0 | } |
514 | |
|
515 | 0 | return TRUE; |
516 | 0 | } |
517 | | |
518 | | static gboolean tcp_chr_hup(QIOChannel *channel, |
519 | | GIOCondition cond, |
520 | | void *opaque) |
521 | 0 | { |
522 | 0 | Chardev *chr = CHARDEV(opaque); |
523 | 0 | trace_chr_socket_hangup(chr, chr->label); |
524 | 0 | tcp_chr_disconnect(chr); |
525 | 0 | return G_SOURCE_REMOVE; |
526 | 0 | } |
527 | | |
528 | | static int tcp_chr_sync_read(Chardev *chr, const uint8_t *buf, int len) |
529 | 0 | { |
530 | 0 | SocketChardev *s = SOCKET_CHARDEV(chr); |
531 | 0 | int size; |
532 | 0 | int saved_errno; |
533 | 0 | Error *local_err = NULL; |
534 | |
|
535 | 0 | if (s->state != TCP_CHARDEV_STATE_CONNECTED) { |
536 | 0 | return 0; |
537 | 0 | } |
538 | | |
539 | 0 | if (!qio_channel_set_blocking(s->ioc, true, &local_err)) { |
540 | 0 | error_report_err(local_err); |
541 | 0 | return -1; |
542 | 0 | } |
543 | 0 | size = tcp_chr_recv(chr, (void *) buf, len); |
544 | 0 | saved_errno = errno; |
545 | 0 | if (s->state != TCP_CHARDEV_STATE_DISCONNECTED) { |
546 | 0 | if (!qio_channel_set_blocking(s->ioc, false, &local_err)) { |
547 | 0 | error_report_err(local_err); |
548 | | /* failed to recover non-blocking state */ |
549 | 0 | tcp_chr_disconnect(chr); |
550 | 0 | } |
551 | 0 | } |
552 | 0 | if (size == 0) { |
553 | | /* connection closed */ |
554 | 0 | tcp_chr_disconnect(chr); |
555 | 0 | } |
556 | |
|
557 | 0 | errno = saved_errno; |
558 | 0 | return size; |
559 | 0 | } |
560 | | |
561 | | static char *qemu_chr_compute_filename(SocketChardev *s) |
562 | 0 | { |
563 | 0 | struct sockaddr_storage *ss = &s->sioc->localAddr; |
564 | 0 | struct sockaddr_storage *ps = &s->sioc->remoteAddr; |
565 | 0 | socklen_t ss_len = s->sioc->localAddrLen; |
566 | 0 | socklen_t ps_len = s->sioc->remoteAddrLen; |
567 | 0 | char shost[NI_MAXHOST], sserv[NI_MAXSERV]; |
568 | 0 | char phost[NI_MAXHOST], pserv[NI_MAXSERV]; |
569 | 0 | const char *left = "", *right = ""; |
570 | |
|
571 | 0 | switch (ss->ss_family) { |
572 | 0 | case AF_UNIX: |
573 | 0 | if (s->is_listen) { |
574 | 0 | return g_strdup_printf("unix:%s,server=on", |
575 | 0 | ((struct sockaddr_un *)(ss))->sun_path); |
576 | 0 | } else { |
577 | 0 | return g_strdup_printf("unix:%s", |
578 | 0 | ((struct sockaddr_un *)(ps))->sun_path); |
579 | 0 | } |
580 | 0 | case AF_INET6: |
581 | 0 | left = "["; |
582 | 0 | right = "]"; |
583 | | /* fall through */ |
584 | 0 | case AF_INET: |
585 | 0 | getnameinfo((struct sockaddr *) ss, ss_len, shost, sizeof(shost), |
586 | 0 | sserv, sizeof(sserv), NI_NUMERICHOST | NI_NUMERICSERV); |
587 | 0 | getnameinfo((struct sockaddr *) ps, ps_len, phost, sizeof(phost), |
588 | 0 | pserv, sizeof(pserv), NI_NUMERICHOST | NI_NUMERICSERV); |
589 | 0 | return g_strdup_printf("%s:%s%s%s:%s%s <-> %s%s%s:%s", |
590 | 0 | qemu_chr_socket_protocol(s), |
591 | 0 | left, shost, right, sserv, |
592 | 0 | s->is_listen ? ",server=on" : "", |
593 | 0 | left, phost, right, pserv); |
594 | | |
595 | 0 | default: |
596 | 0 | return g_strdup_printf("unknown"); |
597 | 0 | } |
598 | 0 | } |
599 | | |
600 | | static void update_ioc_handlers(SocketChardev *s) |
601 | 0 | { |
602 | 0 | Chardev *chr = CHARDEV(s); |
603 | |
|
604 | 0 | if (s->state != TCP_CHARDEV_STATE_CONNECTED) { |
605 | 0 | return; |
606 | 0 | } |
607 | | |
608 | 0 | remove_fd_in_watch(chr); |
609 | 0 | chr->gsource = io_add_watch_poll(chr, s->ioc, |
610 | 0 | tcp_chr_read_poll, |
611 | 0 | tcp_chr_read, chr, |
612 | 0 | chr->gcontext); |
613 | |
|
614 | 0 | remove_hup_source(s); |
615 | 0 | s->hup_source = qio_channel_create_watch(s->ioc, G_IO_HUP); |
616 | | /* |
617 | | * poll() is liable to return POLLHUP even when there is |
618 | | * still incoming data available to read on the FD. If |
619 | | * we have the hup_source at the same priority as the |
620 | | * main io_add_watch_poll GSource, then we might end up |
621 | | * processing the POLLHUP event first, closing the FD, |
622 | | * and as a result silently discard data we should have |
623 | | * read. |
624 | | * |
625 | | * By setting the hup_source to G_PRIORITY_DEFAULT + 1, |
626 | | * we ensure that io_add_watch_poll GSource will always |
627 | | * be dispatched first, thus guaranteeing we will be |
628 | | * able to process all incoming data before closing the |
629 | | * FD |
630 | | */ |
631 | 0 | g_source_set_priority(s->hup_source, G_PRIORITY_DEFAULT + 1); |
632 | 0 | g_source_set_callback(s->hup_source, (GSourceFunc)tcp_chr_hup, |
633 | 0 | chr, NULL); |
634 | 0 | g_source_attach(s->hup_source, chr->gcontext); |
635 | 0 | } |
636 | | |
637 | | static void tcp_chr_connect(void *opaque) |
638 | 0 | { |
639 | 0 | Chardev *chr = CHARDEV(opaque); |
640 | 0 | SocketChardev *s = SOCKET_CHARDEV(opaque); |
641 | |
|
642 | 0 | tcp_chr_change_state(s, TCP_CHARDEV_STATE_CONNECTED); |
643 | 0 | update_ioc_handlers(s); |
644 | 0 | qemu_chr_be_event(chr, CHR_EVENT_OPENED); |
645 | 0 | } |
646 | | |
647 | | static void tcp_chr_telnet_destroy(SocketChardev *s) |
648 | 0 | { |
649 | 0 | if (s->telnet_source) { |
650 | 0 | g_source_destroy(s->telnet_source); |
651 | 0 | g_source_unref(s->telnet_source); |
652 | 0 | s->telnet_source = NULL; |
653 | 0 | } |
654 | 0 | } |
655 | | |
656 | | static void tcp_chr_update_read_handler(Chardev *chr) |
657 | 0 | { |
658 | 0 | SocketChardev *s = SOCKET_CHARDEV(chr); |
659 | |
|
660 | 0 | if (s->listener && s->state == TCP_CHARDEV_STATE_DISCONNECTED) { |
661 | | /* |
662 | | * It's possible that chardev context is changed in |
663 | | * qemu_chr_be_update_read_handlers(). Reset it for QIO net |
664 | | * listener if there is. |
665 | | */ |
666 | 0 | qio_net_listener_set_client_func_full(s->listener, tcp_chr_accept, |
667 | 0 | chr, NULL, chr->gcontext); |
668 | 0 | } |
669 | |
|
670 | 0 | if (s->telnet_source) { |
671 | 0 | tcp_chr_telnet_init(CHARDEV(s)); |
672 | 0 | } |
673 | |
|
674 | 0 | update_ioc_handlers(s); |
675 | 0 | } |
676 | | |
677 | | static gboolean tcp_chr_telnet_init_io(QIOChannel *ioc, |
678 | | GIOCondition cond G_GNUC_UNUSED, |
679 | | gpointer user_data) |
680 | 0 | { |
681 | 0 | SocketChardev *s = user_data; |
682 | 0 | Chardev *chr = CHARDEV(s); |
683 | 0 | TCPChardevTelnetInit *init = s->telnet_init; |
684 | 0 | Error *err = NULL; |
685 | 0 | ssize_t ret; |
686 | |
|
687 | 0 | assert(init); |
688 | |
|
689 | 0 | ret = qio_channel_write(ioc, init->buf, init->buflen, &err); |
690 | 0 | if (ret < 0) { |
691 | 0 | if (ret == QIO_CHANNEL_ERR_BLOCK) { |
692 | 0 | ret = 0; |
693 | 0 | } else { |
694 | 0 | trace_chr_socket_write_err(chr, chr->label, error_get_pretty(err)); |
695 | 0 | error_free(err); |
696 | 0 | tcp_chr_disconnect(chr); |
697 | 0 | goto end; |
698 | 0 | } |
699 | 0 | } |
700 | 0 | init->buflen -= ret; |
701 | |
|
702 | 0 | if (init->buflen == 0) { |
703 | 0 | tcp_chr_connect(chr); |
704 | 0 | goto end; |
705 | 0 | } |
706 | | |
707 | 0 | memmove(init->buf, init->buf + ret, init->buflen); |
708 | |
|
709 | 0 | return G_SOURCE_CONTINUE; |
710 | | |
711 | 0 | end: |
712 | 0 | g_free(s->telnet_init); |
713 | 0 | s->telnet_init = NULL; |
714 | 0 | g_source_unref(s->telnet_source); |
715 | 0 | s->telnet_source = NULL; |
716 | 0 | return G_SOURCE_REMOVE; |
717 | 0 | } |
718 | | |
719 | | static void tcp_chr_telnet_init(Chardev *chr) |
720 | 0 | { |
721 | 0 | SocketChardev *s = SOCKET_CHARDEV(chr); |
722 | 0 | TCPChardevTelnetInit *init; |
723 | 0 | size_t n = 0; |
724 | | |
725 | | /* Destroy existing task */ |
726 | 0 | tcp_chr_telnet_destroy(s); |
727 | |
|
728 | 0 | if (s->telnet_init) { |
729 | | /* We are possibly during a handshake already */ |
730 | 0 | goto cont; |
731 | 0 | } |
732 | | |
733 | 0 | s->telnet_init = g_new0(TCPChardevTelnetInit, 1); |
734 | 0 | init = s->telnet_init; |
735 | |
|
736 | 0 | #define IACSET(x, a, b, c) \ |
737 | 0 | do { \ |
738 | 0 | x[n++] = a; \ |
739 | 0 | x[n++] = b; \ |
740 | 0 | x[n++] = c; \ |
741 | 0 | } while (0) |
742 | |
|
743 | 0 | if (!s->is_tn3270) { |
744 | 0 | init->buflen = 12; |
745 | | /* Prep the telnet negotiation to put telnet in binary, |
746 | | * no echo, single char mode */ |
747 | 0 | IACSET(init->buf, 0xff, 0xfb, 0x01); /* IAC WILL ECHO */ |
748 | 0 | IACSET(init->buf, 0xff, 0xfb, 0x03); /* IAC WILL Suppress go ahead */ |
749 | 0 | IACSET(init->buf, 0xff, 0xfb, 0x00); /* IAC WILL Binary */ |
750 | 0 | IACSET(init->buf, 0xff, 0xfd, 0x00); /* IAC DO Binary */ |
751 | 0 | } else { |
752 | 0 | init->buflen = 21; |
753 | | /* Prep the TN3270 negotiation based on RFC1576 */ |
754 | 0 | IACSET(init->buf, 0xff, 0xfd, 0x19); /* IAC DO EOR */ |
755 | 0 | IACSET(init->buf, 0xff, 0xfb, 0x19); /* IAC WILL EOR */ |
756 | 0 | IACSET(init->buf, 0xff, 0xfd, 0x00); /* IAC DO BINARY */ |
757 | 0 | IACSET(init->buf, 0xff, 0xfb, 0x00); /* IAC WILL BINARY */ |
758 | 0 | IACSET(init->buf, 0xff, 0xfd, 0x18); /* IAC DO TERMINAL TYPE */ |
759 | 0 | IACSET(init->buf, 0xff, 0xfa, 0x18); /* IAC SB TERMINAL TYPE */ |
760 | 0 | IACSET(init->buf, 0x01, 0xff, 0xf0); /* SEND IAC SE */ |
761 | 0 | } |
762 | |
|
763 | 0 | #undef IACSET |
764 | |
|
765 | 0 | cont: |
766 | 0 | s->telnet_source = qio_channel_add_watch_source(s->ioc, G_IO_OUT, |
767 | 0 | tcp_chr_telnet_init_io, |
768 | 0 | s, NULL, |
769 | 0 | chr->gcontext); |
770 | 0 | } |
771 | | |
772 | | |
773 | | static void tcp_chr_websock_handshake(QIOTask *task, gpointer user_data) |
774 | 0 | { |
775 | 0 | Chardev *chr = user_data; |
776 | 0 | SocketChardev *s = user_data; |
777 | 0 | Error *err = NULL; |
778 | |
|
779 | 0 | if (qio_task_propagate_error(task, &err)) { |
780 | 0 | trace_chr_socket_ws_handshake_err(chr, chr->label, |
781 | 0 | error_get_pretty(err)); |
782 | 0 | error_free(err); |
783 | 0 | tcp_chr_disconnect(chr); |
784 | 0 | } else { |
785 | 0 | if (s->do_telnetopt) { |
786 | 0 | tcp_chr_telnet_init(chr); |
787 | 0 | } else { |
788 | 0 | tcp_chr_connect(chr); |
789 | 0 | } |
790 | 0 | } |
791 | 0 | } |
792 | | |
793 | | |
794 | | static void tcp_chr_websock_init(Chardev *chr) |
795 | 0 | { |
796 | 0 | SocketChardev *s = SOCKET_CHARDEV(chr); |
797 | 0 | QIOChannelWebsock *wioc = NULL; |
798 | 0 | gchar *name; |
799 | |
|
800 | 0 | wioc = qio_channel_websock_new_server(s->ioc); |
801 | |
|
802 | 0 | name = g_strdup_printf("chardev-websocket-server-%s", chr->label); |
803 | 0 | qio_channel_set_name(QIO_CHANNEL(wioc), name); |
804 | 0 | g_free(name); |
805 | 0 | object_unref(OBJECT(s->ioc)); |
806 | 0 | s->ioc = QIO_CHANNEL(wioc); |
807 | |
|
808 | 0 | qio_channel_websock_handshake(wioc, tcp_chr_websock_handshake, chr, NULL); |
809 | 0 | } |
810 | | |
811 | | |
812 | | static void tcp_chr_tls_handshake(QIOTask *task, |
813 | | gpointer user_data) |
814 | 0 | { |
815 | 0 | Chardev *chr = user_data; |
816 | 0 | SocketChardev *s = user_data; |
817 | 0 | Error *err = NULL; |
818 | |
|
819 | 0 | if (qio_task_propagate_error(task, &err)) { |
820 | 0 | trace_chr_socket_tls_handshake_err(chr, chr->label, |
821 | 0 | error_get_pretty(err)); |
822 | 0 | error_free(err); |
823 | 0 | tcp_chr_disconnect(chr); |
824 | 0 | } else { |
825 | 0 | if (s->is_websock) { |
826 | 0 | tcp_chr_websock_init(chr); |
827 | 0 | } else if (s->do_telnetopt) { |
828 | 0 | tcp_chr_telnet_init(chr); |
829 | 0 | } else { |
830 | 0 | tcp_chr_connect(chr); |
831 | 0 | } |
832 | 0 | } |
833 | 0 | } |
834 | | |
835 | | |
836 | | static void tcp_chr_tls_init(Chardev *chr) |
837 | 0 | { |
838 | 0 | SocketChardev *s = SOCKET_CHARDEV(chr); |
839 | 0 | QIOChannelTLS *tioc; |
840 | 0 | gchar *name; |
841 | 0 | Error *err = NULL; |
842 | |
|
843 | 0 | if (s->is_listen) { |
844 | 0 | tioc = qio_channel_tls_new_server( |
845 | 0 | s->ioc, s->tls_creds, |
846 | 0 | s->tls_authz, |
847 | 0 | &err); |
848 | 0 | } else { |
849 | 0 | tioc = qio_channel_tls_new_client( |
850 | 0 | s->ioc, s->tls_creds, |
851 | 0 | s->addr->u.inet.host, |
852 | 0 | &err); |
853 | 0 | } |
854 | 0 | if (tioc == NULL) { |
855 | 0 | trace_chr_socket_tls_init_err(chr, chr->label, error_get_pretty(err)); |
856 | 0 | error_free(err); |
857 | 0 | tcp_chr_disconnect(chr); |
858 | 0 | return; |
859 | 0 | } |
860 | 0 | name = g_strdup_printf("chardev-tls-%s-%s", |
861 | 0 | s->is_listen ? "server" : "client", |
862 | 0 | chr->label); |
863 | 0 | qio_channel_set_name(QIO_CHANNEL(tioc), name); |
864 | 0 | g_free(name); |
865 | 0 | object_unref(OBJECT(s->ioc)); |
866 | 0 | s->ioc = QIO_CHANNEL(tioc); |
867 | |
|
868 | 0 | qio_channel_tls_handshake(tioc, |
869 | 0 | tcp_chr_tls_handshake, |
870 | 0 | chr, |
871 | 0 | NULL, |
872 | 0 | chr->gcontext); |
873 | 0 | } |
874 | | |
875 | | |
876 | | static void tcp_chr_set_client_ioc_name(Chardev *chr, |
877 | | QIOChannelSocket *sioc) |
878 | 0 | { |
879 | 0 | SocketChardev *s = SOCKET_CHARDEV(chr); |
880 | 0 | char *name; |
881 | 0 | name = g_strdup_printf("chardev-tcp-%s-%s", |
882 | 0 | s->is_listen ? "server" : "client", |
883 | 0 | chr->label); |
884 | 0 | qio_channel_set_name(QIO_CHANNEL(sioc), name); |
885 | 0 | g_free(name); |
886 | |
|
887 | 0 | } |
888 | | |
889 | | static int tcp_chr_new_client(Chardev *chr, QIOChannelSocket *sioc) |
890 | 0 | { |
891 | 0 | SocketChardev *s = SOCKET_CHARDEV(chr); |
892 | 0 | Error *local_err = NULL; |
893 | |
|
894 | 0 | if (s->state != TCP_CHARDEV_STATE_CONNECTING) { |
895 | 0 | return -1; |
896 | 0 | } |
897 | | |
898 | 0 | if (!qio_channel_set_blocking(QIO_CHANNEL(sioc), false, &local_err)) { |
899 | 0 | error_report_err(local_err); |
900 | 0 | return -1; |
901 | 0 | } |
902 | | |
903 | 0 | s->ioc = QIO_CHANNEL(sioc); |
904 | 0 | object_ref(OBJECT(sioc)); |
905 | 0 | s->sioc = sioc; |
906 | 0 | object_ref(OBJECT(sioc)); |
907 | |
|
908 | 0 | if (s->registered_yank) { |
909 | 0 | yank_register_function(CHARDEV_YANK_INSTANCE(chr->label), |
910 | 0 | char_socket_yank_iochannel, |
911 | 0 | QIO_CHANNEL(sioc)); |
912 | 0 | } |
913 | |
|
914 | 0 | if (s->do_nodelay) { |
915 | 0 | qio_channel_set_delay(s->ioc, false); |
916 | 0 | } |
917 | 0 | if (s->listener) { |
918 | 0 | qio_net_listener_set_client_func_full(s->listener, NULL, NULL, |
919 | 0 | NULL, chr->gcontext); |
920 | 0 | } |
921 | |
|
922 | 0 | if (s->tls_creds) { |
923 | 0 | tcp_chr_tls_init(chr); |
924 | 0 | } else if (s->is_websock) { |
925 | 0 | tcp_chr_websock_init(chr); |
926 | 0 | } else if (s->do_telnetopt) { |
927 | 0 | tcp_chr_telnet_init(chr); |
928 | 0 | } else { |
929 | 0 | tcp_chr_connect(chr); |
930 | 0 | } |
931 | |
|
932 | 0 | return 0; |
933 | 0 | } |
934 | | |
935 | | |
936 | | static int tcp_chr_add_client(Chardev *chr, int fd) |
937 | 0 | { |
938 | 0 | int ret; |
939 | 0 | QIOChannelSocket *sioc; |
940 | 0 | SocketChardev *s = SOCKET_CHARDEV(chr); |
941 | |
|
942 | 0 | if (s->state != TCP_CHARDEV_STATE_DISCONNECTED) { |
943 | 0 | return -1; |
944 | 0 | } |
945 | | |
946 | 0 | sioc = qio_channel_socket_new_fd(fd, NULL); |
947 | 0 | if (!sioc) { |
948 | 0 | return -1; |
949 | 0 | } |
950 | 0 | tcp_chr_change_state(s, TCP_CHARDEV_STATE_CONNECTING); |
951 | 0 | tcp_chr_set_client_ioc_name(chr, sioc); |
952 | 0 | ret = tcp_chr_new_client(chr, sioc); |
953 | 0 | object_unref(OBJECT(sioc)); |
954 | 0 | return ret; |
955 | 0 | } |
956 | | |
957 | | static void tcp_chr_accept(QIONetListener *listener, |
958 | | QIOChannelSocket *cioc, |
959 | | void *opaque) |
960 | 0 | { |
961 | 0 | Chardev *chr = CHARDEV(opaque); |
962 | 0 | SocketChardev *s = SOCKET_CHARDEV(chr); |
963 | |
|
964 | 0 | tcp_chr_change_state(s, TCP_CHARDEV_STATE_CONNECTING); |
965 | 0 | tcp_chr_set_client_ioc_name(chr, cioc); |
966 | 0 | tcp_chr_new_client(chr, cioc); |
967 | 0 | } |
968 | | |
969 | | |
970 | | static int tcp_chr_connect_client_sync(Chardev *chr, Error **errp) |
971 | 0 | { |
972 | 0 | SocketChardev *s = SOCKET_CHARDEV(chr); |
973 | 0 | QIOChannelSocket *sioc = qio_channel_socket_new(); |
974 | 0 | tcp_chr_change_state(s, TCP_CHARDEV_STATE_CONNECTING); |
975 | 0 | tcp_chr_set_client_ioc_name(chr, sioc); |
976 | 0 | if (qio_channel_socket_connect_sync(sioc, s->addr, errp) < 0) { |
977 | 0 | tcp_chr_change_state(s, TCP_CHARDEV_STATE_DISCONNECTED); |
978 | 0 | object_unref(OBJECT(sioc)); |
979 | 0 | return -1; |
980 | 0 | } |
981 | 0 | tcp_chr_new_client(chr, sioc); |
982 | 0 | object_unref(OBJECT(sioc)); |
983 | 0 | return 0; |
984 | 0 | } |
985 | | |
986 | | |
987 | | static void tcp_chr_accept_server_sync(Chardev *chr) |
988 | 0 | { |
989 | 0 | SocketChardev *s = SOCKET_CHARDEV(chr); |
990 | 0 | QIOChannelSocket *sioc; |
991 | 0 | g_autofree char *filename = qemu_chr_get_filename(chr); |
992 | 0 | info_report("QEMU waiting for connection on: %s", filename); |
993 | 0 | tcp_chr_change_state(s, TCP_CHARDEV_STATE_CONNECTING); |
994 | 0 | sioc = qio_net_listener_wait_client(s->listener); |
995 | 0 | tcp_chr_set_client_ioc_name(chr, sioc); |
996 | 0 | tcp_chr_new_client(chr, sioc); |
997 | 0 | object_unref(OBJECT(sioc)); |
998 | 0 | } |
999 | | |
1000 | | |
1001 | | static int tcp_chr_wait_connected(Chardev *chr, Error **errp) |
1002 | 0 | { |
1003 | 0 | SocketChardev *s = SOCKET_CHARDEV(chr); |
1004 | 0 | const char *opts[] = { "telnet", "tn3270", "websock", "tls-creds" }; |
1005 | 0 | bool optset[] = { s->is_telnet, s->is_tn3270, s->is_websock, s->tls_creds }; |
1006 | 0 | size_t i; |
1007 | |
|
1008 | 0 | QEMU_BUILD_BUG_ON(G_N_ELEMENTS(opts) != G_N_ELEMENTS(optset)); |
1009 | 0 | for (i = 0; i < G_N_ELEMENTS(opts); i++) { |
1010 | 0 | if (optset[i]) { |
1011 | 0 | error_setg(errp, |
1012 | 0 | "'%s' option is incompatible with waiting for " |
1013 | 0 | "connection completion", opts[i]); |
1014 | 0 | return -1; |
1015 | 0 | } |
1016 | 0 | } |
1017 | | |
1018 | 0 | tcp_chr_reconn_timer_cancel(s); |
1019 | | |
1020 | | /* |
1021 | | * We expect states to be as follows: |
1022 | | * |
1023 | | * - server |
1024 | | * - wait -> CONNECTED |
1025 | | * - nowait -> DISCONNECTED |
1026 | | * - client |
1027 | | * - reconnect == 0 -> CONNECTED |
1028 | | * - reconnect != 0 -> CONNECTING |
1029 | | * |
1030 | | */ |
1031 | 0 | if (s->state == TCP_CHARDEV_STATE_CONNECTING) { |
1032 | 0 | if (!s->connect_task) { |
1033 | 0 | error_setg(errp, |
1034 | 0 | "Unexpected 'connecting' state without connect task " |
1035 | 0 | "while waiting for connection completion"); |
1036 | 0 | return -1; |
1037 | 0 | } |
1038 | | /* |
1039 | | * tcp_chr_wait_connected should only ever be run from the |
1040 | | * main loop thread associated with chr->gcontext, otherwise |
1041 | | * qio_task_wait_thread has a dangerous race condition with |
1042 | | * free'ing of the s->connect_task object. |
1043 | | * |
1044 | | * Acquiring the main context doesn't 100% prove we're in |
1045 | | * the main loop thread, but it does at least guarantee |
1046 | | * that the main loop won't be executed by another thread |
1047 | | * avoiding the race condition with the task idle callback. |
1048 | | */ |
1049 | 0 | g_main_context_acquire(chr->gcontext); |
1050 | 0 | qio_task_wait_thread(s->connect_task); |
1051 | 0 | g_main_context_release(chr->gcontext); |
1052 | | |
1053 | | /* |
1054 | | * The completion callback (qemu_chr_socket_connected) for |
1055 | | * s->connect_task should have set this to NULL by the time |
1056 | | * qio_task_wait_thread has returned. |
1057 | | */ |
1058 | 0 | assert(!s->connect_task); |
1059 | | |
1060 | | /* |
1061 | | * NB we are *not* guaranteed to have "s->state == ..CONNECTED" |
1062 | | * at this point as this first connect may be failed, so |
1063 | | * allow the next loop to run regardless. |
1064 | | */ |
1065 | 0 | } |
1066 | | |
1067 | 0 | while (s->state != TCP_CHARDEV_STATE_CONNECTED) { |
1068 | 0 | if (s->is_listen) { |
1069 | 0 | tcp_chr_accept_server_sync(chr); |
1070 | 0 | } else { |
1071 | 0 | Error *err = NULL; |
1072 | 0 | if (tcp_chr_connect_client_sync(chr, &err) < 0) { |
1073 | 0 | if (s->reconnect_time_ms) { |
1074 | 0 | error_free(err); |
1075 | 0 | g_usleep(s->reconnect_time_ms * 1000ULL); |
1076 | 0 | } else { |
1077 | 0 | error_propagate(errp, err); |
1078 | 0 | return -1; |
1079 | 0 | } |
1080 | 0 | } |
1081 | 0 | } |
1082 | 0 | } |
1083 | | |
1084 | 0 | return 0; |
1085 | 0 | } |
1086 | | |
1087 | | static void char_socket_finalize(Object *obj) |
1088 | 0 | { |
1089 | 0 | Chardev *chr = CHARDEV(obj); |
1090 | 0 | SocketChardev *s = SOCKET_CHARDEV(obj); |
1091 | |
|
1092 | 0 | tcp_chr_free_connection(chr); |
1093 | 0 | tcp_chr_reconn_timer_cancel(s); |
1094 | 0 | qapi_free_SocketAddress(s->addr); |
1095 | 0 | tcp_chr_telnet_destroy(s); |
1096 | 0 | g_free(s->telnet_init); |
1097 | 0 | if (s->listener) { |
1098 | 0 | qio_net_listener_set_client_func_full(s->listener, NULL, NULL, |
1099 | 0 | NULL, chr->gcontext); |
1100 | 0 | object_unref(OBJECT(s->listener)); |
1101 | 0 | s->listener = NULL; |
1102 | 0 | } |
1103 | 0 | if (s->tls_creds) { |
1104 | 0 | object_unref(OBJECT(s->tls_creds)); |
1105 | 0 | } |
1106 | 0 | g_free(s->tls_authz); |
1107 | 0 | if (s->registered_yank) { |
1108 | | /* |
1109 | | * In the chardev-change special-case, we shouldn't unregister the yank |
1110 | | * instance, as it still may be needed. |
1111 | | */ |
1112 | 0 | if (!chr->handover_yank_instance) { |
1113 | 0 | yank_unregister_instance(CHARDEV_YANK_INSTANCE(chr->label)); |
1114 | 0 | } |
1115 | 0 | } |
1116 | |
|
1117 | 0 | qemu_chr_be_event(chr, CHR_EVENT_CLOSED); |
1118 | 0 | } |
1119 | | |
1120 | | static void qemu_chr_socket_connected(QIOTask *task, void *opaque) |
1121 | 0 | { |
1122 | 0 | QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(qio_task_get_source(task)); |
1123 | 0 | Chardev *chr = CHARDEV(opaque); |
1124 | 0 | SocketChardev *s = SOCKET_CHARDEV(chr); |
1125 | 0 | Error *err = NULL; |
1126 | |
|
1127 | 0 | s->connect_task = NULL; |
1128 | |
|
1129 | 0 | if (qio_task_propagate_error(task, &err)) { |
1130 | 0 | tcp_chr_change_state(s, TCP_CHARDEV_STATE_DISCONNECTED); |
1131 | 0 | check_report_connect_error(chr, err); |
1132 | 0 | goto cleanup; |
1133 | 0 | } |
1134 | | |
1135 | 0 | s->connect_err_reported = false; |
1136 | 0 | tcp_chr_new_client(chr, sioc); |
1137 | |
|
1138 | 0 | cleanup: |
1139 | 0 | object_unref(OBJECT(sioc)); |
1140 | 0 | } |
1141 | | |
1142 | | |
1143 | | static void tcp_chr_connect_client_task(QIOTask *task, |
1144 | | gpointer opaque) |
1145 | 0 | { |
1146 | 0 | QIOChannelSocket *ioc = QIO_CHANNEL_SOCKET(qio_task_get_source(task)); |
1147 | 0 | SocketAddress *addr = opaque; |
1148 | 0 | Error *err = NULL; |
1149 | |
|
1150 | 0 | qio_channel_socket_connect_sync(ioc, addr, &err); |
1151 | |
|
1152 | 0 | qio_task_set_error(task, err); |
1153 | 0 | } |
1154 | | |
1155 | | |
1156 | | static void tcp_chr_connect_client_async(Chardev *chr) |
1157 | 0 | { |
1158 | 0 | SocketChardev *s = SOCKET_CHARDEV(chr); |
1159 | 0 | QIOChannelSocket *sioc; |
1160 | |
|
1161 | 0 | tcp_chr_change_state(s, TCP_CHARDEV_STATE_CONNECTING); |
1162 | 0 | sioc = qio_channel_socket_new(); |
1163 | 0 | tcp_chr_set_client_ioc_name(chr, sioc); |
1164 | | /* |
1165 | | * Normally code would use the qio_channel_socket_connect_async |
1166 | | * method which uses a QIOTask + qio_task_set_error internally |
1167 | | * to avoid blocking. The tcp_chr_wait_connected method, however, |
1168 | | * needs a way to synchronize with completion of the background |
1169 | | * connect task which can't be done with the QIOChannelSocket |
1170 | | * async APIs. Thus we must use QIOTask directly to implement |
1171 | | * the non-blocking concept locally. |
1172 | | */ |
1173 | 0 | s->connect_task = qio_task_new(OBJECT(sioc), |
1174 | 0 | qemu_chr_socket_connected, |
1175 | 0 | object_ref(OBJECT(chr)), |
1176 | 0 | (GDestroyNotify)object_unref); |
1177 | 0 | qio_task_run_in_thread(s->connect_task, |
1178 | 0 | tcp_chr_connect_client_task, |
1179 | 0 | s->addr, |
1180 | 0 | NULL, |
1181 | 0 | chr->gcontext); |
1182 | 0 | } |
1183 | | |
1184 | | static gboolean socket_reconnect_timeout(gpointer opaque) |
1185 | 0 | { |
1186 | 0 | Chardev *chr = CHARDEV(opaque); |
1187 | 0 | SocketChardev *s = SOCKET_CHARDEV(opaque); |
1188 | |
|
1189 | 0 | qemu_mutex_lock(&chr->chr_write_lock); |
1190 | 0 | g_source_unref(s->reconnect_timer); |
1191 | 0 | s->reconnect_timer = NULL; |
1192 | 0 | qemu_mutex_unlock(&chr->chr_write_lock); |
1193 | |
|
1194 | 0 | if (chr->be_open) { |
1195 | 0 | return false; |
1196 | 0 | } |
1197 | | |
1198 | 0 | tcp_chr_connect_client_async(chr); |
1199 | |
|
1200 | 0 | return false; |
1201 | 0 | } |
1202 | | |
1203 | | |
1204 | | static int qmp_chardev_open_socket_server(Chardev *chr, |
1205 | | bool is_telnet, |
1206 | | bool is_waitconnect, |
1207 | | Error **errp) |
1208 | 0 | { |
1209 | 0 | SocketChardev *s = SOCKET_CHARDEV(chr); |
1210 | 0 | char *name; |
1211 | 0 | if (is_telnet) { |
1212 | 0 | s->do_telnetopt = 1; |
1213 | 0 | } |
1214 | 0 | s->listener = qio_net_listener_new(); |
1215 | |
|
1216 | 0 | name = g_strdup_printf("chardev-tcp-listener-%s", chr->label); |
1217 | 0 | qio_net_listener_set_name(s->listener, name); |
1218 | 0 | g_free(name); |
1219 | |
|
1220 | 0 | if (s->addr->type == SOCKET_ADDRESS_TYPE_FD && !*s->addr->u.fd.str) { |
1221 | 0 | goto skip_listen; |
1222 | 0 | } |
1223 | | |
1224 | 0 | if (qio_net_listener_open_sync(s->listener, s->addr, 1, errp) < 0) { |
1225 | 0 | object_unref(OBJECT(s->listener)); |
1226 | 0 | s->listener = NULL; |
1227 | 0 | return -1; |
1228 | 0 | } |
1229 | | |
1230 | 0 | qapi_free_SocketAddress(s->addr); |
1231 | 0 | s->addr = qio_net_listener_get_local_address(s->listener, 0, errp); |
1232 | |
|
1233 | 0 | skip_listen: |
1234 | 0 | if (is_waitconnect) { |
1235 | 0 | tcp_chr_accept_server_sync(chr); |
1236 | 0 | } else { |
1237 | 0 | qio_net_listener_set_client_func_full(s->listener, |
1238 | 0 | tcp_chr_accept, |
1239 | 0 | chr, NULL, |
1240 | 0 | chr->gcontext); |
1241 | 0 | } |
1242 | |
|
1243 | 0 | return 0; |
1244 | 0 | } |
1245 | | |
1246 | | |
1247 | | static int qmp_chardev_open_socket_client(Chardev *chr, |
1248 | | int64_t reconnect_ms, |
1249 | | Error **errp) |
1250 | 0 | { |
1251 | 0 | SocketChardev *s = SOCKET_CHARDEV(chr); |
1252 | |
|
1253 | 0 | if (reconnect_ms > 0) { |
1254 | 0 | s->reconnect_time_ms = reconnect_ms; |
1255 | 0 | tcp_chr_connect_client_async(chr); |
1256 | 0 | return 0; |
1257 | 0 | } else { |
1258 | 0 | return tcp_chr_connect_client_sync(chr, errp); |
1259 | 0 | } |
1260 | 0 | } |
1261 | | |
1262 | | |
1263 | | static bool qmp_chardev_validate_socket(ChardevSocket *sock, |
1264 | | SocketAddress *addr, |
1265 | | Error **errp) |
1266 | 0 | { |
1267 | | /* Validate any options which have a dependency on address type */ |
1268 | 0 | switch (addr->type) { |
1269 | 0 | case SOCKET_ADDRESS_TYPE_FD: |
1270 | 0 | if (sock->has_reconnect_ms) { |
1271 | 0 | error_setg(errp, |
1272 | 0 | "'reconnect-ms' option is incompatible with " |
1273 | 0 | "'fd' address type"); |
1274 | 0 | return false; |
1275 | 0 | } |
1276 | 0 | if (sock->tls_creds && |
1277 | 0 | !(sock->has_server && sock->server)) { |
1278 | 0 | error_setg(errp, |
1279 | 0 | "'tls_creds' option is incompatible with " |
1280 | 0 | "'fd' address type as client"); |
1281 | 0 | return false; |
1282 | 0 | } |
1283 | 0 | break; |
1284 | | |
1285 | 0 | case SOCKET_ADDRESS_TYPE_UNIX: |
1286 | 0 | if (sock->tls_creds) { |
1287 | 0 | error_setg(errp, |
1288 | 0 | "'tls_creds' option is incompatible with " |
1289 | 0 | "'unix' address type"); |
1290 | 0 | return false; |
1291 | 0 | } |
1292 | 0 | break; |
1293 | | |
1294 | 0 | case SOCKET_ADDRESS_TYPE_INET: |
1295 | 0 | break; |
1296 | | |
1297 | 0 | case SOCKET_ADDRESS_TYPE_VSOCK: |
1298 | 0 | if (sock->tls_creds) { |
1299 | 0 | error_setg(errp, |
1300 | 0 | "'tls_creds' option is incompatible with " |
1301 | 0 | "'vsock' address type"); |
1302 | 0 | return false; |
1303 | 0 | } |
1304 | | |
1305 | 0 | default: |
1306 | 0 | break; |
1307 | 0 | } |
1308 | | |
1309 | 0 | if (sock->tls_authz && !sock->tls_creds) { |
1310 | 0 | error_setg(errp, "'tls_authz' option requires 'tls_creds' option"); |
1311 | 0 | return false; |
1312 | 0 | } |
1313 | | |
1314 | | /* Validate any options which have a dependency on client vs server */ |
1315 | 0 | if (!sock->has_server || sock->server) { |
1316 | 0 | if (sock->has_reconnect_ms) { |
1317 | 0 | error_setg(errp, |
1318 | 0 | "'reconnect-ms' option is incompatible with " |
1319 | 0 | "socket in server listen mode"); |
1320 | 0 | return false; |
1321 | 0 | } |
1322 | 0 | } else { |
1323 | 0 | if (sock->has_websocket && sock->websocket) { |
1324 | 0 | error_setg(errp, "%s", "Websocket client is not implemented"); |
1325 | 0 | return false; |
1326 | 0 | } |
1327 | 0 | if (sock->has_wait) { |
1328 | 0 | error_setg(errp, "%s", |
1329 | 0 | "'wait' option is incompatible with " |
1330 | 0 | "socket in client connect mode"); |
1331 | 0 | return false; |
1332 | 0 | } |
1333 | 0 | } |
1334 | | |
1335 | 0 | return true; |
1336 | 0 | } |
1337 | | |
1338 | | |
1339 | | static bool tcp_chr_open(Chardev *chr, ChardevBackend *backend, Error **errp) |
1340 | 0 | { |
1341 | 0 | SocketChardev *s = SOCKET_CHARDEV(chr); |
1342 | 0 | ChardevSocket *sock = backend->u.socket.data; |
1343 | 0 | bool do_nodelay = sock->has_nodelay ? sock->nodelay : false; |
1344 | 0 | bool is_listen = sock->has_server ? sock->server : true; |
1345 | 0 | bool is_telnet = sock->has_telnet ? sock->telnet : false; |
1346 | 0 | bool is_tn3270 = sock->has_tn3270 ? sock->tn3270 : false; |
1347 | 0 | bool is_waitconnect = sock->has_wait ? sock->wait : false; |
1348 | 0 | bool is_websock = sock->has_websocket ? sock->websocket : false; |
1349 | 0 | int64_t reconnect_ms = sock->has_reconnect_ms ? sock->reconnect_ms : 0; |
1350 | 0 | SocketAddress *addr; |
1351 | |
|
1352 | 0 | s->is_listen = is_listen; |
1353 | 0 | s->is_telnet = is_telnet; |
1354 | 0 | s->is_tn3270 = is_tn3270; |
1355 | 0 | s->is_websock = is_websock; |
1356 | 0 | s->do_nodelay = do_nodelay; |
1357 | 0 | if (sock->tls_creds) { |
1358 | 0 | Object *creds; |
1359 | 0 | creds = object_resolve_path_component( |
1360 | 0 | object_get_objects_root(), sock->tls_creds); |
1361 | 0 | if (!creds) { |
1362 | 0 | error_setg(errp, "No TLS credentials with id '%s'", |
1363 | 0 | sock->tls_creds); |
1364 | 0 | return false; |
1365 | 0 | } |
1366 | 0 | s->tls_creds = (QCryptoTLSCreds *) |
1367 | 0 | object_dynamic_cast(creds, |
1368 | 0 | TYPE_QCRYPTO_TLS_CREDS); |
1369 | 0 | if (!s->tls_creds) { |
1370 | 0 | error_setg(errp, "Object with id '%s' is not TLS credentials", |
1371 | 0 | sock->tls_creds); |
1372 | 0 | return false; |
1373 | 0 | } |
1374 | 0 | object_ref(OBJECT(s->tls_creds)); |
1375 | 0 | if (!qcrypto_tls_creds_check_endpoint(s->tls_creds, |
1376 | 0 | is_listen |
1377 | 0 | ? QCRYPTO_TLS_CREDS_ENDPOINT_SERVER |
1378 | 0 | : QCRYPTO_TLS_CREDS_ENDPOINT_CLIENT, |
1379 | 0 | errp)) { |
1380 | 0 | return false; |
1381 | 0 | } |
1382 | 0 | } |
1383 | 0 | s->tls_authz = g_strdup(sock->tls_authz); |
1384 | |
|
1385 | 0 | s->addr = addr = socket_address_flatten(sock->addr); |
1386 | |
|
1387 | 0 | if (!qmp_chardev_validate_socket(sock, addr, errp)) { |
1388 | 0 | return false; |
1389 | 0 | } |
1390 | | |
1391 | 0 | qemu_chr_set_feature(chr, QEMU_CHAR_FEATURE_RECONNECTABLE); |
1392 | 0 | #ifndef _WIN32 |
1393 | | /* TODO SOCKET_ADDRESS_FD where fd has AF_UNIX */ |
1394 | 0 | if (addr->type == SOCKET_ADDRESS_TYPE_UNIX) { |
1395 | 0 | qemu_chr_set_feature(chr, QEMU_CHAR_FEATURE_FD_PASS); |
1396 | 0 | } |
1397 | 0 | #endif |
1398 | | |
1399 | | /* |
1400 | | * In the chardev-change special-case, we shouldn't register a new yank |
1401 | | * instance, as there already may be one. |
1402 | | */ |
1403 | 0 | if (!chr->handover_yank_instance) { |
1404 | 0 | if (!yank_register_instance(CHARDEV_YANK_INSTANCE(chr->label), errp)) { |
1405 | 0 | return false; |
1406 | 0 | } |
1407 | 0 | } |
1408 | 0 | s->registered_yank = true; |
1409 | |
|
1410 | 0 | if (s->is_listen) { |
1411 | 0 | if (qmp_chardev_open_socket_server(chr, is_telnet || is_tn3270, |
1412 | 0 | is_waitconnect, errp) < 0) { |
1413 | 0 | return false; |
1414 | 0 | } |
1415 | 0 | } else { |
1416 | 0 | if (qmp_chardev_open_socket_client(chr, reconnect_ms, errp) < 0) { |
1417 | 0 | return false; |
1418 | 0 | } |
1419 | 0 | } |
1420 | | |
1421 | | /* be isn't opened until we get a connection */ |
1422 | 0 | return true; |
1423 | 0 | } |
1424 | | |
1425 | | static void tcp_chr_parse(QemuOpts *opts, ChardevBackend *backend, Error **errp) |
1426 | 0 | { |
1427 | 0 | const char *path = qemu_opt_get(opts, "path"); |
1428 | 0 | const char *host = qemu_opt_get(opts, "host"); |
1429 | 0 | const char *port = qemu_opt_get(opts, "port"); |
1430 | 0 | const char *fd = qemu_opt_get(opts, "fd"); |
1431 | 0 | #ifdef CONFIG_LINUX |
1432 | 0 | bool tight = qemu_opt_get_bool(opts, "tight", true); |
1433 | 0 | bool abstract = qemu_opt_get_bool(opts, "abstract", false); |
1434 | 0 | #endif |
1435 | 0 | SocketAddressLegacy *addr; |
1436 | 0 | ChardevSocket *sock; |
1437 | |
|
1438 | 0 | if ((!!path + !!fd + !!host) > 1) { |
1439 | 0 | error_setg(errp, |
1440 | 0 | "None or one of 'path', 'fd' or 'host' option required."); |
1441 | 0 | return; |
1442 | 0 | } |
1443 | | |
1444 | 0 | if (host && !port) { |
1445 | 0 | error_setg(errp, "chardev: socket: no port given"); |
1446 | 0 | return; |
1447 | 0 | } |
1448 | | |
1449 | 0 | backend->type = CHARDEV_BACKEND_KIND_SOCKET; |
1450 | 0 | sock = backend->u.socket.data = g_new0(ChardevSocket, 1); |
1451 | 0 | qemu_chr_parse_common(opts, qapi_ChardevSocket_base(sock)); |
1452 | |
|
1453 | 0 | if (qemu_opt_get(opts, "delay") && qemu_opt_get(opts, "nodelay")) { |
1454 | 0 | error_setg(errp, "'delay' and 'nodelay' are mutually exclusive"); |
1455 | 0 | return; |
1456 | 0 | } |
1457 | 0 | sock->has_nodelay = |
1458 | 0 | qemu_opt_get(opts, "delay") || |
1459 | 0 | qemu_opt_get(opts, "nodelay"); |
1460 | 0 | sock->nodelay = |
1461 | 0 | !qemu_opt_get_bool(opts, "delay", true) || |
1462 | 0 | qemu_opt_get_bool(opts, "nodelay", false); |
1463 | | |
1464 | | /* |
1465 | | * We have different default to QMP for 'server', hence |
1466 | | * we can't just check for existence of 'server' |
1467 | | */ |
1468 | 0 | sock->has_server = true; |
1469 | 0 | sock->server = qemu_opt_get_bool(opts, "server", false); |
1470 | 0 | sock->has_telnet = qemu_opt_get(opts, "telnet"); |
1471 | 0 | sock->telnet = qemu_opt_get_bool(opts, "telnet", false); |
1472 | 0 | sock->has_tn3270 = qemu_opt_get(opts, "tn3270"); |
1473 | 0 | sock->tn3270 = qemu_opt_get_bool(opts, "tn3270", false); |
1474 | 0 | sock->has_websocket = qemu_opt_get(opts, "websocket"); |
1475 | 0 | sock->websocket = qemu_opt_get_bool(opts, "websocket", false); |
1476 | | /* |
1477 | | * We have different default to QMP for 'wait' when 'server' |
1478 | | * is set, hence we can't just check for existence of 'wait' |
1479 | | */ |
1480 | 0 | sock->has_wait = qemu_opt_find(opts, "wait") || sock->server; |
1481 | 0 | sock->wait = qemu_opt_get_bool(opts, "wait", true); |
1482 | 0 | sock->has_reconnect_ms = qemu_opt_find(opts, "reconnect-ms"); |
1483 | 0 | sock->reconnect_ms = qemu_opt_get_number(opts, "reconnect-ms", 0); |
1484 | |
|
1485 | 0 | sock->tls_creds = g_strdup(qemu_opt_get(opts, "tls-creds")); |
1486 | 0 | sock->tls_authz = g_strdup(qemu_opt_get(opts, "tls-authz")); |
1487 | |
|
1488 | 0 | addr = g_new0(SocketAddressLegacy, 1); |
1489 | 0 | if (path) { |
1490 | 0 | UnixSocketAddress *q_unix; |
1491 | 0 | addr->type = SOCKET_ADDRESS_TYPE_UNIX; |
1492 | 0 | q_unix = addr->u.q_unix.data = g_new0(UnixSocketAddress, 1); |
1493 | 0 | q_unix->path = g_strdup(path); |
1494 | 0 | #ifdef CONFIG_LINUX |
1495 | 0 | q_unix->has_tight = true; |
1496 | 0 | q_unix->tight = tight; |
1497 | 0 | q_unix->has_abstract = true; |
1498 | 0 | q_unix->abstract = abstract; |
1499 | 0 | #endif |
1500 | 0 | } else if (host) { |
1501 | 0 | addr->type = SOCKET_ADDRESS_TYPE_INET; |
1502 | 0 | addr->u.inet.data = g_new(InetSocketAddress, 1); |
1503 | 0 | *addr->u.inet.data = (InetSocketAddress) { |
1504 | 0 | .host = g_strdup(host), |
1505 | 0 | .port = g_strdup(port), |
1506 | 0 | .has_to = qemu_opt_get(opts, "to"), |
1507 | 0 | .to = qemu_opt_get_number(opts, "to", 0), |
1508 | 0 | .has_ipv4 = qemu_opt_get(opts, "ipv4"), |
1509 | 0 | .ipv4 = qemu_opt_get_bool(opts, "ipv4", 0), |
1510 | 0 | .has_ipv6 = qemu_opt_get(opts, "ipv6"), |
1511 | 0 | .ipv6 = qemu_opt_get_bool(opts, "ipv6", 0), |
1512 | 0 | }; |
1513 | 0 | } else { |
1514 | 0 | addr->type = SOCKET_ADDRESS_TYPE_FD; |
1515 | 0 | addr->u.fd.data = g_new(FdSocketAddress, 1); |
1516 | 0 | addr->u.fd.data->str = g_strdup(fd); |
1517 | 0 | } |
1518 | 0 | sock->addr = addr; |
1519 | 0 | } |
1520 | | |
1521 | | static void |
1522 | | char_socket_get_addr(Object *obj, Visitor *v, const char *name, |
1523 | | void *opaque, Error **errp) |
1524 | 0 | { |
1525 | 0 | SocketChardev *s = SOCKET_CHARDEV(obj); |
1526 | |
|
1527 | 0 | if (!s->addr) { |
1528 | 0 | error_setg(errp, "socket not connected"); |
1529 | 0 | return; |
1530 | 0 | } |
1531 | 0 | visit_type_SocketAddress(v, name, &s->addr, errp); |
1532 | 0 | } |
1533 | | |
1534 | | static bool |
1535 | | char_socket_get_connected(Object *obj, Error **errp) |
1536 | 0 | { |
1537 | 0 | SocketChardev *s = SOCKET_CHARDEV(obj); |
1538 | |
|
1539 | 0 | return s->state == TCP_CHARDEV_STATE_CONNECTED; |
1540 | 0 | } |
1541 | | |
1542 | | static void tcp_chr_listener_cleanup(Chardev *chr) |
1543 | 0 | { |
1544 | 0 | SocketChardev *s = SOCKET_CHARDEV(chr); |
1545 | 0 | if (s->listener) { |
1546 | 0 | qio_net_listener_set_client_func_full(s->listener, NULL, NULL, |
1547 | 0 | NULL, chr->gcontext); |
1548 | 0 | } |
1549 | 0 | } |
1550 | | |
1551 | | static void char_socket_class_init(ObjectClass *oc, const void *data) |
1552 | 61 | { |
1553 | 61 | ChardevClass *cc = CHARDEV_CLASS(oc); |
1554 | | |
1555 | 61 | cc->supports_yank = true; |
1556 | | |
1557 | 61 | cc->chr_parse = tcp_chr_parse; |
1558 | 61 | cc->chr_open = tcp_chr_open; |
1559 | 61 | cc->chr_wait_connected = tcp_chr_wait_connected; |
1560 | 61 | cc->chr_write = tcp_chr_write; |
1561 | 61 | cc->chr_sync_read = tcp_chr_sync_read; |
1562 | 61 | cc->chr_disconnect = tcp_chr_disconnect; |
1563 | 61 | cc->chr_get_msgfds = tcp_chr_get_msgfds; |
1564 | 61 | cc->chr_set_msgfds = tcp_chr_set_msgfds; |
1565 | 61 | cc->chr_add_client = tcp_chr_add_client; |
1566 | 61 | cc->chr_add_watch = tcp_chr_add_watch; |
1567 | 61 | cc->chr_update_read_handler = tcp_chr_update_read_handler; |
1568 | 61 | cc->chr_listener_cleanup = tcp_chr_listener_cleanup; |
1569 | 61 | cc->chr_get_filename = tcp_chr_get_filename; |
1570 | | |
1571 | 61 | object_class_property_add(oc, "addr", "SocketAddress", |
1572 | 61 | char_socket_get_addr, NULL, |
1573 | 61 | NULL, NULL); |
1574 | | |
1575 | 61 | object_class_property_add_bool(oc, "connected", char_socket_get_connected, |
1576 | 61 | NULL); |
1577 | 61 | } |
1578 | | |
1579 | | static const TypeInfo char_socket_type_info = { |
1580 | | .name = TYPE_CHARDEV_SOCKET, |
1581 | | .parent = TYPE_CHARDEV, |
1582 | | .instance_size = sizeof(SocketChardev), |
1583 | | .instance_finalize = char_socket_finalize, |
1584 | | .class_init = char_socket_class_init, |
1585 | | }; |
1586 | | |
1587 | | static void register_types(void) |
1588 | 61 | { |
1589 | 61 | type_register_static(&char_socket_type_info); |
1590 | 61 | } |
1591 | | |
1592 | | type_init(register_types); |