blob: 91496ceda90ce8a089c961f2aadcd71a5a0d8a23 [file] [log] [blame]
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001/*
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 */
Markus Armbruster922a01a2018-02-01 12:18:46 +010024
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +030025#include "qemu/osdep.h"
Marc-André Lureau8228e352017-01-26 17:19:46 +040026#include "chardev/char.h"
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +030027#include "io/channel-socket.h"
Julia Suvorova981b06e2018-10-19 01:35:00 +030028#include "io/channel-websock.h"
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +030029#include "qemu/error-report.h"
Markus Armbruster0b8fa322019-05-23 16:35:07 +020030#include "qemu/module.h"
Markus Armbruster922a01a2018-02-01 12:18:46 +010031#include "qemu/option.h"
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +030032#include "qapi/error.h"
33#include "qapi/clone-visitor.h"
Markus Armbruster9af23982018-02-11 10:36:01 +010034#include "qapi/qapi-visit-sockets.h"
Lukas Straub8ee44802020-12-28 16:08:48 +010035#include "qemu/yank.h"
Daniel P. Berrangé6ffade72024-03-15 13:04:44 +000036#include "trace.h"
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +030037
Marc-André Lureau8228e352017-01-26 17:19:46 +040038#include "chardev/char-io.h"
Marc-André Lureaufa670c82021-07-26 00:03:01 +040039#include "chardev/char-socket.h"
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +030040
41static gboolean socket_reconnect_timeout(gpointer opaque);
Peter Xuce1230c2018-03-06 13:33:15 +080042static void tcp_chr_telnet_init(Chardev *chr);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +030043
Daniel P. Berrangé32423cc2019-02-11 18:24:37 +000044static void tcp_chr_change_state(SocketChardev *s, TCPChardevState state)
45{
46 switch (state) {
47 case TCP_CHARDEV_STATE_DISCONNECTED:
48 break;
49 case TCP_CHARDEV_STATE_CONNECTING:
50 assert(s->state == TCP_CHARDEV_STATE_DISCONNECTED);
51 break;
52 case TCP_CHARDEV_STATE_CONNECTED:
53 assert(s->state == TCP_CHARDEV_STATE_CONNECTING);
54 break;
55 }
56 s->state = state;
57}
58
Peter Xu2c716ba2018-01-04 22:18:35 +080059static void tcp_chr_reconn_timer_cancel(SocketChardev *s)
60{
61 if (s->reconnect_timer) {
62 g_source_destroy(s->reconnect_timer);
63 g_source_unref(s->reconnect_timer);
64 s->reconnect_timer = NULL;
65 }
66}
67
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +030068static void qemu_chr_socket_restart_timer(Chardev *chr)
69{
70 SocketChardev *s = SOCKET_CHARDEV(chr);
71 char *name;
72
Daniel P. Berrangé32423cc2019-02-11 18:24:37 +000073 assert(s->state == TCP_CHARDEV_STATE_DISCONNECTED);
Daniel P. Berrangé4b473732019-02-11 18:24:40 +000074 assert(!s->reconnect_timer);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +030075 name = g_strdup_printf("chardev-socket-reconnect-%s", chr->label);
Peter Xu2c716ba2018-01-04 22:18:35 +080076 s->reconnect_timer = qemu_chr_timeout_add_ms(chr,
Daniil Tatianinc8e2b6b2024-09-13 12:46:04 +030077 s->reconnect_time_ms,
Peter Xu2c716ba2018-01-04 22:18:35 +080078 socket_reconnect_timeout,
79 chr);
80 g_source_set_name(s->reconnect_timer, name);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +030081 g_free(name);
82}
83
84static void check_report_connect_error(Chardev *chr,
85 Error *err)
86{
87 SocketChardev *s = SOCKET_CHARDEV(chr);
88
89 if (!s->connect_err_reported) {
Markus Armbruster5217f182020-05-05 12:19:03 +020090 error_reportf_err(err,
91 "Unable to connect character device %s: ",
92 chr->label);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +030093 s->connect_err_reported = true;
lichuned4e0d22020-06-22 05:30:17 +080094 } else {
95 error_free(err);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +030096 }
97 qemu_chr_socket_restart_timer(chr);
98}
99
Daniel P. Berrange194b7f02017-12-18 13:54:17 +0000100static void tcp_chr_accept(QIONetListener *listener,
101 QIOChannelSocket *cioc,
102 void *opaque);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300103
Anton Nefedovb0a335e2017-02-02 17:26:29 +0300104static int tcp_chr_read_poll(void *opaque);
Alberto Garcia78d01592019-08-12 18:58:29 +0300105static void tcp_chr_disconnect_locked(Chardev *chr);
Anton Nefedovb0a335e2017-02-02 17:26:29 +0300106
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300107/* Called with chr_write_lock held. */
108static int tcp_chr_write(Chardev *chr, const uint8_t *buf, int len)
109{
110 SocketChardev *s = SOCKET_CHARDEV(chr);
111
Daniel P. Berrangé32423cc2019-02-11 18:24:37 +0000112 if (s->state == TCP_CHARDEV_STATE_CONNECTED) {
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300113 int ret = io_channel_send_full(s->ioc, buf, len,
114 s->write_msgfds,
115 s->write_msgfds_num);
116
xinhua.Cao81e34932018-07-04 11:36:42 +0800117 /* free the written msgfds in any cases
118 * other than ret < 0 && errno == EAGAIN
119 */
120 if (!(ret < 0 && EAGAIN == errno)
121 && s->write_msgfds_num) {
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300122 g_free(s->write_msgfds);
123 s->write_msgfds = 0;
124 s->write_msgfds_num = 0;
125 }
126
Anton Nefedovb0a335e2017-02-02 17:26:29 +0300127 if (ret < 0 && errno != EAGAIN) {
128 if (tcp_chr_read_poll(chr) <= 0) {
Dima Stepanov27109442020-05-28 12:11:18 +0300129 /* Perform disconnect and return error. */
Daniel P. Berrangé6ffade72024-03-15 13:04:44 +0000130 trace_chr_socket_poll_err(chr, chr->label);
Alberto Garcia78d01592019-08-12 18:58:29 +0300131 tcp_chr_disconnect_locked(chr);
Anton Nefedovb0a335e2017-02-02 17:26:29 +0300132 } /* else let the read handler finish it properly */
133 }
134
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300135 return ret;
136 } else {
Dima Stepanov27109442020-05-28 12:11:18 +0300137 /* Indicate an error. */
138 errno = EIO;
139 return -1;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300140 }
141}
142
143static int tcp_chr_read_poll(void *opaque)
144{
145 Chardev *chr = CHARDEV(opaque);
146 SocketChardev *s = SOCKET_CHARDEV(opaque);
Daniel P. Berrangé32423cc2019-02-11 18:24:37 +0000147 if (s->state != TCP_CHARDEV_STATE_CONNECTED) {
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300148 return 0;
149 }
150 s->max_size = qemu_chr_be_can_write(chr);
151 return s->max_size;
152}
153
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300154static void tcp_chr_process_IAC_bytes(Chardev *chr,
155 SocketChardev *s,
156 uint8_t *buf, int *size)
157{
Jing Liuae92cbd2016-09-23 08:06:11 +0200158 /* Handle any telnet or tn3270 client's basic IAC options.
159 * For telnet options, it satisfies char by char mode with no echo.
160 * For tn3270 options, it satisfies binary mode with EOR.
161 * All IAC options will be removed from the buf and the do_opt
162 * pointer will be used to track the state of the width of the
163 * IAC information.
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300164 *
Jing Liuae92cbd2016-09-23 08:06:11 +0200165 * RFC854: "All TELNET commands consist of at least a two byte sequence.
166 * The commands dealing with option negotiation are three byte sequences,
167 * the third byte being the code for the option referenced."
168 * "IAC BREAK", "IAC IP", "IAC NOP" and the double IAC are two bytes.
169 * "IAC SB", "IAC SE" and "IAC EOR" are saved to split up data boundary
170 * for tn3270.
171 * NOP, Break and Interrupt Process(IP) might be encountered during a TN3270
172 * session, and NOP and IP need to be done later.
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300173 */
174
175 int i;
176 int j = 0;
177
178 for (i = 0; i < *size; i++) {
179 if (s->do_telnetopt > 1) {
180 if ((unsigned char)buf[i] == IAC && s->do_telnetopt == 2) {
181 /* Double IAC means send an IAC */
182 if (j != i) {
183 buf[j] = buf[i];
184 }
185 j++;
186 s->do_telnetopt = 1;
187 } else {
188 if ((unsigned char)buf[i] == IAC_BREAK
189 && s->do_telnetopt == 2) {
190 /* Handle IAC break commands by sending a serial break */
191 qemu_chr_be_event(chr, CHR_EVENT_BREAK);
192 s->do_telnetopt++;
Jing Liuae92cbd2016-09-23 08:06:11 +0200193 } else if (s->is_tn3270 && ((unsigned char)buf[i] == IAC_EOR
194 || (unsigned char)buf[i] == IAC_SB
195 || (unsigned char)buf[i] == IAC_SE)
196 && s->do_telnetopt == 2) {
197 buf[j++] = IAC;
198 buf[j++] = buf[i];
199 s->do_telnetopt++;
200 } else if (s->is_tn3270 && ((unsigned char)buf[i] == IAC_IP
201 || (unsigned char)buf[i] == IAC_NOP)
202 && s->do_telnetopt == 2) {
203 /* TODO: IP and NOP need to be implemented later. */
204 s->do_telnetopt++;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300205 }
206 s->do_telnetopt++;
207 }
208 if (s->do_telnetopt >= 4) {
209 s->do_telnetopt = 1;
210 }
211 } else {
212 if ((unsigned char)buf[i] == IAC) {
213 s->do_telnetopt = 2;
214 } else {
215 if (j != i) {
216 buf[j] = buf[i];
217 }
218 j++;
219 }
220 }
221 }
222 *size = j;
223}
224
225static int tcp_get_msgfds(Chardev *chr, int *fds, int num)
226{
227 SocketChardev *s = SOCKET_CHARDEV(chr);
228
229 int to_copy = (s->read_msgfds_num < num) ? s->read_msgfds_num : num;
230
231 assert(num <= TCP_MAX_FDS);
232
233 if (to_copy) {
234 int i;
235
236 memcpy(fds, s->read_msgfds, to_copy * sizeof(int));
237
238 /* Close unused fds */
239 for (i = to_copy; i < s->read_msgfds_num; i++) {
240 close(s->read_msgfds[i]);
241 }
242
243 g_free(s->read_msgfds);
244 s->read_msgfds = 0;
245 s->read_msgfds_num = 0;
246 }
247
248 return to_copy;
249}
250
251static int tcp_set_msgfds(Chardev *chr, int *fds, int num)
252{
253 SocketChardev *s = SOCKET_CHARDEV(chr);
254
255 /* clear old pending fd array */
256 g_free(s->write_msgfds);
257 s->write_msgfds = NULL;
258 s->write_msgfds_num = 0;
259
Daniel P. Berrangé32423cc2019-02-11 18:24:37 +0000260 if ((s->state != TCP_CHARDEV_STATE_CONNECTED) ||
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300261 !qio_channel_has_feature(s->ioc,
262 QIO_CHANNEL_FEATURE_FD_PASS)) {
263 return -1;
264 }
265
266 if (num) {
267 s->write_msgfds = g_new(int, num);
268 memcpy(s->write_msgfds, fds, num * sizeof(int));
269 }
270
271 s->write_msgfds_num = num;
272
273 return 0;
274}
275
276static ssize_t tcp_chr_recv(Chardev *chr, char *buf, size_t len)
277{
278 SocketChardev *s = SOCKET_CHARDEV(chr);
279 struct iovec iov = { .iov_base = buf, .iov_len = len };
280 int ret;
281 size_t i;
282 int *msgfds = NULL;
283 size_t msgfds_num = 0;
Daniel P. Berrangé6ffade72024-03-15 13:04:44 +0000284 Error *err = NULL;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300285
286 if (qio_channel_has_feature(s->ioc, QIO_CHANNEL_FEATURE_FD_PASS)) {
287 ret = qio_channel_readv_full(s->ioc, &iov, 1,
288 &msgfds, &msgfds_num,
Daniel P. Berrangé6ffade72024-03-15 13:04:44 +0000289 0, &err);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300290 } else {
291 ret = qio_channel_readv_full(s->ioc, &iov, 1,
292 NULL, NULL,
Daniel P. Berrangé6ffade72024-03-15 13:04:44 +0000293 0, &err);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300294 }
295
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300296 if (msgfds_num) {
297 /* close and clean read_msgfds */
298 for (i = 0; i < s->read_msgfds_num; i++) {
299 close(s->read_msgfds[i]);
300 }
301
302 if (s->read_msgfds_num) {
303 g_free(s->read_msgfds);
304 }
305
306 s->read_msgfds = msgfds;
307 s->read_msgfds_num = msgfds_num;
308 }
309
310 for (i = 0; i < s->read_msgfds_num; i++) {
311 int fd = s->read_msgfds[i];
312 if (fd < 0) {
313 continue;
314 }
315
316 /* O_NONBLOCK is preserved across SCM_RIGHTS so reset it */
Marc-André Lureauff5927b2022-04-25 17:33:47 +0400317 qemu_socket_set_block(fd);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300318
319#ifndef MSG_CMSG_CLOEXEC
320 qemu_set_cloexec(fd);
321#endif
322 }
323
Roman Kagane8797502021-11-11 18:33:46 +0300324 if (ret == QIO_CHANNEL_ERR_BLOCK) {
325 errno = EAGAIN;
326 ret = -1;
327 } else if (ret == -1) {
Daniel P. Berrangé6ffade72024-03-15 13:04:44 +0000328 trace_chr_socket_recv_err(chr, chr->label, error_get_pretty(err));
329 error_free(err);
Roman Kagane8797502021-11-11 18:33:46 +0300330 errno = EIO;
Daniel P. Berrangé6ffade72024-03-15 13:04:44 +0000331 } else if (ret == 0) {
332 trace_chr_socket_recv_eof(chr, chr->label);
Roman Kagane8797502021-11-11 18:33:46 +0300333 }
334
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300335 return ret;
336}
337
338static GSource *tcp_chr_add_watch(Chardev *chr, GIOCondition cond)
339{
340 SocketChardev *s = SOCKET_CHARDEV(chr);
Pavel Dovgalyuk6585b162021-02-09 08:49:30 +0300341 if (!s->ioc) {
342 return NULL;
343 }
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300344 return qio_channel_create_watch(s->ioc, cond);
345}
346
Marc-André Lureaudfe9ea22018-08-17 15:52:23 +0200347static void remove_hup_source(SocketChardev *s)
348{
349 if (s->hup_source != NULL) {
350 g_source_destroy(s->hup_source);
351 g_source_unref(s->hup_source);
352 s->hup_source = NULL;
353 }
354}
355
Lukas Straub1a92d6d2021-03-23 18:52:42 +0100356static void char_socket_yank_iochannel(void *opaque)
357{
358 QIOChannel *ioc = QIO_CHANNEL(opaque);
359
360 qio_channel_shutdown(ioc, QIO_CHANNEL_SHUTDOWN_BOTH, NULL);
361}
362
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300363static void tcp_chr_free_connection(Chardev *chr)
364{
365 SocketChardev *s = SOCKET_CHARDEV(chr);
366 int i;
367
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300368 if (s->read_msgfds_num) {
369 for (i = 0; i < s->read_msgfds_num; i++) {
370 close(s->read_msgfds[i]);
371 }
372 g_free(s->read_msgfds);
373 s->read_msgfds = NULL;
374 s->read_msgfds_num = 0;
375 }
376
Marc-André Lureaudfe9ea22018-08-17 15:52:23 +0200377 remove_hup_source(s);
Klim Kireeva8aa6192018-01-25 16:51:29 +0300378
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300379 tcp_set_msgfds(chr, NULL, 0);
zhanghailiangb19456d2017-04-19 09:15:32 +0800380 remove_fd_in_watch(chr);
Marc-André Lureauebae6472021-02-04 14:52:31 +0400381 if (s->registered_yank &&
382 (s->state == TCP_CHARDEV_STATE_CONNECTING
383 || s->state == TCP_CHARDEV_STATE_CONNECTED)) {
Lukas Straub8ee44802020-12-28 16:08:48 +0100384 yank_unregister_function(CHARDEV_YANK_INSTANCE(chr->label),
Lukas Straub1a92d6d2021-03-23 18:52:42 +0100385 char_socket_yank_iochannel,
Lukas Straub8ee44802020-12-28 16:08:48 +0100386 QIO_CHANNEL(s->sioc));
387 }
Daniel P. Berrangécb8ded02024-01-05 16:09:52 +0000388
389 if (s->ioc) {
390 qio_channel_close(s->ioc, NULL);
391 }
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300392 object_unref(OBJECT(s->sioc));
393 s->sioc = NULL;
394 object_unref(OBJECT(s->ioc));
395 s->ioc = NULL;
396 g_free(chr->filename);
397 chr->filename = NULL;
Daniel P. Berrangé32423cc2019-02-11 18:24:37 +0000398 tcp_chr_change_state(s, TCP_CHARDEV_STATE_DISCONNECTED);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300399}
400
Julia Suvorova4493b6a2018-10-19 01:34:59 +0300401static const char *qemu_chr_socket_protocol(SocketChardev *s)
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300402{
Julia Suvorova4493b6a2018-10-19 01:34:59 +0300403 if (s->is_telnet) {
404 return "telnet";
405 }
Julia Suvorova981b06e2018-10-19 01:35:00 +0300406 return s->is_websock ? "websocket" : "tcp";
Julia Suvorova4493b6a2018-10-19 01:34:59 +0300407}
408
409static char *qemu_chr_socket_address(SocketChardev *s, const char *prefix)
410{
411 switch (s->addr->type) {
Markus Armbrusterbd269eb2017-04-26 09:36:41 +0200412 case SOCKET_ADDRESS_TYPE_INET:
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300413 return g_strdup_printf("%s%s:%s:%s%s", prefix,
Julia Suvorova4493b6a2018-10-19 01:34:59 +0300414 qemu_chr_socket_protocol(s),
415 s->addr->u.inet.host,
416 s->addr->u.inet.port,
Paolo Bonzini9d902d52021-02-25 12:05:22 +0100417 s->is_listen ? ",server=on" : "");
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300418 break;
Markus Armbrusterbd269eb2017-04-26 09:36:41 +0200419 case SOCKET_ADDRESS_TYPE_UNIX:
Markus Armbrusterdea7cd12020-11-02 10:44:20 +0100420 {
421 const char *tight = "", *abstract = "";
422 UnixSocketAddress *sa = &s->addr->u.q_unix;
423
Markus Armbruster8acefc72020-11-02 10:44:22 +0100424#ifdef CONFIG_LINUX
Markus Armbrusterdea7cd12020-11-02 10:44:20 +0100425 if (sa->has_abstract && sa->abstract) {
Marc-André Lureau30f80be2021-07-21 16:55:53 +0400426 abstract = ",abstract=on";
Markus Armbrusterdea7cd12020-11-02 10:44:20 +0100427 if (sa->has_tight && sa->tight) {
Marc-André Lureau30f80be2021-07-21 16:55:53 +0400428 tight = ",tight=on";
Markus Armbrusterdea7cd12020-11-02 10:44:20 +0100429 }
430 }
Markus Armbruster8acefc72020-11-02 10:44:22 +0100431#endif
Markus Armbrusterdea7cd12020-11-02 10:44:20 +0100432
433 return g_strdup_printf("%sunix:%s%s%s%s", prefix, sa->path,
434 abstract, tight,
Paolo Bonzini9d902d52021-02-25 12:05:22 +0100435 s->is_listen ? ",server=on" : "");
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300436 break;
Markus Armbrusterdea7cd12020-11-02 10:44:20 +0100437 }
Markus Armbrusterbd269eb2017-04-26 09:36:41 +0200438 case SOCKET_ADDRESS_TYPE_FD:
Julia Suvorova4493b6a2018-10-19 01:34:59 +0300439 return g_strdup_printf("%sfd:%s%s", prefix, s->addr->u.fd.str,
Paolo Bonzini9d902d52021-02-25 12:05:22 +0100440 s->is_listen ? ",server=on" : "");
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300441 break;
Markus Armbrusterbd269eb2017-04-26 09:36:41 +0200442 case SOCKET_ADDRESS_TYPE_VSOCK:
Markus Armbrusterd2e49aa2017-03-30 19:43:10 +0200443 return g_strdup_printf("%svsock:%s:%s", prefix,
Julia Suvorova4493b6a2018-10-19 01:34:59 +0300444 s->addr->u.vsock.cid,
445 s->addr->u.vsock.port);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300446 default:
447 abort();
448 }
449}
450
Marc-André Lureaubbcde962016-12-20 15:32:31 +0100451static void update_disconnected_filename(SocketChardev *s)
452{
453 Chardev *chr = CHARDEV(s);
454
455 g_free(chr->filename);
Marc-André Lureau90a6d172017-07-04 18:53:35 +0200456 if (s->addr) {
Julia Suvorova4493b6a2018-10-19 01:34:59 +0300457 chr->filename = qemu_chr_socket_address(s, "disconnected:");
Marc-André Lureau90a6d172017-07-04 18:53:35 +0200458 } else {
459 chr->filename = g_strdup("disconnected:socket");
460 }
Marc-André Lureaubbcde962016-12-20 15:32:31 +0100461}
462
Daniel P. Berrange9cca7572017-10-05 16:50:57 +0100463/* NB may be called even if tcp_chr_connect has not been
464 * reached, due to TLS or telnet initialization failure,
Daniel P. Berrangé32423cc2019-02-11 18:24:37 +0000465 * so can *not* assume s->state == TCP_CHARDEV_STATE_CONNECTED
Alberto Garcia78d01592019-08-12 18:58:29 +0300466 * This must be called with chr->chr_write_lock held.
Daniel P. Berrange9cca7572017-10-05 16:50:57 +0100467 */
Alberto Garcia78d01592019-08-12 18:58:29 +0300468static void tcp_chr_disconnect_locked(Chardev *chr)
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300469{
470 SocketChardev *s = SOCKET_CHARDEV(chr);
Daniel P. Berrangé32423cc2019-02-11 18:24:37 +0000471 bool emit_close = s->state == TCP_CHARDEV_STATE_CONNECTED;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300472
Daniel P. Berrangé6ffade72024-03-15 13:04:44 +0000473 trace_chr_socket_disconnect(chr, chr->label);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300474 tcp_chr_free_connection(chr);
475
Daniel P. Berrange194b7f02017-12-18 13:54:17 +0000476 if (s->listener) {
Peter Xu3da9de52018-03-06 13:33:14 +0800477 qio_net_listener_set_client_func_full(s->listener, tcp_chr_accept,
478 chr, NULL, chr->gcontext);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300479 }
Marc-André Lureaubbcde962016-12-20 15:32:31 +0100480 update_disconnected_filename(s);
Daniel P. Berrange9cca7572017-10-05 16:50:57 +0100481 if (emit_close) {
482 qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
483 }
Daniil Tatianinc8e2b6b2024-09-13 12:46:04 +0300484 if (s->reconnect_time_ms && !s->reconnect_timer) {
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300485 qemu_chr_socket_restart_timer(chr);
486 }
487}
488
Alberto Garcia78d01592019-08-12 18:58:29 +0300489static void tcp_chr_disconnect(Chardev *chr)
490{
491 qemu_mutex_lock(&chr->chr_write_lock);
492 tcp_chr_disconnect_locked(chr);
493 qemu_mutex_unlock(&chr->chr_write_lock);
494}
495
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300496static gboolean tcp_chr_read(QIOChannel *chan, GIOCondition cond, void *opaque)
497{
498 Chardev *chr = CHARDEV(opaque);
499 SocketChardev *s = SOCKET_CHARDEV(opaque);
500 uint8_t buf[CHR_READ_BUF_LEN];
501 int len, size;
502
Daniel P. Berrangé32423cc2019-02-11 18:24:37 +0000503 if ((s->state != TCP_CHARDEV_STATE_CONNECTED) ||
504 s->max_size <= 0) {
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300505 return TRUE;
506 }
Daniel P. Berrangée8ee8272024-03-18 13:03:19 +0000507 len = sizeof(buf);
508 if (len > s->max_size) {
509 len = s->max_size;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300510 }
511 size = tcp_chr_recv(chr, (void *)buf, len);
Daniel P. Berrangéc863fde2018-02-22 12:13:51 +0000512 if (size == 0 || (size == -1 && errno != EAGAIN)) {
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300513 /* connection closed */
514 tcp_chr_disconnect(chr);
515 } else if (size > 0) {
516 if (s->do_telnetopt) {
517 tcp_chr_process_IAC_bytes(chr, s, buf, &size);
518 }
519 if (size > 0) {
520 qemu_chr_be_write(chr, buf, size);
521 }
522 }
523
524 return TRUE;
525}
526
Klim Kireeva8aa6192018-01-25 16:51:29 +0300527static gboolean tcp_chr_hup(QIOChannel *channel,
528 GIOCondition cond,
529 void *opaque)
530{
531 Chardev *chr = CHARDEV(opaque);
Daniel P. Berrangé6ffade72024-03-15 13:04:44 +0000532 trace_chr_socket_hangup(chr, chr->label);
Klim Kireeva8aa6192018-01-25 16:51:29 +0300533 tcp_chr_disconnect(chr);
534 return G_SOURCE_REMOVE;
535}
536
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300537static int tcp_chr_sync_read(Chardev *chr, const uint8_t *buf, int len)
538{
539 SocketChardev *s = SOCKET_CHARDEV(chr);
540 int size;
Roman Kagan66626502021-11-11 18:33:47 +0300541 int saved_errno;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300542
Daniel P. Berrangé32423cc2019-02-11 18:24:37 +0000543 if (s->state != TCP_CHARDEV_STATE_CONNECTED) {
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300544 return 0;
545 }
546
Marc-André Lureaubcdeb9b2017-07-06 19:03:53 +0200547 qio_channel_set_blocking(s->ioc, true, NULL);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300548 size = tcp_chr_recv(chr, (void *) buf, len);
Roman Kagan66626502021-11-11 18:33:47 +0300549 saved_errno = errno;
Sai Pavan Boddu4d1d4602020-04-19 15:21:40 +0530550 if (s->state != TCP_CHARDEV_STATE_DISCONNECTED) {
551 qio_channel_set_blocking(s->ioc, false, NULL);
552 }
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300553 if (size == 0) {
554 /* connection closed */
555 tcp_chr_disconnect(chr);
556 }
557
Roman Kagan66626502021-11-11 18:33:47 +0300558 errno = saved_errno;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300559 return size;
560}
561
Julia Suvorova4493b6a2018-10-19 01:34:59 +0300562static char *qemu_chr_compute_filename(SocketChardev *s)
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300563{
Julia Suvorova4493b6a2018-10-19 01:34:59 +0300564 struct sockaddr_storage *ss = &s->sioc->localAddr;
565 struct sockaddr_storage *ps = &s->sioc->remoteAddr;
566 socklen_t ss_len = s->sioc->localAddrLen;
567 socklen_t ps_len = s->sioc->remoteAddrLen;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300568 char shost[NI_MAXHOST], sserv[NI_MAXSERV];
569 char phost[NI_MAXHOST], pserv[NI_MAXSERV];
570 const char *left = "", *right = "";
571
572 switch (ss->ss_family) {
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300573 case AF_UNIX:
574 return g_strdup_printf("unix:%s%s",
575 ((struct sockaddr_un *)(ss))->sun_path,
Paolo Bonzini9d902d52021-02-25 12:05:22 +0100576 s->is_listen ? ",server=on" : "");
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300577 case AF_INET6:
578 left = "[";
579 right = "]";
580 /* fall through */
581 case AF_INET:
582 getnameinfo((struct sockaddr *) ss, ss_len, shost, sizeof(shost),
583 sserv, sizeof(sserv), NI_NUMERICHOST | NI_NUMERICSERV);
584 getnameinfo((struct sockaddr *) ps, ps_len, phost, sizeof(phost),
585 pserv, sizeof(pserv), NI_NUMERICHOST | NI_NUMERICSERV);
586 return g_strdup_printf("%s:%s%s%s:%s%s <-> %s%s%s:%s",
Julia Suvorova4493b6a2018-10-19 01:34:59 +0300587 qemu_chr_socket_protocol(s),
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300588 left, shost, right, sserv,
Paolo Bonzini9d902d52021-02-25 12:05:22 +0100589 s->is_listen ? ",server=on" : "",
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300590 left, phost, right, pserv);
591
592 default:
593 return g_strdup_printf("unknown");
594 }
595}
596
Marc-André Lureaudfe9ea22018-08-17 15:52:23 +0200597static void update_ioc_handlers(SocketChardev *s)
598{
599 Chardev *chr = CHARDEV(s);
600
Daniel P. Berrangé32423cc2019-02-11 18:24:37 +0000601 if (s->state != TCP_CHARDEV_STATE_CONNECTED) {
Marc-André Lureaudfe9ea22018-08-17 15:52:23 +0200602 return;
603 }
604
605 remove_fd_in_watch(chr);
606 chr->gsource = io_add_watch_poll(chr, s->ioc,
607 tcp_chr_read_poll,
608 tcp_chr_read, chr,
609 chr->gcontext);
610
611 remove_hup_source(s);
612 s->hup_source = qio_channel_create_watch(s->ioc, G_IO_HUP);
Daniel P. Berrangé8bd8b042024-03-18 18:06:59 +0000613 /*
614 * poll() is liable to return POLLHUP even when there is
615 * still incoming data available to read on the FD. If
616 * we have the hup_source at the same priority as the
617 * main io_add_watch_poll GSource, then we might end up
618 * processing the POLLHUP event first, closing the FD,
619 * and as a result silently discard data we should have
620 * read.
621 *
622 * By setting the hup_source to G_PRIORITY_DEFAULT + 1,
623 * we ensure that io_add_watch_poll GSource will always
624 * be dispatched first, thus guaranteeing we will be
625 * able to process all incoming data before closing the
626 * FD
627 */
628 g_source_set_priority(s->hup_source, G_PRIORITY_DEFAULT + 1);
Marc-André Lureaudfe9ea22018-08-17 15:52:23 +0200629 g_source_set_callback(s->hup_source, (GSourceFunc)tcp_chr_hup,
630 chr, NULL);
631 g_source_attach(s->hup_source, chr->gcontext);
632}
633
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300634static void tcp_chr_connect(void *opaque)
635{
636 Chardev *chr = CHARDEV(opaque);
637 SocketChardev *s = SOCKET_CHARDEV(opaque);
638
639 g_free(chr->filename);
Julia Suvorova4493b6a2018-10-19 01:34:59 +0300640 chr->filename = qemu_chr_compute_filename(s);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300641
Daniel P. Berrangé32423cc2019-02-11 18:24:37 +0000642 tcp_chr_change_state(s, TCP_CHARDEV_STATE_CONNECTED);
Marc-André Lureaudfe9ea22018-08-17 15:52:23 +0200643 update_ioc_handlers(s);
Marc-André Lureau63618132016-12-14 14:23:02 +0300644 qemu_chr_be_event(chr, CHR_EVENT_OPENED);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300645}
646
Peter Xuce1230c2018-03-06 13:33:15 +0800647static void tcp_chr_telnet_destroy(SocketChardev *s)
648{
649 if (s->telnet_source) {
650 g_source_destroy(s->telnet_source);
651 g_source_unref(s->telnet_source);
652 s->telnet_source = NULL;
653 }
654}
655
Peter Xubb86d052017-09-21 14:35:54 +0800656static void tcp_chr_update_read_handler(Chardev *chr)
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300657{
658 SocketChardev *s = SOCKET_CHARDEV(chr);
659
Paolo Bonzini5b774fe2019-02-20 15:33:27 +0100660 if (s->listener && s->state == TCP_CHARDEV_STATE_DISCONNECTED) {
Peter Xu3da9de52018-03-06 13:33:14 +0800661 /*
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 qio_net_listener_set_client_func_full(s->listener, tcp_chr_accept,
667 chr, NULL, chr->gcontext);
668 }
669
Peter Xuce1230c2018-03-06 13:33:15 +0800670 if (s->telnet_source) {
671 tcp_chr_telnet_init(CHARDEV(s));
672 }
673
Marc-André Lureaudfe9ea22018-08-17 15:52:23 +0200674 update_ioc_handlers(s);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300675}
676
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300677static gboolean tcp_chr_telnet_init_io(QIOChannel *ioc,
678 GIOCondition cond G_GNUC_UNUSED,
679 gpointer user_data)
680{
Peter Xuce1230c2018-03-06 13:33:15 +0800681 SocketChardev *s = user_data;
682 Chardev *chr = CHARDEV(s);
683 TCPChardevTelnetInit *init = s->telnet_init;
Daniel P. Berrangé6ffade72024-03-15 13:04:44 +0000684 Error *err = NULL;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300685 ssize_t ret;
686
Peter Xuce1230c2018-03-06 13:33:15 +0800687 assert(init);
688
Daniel P. Berrangé6ffade72024-03-15 13:04:44 +0000689 ret = qio_channel_write(ioc, init->buf, init->buflen, &err);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300690 if (ret < 0) {
691 if (ret == QIO_CHANNEL_ERR_BLOCK) {
692 ret = 0;
693 } else {
Daniel P. Berrangé6ffade72024-03-15 13:04:44 +0000694 trace_chr_socket_write_err(chr, chr->label, error_get_pretty(err));
695 error_free(err);
Peter Xuce1230c2018-03-06 13:33:15 +0800696 tcp_chr_disconnect(chr);
Peter Xu8b2ec542018-03-01 16:44:24 +0800697 goto end;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300698 }
699 }
700 init->buflen -= ret;
701
702 if (init->buflen == 0) {
Peter Xuce1230c2018-03-06 13:33:15 +0800703 tcp_chr_connect(chr);
Peter Xu8b2ec542018-03-01 16:44:24 +0800704 goto end;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300705 }
706
707 memmove(init->buf, init->buf + ret, init->buflen);
708
Peter Xu8b2ec542018-03-01 16:44:24 +0800709 return G_SOURCE_CONTINUE;
710
711end:
Peter Xuce1230c2018-03-06 13:33:15 +0800712 g_free(s->telnet_init);
713 s->telnet_init = NULL;
714 g_source_unref(s->telnet_source);
715 s->telnet_source = NULL;
Peter Xu8b2ec542018-03-01 16:44:24 +0800716 return G_SOURCE_REMOVE;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300717}
718
719static void tcp_chr_telnet_init(Chardev *chr)
720{
721 SocketChardev *s = SOCKET_CHARDEV(chr);
Peter Xuce1230c2018-03-06 13:33:15 +0800722 TCPChardevTelnetInit *init;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300723 size_t n = 0;
724
Peter Xuce1230c2018-03-06 13:33:15 +0800725 /* Destroy existing task */
726 tcp_chr_telnet_destroy(s);
727
728 if (s->telnet_init) {
729 /* We are possibly during a handshake already */
730 goto cont;
731 }
732
733 s->telnet_init = g_new0(TCPChardevTelnetInit, 1);
734 init = s->telnet_init;
735
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300736#define IACSET(x, a, b, c) \
737 do { \
738 x[n++] = a; \
739 x[n++] = b; \
740 x[n++] = c; \
741 } while (0)
742
Jing Liuae92cbd2016-09-23 08:06:11 +0200743 if (!s->is_tn3270) {
744 init->buflen = 12;
Michael Tokarev0a19d872023-07-14 14:33:49 +0300745 /* Prep the telnet negotiation to put telnet in binary,
Jing Liuae92cbd2016-09-23 08:06:11 +0200746 * no echo, single char mode */
747 IACSET(init->buf, 0xff, 0xfb, 0x01); /* IAC WILL ECHO */
748 IACSET(init->buf, 0xff, 0xfb, 0x03); /* IAC WILL Suppress go ahead */
749 IACSET(init->buf, 0xff, 0xfb, 0x00); /* IAC WILL Binary */
750 IACSET(init->buf, 0xff, 0xfd, 0x00); /* IAC DO Binary */
751 } else {
752 init->buflen = 21;
Michael Tokarev0a19d872023-07-14 14:33:49 +0300753 /* Prep the TN3270 negotiation based on RFC1576 */
Jing Liuae92cbd2016-09-23 08:06:11 +0200754 IACSET(init->buf, 0xff, 0xfd, 0x19); /* IAC DO EOR */
755 IACSET(init->buf, 0xff, 0xfb, 0x19); /* IAC WILL EOR */
756 IACSET(init->buf, 0xff, 0xfd, 0x00); /* IAC DO BINARY */
757 IACSET(init->buf, 0xff, 0xfb, 0x00); /* IAC WILL BINARY */
758 IACSET(init->buf, 0xff, 0xfd, 0x18); /* IAC DO TERMINAL TYPE */
759 IACSET(init->buf, 0xff, 0xfa, 0x18); /* IAC SB TERMINAL TYPE */
760 IACSET(init->buf, 0x01, 0xff, 0xf0); /* SEND IAC SE */
761 }
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300762
763#undef IACSET
764
Peter Xuce1230c2018-03-06 13:33:15 +0800765cont:
766 s->telnet_source = qio_channel_add_watch_source(s->ioc, G_IO_OUT,
767 tcp_chr_telnet_init_io,
768 s, NULL,
769 chr->gcontext);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300770}
771
772
Julia Suvorova981b06e2018-10-19 01:35:00 +0300773static void tcp_chr_websock_handshake(QIOTask *task, gpointer user_data)
774{
775 Chardev *chr = user_data;
776 SocketChardev *s = user_data;
Marc-André Lureau81cd34a2023-05-10 11:25:31 +0400777 Error *err = NULL;
Julia Suvorova981b06e2018-10-19 01:35:00 +0300778
Marc-André Lureau81cd34a2023-05-10 11:25:31 +0400779 if (qio_task_propagate_error(task, &err)) {
Daniel P. Berrangé6ffade72024-03-15 13:04:44 +0000780 trace_chr_socket_ws_handshake_err(chr, chr->label,
781 error_get_pretty(err));
782 error_free(err);
Julia Suvorova981b06e2018-10-19 01:35:00 +0300783 tcp_chr_disconnect(chr);
784 } else {
785 if (s->do_telnetopt) {
786 tcp_chr_telnet_init(chr);
787 } else {
788 tcp_chr_connect(chr);
789 }
790 }
791}
792
793
794static void tcp_chr_websock_init(Chardev *chr)
795{
796 SocketChardev *s = SOCKET_CHARDEV(chr);
797 QIOChannelWebsock *wioc = NULL;
798 gchar *name;
799
800 wioc = qio_channel_websock_new_server(s->ioc);
801
802 name = g_strdup_printf("chardev-websocket-server-%s", chr->label);
803 qio_channel_set_name(QIO_CHANNEL(wioc), name);
804 g_free(name);
805 object_unref(OBJECT(s->ioc));
806 s->ioc = QIO_CHANNEL(wioc);
807
808 qio_channel_websock_handshake(wioc, tcp_chr_websock_handshake, chr, NULL);
809}
810
811
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300812static void tcp_chr_tls_handshake(QIOTask *task,
813 gpointer user_data)
814{
815 Chardev *chr = user_data;
816 SocketChardev *s = user_data;
Marc-André Lureau81cd34a2023-05-10 11:25:31 +0400817 Error *err = NULL;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300818
Marc-André Lureau81cd34a2023-05-10 11:25:31 +0400819 if (qio_task_propagate_error(task, &err)) {
Daniel P. Berrangé6ffade72024-03-15 13:04:44 +0000820 trace_chr_socket_tls_handshake_err(chr, chr->label,
821 error_get_pretty(err));
822 error_free(err);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300823 tcp_chr_disconnect(chr);
824 } else {
Julia Suvorova981b06e2018-10-19 01:35:00 +0300825 if (s->is_websock) {
826 tcp_chr_websock_init(chr);
827 } else if (s->do_telnetopt) {
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300828 tcp_chr_telnet_init(chr);
829 } else {
830 tcp_chr_connect(chr);
831 }
832 }
833}
834
835
836static void tcp_chr_tls_init(Chardev *chr)
837{
838 SocketChardev *s = SOCKET_CHARDEV(chr);
839 QIOChannelTLS *tioc;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300840 gchar *name;
Daniel P. Berrangé6ffade72024-03-15 13:04:44 +0000841 Error *err = NULL;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300842
843 if (s->is_listen) {
844 tioc = qio_channel_tls_new_server(
845 s->ioc, s->tls_creds,
Daniel P. Berrangefd4a5fd2019-03-08 15:21:50 +0000846 s->tls_authz,
Daniel P. Berrangé6ffade72024-03-15 13:04:44 +0000847 &err);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300848 } else {
849 tioc = qio_channel_tls_new_client(
850 s->ioc, s->tls_creds,
Markus Armbrusterbd269eb2017-04-26 09:36:41 +0200851 s->addr->u.inet.host,
Daniel P. Berrangé6ffade72024-03-15 13:04:44 +0000852 &err);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300853 }
854 if (tioc == NULL) {
Daniel P. Berrangé6ffade72024-03-15 13:04:44 +0000855 trace_chr_socket_tls_init_err(chr, chr->label, error_get_pretty(err));
856 error_free(err);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300857 tcp_chr_disconnect(chr);
858 return;
859 }
860 name = g_strdup_printf("chardev-tls-%s-%s",
861 s->is_listen ? "server" : "client",
862 chr->label);
863 qio_channel_set_name(QIO_CHANNEL(tioc), name);
864 g_free(name);
865 object_unref(OBJECT(s->ioc));
866 s->ioc = QIO_CHANNEL(tioc);
867
868 qio_channel_tls_handshake(tioc,
869 tcp_chr_tls_handshake,
870 chr,
Peter Xu1939ccd2018-03-05 14:43:24 +0800871 NULL,
Peter Xu05b6cc42018-03-06 13:33:19 +0800872 chr->gcontext);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300873}
874
875
876static void tcp_chr_set_client_ioc_name(Chardev *chr,
877 QIOChannelSocket *sioc)
878{
879 SocketChardev *s = SOCKET_CHARDEV(chr);
880 char *name;
881 name = g_strdup_printf("chardev-tcp-%s-%s",
882 s->is_listen ? "server" : "client",
883 chr->label);
884 qio_channel_set_name(QIO_CHANNEL(sioc), name);
885 g_free(name);
886
887}
888
889static int tcp_chr_new_client(Chardev *chr, QIOChannelSocket *sioc)
890{
891 SocketChardev *s = SOCKET_CHARDEV(chr);
892
Daniel P. Berrangé32423cc2019-02-11 18:24:37 +0000893 if (s->state != TCP_CHARDEV_STATE_CONNECTING) {
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300894 return -1;
895 }
896
897 s->ioc = QIO_CHANNEL(sioc);
898 object_ref(OBJECT(sioc));
899 s->sioc = sioc;
900 object_ref(OBJECT(sioc));
901
902 qio_channel_set_blocking(s->ioc, false, NULL);
903
904 if (s->do_nodelay) {
905 qio_channel_set_delay(s->ioc, false);
906 }
Daniel P. Berrange194b7f02017-12-18 13:54:17 +0000907 if (s->listener) {
Peter Xu3da9de52018-03-06 13:33:14 +0800908 qio_net_listener_set_client_func_full(s->listener, NULL, NULL,
909 NULL, chr->gcontext);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300910 }
911
912 if (s->tls_creds) {
913 tcp_chr_tls_init(chr);
Julia Suvorova981b06e2018-10-19 01:35:00 +0300914 } else if (s->is_websock) {
915 tcp_chr_websock_init(chr);
916 } else if (s->do_telnetopt) {
917 tcp_chr_telnet_init(chr);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300918 } else {
Julia Suvorova981b06e2018-10-19 01:35:00 +0300919 tcp_chr_connect(chr);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300920 }
921
922 return 0;
923}
924
925
926static int tcp_chr_add_client(Chardev *chr, int fd)
927{
928 int ret;
929 QIOChannelSocket *sioc;
Daniel P. Berrangé32423cc2019-02-11 18:24:37 +0000930 SocketChardev *s = SOCKET_CHARDEV(chr);
931
932 if (s->state != TCP_CHARDEV_STATE_DISCONNECTED) {
933 return -1;
934 }
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300935
936 sioc = qio_channel_socket_new_fd(fd, NULL);
937 if (!sioc) {
938 return -1;
939 }
Daniel P. Berrangé32423cc2019-02-11 18:24:37 +0000940 tcp_chr_change_state(s, TCP_CHARDEV_STATE_CONNECTING);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300941 tcp_chr_set_client_ioc_name(chr, sioc);
Marc-André Lureauebae6472021-02-04 14:52:31 +0400942 if (s->registered_yank) {
943 yank_register_function(CHARDEV_YANK_INSTANCE(chr->label),
Lukas Straub1a92d6d2021-03-23 18:52:42 +0100944 char_socket_yank_iochannel,
Marc-André Lureauebae6472021-02-04 14:52:31 +0400945 QIO_CHANNEL(sioc));
946 }
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300947 ret = tcp_chr_new_client(chr, sioc);
948 object_unref(OBJECT(sioc));
949 return ret;
950}
951
Daniel P. Berrange194b7f02017-12-18 13:54:17 +0000952static void tcp_chr_accept(QIONetListener *listener,
953 QIOChannelSocket *cioc,
954 void *opaque)
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300955{
956 Chardev *chr = CHARDEV(opaque);
Daniel P. Berrangé32423cc2019-02-11 18:24:37 +0000957 SocketChardev *s = SOCKET_CHARDEV(chr);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300958
Daniel P. Berrangé32423cc2019-02-11 18:24:37 +0000959 tcp_chr_change_state(s, TCP_CHARDEV_STATE_CONNECTING);
Daniel P. Berrange194b7f02017-12-18 13:54:17 +0000960 tcp_chr_set_client_ioc_name(chr, cioc);
Marc-André Lureauebae6472021-02-04 14:52:31 +0400961 if (s->registered_yank) {
962 yank_register_function(CHARDEV_YANK_INSTANCE(chr->label),
Lukas Straub1a92d6d2021-03-23 18:52:42 +0100963 char_socket_yank_iochannel,
Marc-André Lureauebae6472021-02-04 14:52:31 +0400964 QIO_CHANNEL(cioc));
965 }
Daniel P. Berrange194b7f02017-12-18 13:54:17 +0000966 tcp_chr_new_client(chr, cioc);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300967}
968
Daniel P. Berrangéefae0b92019-02-11 18:24:35 +0000969
970static int tcp_chr_connect_client_sync(Chardev *chr, Error **errp)
971{
972 SocketChardev *s = SOCKET_CHARDEV(chr);
973 QIOChannelSocket *sioc = qio_channel_socket_new();
Daniel P. Berrangé32423cc2019-02-11 18:24:37 +0000974 tcp_chr_change_state(s, TCP_CHARDEV_STATE_CONNECTING);
Daniel P. Berrangéefae0b92019-02-11 18:24:35 +0000975 tcp_chr_set_client_ioc_name(chr, sioc);
976 if (qio_channel_socket_connect_sync(sioc, s->addr, errp) < 0) {
Daniel P. Berrangé32423cc2019-02-11 18:24:37 +0000977 tcp_chr_change_state(s, TCP_CHARDEV_STATE_DISCONNECTED);
Daniel P. Berrangéefae0b92019-02-11 18:24:35 +0000978 object_unref(OBJECT(sioc));
979 return -1;
980 }
Marc-André Lureauebae6472021-02-04 14:52:31 +0400981 if (s->registered_yank) {
982 yank_register_function(CHARDEV_YANK_INSTANCE(chr->label),
Lukas Straub1a92d6d2021-03-23 18:52:42 +0100983 char_socket_yank_iochannel,
Marc-André Lureauebae6472021-02-04 14:52:31 +0400984 QIO_CHANNEL(sioc));
985 }
Daniel P. Berrangéefae0b92019-02-11 18:24:35 +0000986 tcp_chr_new_client(chr, sioc);
987 object_unref(OBJECT(sioc));
988 return 0;
989}
990
991
992static void tcp_chr_accept_server_sync(Chardev *chr)
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +0300993{
994 SocketChardev *s = SOCKET_CHARDEV(chr);
995 QIOChannelSocket *sioc;
Daniel P. Berrangéefae0b92019-02-11 18:24:35 +0000996 info_report("QEMU waiting for connection on: %s",
997 chr->filename);
Daniel P. Berrangé32423cc2019-02-11 18:24:37 +0000998 tcp_chr_change_state(s, TCP_CHARDEV_STATE_CONNECTING);
Daniel P. Berrangéefae0b92019-02-11 18:24:35 +0000999 sioc = qio_net_listener_wait_client(s->listener);
1000 tcp_chr_set_client_ioc_name(chr, sioc);
Marc-André Lureauebae6472021-02-04 14:52:31 +04001001 if (s->registered_yank) {
1002 yank_register_function(CHARDEV_YANK_INSTANCE(chr->label),
Lukas Straub1a92d6d2021-03-23 18:52:42 +01001003 char_socket_yank_iochannel,
Marc-André Lureauebae6472021-02-04 14:52:31 +04001004 QIO_CHANNEL(sioc));
1005 }
Daniel P. Berrangéefae0b92019-02-11 18:24:35 +00001006 tcp_chr_new_client(chr, sioc);
1007 object_unref(OBJECT(sioc));
1008}
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001009
Daniel P. Berrangéefae0b92019-02-11 18:24:35 +00001010
1011static int tcp_chr_wait_connected(Chardev *chr, Error **errp)
1012{
1013 SocketChardev *s = SOCKET_CHARDEV(chr);
Daniel P. Berrangéd1885e52019-02-11 18:24:39 +00001014 const char *opts[] = { "telnet", "tn3270", "websock", "tls-creds" };
1015 bool optset[] = { s->is_telnet, s->is_tn3270, s->is_websock, s->tls_creds };
1016 size_t i;
1017
1018 QEMU_BUILD_BUG_ON(G_N_ELEMENTS(opts) != G_N_ELEMENTS(optset));
1019 for (i = 0; i < G_N_ELEMENTS(opts); i++) {
1020 if (optset[i]) {
1021 error_setg(errp,
1022 "'%s' option is incompatible with waiting for "
1023 "connection completion", opts[i]);
1024 return -1;
1025 }
1026 }
1027
Daniel P. Berrangé4b473732019-02-11 18:24:40 +00001028 tcp_chr_reconn_timer_cancel(s);
1029
1030 /*
1031 * We expect states to be as follows:
1032 *
1033 * - server
1034 * - wait -> CONNECTED
1035 * - nowait -> DISCONNECTED
1036 * - client
1037 * - reconnect == 0 -> CONNECTED
1038 * - reconnect != 0 -> CONNECTING
1039 *
1040 */
1041 if (s->state == TCP_CHARDEV_STATE_CONNECTING) {
1042 if (!s->connect_task) {
1043 error_setg(errp,
1044 "Unexpected 'connecting' state without connect task "
1045 "while waiting for connection completion");
1046 return -1;
1047 }
1048 /*
1049 * tcp_chr_wait_connected should only ever be run from the
1050 * main loop thread associated with chr->gcontext, otherwise
1051 * qio_task_wait_thread has a dangerous race condition with
1052 * free'ing of the s->connect_task object.
1053 *
1054 * Acquiring the main context doesn't 100% prove we're in
1055 * the main loop thread, but it does at least guarantee
1056 * that the main loop won't be executed by another thread
1057 * avoiding the race condition with the task idle callback.
1058 */
1059 g_main_context_acquire(chr->gcontext);
1060 qio_task_wait_thread(s->connect_task);
1061 g_main_context_release(chr->gcontext);
1062
1063 /*
1064 * The completion callback (qemu_chr_socket_connected) for
1065 * s->connect_task should have set this to NULL by the time
1066 * qio_task_wait_thread has returned.
1067 */
1068 assert(!s->connect_task);
1069
1070 /*
1071 * NB we are *not* guaranteed to have "s->state == ..CONNECTED"
1072 * at this point as this first connect may be failed, so
1073 * allow the next loop to run regardless.
1074 */
1075 }
1076
1077 while (s->state != TCP_CHARDEV_STATE_CONNECTED) {
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001078 if (s->is_listen) {
Daniel P. Berrangéefae0b92019-02-11 18:24:35 +00001079 tcp_chr_accept_server_sync(chr);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001080 } else {
Daniel P. Berrangé25d93b62019-02-11 18:24:38 +00001081 Error *err = NULL;
1082 if (tcp_chr_connect_client_sync(chr, &err) < 0) {
Daniil Tatianinc8e2b6b2024-09-13 12:46:04 +03001083 if (s->reconnect_time_ms) {
Daniel P. Berrangé25d93b62019-02-11 18:24:38 +00001084 error_free(err);
Daniil Tatianinc8e2b6b2024-09-13 12:46:04 +03001085 g_usleep(s->reconnect_time_ms * 1000ULL);
Daniel P. Berrangé25d93b62019-02-11 18:24:38 +00001086 } else {
1087 error_propagate(errp, err);
1088 return -1;
1089 }
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001090 }
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001091 }
1092 }
1093
1094 return 0;
1095}
1096
1097static void char_socket_finalize(Object *obj)
1098{
1099 Chardev *chr = CHARDEV(obj);
1100 SocketChardev *s = SOCKET_CHARDEV(obj);
1101
1102 tcp_chr_free_connection(chr);
Peter Xu2c716ba2018-01-04 22:18:35 +08001103 tcp_chr_reconn_timer_cancel(s);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001104 qapi_free_SocketAddress(s->addr);
Peter Xuce1230c2018-03-06 13:33:15 +08001105 tcp_chr_telnet_destroy(s);
1106 g_free(s->telnet_init);
Daniel P. Berrange194b7f02017-12-18 13:54:17 +00001107 if (s->listener) {
Peter Xu3da9de52018-03-06 13:33:14 +08001108 qio_net_listener_set_client_func_full(s->listener, NULL, NULL,
1109 NULL, chr->gcontext);
Daniel P. Berrange194b7f02017-12-18 13:54:17 +00001110 object_unref(OBJECT(s->listener));
Yajun Wub8a7f512023-02-14 10:14:30 +08001111 s->listener = NULL;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001112 }
1113 if (s->tls_creds) {
1114 object_unref(OBJECT(s->tls_creds));
1115 }
Daniel P. Berrangefd4a5fd2019-03-08 15:21:50 +00001116 g_free(s->tls_authz);
Lukas Straub8ee44802020-12-28 16:08:48 +01001117 if (s->registered_yank) {
Lukas Straubfeb774c2021-03-30 20:13:31 +02001118 /*
1119 * In the chardev-change special-case, we shouldn't unregister the yank
1120 * instance, as it still may be needed.
1121 */
1122 if (!chr->handover_yank_instance) {
1123 yank_unregister_instance(CHARDEV_YANK_INSTANCE(chr->label));
1124 }
Lukas Straub8ee44802020-12-28 16:08:48 +01001125 }
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001126
1127 qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
1128}
1129
1130static void qemu_chr_socket_connected(QIOTask *task, void *opaque)
1131{
1132 QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(qio_task_get_source(task));
1133 Chardev *chr = CHARDEV(opaque);
1134 SocketChardev *s = SOCKET_CHARDEV(chr);
1135 Error *err = NULL;
1136
Daniel P. Berrangé4b473732019-02-11 18:24:40 +00001137 s->connect_task = NULL;
1138
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001139 if (qio_task_propagate_error(task, &err)) {
Daniel P. Berrangé32423cc2019-02-11 18:24:37 +00001140 tcp_chr_change_state(s, TCP_CHARDEV_STATE_DISCONNECTED);
Marc-André Lureauebae6472021-02-04 14:52:31 +04001141 if (s->registered_yank) {
1142 yank_unregister_function(CHARDEV_YANK_INSTANCE(chr->label),
Lukas Straub1a92d6d2021-03-23 18:52:42 +01001143 char_socket_yank_iochannel,
Marc-André Lureauebae6472021-02-04 14:52:31 +04001144 QIO_CHANNEL(sioc));
1145 }
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001146 check_report_connect_error(chr, err);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001147 goto cleanup;
1148 }
1149
1150 s->connect_err_reported = false;
1151 tcp_chr_new_client(chr, sioc);
1152
1153cleanup:
1154 object_unref(OBJECT(sioc));
1155}
1156
Daniel P. Berrangé4b473732019-02-11 18:24:40 +00001157
1158static void tcp_chr_connect_client_task(QIOTask *task,
1159 gpointer opaque)
1160{
1161 QIOChannelSocket *ioc = QIO_CHANNEL_SOCKET(qio_task_get_source(task));
1162 SocketAddress *addr = opaque;
1163 Error *err = NULL;
1164
1165 qio_channel_socket_connect_sync(ioc, addr, &err);
1166
1167 qio_task_set_error(task, err);
1168}
1169
1170
Daniel P. Berrangéefae0b92019-02-11 18:24:35 +00001171static void tcp_chr_connect_client_async(Chardev *chr)
Peter Xu3e7d4d22018-03-06 13:33:17 +08001172{
1173 SocketChardev *s = SOCKET_CHARDEV(chr);
1174 QIOChannelSocket *sioc;
1175
Daniel P. Berrangé32423cc2019-02-11 18:24:37 +00001176 tcp_chr_change_state(s, TCP_CHARDEV_STATE_CONNECTING);
Peter Xu3e7d4d22018-03-06 13:33:17 +08001177 sioc = qio_channel_socket_new();
1178 tcp_chr_set_client_ioc_name(chr, sioc);
Marc-André Lureauebae6472021-02-04 14:52:31 +04001179 if (s->registered_yank) {
1180 yank_register_function(CHARDEV_YANK_INSTANCE(chr->label),
Lukas Straub1a92d6d2021-03-23 18:52:42 +01001181 char_socket_yank_iochannel,
Marc-André Lureauebae6472021-02-04 14:52:31 +04001182 QIO_CHANNEL(sioc));
1183 }
Daniel P. Berrangé4b473732019-02-11 18:24:40 +00001184 /*
1185 * Normally code would use the qio_channel_socket_connect_async
1186 * method which uses a QIOTask + qio_task_set_error internally
1187 * to avoid blocking. The tcp_chr_wait_connected method, however,
1188 * needs a way to synchronize with completion of the background
1189 * connect task which can't be done with the QIOChannelSocket
1190 * async APIs. Thus we must use QIOTask directly to implement
1191 * the non-blocking concept locally.
1192 */
1193 s->connect_task = qio_task_new(OBJECT(sioc),
1194 qemu_chr_socket_connected,
Marc-André Lureau68066012020-04-20 13:20:12 +02001195 object_ref(OBJECT(chr)),
1196 (GDestroyNotify)object_unref);
Daniel P. Berrangé4b473732019-02-11 18:24:40 +00001197 qio_task_run_in_thread(s->connect_task,
1198 tcp_chr_connect_client_task,
1199 s->addr,
1200 NULL,
1201 chr->gcontext);
Peter Xu3e7d4d22018-03-06 13:33:17 +08001202}
1203
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001204static gboolean socket_reconnect_timeout(gpointer opaque)
1205{
1206 Chardev *chr = CHARDEV(opaque);
1207 SocketChardev *s = SOCKET_CHARDEV(opaque);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001208
Alberto Garcia78d01592019-08-12 18:58:29 +03001209 qemu_mutex_lock(&chr->chr_write_lock);
Peter Xu2c716ba2018-01-04 22:18:35 +08001210 g_source_unref(s->reconnect_timer);
1211 s->reconnect_timer = NULL;
Alberto Garcia78d01592019-08-12 18:58:29 +03001212 qemu_mutex_unlock(&chr->chr_write_lock);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001213
1214 if (chr->be_open) {
1215 return false;
1216 }
1217
Daniel P. Berrangéefae0b92019-02-11 18:24:35 +00001218 tcp_chr_connect_client_async(chr);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001219
1220 return false;
1221}
1222
Daniel P. Berrangé16459842019-02-11 18:24:29 +00001223
Daniel P. Berrangéb5e18e52019-02-11 18:24:36 +00001224static int qmp_chardev_open_socket_server(Chardev *chr,
1225 bool is_telnet,
1226 bool is_waitconnect,
1227 Error **errp)
1228{
1229 SocketChardev *s = SOCKET_CHARDEV(chr);
1230 char *name;
1231 if (is_telnet) {
1232 s->do_telnetopt = 1;
1233 }
1234 s->listener = qio_net_listener_new();
1235
1236 name = g_strdup_printf("chardev-tcp-listener-%s", chr->label);
1237 qio_net_listener_set_name(s->listener, name);
1238 g_free(name);
1239
Marc-André Lureau1b877512021-07-25 23:59:12 +04001240 if (s->addr->type == SOCKET_ADDRESS_TYPE_FD && !*s->addr->u.fd.str) {
1241 goto skip_listen;
1242 }
1243
Juan Quintelafc8135c2019-08-19 18:08:21 +02001244 if (qio_net_listener_open_sync(s->listener, s->addr, 1, errp) < 0) {
Daniel P. Berrangéb5e18e52019-02-11 18:24:36 +00001245 object_unref(OBJECT(s->listener));
1246 s->listener = NULL;
1247 return -1;
1248 }
1249
1250 qapi_free_SocketAddress(s->addr);
1251 s->addr = socket_local_address(s->listener->sioc[0]->fd, errp);
Marc-André Lureau1b877512021-07-25 23:59:12 +04001252
1253skip_listen:
Daniel P. Berrangéb5e18e52019-02-11 18:24:36 +00001254 update_disconnected_filename(s);
1255
1256 if (is_waitconnect) {
1257 tcp_chr_accept_server_sync(chr);
1258 } else {
1259 qio_net_listener_set_client_func_full(s->listener,
1260 tcp_chr_accept,
1261 chr, NULL,
1262 chr->gcontext);
1263 }
1264
1265 return 0;
1266}
1267
1268
1269static int qmp_chardev_open_socket_client(Chardev *chr,
Daniil Tatianinc8e2b6b2024-09-13 12:46:04 +03001270 int64_t reconnect_ms,
Daniel P. Berrangéb5e18e52019-02-11 18:24:36 +00001271 Error **errp)
1272{
1273 SocketChardev *s = SOCKET_CHARDEV(chr);
1274
Daniil Tatianinc8e2b6b2024-09-13 12:46:04 +03001275 if (reconnect_ms > 0) {
1276 s->reconnect_time_ms = reconnect_ms;
Daniel P. Berrangéb5e18e52019-02-11 18:24:36 +00001277 tcp_chr_connect_client_async(chr);
1278 return 0;
1279 } else {
1280 return tcp_chr_connect_client_sync(chr, errp);
1281 }
1282}
1283
1284
Daniel P. Berrangé16459842019-02-11 18:24:29 +00001285static bool qmp_chardev_validate_socket(ChardevSocket *sock,
1286 SocketAddress *addr,
1287 Error **errp)
1288{
1289 /* Validate any options which have a dependency on address type */
1290 switch (addr->type) {
1291 case SOCKET_ADDRESS_TYPE_FD:
1292 if (sock->has_reconnect) {
1293 error_setg(errp,
1294 "'reconnect' option is incompatible with "
1295 "'fd' address type");
1296 return false;
1297 }
Markus Armbruster8de69ef2022-11-04 17:06:53 +01001298 if (sock->tls_creds &&
Daniel P. Berrangé16459842019-02-11 18:24:29 +00001299 !(sock->has_server && sock->server)) {
1300 error_setg(errp,
1301 "'tls_creds' option is incompatible with "
1302 "'fd' address type as client");
1303 return false;
1304 }
1305 break;
1306
1307 case SOCKET_ADDRESS_TYPE_UNIX:
Markus Armbruster8de69ef2022-11-04 17:06:53 +01001308 if (sock->tls_creds) {
Daniel P. Berrangé16459842019-02-11 18:24:29 +00001309 error_setg(errp,
1310 "'tls_creds' option is incompatible with "
1311 "'unix' address type");
1312 return false;
1313 }
1314 break;
1315
1316 case SOCKET_ADDRESS_TYPE_INET:
1317 break;
1318
1319 case SOCKET_ADDRESS_TYPE_VSOCK:
Markus Armbruster8de69ef2022-11-04 17:06:53 +01001320 if (sock->tls_creds) {
Daniel P. Berrangé16459842019-02-11 18:24:29 +00001321 error_setg(errp,
1322 "'tls_creds' option is incompatible with "
1323 "'vsock' address type");
1324 return false;
1325 }
1326
1327 default:
1328 break;
1329 }
1330
Markus Armbruster8de69ef2022-11-04 17:06:53 +01001331 if (sock->tls_authz && !sock->tls_creds) {
Daniel P. Berrangefd4a5fd2019-03-08 15:21:50 +00001332 error_setg(errp, "'tls_authz' option requires 'tls_creds' option");
1333 return false;
1334 }
1335
Michael Tokarev0a19d872023-07-14 14:33:49 +03001336 /* Validate any options which have a dependency on client vs server */
Daniel P. Berrangé4a0582f2019-02-11 18:24:30 +00001337 if (!sock->has_server || sock->server) {
1338 if (sock->has_reconnect) {
1339 error_setg(errp,
1340 "'reconnect' option is incompatible with "
1341 "socket in server listen mode");
1342 return false;
1343 }
1344 } else {
Daniel P. Berrangé16459842019-02-11 18:24:29 +00001345 if (sock->has_websocket && sock->websocket) {
1346 error_setg(errp, "%s", "Websocket client is not implemented");
1347 return false;
1348 }
Daniel P. Berrangé767abe72019-02-11 18:24:31 +00001349 if (sock->has_wait) {
Daniel P. Berrangé24e13a42021-02-22 13:47:17 +00001350 error_setg(errp, "%s",
1351 "'wait' option is incompatible with "
1352 "socket in client connect mode");
1353 return false;
Daniel P. Berrangé767abe72019-02-11 18:24:31 +00001354 }
Daniel P. Berrangé16459842019-02-11 18:24:29 +00001355 }
1356
Daniil Tatianinc8e2b6b2024-09-13 12:46:04 +03001357 if (sock->has_reconnect_ms && sock->has_reconnect) {
1358 error_setg(errp,
1359 "'reconnect' and 'reconnect-ms' are mutually exclusive");
1360 return false;
1361 }
1362
Daniel P. Berrangé16459842019-02-11 18:24:29 +00001363 return true;
1364}
1365
1366
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001367static void qmp_chardev_open_socket(Chardev *chr,
1368 ChardevBackend *backend,
1369 bool *be_opened,
1370 Error **errp)
1371{
1372 SocketChardev *s = SOCKET_CHARDEV(chr);
1373 ChardevSocket *sock = backend->u.socket.data;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001374 bool do_nodelay = sock->has_nodelay ? sock->nodelay : false;
1375 bool is_listen = sock->has_server ? sock->server : true;
1376 bool is_telnet = sock->has_telnet ? sock->telnet : false;
Jing Liuae92cbd2016-09-23 08:06:11 +02001377 bool is_tn3270 = sock->has_tn3270 ? sock->tn3270 : false;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001378 bool is_waitconnect = sock->has_wait ? sock->wait : false;
Julia Suvorova981b06e2018-10-19 01:35:00 +03001379 bool is_websock = sock->has_websocket ? sock->websocket : false;
Daniil Tatianinc8e2b6b2024-09-13 12:46:04 +03001380 int64_t reconnect_ms = 0;
Markus Armbrusterbd269eb2017-04-26 09:36:41 +02001381 SocketAddress *addr;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001382
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001383 s->is_listen = is_listen;
1384 s->is_telnet = is_telnet;
Jing Liuae92cbd2016-09-23 08:06:11 +02001385 s->is_tn3270 = is_tn3270;
Julia Suvorova981b06e2018-10-19 01:35:00 +03001386 s->is_websock = is_websock;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001387 s->do_nodelay = do_nodelay;
1388 if (sock->tls_creds) {
1389 Object *creds;
1390 creds = object_resolve_path_component(
1391 object_get_objects_root(), sock->tls_creds);
1392 if (!creds) {
1393 error_setg(errp, "No TLS credentials with id '%s'",
1394 sock->tls_creds);
Daniel P. Berrangée154fd72019-02-11 18:24:34 +00001395 return;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001396 }
1397 s->tls_creds = (QCryptoTLSCreds *)
1398 object_dynamic_cast(creds,
1399 TYPE_QCRYPTO_TLS_CREDS);
1400 if (!s->tls_creds) {
1401 error_setg(errp, "Object with id '%s' is not TLS credentials",
1402 sock->tls_creds);
Daniel P. Berrangée154fd72019-02-11 18:24:34 +00001403 return;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001404 }
1405 object_ref(OBJECT(s->tls_creds));
Philippe Mathieu-Daudé8612df22021-06-28 18:09:11 +02001406 if (!qcrypto_tls_creds_check_endpoint(s->tls_creds,
1407 is_listen
1408 ? QCRYPTO_TLS_CREDS_ENDPOINT_SERVER
1409 : QCRYPTO_TLS_CREDS_ENDPOINT_CLIENT,
1410 errp)) {
1411 return;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001412 }
1413 }
Daniel P. Berrangefd4a5fd2019-03-08 15:21:50 +00001414 s->tls_authz = g_strdup(sock->tls_authz);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001415
Markus Armbrusterbd269eb2017-04-26 09:36:41 +02001416 s->addr = addr = socket_address_flatten(sock->addr);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001417
Daniel P. Berrangé16459842019-02-11 18:24:29 +00001418 if (!qmp_chardev_validate_socket(sock, addr, errp)) {
Daniel P. Berrangée154fd72019-02-11 18:24:34 +00001419 return;
Marc-André Lureau4591bd42018-07-17 14:31:45 +02001420 }
Daniel P. Berrangé16459842019-02-11 18:24:29 +00001421
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001422 qemu_chr_set_feature(chr, QEMU_CHAR_FEATURE_RECONNECTABLE);
Bin Meng120fa5e2022-08-02 15:51:59 +08001423#ifndef _WIN32
Markus Armbrusterca0b64e2017-03-30 19:43:09 +02001424 /* TODO SOCKET_ADDRESS_FD where fd has AF_UNIX */
Markus Armbrusterbd269eb2017-04-26 09:36:41 +02001425 if (addr->type == SOCKET_ADDRESS_TYPE_UNIX) {
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001426 qemu_chr_set_feature(chr, QEMU_CHAR_FEATURE_FD_PASS);
1427 }
Bin Meng120fa5e2022-08-02 15:51:59 +08001428#endif
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001429
Lukas Straubfeb774c2021-03-30 20:13:31 +02001430 /*
1431 * In the chardev-change special-case, we shouldn't register a new yank
1432 * instance, as there already may be one.
1433 */
1434 if (!chr->handover_yank_instance) {
1435 if (!yank_register_instance(CHARDEV_YANK_INSTANCE(chr->label), errp)) {
1436 return;
1437 }
Lukas Straub8ee44802020-12-28 16:08:48 +01001438 }
1439 s->registered_yank = true;
1440
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001441 /* be isn't opened until we get a connection */
1442 *be_opened = false;
1443
Marc-André Lureaubbcde962016-12-20 15:32:31 +01001444 update_disconnected_filename(s);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001445
Daniel P. Berrangéb5e18e52019-02-11 18:24:36 +00001446 if (s->is_listen) {
1447 if (qmp_chardev_open_socket_server(chr, is_telnet || is_tn3270,
1448 is_waitconnect, errp) < 0) {
1449 return;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001450 }
Marc-André Lureau5573f982018-08-17 15:52:22 +02001451 } else {
Daniil Tatianinc8e2b6b2024-09-13 12:46:04 +03001452 if (sock->has_reconnect) {
1453 reconnect_ms = sock->reconnect * 1000ULL;
1454 } else if (sock->has_reconnect_ms) {
1455 reconnect_ms = sock->reconnect_ms;
1456 }
1457
1458 if (qmp_chardev_open_socket_client(chr, reconnect_ms, errp) < 0) {
Daniel P. Berrangée154fd72019-02-11 18:24:34 +00001459 return;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001460 }
1461 }
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001462}
1463
1464static void qemu_chr_parse_socket(QemuOpts *opts, ChardevBackend *backend,
1465 Error **errp)
1466{
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001467 const char *path = qemu_opt_get(opts, "path");
1468 const char *host = qemu_opt_get(opts, "host");
1469 const char *port = qemu_opt_get(opts, "port");
Daniel P. Berrange09357002017-12-21 12:57:54 +00001470 const char *fd = qemu_opt_get(opts, "fd");
Markus Armbruster8acefc72020-11-02 10:44:22 +01001471#ifdef CONFIG_LINUX
xiaoqiang zhao776b97d2020-05-16 11:13:25 +08001472 bool tight = qemu_opt_get_bool(opts, "tight", true);
1473 bool abstract = qemu_opt_get_bool(opts, "abstract", false);
Markus Armbruster8acefc72020-11-02 10:44:22 +01001474#endif
Markus Armbrusterdfd100f2017-04-26 09:36:39 +02001475 SocketAddressLegacy *addr;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001476 ChardevSocket *sock;
1477
Marc-André Lureau1b877512021-07-25 23:59:12 +04001478 if ((!!path + !!fd + !!host) > 1) {
Daniel P. Berrange9bb40602017-12-22 13:20:40 +00001479 error_setg(errp,
Marc-André Lureau1b877512021-07-25 23:59:12 +04001480 "None or one of 'path', 'fd' or 'host' option required.");
Daniel P. Berrange9bb40602017-12-22 13:20:40 +00001481 return;
1482 }
1483
Daniel P. Berrangé16459842019-02-11 18:24:29 +00001484 if (host && !port) {
1485 error_setg(errp, "chardev: socket: no port given");
1486 return;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001487 }
1488
Daniel P. Berrangé16459842019-02-11 18:24:29 +00001489 backend->type = CHARDEV_BACKEND_KIND_SOCKET;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001490 sock = backend->u.socket.data = g_new0(ChardevSocket, 1);
1491 qemu_chr_parse_common(opts, qapi_ChardevSocket_base(sock));
1492
Paolo Bonzinia9b13152021-02-25 11:47:52 +01001493 if (qemu_opt_get(opts, "delay") && qemu_opt_get(opts, "nodelay")) {
1494 error_setg(errp, "'delay' and 'nodelay' are mutually exclusive");
1495 return;
1496 }
1497 sock->has_nodelay =
1498 qemu_opt_get(opts, "delay") ||
1499 qemu_opt_get(opts, "nodelay");
1500 sock->nodelay =
1501 !qemu_opt_get_bool(opts, "delay", true) ||
1502 qemu_opt_get_bool(opts, "nodelay", false);
1503
Daniel P. Berrangé5981c3a2019-02-11 18:24:32 +00001504 /*
1505 * We have different default to QMP for 'server', hence
1506 * we can't just check for existence of 'server'
1507 */
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001508 sock->has_server = true;
Daniel P. Berrangé5981c3a2019-02-11 18:24:32 +00001509 sock->server = qemu_opt_get_bool(opts, "server", false);
1510 sock->has_telnet = qemu_opt_get(opts, "telnet");
1511 sock->telnet = qemu_opt_get_bool(opts, "telnet", false);
1512 sock->has_tn3270 = qemu_opt_get(opts, "tn3270");
1513 sock->tn3270 = qemu_opt_get_bool(opts, "tn3270", false);
1514 sock->has_websocket = qemu_opt_get(opts, "websocket");
1515 sock->websocket = qemu_opt_get_bool(opts, "websocket", false);
Daniel P. Berrangé767abe72019-02-11 18:24:31 +00001516 /*
1517 * We have different default to QMP for 'wait' when 'server'
1518 * is set, hence we can't just check for existence of 'wait'
1519 */
Daniel P. Berrangé5981c3a2019-02-11 18:24:32 +00001520 sock->has_wait = qemu_opt_find(opts, "wait") || sock->server;
1521 sock->wait = qemu_opt_get_bool(opts, "wait", true);
Marc-André Lureau3b023752018-07-17 14:43:51 +02001522 sock->has_reconnect = qemu_opt_find(opts, "reconnect");
Daniel P. Berrangé5981c3a2019-02-11 18:24:32 +00001523 sock->reconnect = qemu_opt_get_number(opts, "reconnect", 0);
Daniil Tatianinc8e2b6b2024-09-13 12:46:04 +03001524 sock->has_reconnect_ms = qemu_opt_find(opts, "reconnect-ms");
1525 sock->reconnect_ms = qemu_opt_get_number(opts, "reconnect-ms", 0);
1526
Daniel P. Berrangé5981c3a2019-02-11 18:24:32 +00001527 sock->tls_creds = g_strdup(qemu_opt_get(opts, "tls-creds"));
Daniel P. Berrangefd4a5fd2019-03-08 15:21:50 +00001528 sock->tls_authz = g_strdup(qemu_opt_get(opts, "tls-authz"));
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001529
Markus Armbrusterdfd100f2017-04-26 09:36:39 +02001530 addr = g_new0(SocketAddressLegacy, 1);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001531 if (path) {
1532 UnixSocketAddress *q_unix;
Markus Armbruster935a8672021-09-17 16:31:19 +02001533 addr->type = SOCKET_ADDRESS_TYPE_UNIX;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001534 q_unix = addr->u.q_unix.data = g_new0(UnixSocketAddress, 1);
1535 q_unix->path = g_strdup(path);
Markus Armbruster8acefc72020-11-02 10:44:22 +01001536#ifdef CONFIG_LINUX
Markus Armbrusterb08cc972020-11-02 10:44:18 +01001537 q_unix->has_tight = true;
xiaoqiang zhao776b97d2020-05-16 11:13:25 +08001538 q_unix->tight = tight;
Markus Armbrusterb08cc972020-11-02 10:44:18 +01001539 q_unix->has_abstract = true;
xiaoqiang zhao776b97d2020-05-16 11:13:25 +08001540 q_unix->abstract = abstract;
Markus Armbruster8acefc72020-11-02 10:44:22 +01001541#endif
Daniel P. Berrange9bb40602017-12-22 13:20:40 +00001542 } else if (host) {
Markus Armbruster935a8672021-09-17 16:31:19 +02001543 addr->type = SOCKET_ADDRESS_TYPE_INET;
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001544 addr->u.inet.data = g_new(InetSocketAddress, 1);
1545 *addr->u.inet.data = (InetSocketAddress) {
1546 .host = g_strdup(host),
1547 .port = g_strdup(port),
1548 .has_to = qemu_opt_get(opts, "to"),
1549 .to = qemu_opt_get_number(opts, "to", 0),
1550 .has_ipv4 = qemu_opt_get(opts, "ipv4"),
1551 .ipv4 = qemu_opt_get_bool(opts, "ipv4", 0),
1552 .has_ipv6 = qemu_opt_get(opts, "ipv6"),
1553 .ipv6 = qemu_opt_get_bool(opts, "ipv6", 0),
1554 };
Marc-André Lureau1b877512021-07-25 23:59:12 +04001555 } else {
Markus Armbruster935a8672021-09-17 16:31:19 +02001556 addr->type = SOCKET_ADDRESS_TYPE_FD;
Markus Armbruster4edb1962024-02-05 08:47:07 +01001557 addr->u.fd.data = g_new(FdSocketAddress, 1);
Daniel P. Berrange09357002017-12-21 12:57:54 +00001558 addr->u.fd.data->str = g_strdup(fd);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001559 }
1560 sock->addr = addr;
1561}
1562
Marc-André Lureau123676e2016-12-21 12:26:38 +01001563static void
1564char_socket_get_addr(Object *obj, Visitor *v, const char *name,
1565 void *opaque, Error **errp)
1566{
1567 SocketChardev *s = SOCKET_CHARDEV(obj);
1568
1569 visit_type_SocketAddress(v, name, &s->addr, errp);
1570}
1571
Marc-André Lureauda2d19b2016-12-21 15:43:46 +01001572static bool
1573char_socket_get_connected(Object *obj, Error **errp)
1574{
1575 SocketChardev *s = SOCKET_CHARDEV(obj);
1576
Daniel P. Berrangé32423cc2019-02-11 18:24:37 +00001577 return s->state == TCP_CHARDEV_STATE_CONNECTED;
Marc-André Lureauda2d19b2016-12-21 15:43:46 +01001578}
1579
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001580static void char_socket_class_init(ObjectClass *oc, void *data)
1581{
1582 ChardevClass *cc = CHARDEV_CLASS(oc);
1583
Lukas Straubfeb774c2021-03-30 20:13:31 +02001584 cc->supports_yank = true;
1585
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001586 cc->parse = qemu_chr_parse_socket;
1587 cc->open = qmp_chardev_open_socket;
1588 cc->chr_wait_connected = tcp_chr_wait_connected;
1589 cc->chr_write = tcp_chr_write;
1590 cc->chr_sync_read = tcp_chr_sync_read;
1591 cc->chr_disconnect = tcp_chr_disconnect;
1592 cc->get_msgfds = tcp_get_msgfds;
1593 cc->set_msgfds = tcp_set_msgfds;
1594 cc->chr_add_client = tcp_chr_add_client;
1595 cc->chr_add_watch = tcp_chr_add_watch;
1596 cc->chr_update_read_handler = tcp_chr_update_read_handler;
Marc-André Lureau123676e2016-12-21 12:26:38 +01001597
1598 object_class_property_add(oc, "addr", "SocketAddress",
1599 char_socket_get_addr, NULL,
Markus Armbrusterd2623122020-05-05 17:29:22 +02001600 NULL, NULL);
Marc-André Lureauda2d19b2016-12-21 15:43:46 +01001601
1602 object_class_property_add_bool(oc, "connected", char_socket_get_connected,
Markus Armbrusterd2623122020-05-05 17:29:22 +02001603 NULL);
Marc-André Lureaud24ca4b2016-12-12 18:41:00 +03001604}
1605
1606static const TypeInfo char_socket_type_info = {
1607 .name = TYPE_CHARDEV_SOCKET,
1608 .parent = TYPE_CHARDEV,
1609 .instance_size = sizeof(SocketChardev),
1610 .instance_finalize = char_socket_finalize,
1611 .class_init = char_socket_class_init,
1612};
1613
1614static void register_types(void)
1615{
1616 type_register_static(&char_socket_type_info);
1617}
1618
1619type_init(register_types);