4 * Copyright (c) 2003-2008 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
25 #include "qemu/osdep.h"
26 #include "chardev/char.h"
27 #include "io/channel-socket.h"
28 #include "io/channel-tls.h"
29 #include "io/channel-websock.h"
30 #include "io/net-listener.h"
31 #include "qemu/error-report.h"
32 #include "qemu/option.h"
33 #include "qapi/error.h"
34 #include "qapi/clone-visitor.h"
35 #include "qapi/qapi-visit-sockets.h"
37 #include "chardev/char-io.h"
39 /***********************************************************/
42 #define TCP_MAX_FDS 16
47 } TCPChardevTelnetInit
;
50 TCP_CHARDEV_STATE_DISCONNECTED
,
51 TCP_CHARDEV_STATE_CONNECTING
,
52 TCP_CHARDEV_STATE_CONNECTED
,
57 QIOChannel
*ioc
; /* Client I/O channel */
58 QIOChannelSocket
*sioc
; /* Client master channel */
59 QIONetListener
*listener
;
61 QCryptoTLSCreds
*tls_creds
;
63 TCPChardevState state
;
68 size_t read_msgfds_num
;
70 size_t write_msgfds_num
;
76 GSource
*telnet_source
;
77 TCPChardevTelnetInit
*telnet_init
;
81 GSource
*reconnect_timer
;
82 int64_t reconnect_time
;
83 bool connect_err_reported
;
85 QIOTask
*connect_task
;
88 #define SOCKET_CHARDEV(obj) \
89 OBJECT_CHECK(SocketChardev, (obj), TYPE_CHARDEV_SOCKET)
91 static gboolean
socket_reconnect_timeout(gpointer opaque
);
92 static void tcp_chr_telnet_init(Chardev
*chr
);
94 static void tcp_chr_change_state(SocketChardev
*s
, TCPChardevState state
)
97 case TCP_CHARDEV_STATE_DISCONNECTED
:
99 case TCP_CHARDEV_STATE_CONNECTING
:
100 assert(s
->state
== TCP_CHARDEV_STATE_DISCONNECTED
);
102 case TCP_CHARDEV_STATE_CONNECTED
:
103 assert(s
->state
== TCP_CHARDEV_STATE_CONNECTING
);
109 static void tcp_chr_reconn_timer_cancel(SocketChardev
*s
)
111 if (s
->reconnect_timer
) {
112 g_source_destroy(s
->reconnect_timer
);
113 g_source_unref(s
->reconnect_timer
);
114 s
->reconnect_timer
= NULL
;
118 static void qemu_chr_socket_restart_timer(Chardev
*chr
)
120 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
123 assert(s
->state
== TCP_CHARDEV_STATE_DISCONNECTED
);
124 assert(!s
->reconnect_timer
);
125 name
= g_strdup_printf("chardev-socket-reconnect-%s", chr
->label
);
126 s
->reconnect_timer
= qemu_chr_timeout_add_ms(chr
,
127 s
->reconnect_time
* 1000,
128 socket_reconnect_timeout
,
130 g_source_set_name(s
->reconnect_timer
, name
);
134 static void check_report_connect_error(Chardev
*chr
,
137 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
139 if (!s
->connect_err_reported
) {
140 error_report("Unable to connect character device %s: %s",
141 chr
->label
, error_get_pretty(err
));
142 s
->connect_err_reported
= true;
144 qemu_chr_socket_restart_timer(chr
);
147 static void tcp_chr_accept(QIONetListener
*listener
,
148 QIOChannelSocket
*cioc
,
151 static int tcp_chr_read_poll(void *opaque
);
152 static void tcp_chr_disconnect(Chardev
*chr
);
154 /* Called with chr_write_lock held. */
155 static int tcp_chr_write(Chardev
*chr
, const uint8_t *buf
, int len
)
157 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
159 if (s
->state
== TCP_CHARDEV_STATE_CONNECTED
) {
160 int ret
= io_channel_send_full(s
->ioc
, buf
, len
,
162 s
->write_msgfds_num
);
164 /* free the written msgfds in any cases
165 * other than ret < 0 && errno == EAGAIN
167 if (!(ret
< 0 && EAGAIN
== errno
)
168 && s
->write_msgfds_num
) {
169 g_free(s
->write_msgfds
);
171 s
->write_msgfds_num
= 0;
174 if (ret
< 0 && errno
!= EAGAIN
) {
175 if (tcp_chr_read_poll(chr
) <= 0) {
176 tcp_chr_disconnect(chr
);
178 } /* else let the read handler finish it properly */
183 /* XXX: indicate an error ? */
188 static int tcp_chr_read_poll(void *opaque
)
190 Chardev
*chr
= CHARDEV(opaque
);
191 SocketChardev
*s
= SOCKET_CHARDEV(opaque
);
192 if (s
->state
!= TCP_CHARDEV_STATE_CONNECTED
) {
195 s
->max_size
= qemu_chr_be_can_write(chr
);
199 static void tcp_chr_process_IAC_bytes(Chardev
*chr
,
201 uint8_t *buf
, int *size
)
203 /* Handle any telnet or tn3270 client's basic IAC options.
204 * For telnet options, it satisfies char by char mode with no echo.
205 * For tn3270 options, it satisfies binary mode with EOR.
206 * All IAC options will be removed from the buf and the do_opt
207 * pointer will be used to track the state of the width of the
210 * RFC854: "All TELNET commands consist of at least a two byte sequence.
211 * The commands dealing with option negotiation are three byte sequences,
212 * the third byte being the code for the option referenced."
213 * "IAC BREAK", "IAC IP", "IAC NOP" and the double IAC are two bytes.
214 * "IAC SB", "IAC SE" and "IAC EOR" are saved to split up data boundary
216 * NOP, Break and Interrupt Process(IP) might be encountered during a TN3270
217 * session, and NOP and IP need to be done later.
223 for (i
= 0; i
< *size
; i
++) {
224 if (s
->do_telnetopt
> 1) {
225 if ((unsigned char)buf
[i
] == IAC
&& s
->do_telnetopt
== 2) {
226 /* Double IAC means send an IAC */
233 if ((unsigned char)buf
[i
] == IAC_BREAK
234 && s
->do_telnetopt
== 2) {
235 /* Handle IAC break commands by sending a serial break */
236 qemu_chr_be_event(chr
, CHR_EVENT_BREAK
);
238 } else if (s
->is_tn3270
&& ((unsigned char)buf
[i
] == IAC_EOR
239 || (unsigned char)buf
[i
] == IAC_SB
240 || (unsigned char)buf
[i
] == IAC_SE
)
241 && s
->do_telnetopt
== 2) {
245 } else if (s
->is_tn3270
&& ((unsigned char)buf
[i
] == IAC_IP
246 || (unsigned char)buf
[i
] == IAC_NOP
)
247 && s
->do_telnetopt
== 2) {
248 /* TODO: IP and NOP need to be implemented later. */
253 if (s
->do_telnetopt
>= 4) {
257 if ((unsigned char)buf
[i
] == IAC
) {
270 static int tcp_get_msgfds(Chardev
*chr
, int *fds
, int num
)
272 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
274 int to_copy
= (s
->read_msgfds_num
< num
) ? s
->read_msgfds_num
: num
;
276 assert(num
<= TCP_MAX_FDS
);
281 memcpy(fds
, s
->read_msgfds
, to_copy
* sizeof(int));
283 /* Close unused fds */
284 for (i
= to_copy
; i
< s
->read_msgfds_num
; i
++) {
285 close(s
->read_msgfds
[i
]);
288 g_free(s
->read_msgfds
);
290 s
->read_msgfds_num
= 0;
296 static int tcp_set_msgfds(Chardev
*chr
, int *fds
, int num
)
298 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
300 /* clear old pending fd array */
301 g_free(s
->write_msgfds
);
302 s
->write_msgfds
= NULL
;
303 s
->write_msgfds_num
= 0;
305 if ((s
->state
!= TCP_CHARDEV_STATE_CONNECTED
) ||
306 !qio_channel_has_feature(s
->ioc
,
307 QIO_CHANNEL_FEATURE_FD_PASS
)) {
312 s
->write_msgfds
= g_new(int, num
);
313 memcpy(s
->write_msgfds
, fds
, num
* sizeof(int));
316 s
->write_msgfds_num
= num
;
321 static ssize_t
tcp_chr_recv(Chardev
*chr
, char *buf
, size_t len
)
323 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
324 struct iovec iov
= { .iov_base
= buf
, .iov_len
= len
};
328 size_t msgfds_num
= 0;
330 if (qio_channel_has_feature(s
->ioc
, QIO_CHANNEL_FEATURE_FD_PASS
)) {
331 ret
= qio_channel_readv_full(s
->ioc
, &iov
, 1,
332 &msgfds
, &msgfds_num
,
335 ret
= qio_channel_readv_full(s
->ioc
, &iov
, 1,
340 if (ret
== QIO_CHANNEL_ERR_BLOCK
) {
343 } else if (ret
== -1) {
348 /* close and clean read_msgfds */
349 for (i
= 0; i
< s
->read_msgfds_num
; i
++) {
350 close(s
->read_msgfds
[i
]);
353 if (s
->read_msgfds_num
) {
354 g_free(s
->read_msgfds
);
357 s
->read_msgfds
= msgfds
;
358 s
->read_msgfds_num
= msgfds_num
;
361 for (i
= 0; i
< s
->read_msgfds_num
; i
++) {
362 int fd
= s
->read_msgfds
[i
];
367 /* O_NONBLOCK is preserved across SCM_RIGHTS so reset it */
370 #ifndef MSG_CMSG_CLOEXEC
371 qemu_set_cloexec(fd
);
378 static GSource
*tcp_chr_add_watch(Chardev
*chr
, GIOCondition cond
)
380 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
381 return qio_channel_create_watch(s
->ioc
, cond
);
384 static void remove_hup_source(SocketChardev
*s
)
386 if (s
->hup_source
!= NULL
) {
387 g_source_destroy(s
->hup_source
);
388 g_source_unref(s
->hup_source
);
389 s
->hup_source
= NULL
;
393 static void tcp_chr_free_connection(Chardev
*chr
)
395 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
398 if (s
->read_msgfds_num
) {
399 for (i
= 0; i
< s
->read_msgfds_num
; i
++) {
400 close(s
->read_msgfds
[i
]);
402 g_free(s
->read_msgfds
);
403 s
->read_msgfds
= NULL
;
404 s
->read_msgfds_num
= 0;
407 remove_hup_source(s
);
409 tcp_set_msgfds(chr
, NULL
, 0);
410 remove_fd_in_watch(chr
);
411 object_unref(OBJECT(s
->sioc
));
413 object_unref(OBJECT(s
->ioc
));
415 g_free(chr
->filename
);
416 chr
->filename
= NULL
;
417 tcp_chr_change_state(s
, TCP_CHARDEV_STATE_DISCONNECTED
);
420 static const char *qemu_chr_socket_protocol(SocketChardev
*s
)
425 return s
->is_websock
? "websocket" : "tcp";
428 static char *qemu_chr_socket_address(SocketChardev
*s
, const char *prefix
)
430 switch (s
->addr
->type
) {
431 case SOCKET_ADDRESS_TYPE_INET
:
432 return g_strdup_printf("%s%s:%s:%s%s", prefix
,
433 qemu_chr_socket_protocol(s
),
434 s
->addr
->u
.inet
.host
,
435 s
->addr
->u
.inet
.port
,
436 s
->is_listen
? ",server" : "");
438 case SOCKET_ADDRESS_TYPE_UNIX
:
439 return g_strdup_printf("%sunix:%s%s", prefix
,
440 s
->addr
->u
.q_unix
.path
,
441 s
->is_listen
? ",server" : "");
443 case SOCKET_ADDRESS_TYPE_FD
:
444 return g_strdup_printf("%sfd:%s%s", prefix
, s
->addr
->u
.fd
.str
,
445 s
->is_listen
? ",server" : "");
447 case SOCKET_ADDRESS_TYPE_VSOCK
:
448 return g_strdup_printf("%svsock:%s:%s", prefix
,
449 s
->addr
->u
.vsock
.cid
,
450 s
->addr
->u
.vsock
.port
);
456 static void update_disconnected_filename(SocketChardev
*s
)
458 Chardev
*chr
= CHARDEV(s
);
460 g_free(chr
->filename
);
462 chr
->filename
= qemu_chr_socket_address(s
, "disconnected:");
464 chr
->filename
= g_strdup("disconnected:socket");
468 /* NB may be called even if tcp_chr_connect has not been
469 * reached, due to TLS or telnet initialization failure,
470 * so can *not* assume s->state == TCP_CHARDEV_STATE_CONNECTED
472 static void tcp_chr_disconnect(Chardev
*chr
)
474 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
475 bool emit_close
= s
->state
== TCP_CHARDEV_STATE_CONNECTED
;
477 tcp_chr_free_connection(chr
);
480 qio_net_listener_set_client_func_full(s
->listener
, tcp_chr_accept
,
481 chr
, NULL
, chr
->gcontext
);
483 update_disconnected_filename(s
);
485 qemu_chr_be_event(chr
, CHR_EVENT_CLOSED
);
487 if (s
->reconnect_time
) {
488 qemu_chr_socket_restart_timer(chr
);
492 static gboolean
tcp_chr_read(QIOChannel
*chan
, GIOCondition cond
, void *opaque
)
494 Chardev
*chr
= CHARDEV(opaque
);
495 SocketChardev
*s
= SOCKET_CHARDEV(opaque
);
496 uint8_t buf
[CHR_READ_BUF_LEN
];
499 if ((s
->state
!= TCP_CHARDEV_STATE_CONNECTED
) ||
504 if (len
> s
->max_size
) {
507 size
= tcp_chr_recv(chr
, (void *)buf
, len
);
508 if (size
== 0 || (size
== -1 && errno
!= EAGAIN
)) {
509 /* connection closed */
510 tcp_chr_disconnect(chr
);
511 } else if (size
> 0) {
512 if (s
->do_telnetopt
) {
513 tcp_chr_process_IAC_bytes(chr
, s
, buf
, &size
);
516 qemu_chr_be_write(chr
, buf
, size
);
523 static gboolean
tcp_chr_hup(QIOChannel
*channel
,
527 Chardev
*chr
= CHARDEV(opaque
);
528 tcp_chr_disconnect(chr
);
529 return G_SOURCE_REMOVE
;
532 static int tcp_chr_sync_read(Chardev
*chr
, const uint8_t *buf
, int len
)
534 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
537 if (s
->state
!= TCP_CHARDEV_STATE_CONNECTED
) {
541 qio_channel_set_blocking(s
->ioc
, true, NULL
);
542 size
= tcp_chr_recv(chr
, (void *) buf
, len
);
543 qio_channel_set_blocking(s
->ioc
, false, NULL
);
545 /* connection closed */
546 tcp_chr_disconnect(chr
);
552 static char *qemu_chr_compute_filename(SocketChardev
*s
)
554 struct sockaddr_storage
*ss
= &s
->sioc
->localAddr
;
555 struct sockaddr_storage
*ps
= &s
->sioc
->remoteAddr
;
556 socklen_t ss_len
= s
->sioc
->localAddrLen
;
557 socklen_t ps_len
= s
->sioc
->remoteAddrLen
;
558 char shost
[NI_MAXHOST
], sserv
[NI_MAXSERV
];
559 char phost
[NI_MAXHOST
], pserv
[NI_MAXSERV
];
560 const char *left
= "", *right
= "";
562 switch (ss
->ss_family
) {
565 return g_strdup_printf("unix:%s%s",
566 ((struct sockaddr_un
*)(ss
))->sun_path
,
567 s
->is_listen
? ",server" : "");
574 getnameinfo((struct sockaddr
*) ss
, ss_len
, shost
, sizeof(shost
),
575 sserv
, sizeof(sserv
), NI_NUMERICHOST
| NI_NUMERICSERV
);
576 getnameinfo((struct sockaddr
*) ps
, ps_len
, phost
, sizeof(phost
),
577 pserv
, sizeof(pserv
), NI_NUMERICHOST
| NI_NUMERICSERV
);
578 return g_strdup_printf("%s:%s%s%s:%s%s <-> %s%s%s:%s",
579 qemu_chr_socket_protocol(s
),
580 left
, shost
, right
, sserv
,
581 s
->is_listen
? ",server" : "",
582 left
, phost
, right
, pserv
);
585 return g_strdup_printf("unknown");
589 static void update_ioc_handlers(SocketChardev
*s
)
591 Chardev
*chr
= CHARDEV(s
);
593 if (s
->state
!= TCP_CHARDEV_STATE_CONNECTED
) {
597 remove_fd_in_watch(chr
);
598 chr
->gsource
= io_add_watch_poll(chr
, s
->ioc
,
603 remove_hup_source(s
);
604 s
->hup_source
= qio_channel_create_watch(s
->ioc
, G_IO_HUP
);
605 g_source_set_callback(s
->hup_source
, (GSourceFunc
)tcp_chr_hup
,
607 g_source_attach(s
->hup_source
, chr
->gcontext
);
610 static void tcp_chr_connect(void *opaque
)
612 Chardev
*chr
= CHARDEV(opaque
);
613 SocketChardev
*s
= SOCKET_CHARDEV(opaque
);
615 g_free(chr
->filename
);
616 chr
->filename
= qemu_chr_compute_filename(s
);
618 tcp_chr_change_state(s
, TCP_CHARDEV_STATE_CONNECTED
);
619 update_ioc_handlers(s
);
620 qemu_chr_be_event(chr
, CHR_EVENT_OPENED
);
623 static void tcp_chr_telnet_destroy(SocketChardev
*s
)
625 if (s
->telnet_source
) {
626 g_source_destroy(s
->telnet_source
);
627 g_source_unref(s
->telnet_source
);
628 s
->telnet_source
= NULL
;
632 static void tcp_chr_update_read_handler(Chardev
*chr
)
634 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
636 if (s
->listener
&& s
->state
== TCP_CHARDEV_STATE_DISCONNECTED
) {
638 * It's possible that chardev context is changed in
639 * qemu_chr_be_update_read_handlers(). Reset it for QIO net
640 * listener if there is.
642 qio_net_listener_set_client_func_full(s
->listener
, tcp_chr_accept
,
643 chr
, NULL
, chr
->gcontext
);
646 if (s
->telnet_source
) {
647 tcp_chr_telnet_init(CHARDEV(s
));
650 update_ioc_handlers(s
);
653 static gboolean
tcp_chr_telnet_init_io(QIOChannel
*ioc
,
654 GIOCondition cond G_GNUC_UNUSED
,
657 SocketChardev
*s
= user_data
;
658 Chardev
*chr
= CHARDEV(s
);
659 TCPChardevTelnetInit
*init
= s
->telnet_init
;
664 ret
= qio_channel_write(ioc
, init
->buf
, init
->buflen
, NULL
);
666 if (ret
== QIO_CHANNEL_ERR_BLOCK
) {
669 tcp_chr_disconnect(chr
);
675 if (init
->buflen
== 0) {
676 tcp_chr_connect(chr
);
680 memmove(init
->buf
, init
->buf
+ ret
, init
->buflen
);
682 return G_SOURCE_CONTINUE
;
685 g_free(s
->telnet_init
);
686 s
->telnet_init
= NULL
;
687 g_source_unref(s
->telnet_source
);
688 s
->telnet_source
= NULL
;
689 return G_SOURCE_REMOVE
;
692 static void tcp_chr_telnet_init(Chardev
*chr
)
694 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
695 TCPChardevTelnetInit
*init
;
698 /* Destroy existing task */
699 tcp_chr_telnet_destroy(s
);
701 if (s
->telnet_init
) {
702 /* We are possibly during a handshake already */
706 s
->telnet_init
= g_new0(TCPChardevTelnetInit
, 1);
707 init
= s
->telnet_init
;
709 #define IACSET(x, a, b, c) \
718 /* Prep the telnet negotion to put telnet in binary,
719 * no echo, single char mode */
720 IACSET(init
->buf
, 0xff, 0xfb, 0x01); /* IAC WILL ECHO */
721 IACSET(init
->buf
, 0xff, 0xfb, 0x03); /* IAC WILL Suppress go ahead */
722 IACSET(init
->buf
, 0xff, 0xfb, 0x00); /* IAC WILL Binary */
723 IACSET(init
->buf
, 0xff, 0xfd, 0x00); /* IAC DO Binary */
726 /* Prep the TN3270 negotion based on RFC1576 */
727 IACSET(init
->buf
, 0xff, 0xfd, 0x19); /* IAC DO EOR */
728 IACSET(init
->buf
, 0xff, 0xfb, 0x19); /* IAC WILL EOR */
729 IACSET(init
->buf
, 0xff, 0xfd, 0x00); /* IAC DO BINARY */
730 IACSET(init
->buf
, 0xff, 0xfb, 0x00); /* IAC WILL BINARY */
731 IACSET(init
->buf
, 0xff, 0xfd, 0x18); /* IAC DO TERMINAL TYPE */
732 IACSET(init
->buf
, 0xff, 0xfa, 0x18); /* IAC SB TERMINAL TYPE */
733 IACSET(init
->buf
, 0x01, 0xff, 0xf0); /* SEND IAC SE */
739 s
->telnet_source
= qio_channel_add_watch_source(s
->ioc
, G_IO_OUT
,
740 tcp_chr_telnet_init_io
,
746 static void tcp_chr_websock_handshake(QIOTask
*task
, gpointer user_data
)
748 Chardev
*chr
= user_data
;
749 SocketChardev
*s
= user_data
;
751 if (qio_task_propagate_error(task
, NULL
)) {
752 tcp_chr_disconnect(chr
);
754 if (s
->do_telnetopt
) {
755 tcp_chr_telnet_init(chr
);
757 tcp_chr_connect(chr
);
763 static void tcp_chr_websock_init(Chardev
*chr
)
765 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
766 QIOChannelWebsock
*wioc
= NULL
;
769 wioc
= qio_channel_websock_new_server(s
->ioc
);
771 name
= g_strdup_printf("chardev-websocket-server-%s", chr
->label
);
772 qio_channel_set_name(QIO_CHANNEL(wioc
), name
);
774 object_unref(OBJECT(s
->ioc
));
775 s
->ioc
= QIO_CHANNEL(wioc
);
777 qio_channel_websock_handshake(wioc
, tcp_chr_websock_handshake
, chr
, NULL
);
781 static void tcp_chr_tls_handshake(QIOTask
*task
,
784 Chardev
*chr
= user_data
;
785 SocketChardev
*s
= user_data
;
787 if (qio_task_propagate_error(task
, NULL
)) {
788 tcp_chr_disconnect(chr
);
791 tcp_chr_websock_init(chr
);
792 } else if (s
->do_telnetopt
) {
793 tcp_chr_telnet_init(chr
);
795 tcp_chr_connect(chr
);
801 static void tcp_chr_tls_init(Chardev
*chr
)
803 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
809 tioc
= qio_channel_tls_new_server(
810 s
->ioc
, s
->tls_creds
,
814 tioc
= qio_channel_tls_new_client(
815 s
->ioc
, s
->tls_creds
,
816 s
->addr
->u
.inet
.host
,
821 tcp_chr_disconnect(chr
);
824 name
= g_strdup_printf("chardev-tls-%s-%s",
825 s
->is_listen
? "server" : "client",
827 qio_channel_set_name(QIO_CHANNEL(tioc
), name
);
829 object_unref(OBJECT(s
->ioc
));
830 s
->ioc
= QIO_CHANNEL(tioc
);
832 qio_channel_tls_handshake(tioc
,
833 tcp_chr_tls_handshake
,
840 static void tcp_chr_set_client_ioc_name(Chardev
*chr
,
841 QIOChannelSocket
*sioc
)
843 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
845 name
= g_strdup_printf("chardev-tcp-%s-%s",
846 s
->is_listen
? "server" : "client",
848 qio_channel_set_name(QIO_CHANNEL(sioc
), name
);
853 static int tcp_chr_new_client(Chardev
*chr
, QIOChannelSocket
*sioc
)
855 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
857 if (s
->state
!= TCP_CHARDEV_STATE_CONNECTING
) {
861 s
->ioc
= QIO_CHANNEL(sioc
);
862 object_ref(OBJECT(sioc
));
864 object_ref(OBJECT(sioc
));
866 qio_channel_set_blocking(s
->ioc
, false, NULL
);
869 qio_channel_set_delay(s
->ioc
, false);
872 qio_net_listener_set_client_func_full(s
->listener
, NULL
, NULL
,
873 NULL
, chr
->gcontext
);
877 tcp_chr_tls_init(chr
);
878 } else if (s
->is_websock
) {
879 tcp_chr_websock_init(chr
);
880 } else if (s
->do_telnetopt
) {
881 tcp_chr_telnet_init(chr
);
883 tcp_chr_connect(chr
);
890 static int tcp_chr_add_client(Chardev
*chr
, int fd
)
893 QIOChannelSocket
*sioc
;
894 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
896 if (s
->state
!= TCP_CHARDEV_STATE_DISCONNECTED
) {
900 sioc
= qio_channel_socket_new_fd(fd
, NULL
);
904 tcp_chr_change_state(s
, TCP_CHARDEV_STATE_CONNECTING
);
905 tcp_chr_set_client_ioc_name(chr
, sioc
);
906 ret
= tcp_chr_new_client(chr
, sioc
);
907 object_unref(OBJECT(sioc
));
911 static void tcp_chr_accept(QIONetListener
*listener
,
912 QIOChannelSocket
*cioc
,
915 Chardev
*chr
= CHARDEV(opaque
);
916 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
918 tcp_chr_change_state(s
, TCP_CHARDEV_STATE_CONNECTING
);
919 tcp_chr_set_client_ioc_name(chr
, cioc
);
920 tcp_chr_new_client(chr
, cioc
);
924 static int tcp_chr_connect_client_sync(Chardev
*chr
, Error
**errp
)
926 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
927 QIOChannelSocket
*sioc
= qio_channel_socket_new();
928 tcp_chr_change_state(s
, TCP_CHARDEV_STATE_CONNECTING
);
929 tcp_chr_set_client_ioc_name(chr
, sioc
);
930 if (qio_channel_socket_connect_sync(sioc
, s
->addr
, errp
) < 0) {
931 tcp_chr_change_state(s
, TCP_CHARDEV_STATE_DISCONNECTED
);
932 object_unref(OBJECT(sioc
));
935 tcp_chr_new_client(chr
, sioc
);
936 object_unref(OBJECT(sioc
));
941 static void tcp_chr_accept_server_sync(Chardev
*chr
)
943 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
944 QIOChannelSocket
*sioc
;
945 info_report("QEMU waiting for connection on: %s",
947 tcp_chr_change_state(s
, TCP_CHARDEV_STATE_CONNECTING
);
948 sioc
= qio_net_listener_wait_client(s
->listener
);
949 tcp_chr_set_client_ioc_name(chr
, sioc
);
950 tcp_chr_new_client(chr
, sioc
);
951 object_unref(OBJECT(sioc
));
955 static int tcp_chr_wait_connected(Chardev
*chr
, Error
**errp
)
957 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
958 const char *opts
[] = { "telnet", "tn3270", "websock", "tls-creds" };
959 bool optset
[] = { s
->is_telnet
, s
->is_tn3270
, s
->is_websock
, s
->tls_creds
};
962 QEMU_BUILD_BUG_ON(G_N_ELEMENTS(opts
) != G_N_ELEMENTS(optset
));
963 for (i
= 0; i
< G_N_ELEMENTS(opts
); i
++) {
966 "'%s' option is incompatible with waiting for "
967 "connection completion", opts
[i
]);
972 tcp_chr_reconn_timer_cancel(s
);
975 * We expect states to be as follows:
978 * - wait -> CONNECTED
979 * - nowait -> DISCONNECTED
981 * - reconnect == 0 -> CONNECTED
982 * - reconnect != 0 -> CONNECTING
985 if (s
->state
== TCP_CHARDEV_STATE_CONNECTING
) {
986 if (!s
->connect_task
) {
988 "Unexpected 'connecting' state without connect task "
989 "while waiting for connection completion");
993 * tcp_chr_wait_connected should only ever be run from the
994 * main loop thread associated with chr->gcontext, otherwise
995 * qio_task_wait_thread has a dangerous race condition with
996 * free'ing of the s->connect_task object.
998 * Acquiring the main context doesn't 100% prove we're in
999 * the main loop thread, but it does at least guarantee
1000 * that the main loop won't be executed by another thread
1001 * avoiding the race condition with the task idle callback.
1003 g_main_context_acquire(chr
->gcontext
);
1004 qio_task_wait_thread(s
->connect_task
);
1005 g_main_context_release(chr
->gcontext
);
1008 * The completion callback (qemu_chr_socket_connected) for
1009 * s->connect_task should have set this to NULL by the time
1010 * qio_task_wait_thread has returned.
1012 assert(!s
->connect_task
);
1015 * NB we are *not* guaranteed to have "s->state == ..CONNECTED"
1016 * at this point as this first connect may be failed, so
1017 * allow the next loop to run regardless.
1021 while (s
->state
!= TCP_CHARDEV_STATE_CONNECTED
) {
1023 tcp_chr_accept_server_sync(chr
);
1026 if (tcp_chr_connect_client_sync(chr
, &err
) < 0) {
1027 if (s
->reconnect_time
) {
1029 g_usleep(s
->reconnect_time
* 1000ULL * 1000ULL);
1031 error_propagate(errp
, err
);
1041 static void char_socket_finalize(Object
*obj
)
1043 Chardev
*chr
= CHARDEV(obj
);
1044 SocketChardev
*s
= SOCKET_CHARDEV(obj
);
1046 tcp_chr_free_connection(chr
);
1047 tcp_chr_reconn_timer_cancel(s
);
1048 qapi_free_SocketAddress(s
->addr
);
1049 tcp_chr_telnet_destroy(s
);
1050 g_free(s
->telnet_init
);
1052 qio_net_listener_set_client_func_full(s
->listener
, NULL
, NULL
,
1053 NULL
, chr
->gcontext
);
1054 object_unref(OBJECT(s
->listener
));
1057 object_unref(OBJECT(s
->tls_creds
));
1059 g_free(s
->tls_authz
);
1061 qemu_chr_be_event(chr
, CHR_EVENT_CLOSED
);
1064 static void qemu_chr_socket_connected(QIOTask
*task
, void *opaque
)
1066 QIOChannelSocket
*sioc
= QIO_CHANNEL_SOCKET(qio_task_get_source(task
));
1067 Chardev
*chr
= CHARDEV(opaque
);
1068 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
1071 s
->connect_task
= NULL
;
1073 if (qio_task_propagate_error(task
, &err
)) {
1074 tcp_chr_change_state(s
, TCP_CHARDEV_STATE_DISCONNECTED
);
1075 check_report_connect_error(chr
, err
);
1080 s
->connect_err_reported
= false;
1081 tcp_chr_new_client(chr
, sioc
);
1084 object_unref(OBJECT(sioc
));
1088 static void tcp_chr_connect_client_task(QIOTask
*task
,
1091 QIOChannelSocket
*ioc
= QIO_CHANNEL_SOCKET(qio_task_get_source(task
));
1092 SocketAddress
*addr
= opaque
;
1095 qio_channel_socket_connect_sync(ioc
, addr
, &err
);
1097 qio_task_set_error(task
, err
);
1101 static void tcp_chr_connect_client_async(Chardev
*chr
)
1103 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
1104 QIOChannelSocket
*sioc
;
1106 tcp_chr_change_state(s
, TCP_CHARDEV_STATE_CONNECTING
);
1107 sioc
= qio_channel_socket_new();
1108 tcp_chr_set_client_ioc_name(chr
, sioc
);
1110 * Normally code would use the qio_channel_socket_connect_async
1111 * method which uses a QIOTask + qio_task_set_error internally
1112 * to avoid blocking. The tcp_chr_wait_connected method, however,
1113 * needs a way to synchronize with completion of the background
1114 * connect task which can't be done with the QIOChannelSocket
1115 * async APIs. Thus we must use QIOTask directly to implement
1116 * the non-blocking concept locally.
1118 s
->connect_task
= qio_task_new(OBJECT(sioc
),
1119 qemu_chr_socket_connected
,
1121 qio_task_run_in_thread(s
->connect_task
,
1122 tcp_chr_connect_client_task
,
1128 static gboolean
socket_reconnect_timeout(gpointer opaque
)
1130 Chardev
*chr
= CHARDEV(opaque
);
1131 SocketChardev
*s
= SOCKET_CHARDEV(opaque
);
1133 g_source_unref(s
->reconnect_timer
);
1134 s
->reconnect_timer
= NULL
;
1140 tcp_chr_connect_client_async(chr
);
1146 static int qmp_chardev_open_socket_server(Chardev
*chr
,
1148 bool is_waitconnect
,
1151 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
1154 s
->do_telnetopt
= 1;
1156 s
->listener
= qio_net_listener_new();
1158 name
= g_strdup_printf("chardev-tcp-listener-%s", chr
->label
);
1159 qio_net_listener_set_name(s
->listener
, name
);
1162 if (qio_net_listener_open_sync(s
->listener
, s
->addr
, errp
) < 0) {
1163 object_unref(OBJECT(s
->listener
));
1168 qapi_free_SocketAddress(s
->addr
);
1169 s
->addr
= socket_local_address(s
->listener
->sioc
[0]->fd
, errp
);
1170 update_disconnected_filename(s
);
1172 if (is_waitconnect
) {
1173 tcp_chr_accept_server_sync(chr
);
1175 qio_net_listener_set_client_func_full(s
->listener
,
1185 static int qmp_chardev_open_socket_client(Chardev
*chr
,
1189 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
1191 if (reconnect
> 0) {
1192 s
->reconnect_time
= reconnect
;
1193 tcp_chr_connect_client_async(chr
);
1196 return tcp_chr_connect_client_sync(chr
, errp
);
1201 static bool qmp_chardev_validate_socket(ChardevSocket
*sock
,
1202 SocketAddress
*addr
,
1205 /* Validate any options which have a dependency on address type */
1206 switch (addr
->type
) {
1207 case SOCKET_ADDRESS_TYPE_FD
:
1208 if (sock
->has_reconnect
) {
1210 "'reconnect' option is incompatible with "
1211 "'fd' address type");
1214 if (sock
->has_tls_creds
&&
1215 !(sock
->has_server
&& sock
->server
)) {
1217 "'tls_creds' option is incompatible with "
1218 "'fd' address type as client");
1223 case SOCKET_ADDRESS_TYPE_UNIX
:
1224 if (sock
->has_tls_creds
) {
1226 "'tls_creds' option is incompatible with "
1227 "'unix' address type");
1232 case SOCKET_ADDRESS_TYPE_INET
:
1235 case SOCKET_ADDRESS_TYPE_VSOCK
:
1236 if (sock
->has_tls_creds
) {
1238 "'tls_creds' option is incompatible with "
1239 "'vsock' address type");
1247 if (sock
->has_tls_authz
&& !sock
->has_tls_creds
) {
1248 error_setg(errp
, "'tls_authz' option requires 'tls_creds' option");
1252 /* Validate any options which have a dependancy on client vs server */
1253 if (!sock
->has_server
|| sock
->server
) {
1254 if (sock
->has_reconnect
) {
1256 "'reconnect' option is incompatible with "
1257 "socket in server listen mode");
1261 if (sock
->has_websocket
&& sock
->websocket
) {
1262 error_setg(errp
, "%s", "Websocket client is not implemented");
1265 if (sock
->has_wait
) {
1266 error_setg(errp
, "%s",
1267 "'wait' option is incompatible with "
1268 "socket in client connect mode");
1277 static void qmp_chardev_open_socket(Chardev
*chr
,
1278 ChardevBackend
*backend
,
1282 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
1283 ChardevSocket
*sock
= backend
->u
.socket
.data
;
1284 bool do_nodelay
= sock
->has_nodelay
? sock
->nodelay
: false;
1285 bool is_listen
= sock
->has_server
? sock
->server
: true;
1286 bool is_telnet
= sock
->has_telnet
? sock
->telnet
: false;
1287 bool is_tn3270
= sock
->has_tn3270
? sock
->tn3270
: false;
1288 bool is_waitconnect
= sock
->has_wait
? sock
->wait
: false;
1289 bool is_websock
= sock
->has_websocket
? sock
->websocket
: false;
1290 int64_t reconnect
= sock
->has_reconnect
? sock
->reconnect
: 0;
1291 SocketAddress
*addr
;
1293 s
->is_listen
= is_listen
;
1294 s
->is_telnet
= is_telnet
;
1295 s
->is_tn3270
= is_tn3270
;
1296 s
->is_websock
= is_websock
;
1297 s
->do_nodelay
= do_nodelay
;
1298 if (sock
->tls_creds
) {
1300 creds
= object_resolve_path_component(
1301 object_get_objects_root(), sock
->tls_creds
);
1303 error_setg(errp
, "No TLS credentials with id '%s'",
1307 s
->tls_creds
= (QCryptoTLSCreds
*)
1308 object_dynamic_cast(creds
,
1309 TYPE_QCRYPTO_TLS_CREDS
);
1310 if (!s
->tls_creds
) {
1311 error_setg(errp
, "Object with id '%s' is not TLS credentials",
1315 object_ref(OBJECT(s
->tls_creds
));
1317 if (s
->tls_creds
->endpoint
!= QCRYPTO_TLS_CREDS_ENDPOINT_SERVER
) {
1318 error_setg(errp
, "%s",
1319 "Expected TLS credentials for server endpoint");
1323 if (s
->tls_creds
->endpoint
!= QCRYPTO_TLS_CREDS_ENDPOINT_CLIENT
) {
1324 error_setg(errp
, "%s",
1325 "Expected TLS credentials for client endpoint");
1330 s
->tls_authz
= g_strdup(sock
->tls_authz
);
1332 s
->addr
= addr
= socket_address_flatten(sock
->addr
);
1334 if (!qmp_chardev_validate_socket(sock
, addr
, errp
)) {
1338 qemu_chr_set_feature(chr
, QEMU_CHAR_FEATURE_RECONNECTABLE
);
1339 /* TODO SOCKET_ADDRESS_FD where fd has AF_UNIX */
1340 if (addr
->type
== SOCKET_ADDRESS_TYPE_UNIX
) {
1341 qemu_chr_set_feature(chr
, QEMU_CHAR_FEATURE_FD_PASS
);
1344 /* be isn't opened until we get a connection */
1347 update_disconnected_filename(s
);
1350 if (qmp_chardev_open_socket_server(chr
, is_telnet
|| is_tn3270
,
1351 is_waitconnect
, errp
) < 0) {
1355 if (qmp_chardev_open_socket_client(chr
, reconnect
, errp
) < 0) {
1361 static void qemu_chr_parse_socket(QemuOpts
*opts
, ChardevBackend
*backend
,
1364 const char *path
= qemu_opt_get(opts
, "path");
1365 const char *host
= qemu_opt_get(opts
, "host");
1366 const char *port
= qemu_opt_get(opts
, "port");
1367 const char *fd
= qemu_opt_get(opts
, "fd");
1368 SocketAddressLegacy
*addr
;
1369 ChardevSocket
*sock
;
1371 if ((!!path
+ !!fd
+ !!host
) != 1) {
1373 "Exactly one of 'path', 'fd' or 'host' required");
1377 if (host
&& !port
) {
1378 error_setg(errp
, "chardev: socket: no port given");
1382 backend
->type
= CHARDEV_BACKEND_KIND_SOCKET
;
1383 sock
= backend
->u
.socket
.data
= g_new0(ChardevSocket
, 1);
1384 qemu_chr_parse_common(opts
, qapi_ChardevSocket_base(sock
));
1386 sock
->has_nodelay
= qemu_opt_get(opts
, "delay");
1387 sock
->nodelay
= !qemu_opt_get_bool(opts
, "delay", true);
1389 * We have different default to QMP for 'server', hence
1390 * we can't just check for existence of 'server'
1392 sock
->has_server
= true;
1393 sock
->server
= qemu_opt_get_bool(opts
, "server", false);
1394 sock
->has_telnet
= qemu_opt_get(opts
, "telnet");
1395 sock
->telnet
= qemu_opt_get_bool(opts
, "telnet", false);
1396 sock
->has_tn3270
= qemu_opt_get(opts
, "tn3270");
1397 sock
->tn3270
= qemu_opt_get_bool(opts
, "tn3270", false);
1398 sock
->has_websocket
= qemu_opt_get(opts
, "websocket");
1399 sock
->websocket
= qemu_opt_get_bool(opts
, "websocket", false);
1401 * We have different default to QMP for 'wait' when 'server'
1402 * is set, hence we can't just check for existence of 'wait'
1404 sock
->has_wait
= qemu_opt_find(opts
, "wait") || sock
->server
;
1405 sock
->wait
= qemu_opt_get_bool(opts
, "wait", true);
1406 sock
->has_reconnect
= qemu_opt_find(opts
, "reconnect");
1407 sock
->reconnect
= qemu_opt_get_number(opts
, "reconnect", 0);
1408 sock
->has_tls_creds
= qemu_opt_get(opts
, "tls-creds");
1409 sock
->tls_creds
= g_strdup(qemu_opt_get(opts
, "tls-creds"));
1410 sock
->has_tls_authz
= qemu_opt_get(opts
, "tls-authz");
1411 sock
->tls_authz
= g_strdup(qemu_opt_get(opts
, "tls-authz"));
1413 addr
= g_new0(SocketAddressLegacy
, 1);
1415 UnixSocketAddress
*q_unix
;
1416 addr
->type
= SOCKET_ADDRESS_LEGACY_KIND_UNIX
;
1417 q_unix
= addr
->u
.q_unix
.data
= g_new0(UnixSocketAddress
, 1);
1418 q_unix
->path
= g_strdup(path
);
1420 addr
->type
= SOCKET_ADDRESS_LEGACY_KIND_INET
;
1421 addr
->u
.inet
.data
= g_new(InetSocketAddress
, 1);
1422 *addr
->u
.inet
.data
= (InetSocketAddress
) {
1423 .host
= g_strdup(host
),
1424 .port
= g_strdup(port
),
1425 .has_to
= qemu_opt_get(opts
, "to"),
1426 .to
= qemu_opt_get_number(opts
, "to", 0),
1427 .has_ipv4
= qemu_opt_get(opts
, "ipv4"),
1428 .ipv4
= qemu_opt_get_bool(opts
, "ipv4", 0),
1429 .has_ipv6
= qemu_opt_get(opts
, "ipv6"),
1430 .ipv6
= qemu_opt_get_bool(opts
, "ipv6", 0),
1433 addr
->type
= SOCKET_ADDRESS_LEGACY_KIND_FD
;
1434 addr
->u
.fd
.data
= g_new(String
, 1);
1435 addr
->u
.fd
.data
->str
= g_strdup(fd
);
1437 g_assert_not_reached();
1443 char_socket_get_addr(Object
*obj
, Visitor
*v
, const char *name
,
1444 void *opaque
, Error
**errp
)
1446 SocketChardev
*s
= SOCKET_CHARDEV(obj
);
1448 visit_type_SocketAddress(v
, name
, &s
->addr
, errp
);
1452 char_socket_get_connected(Object
*obj
, Error
**errp
)
1454 SocketChardev
*s
= SOCKET_CHARDEV(obj
);
1456 return s
->state
== TCP_CHARDEV_STATE_CONNECTED
;
1459 static void char_socket_class_init(ObjectClass
*oc
, void *data
)
1461 ChardevClass
*cc
= CHARDEV_CLASS(oc
);
1463 cc
->parse
= qemu_chr_parse_socket
;
1464 cc
->open
= qmp_chardev_open_socket
;
1465 cc
->chr_wait_connected
= tcp_chr_wait_connected
;
1466 cc
->chr_write
= tcp_chr_write
;
1467 cc
->chr_sync_read
= tcp_chr_sync_read
;
1468 cc
->chr_disconnect
= tcp_chr_disconnect
;
1469 cc
->get_msgfds
= tcp_get_msgfds
;
1470 cc
->set_msgfds
= tcp_set_msgfds
;
1471 cc
->chr_add_client
= tcp_chr_add_client
;
1472 cc
->chr_add_watch
= tcp_chr_add_watch
;
1473 cc
->chr_update_read_handler
= tcp_chr_update_read_handler
;
1475 object_class_property_add(oc
, "addr", "SocketAddress",
1476 char_socket_get_addr
, NULL
,
1477 NULL
, NULL
, &error_abort
);
1479 object_class_property_add_bool(oc
, "connected", char_socket_get_connected
,
1480 NULL
, &error_abort
);
1483 static const TypeInfo char_socket_type_info
= {
1484 .name
= TYPE_CHARDEV_SOCKET
,
1485 .parent
= TYPE_CHARDEV
,
1486 .instance_size
= sizeof(SocketChardev
),
1487 .instance_finalize
= char_socket_finalize
,
1488 .class_init
= char_socket_class_init
,
1491 static void register_types(void)
1493 type_register_static(&char_socket_type_info
);
1496 type_init(register_types
);