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
24 #include "qemu/osdep.h"
25 #include "sysemu/char.h"
26 #include "io/channel-socket.h"
27 #include "io/channel-tls.h"
28 #include "qemu/error-report.h"
29 #include "qapi/error.h"
30 #include "qapi/clone-visitor.h"
34 /***********************************************************/
37 #define TCP_MAX_FDS 16
41 QIOChannel
*ioc
; /* Client I/O channel */
42 QIOChannelSocket
*sioc
; /* Client master channel */
43 QIOChannelSocket
*listen_ioc
;
45 QCryptoTLSCreds
*tls_creds
;
51 size_t read_msgfds_num
;
53 size_t write_msgfds_num
;
60 guint reconnect_timer
;
61 int64_t reconnect_time
;
62 bool connect_err_reported
;
65 #define SOCKET_CHARDEV(obj) \
66 OBJECT_CHECK(SocketChardev, (obj), TYPE_CHARDEV_SOCKET)
68 static gboolean
socket_reconnect_timeout(gpointer opaque
);
70 static void qemu_chr_socket_restart_timer(Chardev
*chr
)
72 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
75 assert(s
->connected
== 0);
76 s
->reconnect_timer
= g_timeout_add_seconds(s
->reconnect_time
,
77 socket_reconnect_timeout
, chr
);
78 name
= g_strdup_printf("chardev-socket-reconnect-%s", chr
->label
);
79 g_source_set_name_by_id(s
->reconnect_timer
, name
);
83 static void check_report_connect_error(Chardev
*chr
,
86 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
88 if (!s
->connect_err_reported
) {
89 error_report("Unable to connect character device %s: %s",
90 chr
->label
, error_get_pretty(err
));
91 s
->connect_err_reported
= true;
93 qemu_chr_socket_restart_timer(chr
);
96 static gboolean
tcp_chr_accept(QIOChannel
*chan
,
100 static int tcp_chr_read_poll(void *opaque
);
101 static void tcp_chr_disconnect(Chardev
*chr
);
103 /* Called with chr_write_lock held. */
104 static int tcp_chr_write(Chardev
*chr
, const uint8_t *buf
, int len
)
106 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
109 int ret
= io_channel_send_full(s
->ioc
, buf
, len
,
111 s
->write_msgfds_num
);
113 /* free the written msgfds, no matter what */
114 if (s
->write_msgfds_num
) {
115 g_free(s
->write_msgfds
);
117 s
->write_msgfds_num
= 0;
120 if (ret
< 0 && errno
!= EAGAIN
) {
121 if (tcp_chr_read_poll(chr
) <= 0) {
122 tcp_chr_disconnect(chr
);
124 } /* else let the read handler finish it properly */
129 /* XXX: indicate an error ? */
134 static int tcp_chr_read_poll(void *opaque
)
136 Chardev
*chr
= CHARDEV(opaque
);
137 SocketChardev
*s
= SOCKET_CHARDEV(opaque
);
141 s
->max_size
= qemu_chr_be_can_write(chr
);
145 static void tcp_chr_process_IAC_bytes(Chardev
*chr
,
147 uint8_t *buf
, int *size
)
149 /* Handle any telnet or tn3270 client's basic IAC options.
150 * For telnet options, it satisfies char by char mode with no echo.
151 * For tn3270 options, it satisfies binary mode with EOR.
152 * All IAC options will be removed from the buf and the do_opt
153 * pointer will be used to track the state of the width of the
156 * RFC854: "All TELNET commands consist of at least a two byte sequence.
157 * The commands dealing with option negotiation are three byte sequences,
158 * the third byte being the code for the option referenced."
159 * "IAC BREAK", "IAC IP", "IAC NOP" and the double IAC are two bytes.
160 * "IAC SB", "IAC SE" and "IAC EOR" are saved to split up data boundary
162 * NOP, Break and Interrupt Process(IP) might be encountered during a TN3270
163 * session, and NOP and IP need to be done later.
169 for (i
= 0; i
< *size
; i
++) {
170 if (s
->do_telnetopt
> 1) {
171 if ((unsigned char)buf
[i
] == IAC
&& s
->do_telnetopt
== 2) {
172 /* Double IAC means send an IAC */
179 if ((unsigned char)buf
[i
] == IAC_BREAK
180 && s
->do_telnetopt
== 2) {
181 /* Handle IAC break commands by sending a serial break */
182 qemu_chr_be_event(chr
, CHR_EVENT_BREAK
);
184 } else if (s
->is_tn3270
&& ((unsigned char)buf
[i
] == IAC_EOR
185 || (unsigned char)buf
[i
] == IAC_SB
186 || (unsigned char)buf
[i
] == IAC_SE
)
187 && s
->do_telnetopt
== 2) {
191 } else if (s
->is_tn3270
&& ((unsigned char)buf
[i
] == IAC_IP
192 || (unsigned char)buf
[i
] == IAC_NOP
)
193 && s
->do_telnetopt
== 2) {
194 /* TODO: IP and NOP need to be implemented later. */
199 if (s
->do_telnetopt
>= 4) {
203 if ((unsigned char)buf
[i
] == IAC
) {
216 static int tcp_get_msgfds(Chardev
*chr
, int *fds
, int num
)
218 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
220 int to_copy
= (s
->read_msgfds_num
< num
) ? s
->read_msgfds_num
: num
;
222 assert(num
<= TCP_MAX_FDS
);
227 memcpy(fds
, s
->read_msgfds
, to_copy
* sizeof(int));
229 /* Close unused fds */
230 for (i
= to_copy
; i
< s
->read_msgfds_num
; i
++) {
231 close(s
->read_msgfds
[i
]);
234 g_free(s
->read_msgfds
);
236 s
->read_msgfds_num
= 0;
242 static int tcp_set_msgfds(Chardev
*chr
, int *fds
, int num
)
244 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
246 /* clear old pending fd array */
247 g_free(s
->write_msgfds
);
248 s
->write_msgfds
= NULL
;
249 s
->write_msgfds_num
= 0;
252 !qio_channel_has_feature(s
->ioc
,
253 QIO_CHANNEL_FEATURE_FD_PASS
)) {
258 s
->write_msgfds
= g_new(int, num
);
259 memcpy(s
->write_msgfds
, fds
, num
* sizeof(int));
262 s
->write_msgfds_num
= num
;
267 static ssize_t
tcp_chr_recv(Chardev
*chr
, char *buf
, size_t len
)
269 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
270 struct iovec iov
= { .iov_base
= buf
, .iov_len
= len
};
274 size_t msgfds_num
= 0;
276 if (qio_channel_has_feature(s
->ioc
, QIO_CHANNEL_FEATURE_FD_PASS
)) {
277 ret
= qio_channel_readv_full(s
->ioc
, &iov
, 1,
278 &msgfds
, &msgfds_num
,
281 ret
= qio_channel_readv_full(s
->ioc
, &iov
, 1,
286 if (ret
== QIO_CHANNEL_ERR_BLOCK
) {
289 } else if (ret
== -1) {
294 /* close and clean read_msgfds */
295 for (i
= 0; i
< s
->read_msgfds_num
; i
++) {
296 close(s
->read_msgfds
[i
]);
299 if (s
->read_msgfds_num
) {
300 g_free(s
->read_msgfds
);
303 s
->read_msgfds
= msgfds
;
304 s
->read_msgfds_num
= msgfds_num
;
307 for (i
= 0; i
< s
->read_msgfds_num
; i
++) {
308 int fd
= s
->read_msgfds
[i
];
313 /* O_NONBLOCK is preserved across SCM_RIGHTS so reset it */
316 #ifndef MSG_CMSG_CLOEXEC
317 qemu_set_cloexec(fd
);
324 static GSource
*tcp_chr_add_watch(Chardev
*chr
, GIOCondition cond
)
326 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
327 return qio_channel_create_watch(s
->ioc
, cond
);
330 static void tcp_chr_free_connection(Chardev
*chr
)
332 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
339 if (s
->read_msgfds_num
) {
340 for (i
= 0; i
< s
->read_msgfds_num
; i
++) {
341 close(s
->read_msgfds
[i
]);
343 g_free(s
->read_msgfds
);
344 s
->read_msgfds
= NULL
;
345 s
->read_msgfds_num
= 0;
348 tcp_set_msgfds(chr
, NULL
, 0);
349 remove_fd_in_watch(chr
, NULL
);
350 object_unref(OBJECT(s
->sioc
));
352 object_unref(OBJECT(s
->ioc
));
354 g_free(chr
->filename
);
355 chr
->filename
= NULL
;
359 static char *SocketAddress_to_str(const char *prefix
, SocketAddress
*addr
,
360 bool is_listen
, bool is_telnet
)
362 switch (addr
->type
) {
363 case SOCKET_ADDRESS_KIND_INET
:
364 return g_strdup_printf("%s%s:%s:%s%s", prefix
,
365 is_telnet
? "telnet" : "tcp",
366 addr
->u
.inet
.data
->host
,
367 addr
->u
.inet
.data
->port
,
368 is_listen
? ",server" : "");
370 case SOCKET_ADDRESS_KIND_UNIX
:
371 return g_strdup_printf("%sunix:%s%s", prefix
,
372 addr
->u
.q_unix
.data
->path
,
373 is_listen
? ",server" : "");
375 case SOCKET_ADDRESS_KIND_FD
:
376 return g_strdup_printf("%sfd:%s%s", prefix
, addr
->u
.fd
.data
->str
,
377 is_listen
? ",server" : "");
379 case SOCKET_ADDRESS_KIND_VSOCK
:
380 return g_strdup_printf("%svsock:%s:%s", prefix
,
381 addr
->u
.vsock
.data
->cid
,
382 addr
->u
.vsock
.data
->port
);
388 static void tcp_chr_disconnect(Chardev
*chr
)
390 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
396 tcp_chr_free_connection(chr
);
399 s
->listen_tag
= qio_channel_add_watch(
400 QIO_CHANNEL(s
->listen_ioc
), G_IO_IN
, tcp_chr_accept
, chr
, NULL
);
402 chr
->filename
= SocketAddress_to_str("disconnected:", s
->addr
,
403 s
->is_listen
, s
->is_telnet
);
404 qemu_chr_be_event(chr
, CHR_EVENT_CLOSED
);
405 if (s
->reconnect_time
) {
406 qemu_chr_socket_restart_timer(chr
);
410 static gboolean
tcp_chr_read(QIOChannel
*chan
, GIOCondition cond
, void *opaque
)
412 Chardev
*chr
= CHARDEV(opaque
);
413 SocketChardev
*s
= SOCKET_CHARDEV(opaque
);
414 uint8_t buf
[CHR_READ_BUF_LEN
];
417 if (!s
->connected
|| s
->max_size
<= 0) {
421 if (len
> s
->max_size
) {
424 size
= tcp_chr_recv(chr
, (void *)buf
, len
);
425 if (size
== 0 || size
== -1) {
426 /* connection closed */
427 tcp_chr_disconnect(chr
);
428 } else if (size
> 0) {
429 if (s
->do_telnetopt
) {
430 tcp_chr_process_IAC_bytes(chr
, s
, buf
, &size
);
433 qemu_chr_be_write(chr
, buf
, size
);
440 static int tcp_chr_sync_read(Chardev
*chr
, const uint8_t *buf
, int len
)
442 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
449 size
= tcp_chr_recv(chr
, (void *) buf
, len
);
451 /* connection closed */
452 tcp_chr_disconnect(chr
);
458 static char *sockaddr_to_str(struct sockaddr_storage
*ss
, socklen_t ss_len
,
459 struct sockaddr_storage
*ps
, socklen_t ps_len
,
460 bool is_listen
, bool is_telnet
)
462 char shost
[NI_MAXHOST
], sserv
[NI_MAXSERV
];
463 char phost
[NI_MAXHOST
], pserv
[NI_MAXSERV
];
464 const char *left
= "", *right
= "";
466 switch (ss
->ss_family
) {
469 return g_strdup_printf("unix:%s%s",
470 ((struct sockaddr_un
*)(ss
))->sun_path
,
471 is_listen
? ",server" : "");
478 getnameinfo((struct sockaddr
*) ss
, ss_len
, shost
, sizeof(shost
),
479 sserv
, sizeof(sserv
), NI_NUMERICHOST
| NI_NUMERICSERV
);
480 getnameinfo((struct sockaddr
*) ps
, ps_len
, phost
, sizeof(phost
),
481 pserv
, sizeof(pserv
), NI_NUMERICHOST
| NI_NUMERICSERV
);
482 return g_strdup_printf("%s:%s%s%s:%s%s <-> %s%s%s:%s",
483 is_telnet
? "telnet" : "tcp",
484 left
, shost
, right
, sserv
,
485 is_listen
? ",server" : "",
486 left
, phost
, right
, pserv
);
489 return g_strdup_printf("unknown");
493 static void tcp_chr_connect(void *opaque
)
495 Chardev
*chr
= CHARDEV(opaque
);
496 SocketChardev
*s
= SOCKET_CHARDEV(opaque
);
498 g_free(chr
->filename
);
499 chr
->filename
= sockaddr_to_str(
500 &s
->sioc
->localAddr
, s
->sioc
->localAddrLen
,
501 &s
->sioc
->remoteAddr
, s
->sioc
->remoteAddrLen
,
502 s
->is_listen
, s
->is_telnet
);
506 chr
->fd_in_tag
= io_add_watch_poll(chr
, s
->ioc
,
511 qemu_chr_be_generic_open(chr
);
514 static void tcp_chr_update_read_handler(Chardev
*chr
,
515 GMainContext
*context
)
517 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
523 remove_fd_in_watch(chr
, NULL
);
525 chr
->fd_in_tag
= io_add_watch_poll(chr
, s
->ioc
,
536 } TCPChardevTelnetInit
;
538 static gboolean
tcp_chr_telnet_init_io(QIOChannel
*ioc
,
539 GIOCondition cond G_GNUC_UNUSED
,
542 TCPChardevTelnetInit
*init
= user_data
;
545 ret
= qio_channel_write(ioc
, init
->buf
, init
->buflen
, NULL
);
547 if (ret
== QIO_CHANNEL_ERR_BLOCK
) {
550 tcp_chr_disconnect(init
->chr
);
556 if (init
->buflen
== 0) {
557 tcp_chr_connect(init
->chr
);
561 memmove(init
->buf
, init
->buf
+ ret
, init
->buflen
);
566 static void tcp_chr_telnet_init(Chardev
*chr
)
568 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
569 TCPChardevTelnetInit
*init
= g_new0(TCPChardevTelnetInit
, 1);
572 #define IACSET(x, a, b, c) \
582 /* Prep the telnet negotion to put telnet in binary,
583 * no echo, single char mode */
584 IACSET(init
->buf
, 0xff, 0xfb, 0x01); /* IAC WILL ECHO */
585 IACSET(init
->buf
, 0xff, 0xfb, 0x03); /* IAC WILL Suppress go ahead */
586 IACSET(init
->buf
, 0xff, 0xfb, 0x00); /* IAC WILL Binary */
587 IACSET(init
->buf
, 0xff, 0xfd, 0x00); /* IAC DO Binary */
590 /* Prep the TN3270 negotion based on RFC1576 */
591 IACSET(init
->buf
, 0xff, 0xfd, 0x19); /* IAC DO EOR */
592 IACSET(init
->buf
, 0xff, 0xfb, 0x19); /* IAC WILL EOR */
593 IACSET(init
->buf
, 0xff, 0xfd, 0x00); /* IAC DO BINARY */
594 IACSET(init
->buf
, 0xff, 0xfb, 0x00); /* IAC WILL BINARY */
595 IACSET(init
->buf
, 0xff, 0xfd, 0x18); /* IAC DO TERMINAL TYPE */
596 IACSET(init
->buf
, 0xff, 0xfa, 0x18); /* IAC SB TERMINAL TYPE */
597 IACSET(init
->buf
, 0x01, 0xff, 0xf0); /* SEND IAC SE */
602 qio_channel_add_watch(
604 tcp_chr_telnet_init_io
,
609 static void tcp_chr_tls_handshake(QIOTask
*task
,
612 Chardev
*chr
= user_data
;
613 SocketChardev
*s
= user_data
;
615 if (qio_task_propagate_error(task
, NULL
)) {
616 tcp_chr_disconnect(chr
);
618 /* tn3270 does not support TLS yet */
619 if (s
->do_telnetopt
&& !s
->is_tn3270
) {
620 tcp_chr_telnet_init(chr
);
622 tcp_chr_connect(chr
);
628 static void tcp_chr_tls_init(Chardev
*chr
)
630 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
636 tioc
= qio_channel_tls_new_server(
637 s
->ioc
, s
->tls_creds
,
638 NULL
, /* XXX Use an ACL */
641 tioc
= qio_channel_tls_new_client(
642 s
->ioc
, s
->tls_creds
,
643 s
->addr
->u
.inet
.data
->host
,
648 tcp_chr_disconnect(chr
);
651 name
= g_strdup_printf("chardev-tls-%s-%s",
652 s
->is_listen
? "server" : "client",
654 qio_channel_set_name(QIO_CHANNEL(tioc
), name
);
656 object_unref(OBJECT(s
->ioc
));
657 s
->ioc
= QIO_CHANNEL(tioc
);
659 qio_channel_tls_handshake(tioc
,
660 tcp_chr_tls_handshake
,
666 static void tcp_chr_set_client_ioc_name(Chardev
*chr
,
667 QIOChannelSocket
*sioc
)
669 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
671 name
= g_strdup_printf("chardev-tcp-%s-%s",
672 s
->is_listen
? "server" : "client",
674 qio_channel_set_name(QIO_CHANNEL(sioc
), name
);
679 static int tcp_chr_new_client(Chardev
*chr
, QIOChannelSocket
*sioc
)
681 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
683 if (s
->ioc
!= NULL
) {
687 s
->ioc
= QIO_CHANNEL(sioc
);
688 object_ref(OBJECT(sioc
));
690 object_ref(OBJECT(sioc
));
692 qio_channel_set_blocking(s
->ioc
, false, NULL
);
695 qio_channel_set_delay(s
->ioc
, false);
698 g_source_remove(s
->listen_tag
);
703 tcp_chr_tls_init(chr
);
705 if (s
->do_telnetopt
) {
706 tcp_chr_telnet_init(chr
);
708 tcp_chr_connect(chr
);
716 static int tcp_chr_add_client(Chardev
*chr
, int fd
)
719 QIOChannelSocket
*sioc
;
721 sioc
= qio_channel_socket_new_fd(fd
, NULL
);
725 tcp_chr_set_client_ioc_name(chr
, sioc
);
726 ret
= tcp_chr_new_client(chr
, sioc
);
727 object_unref(OBJECT(sioc
));
731 static gboolean
tcp_chr_accept(QIOChannel
*channel
,
735 Chardev
*chr
= CHARDEV(opaque
);
736 QIOChannelSocket
*sioc
;
738 sioc
= qio_channel_socket_accept(QIO_CHANNEL_SOCKET(channel
),
744 tcp_chr_new_client(chr
, sioc
);
746 object_unref(OBJECT(sioc
));
751 static int tcp_chr_wait_connected(Chardev
*chr
, Error
**errp
)
753 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
754 QIOChannelSocket
*sioc
;
756 /* It can't wait on s->connected, since it is set asynchronously
757 * in TLS and telnet cases, only wait for an accepted socket */
760 error_report("QEMU waiting for connection on: %s",
762 qio_channel_set_blocking(QIO_CHANNEL(s
->listen_ioc
), true, NULL
);
763 tcp_chr_accept(QIO_CHANNEL(s
->listen_ioc
), G_IO_IN
, chr
);
764 qio_channel_set_blocking(QIO_CHANNEL(s
->listen_ioc
), false, NULL
);
766 sioc
= qio_channel_socket_new();
767 tcp_chr_set_client_ioc_name(chr
, sioc
);
768 if (qio_channel_socket_connect_sync(sioc
, s
->addr
, errp
) < 0) {
769 object_unref(OBJECT(sioc
));
772 tcp_chr_new_client(chr
, sioc
);
773 object_unref(OBJECT(sioc
));
780 static void char_socket_finalize(Object
*obj
)
782 Chardev
*chr
= CHARDEV(obj
);
783 SocketChardev
*s
= SOCKET_CHARDEV(obj
);
785 tcp_chr_free_connection(chr
);
787 if (s
->reconnect_timer
) {
788 g_source_remove(s
->reconnect_timer
);
789 s
->reconnect_timer
= 0;
791 qapi_free_SocketAddress(s
->addr
);
793 g_source_remove(s
->listen_tag
);
797 object_unref(OBJECT(s
->listen_ioc
));
800 object_unref(OBJECT(s
->tls_creds
));
803 qemu_chr_be_event(chr
, CHR_EVENT_CLOSED
);
806 static void qemu_chr_socket_connected(QIOTask
*task
, void *opaque
)
808 QIOChannelSocket
*sioc
= QIO_CHANNEL_SOCKET(qio_task_get_source(task
));
809 Chardev
*chr
= CHARDEV(opaque
);
810 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
813 if (qio_task_propagate_error(task
, &err
)) {
814 check_report_connect_error(chr
, err
);
819 s
->connect_err_reported
= false;
820 tcp_chr_new_client(chr
, sioc
);
823 object_unref(OBJECT(sioc
));
826 static gboolean
socket_reconnect_timeout(gpointer opaque
)
828 Chardev
*chr
= CHARDEV(opaque
);
829 SocketChardev
*s
= SOCKET_CHARDEV(opaque
);
830 QIOChannelSocket
*sioc
;
832 s
->reconnect_timer
= 0;
838 sioc
= qio_channel_socket_new();
839 tcp_chr_set_client_ioc_name(chr
, sioc
);
840 qio_channel_socket_connect_async(sioc
, s
->addr
,
841 qemu_chr_socket_connected
,
847 static void qmp_chardev_open_socket(Chardev
*chr
,
848 ChardevBackend
*backend
,
852 SocketChardev
*s
= SOCKET_CHARDEV(chr
);
853 ChardevSocket
*sock
= backend
->u
.socket
.data
;
854 SocketAddress
*addr
= sock
->addr
;
855 bool do_nodelay
= sock
->has_nodelay
? sock
->nodelay
: false;
856 bool is_listen
= sock
->has_server
? sock
->server
: true;
857 bool is_telnet
= sock
->has_telnet
? sock
->telnet
: false;
858 bool is_tn3270
= sock
->has_tn3270
? sock
->tn3270
: false;
859 bool is_waitconnect
= sock
->has_wait
? sock
->wait
: false;
860 int64_t reconnect
= sock
->has_reconnect
? sock
->reconnect
: 0;
861 QIOChannelSocket
*sioc
= NULL
;
863 s
->is_listen
= is_listen
;
864 s
->is_telnet
= is_telnet
;
865 s
->is_tn3270
= is_tn3270
;
866 s
->do_nodelay
= do_nodelay
;
867 if (sock
->tls_creds
) {
869 creds
= object_resolve_path_component(
870 object_get_objects_root(), sock
->tls_creds
);
872 error_setg(errp
, "No TLS credentials with id '%s'",
876 s
->tls_creds
= (QCryptoTLSCreds
*)
877 object_dynamic_cast(creds
,
878 TYPE_QCRYPTO_TLS_CREDS
);
880 error_setg(errp
, "Object with id '%s' is not TLS credentials",
884 object_ref(OBJECT(s
->tls_creds
));
886 if (s
->tls_creds
->endpoint
!= QCRYPTO_TLS_CREDS_ENDPOINT_SERVER
) {
887 error_setg(errp
, "%s",
888 "Expected TLS credentials for server endpoint");
892 if (s
->tls_creds
->endpoint
!= QCRYPTO_TLS_CREDS_ENDPOINT_CLIENT
) {
893 error_setg(errp
, "%s",
894 "Expected TLS credentials for client endpoint");
900 s
->addr
= QAPI_CLONE(SocketAddress
, sock
->addr
);
902 qemu_chr_set_feature(chr
, QEMU_CHAR_FEATURE_RECONNECTABLE
);
903 /* TODO SOCKET_ADDRESS_FD where fd has AF_UNIX */
904 if (addr
->type
== SOCKET_ADDRESS_KIND_UNIX
) {
905 qemu_chr_set_feature(chr
, QEMU_CHAR_FEATURE_FD_PASS
);
908 /* be isn't opened until we get a connection */
911 chr
->filename
= SocketAddress_to_str("disconnected:",
912 addr
, is_listen
, is_telnet
);
915 if (is_telnet
|| is_tn3270
) {
918 } else if (reconnect
> 0) {
919 s
->reconnect_time
= reconnect
;
922 if (s
->reconnect_time
) {
923 sioc
= qio_channel_socket_new();
924 tcp_chr_set_client_ioc_name(chr
, sioc
);
925 qio_channel_socket_connect_async(sioc
, s
->addr
,
926 qemu_chr_socket_connected
,
931 sioc
= qio_channel_socket_new();
933 name
= g_strdup_printf("chardev-tcp-listener-%s", chr
->label
);
934 qio_channel_set_name(QIO_CHANNEL(sioc
), name
);
937 if (qio_channel_socket_listen_sync(sioc
, s
->addr
, errp
) < 0) {
940 s
->listen_ioc
= sioc
;
941 if (is_waitconnect
&&
942 qemu_chr_wait_connected(chr
, errp
) < 0) {
946 s
->listen_tag
= qio_channel_add_watch(
947 QIO_CHANNEL(s
->listen_ioc
), G_IO_IN
,
948 tcp_chr_accept
, chr
, NULL
);
950 } else if (qemu_chr_wait_connected(chr
, errp
) < 0) {
959 object_unref(OBJECT(sioc
));
963 static void qemu_chr_parse_socket(QemuOpts
*opts
, ChardevBackend
*backend
,
966 bool is_listen
= qemu_opt_get_bool(opts
, "server", false);
967 bool is_waitconnect
= is_listen
&& qemu_opt_get_bool(opts
, "wait", true);
968 bool is_telnet
= qemu_opt_get_bool(opts
, "telnet", false);
969 bool is_tn3270
= qemu_opt_get_bool(opts
, "tn3270", false);
970 bool do_nodelay
= !qemu_opt_get_bool(opts
, "delay", true);
971 int64_t reconnect
= qemu_opt_get_number(opts
, "reconnect", 0);
972 const char *path
= qemu_opt_get(opts
, "path");
973 const char *host
= qemu_opt_get(opts
, "host");
974 const char *port
= qemu_opt_get(opts
, "port");
975 const char *tls_creds
= qemu_opt_get(opts
, "tls-creds");
979 backend
->type
= CHARDEV_BACKEND_KIND_SOCKET
;
982 error_setg(errp
, "chardev: socket: no host given");
986 error_setg(errp
, "chardev: socket: no port given");
991 error_setg(errp
, "TLS can only be used over TCP socket");
996 sock
= backend
->u
.socket
.data
= g_new0(ChardevSocket
, 1);
997 qemu_chr_parse_common(opts
, qapi_ChardevSocket_base(sock
));
999 sock
->has_nodelay
= true;
1000 sock
->nodelay
= do_nodelay
;
1001 sock
->has_server
= true;
1002 sock
->server
= is_listen
;
1003 sock
->has_telnet
= true;
1004 sock
->telnet
= is_telnet
;
1005 sock
->has_tn3270
= true;
1006 sock
->tn3270
= is_tn3270
;
1007 sock
->has_wait
= true;
1008 sock
->wait
= is_waitconnect
;
1009 sock
->has_reconnect
= true;
1010 sock
->reconnect
= reconnect
;
1011 sock
->tls_creds
= g_strdup(tls_creds
);
1013 addr
= g_new0(SocketAddress
, 1);
1015 UnixSocketAddress
*q_unix
;
1016 addr
->type
= SOCKET_ADDRESS_KIND_UNIX
;
1017 q_unix
= addr
->u
.q_unix
.data
= g_new0(UnixSocketAddress
, 1);
1018 q_unix
->path
= g_strdup(path
);
1020 addr
->type
= SOCKET_ADDRESS_KIND_INET
;
1021 addr
->u
.inet
.data
= g_new(InetSocketAddress
, 1);
1022 *addr
->u
.inet
.data
= (InetSocketAddress
) {
1023 .host
= g_strdup(host
),
1024 .port
= g_strdup(port
),
1025 .has_to
= qemu_opt_get(opts
, "to"),
1026 .to
= qemu_opt_get_number(opts
, "to", 0),
1027 .has_ipv4
= qemu_opt_get(opts
, "ipv4"),
1028 .ipv4
= qemu_opt_get_bool(opts
, "ipv4", 0),
1029 .has_ipv6
= qemu_opt_get(opts
, "ipv6"),
1030 .ipv6
= qemu_opt_get_bool(opts
, "ipv6", 0),
1036 static void char_socket_class_init(ObjectClass
*oc
, void *data
)
1038 ChardevClass
*cc
= CHARDEV_CLASS(oc
);
1040 cc
->parse
= qemu_chr_parse_socket
;
1041 cc
->open
= qmp_chardev_open_socket
;
1042 cc
->chr_wait_connected
= tcp_chr_wait_connected
;
1043 cc
->chr_write
= tcp_chr_write
;
1044 cc
->chr_sync_read
= tcp_chr_sync_read
;
1045 cc
->chr_disconnect
= tcp_chr_disconnect
;
1046 cc
->get_msgfds
= tcp_get_msgfds
;
1047 cc
->set_msgfds
= tcp_set_msgfds
;
1048 cc
->chr_add_client
= tcp_chr_add_client
;
1049 cc
->chr_add_watch
= tcp_chr_add_watch
;
1050 cc
->chr_update_read_handler
= tcp_chr_update_read_handler
;
1053 static const TypeInfo char_socket_type_info
= {
1054 .name
= TYPE_CHARDEV_SOCKET
,
1055 .parent
= TYPE_CHARDEV
,
1056 .instance_size
= sizeof(SocketChardev
),
1057 .instance_finalize
= char_socket_finalize
,
1058 .class_init
= char_socket_class_init
,
1061 static void register_types(void)
1063 type_register_static(&char_socket_type_info
);
1066 type_init(register_types
);