blob: 8e3702e1f3a87f4a24e34df400b71e02a4461b4b [file] [log] [blame]
Mark McLoughlin42281ac2009-11-25 18:48:56 +00001/*
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 */
Peter Maydell2744d922016-01-29 17:50:00 +000024#include "qemu/osdep.h"
Mark McLoughlin42281ac2009-11-25 18:48:56 +000025
Paolo Bonzini1422e322012-10-24 08:43:34 +020026#include "net/net.h"
Paolo Bonzinia245fc12012-09-17 18:43:51 +020027#include "clients.h"
Paolo Bonzini83c90892012-12-17 18:19:49 +010028#include "monitor/monitor.h"
Markus Armbrusterda34e652016-03-14 09:01:28 +010029#include "qapi/error.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010030#include "qemu/error-report.h"
31#include "qemu/option.h"
32#include "qemu/sockets.h"
33#include "qemu/iov.h"
Alex Bligh6a1751b2013-08-21 16:02:47 +010034#include "qemu/main-loop.h"
Mark McLoughlin42281ac2009-11-25 18:48:56 +000035
36typedef struct NetSocketState {
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +010037 NetClientState nc;
Zhi Yong Wu011de2b2012-07-20 14:25:53 +010038 int listen_fd;
Mark McLoughlin42281ac2009-11-25 18:48:56 +000039 int fd;
Zhang Chen16a3df42016-05-13 15:35:19 +080040 SocketReadState rs;
Stefan Hajnoczi45a7f542012-08-20 10:14:35 +010041 unsigned int send_index; /* number of bytes sent (only SOCK_STREAM) */
Mark McLoughlin42281ac2009-11-25 18:48:56 +000042 struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
Stefan Hajnoczi863f6782012-08-20 10:21:54 +010043 IOHandler *send_fn; /* differs between SOCK_STREAM/SOCK_DGRAM */
44 bool read_poll; /* waiting to receive data? */
45 bool write_poll; /* waiting to transmit data? */
Mark McLoughlin42281ac2009-11-25 18:48:56 +000046} NetSocketState;
47
Zhi Yong Wu011de2b2012-07-20 14:25:53 +010048static void net_socket_accept(void *opaque);
Stefan Hajnoczi863f6782012-08-20 10:21:54 +010049static void net_socket_writable(void *opaque);
50
Stefan Hajnoczi863f6782012-08-20 10:21:54 +010051static void net_socket_update_fd_handler(NetSocketState *s)
52{
Fam Zheng82e1cc42015-06-04 14:45:18 +080053 qemu_set_fd_handler(s->fd,
54 s->read_poll ? s->send_fn : NULL,
55 s->write_poll ? net_socket_writable : NULL,
56 s);
Stefan Hajnoczi863f6782012-08-20 10:21:54 +010057}
58
59static void net_socket_read_poll(NetSocketState *s, bool enable)
60{
61 s->read_poll = enable;
62 net_socket_update_fd_handler(s);
63}
64
65static void net_socket_write_poll(NetSocketState *s, bool enable)
66{
67 s->write_poll = enable;
68 net_socket_update_fd_handler(s);
69}
70
71static void net_socket_writable(void *opaque)
72{
73 NetSocketState *s = opaque;
74
75 net_socket_write_poll(s, false);
76
77 qemu_flush_queued_packets(&s->nc);
78}
Mark McLoughlin42281ac2009-11-25 18:48:56 +000079
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +010080static ssize_t net_socket_receive(NetClientState *nc, const uint8_t *buf, size_t size)
Mark McLoughlin42281ac2009-11-25 18:48:56 +000081{
Mark McLoughlin564f63e2009-11-25 18:49:08 +000082 NetSocketState *s = DO_UPCAST(NetSocketState, nc, nc);
Stefan Hajnoczi45a7f542012-08-20 10:14:35 +010083 uint32_t len = htonl(size);
84 struct iovec iov[] = {
85 {
86 .iov_base = &len,
87 .iov_len = sizeof(len),
88 }, {
89 .iov_base = (void *)buf,
90 .iov_len = size,
91 },
92 };
93 size_t remaining;
94 ssize_t ret;
Mark McLoughlin42281ac2009-11-25 18:48:56 +000095
Stefan Hajnoczi45a7f542012-08-20 10:14:35 +010096 remaining = iov_size(iov, 2) - s->send_index;
97 ret = iov_send(s->fd, iov, 2, s->send_index, remaining);
98
99 if (ret == -1 && errno == EAGAIN) {
100 ret = 0; /* handled further down */
101 }
102 if (ret == -1) {
103 s->send_index = 0;
104 return -errno;
105 }
106 if (ret < (ssize_t)remaining) {
107 s->send_index += ret;
108 net_socket_write_poll(s, true);
109 return 0;
110 }
111 s->send_index = 0;
112 return size;
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000113}
114
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100115static ssize_t net_socket_receive_dgram(NetClientState *nc, const uint8_t *buf, size_t size)
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000116{
Mark McLoughlin564f63e2009-11-25 18:49:08 +0000117 NetSocketState *s = DO_UPCAST(NetSocketState, nc, nc);
Stefan Hajnoczi213fd502012-08-20 10:28:53 +0100118 ssize_t ret;
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000119
Nikita Ivanov37b0b242022-10-23 12:04:22 +0300120 ret = RETRY_ON_EINTR(
121 s->dgram_dst.sin_family != AF_UNIX ?
122 sendto(s->fd, buf, size, 0,
123 (struct sockaddr *)&s->dgram_dst,
124 sizeof(s->dgram_dst)) :
125 send(s->fd, buf, size, 0)
126 );
Stefan Hajnoczi213fd502012-08-20 10:28:53 +0100127
128 if (ret == -1 && errno == EAGAIN) {
129 net_socket_write_poll(s, true);
130 return 0;
131 }
132 return ret;
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000133}
134
Fam Zheng6e99c632015-06-04 14:45:16 +0800135static void net_socket_send_completed(NetClientState *nc, ssize_t len)
136{
137 NetSocketState *s = DO_UPCAST(NetSocketState, nc, nc);
138
139 if (!s->read_poll) {
140 net_socket_read_poll(s, true);
141 }
142}
143
Zhang Chen16a3df42016-05-13 15:35:19 +0800144static void net_socket_rs_finalize(SocketReadState *rs)
145{
146 NetSocketState *s = container_of(rs, NetSocketState, rs);
147
148 if (qemu_send_packet_async(&s->nc, rs->buf,
149 rs->packet_len,
150 net_socket_send_completed) == 0) {
151 net_socket_read_poll(s, false);
152 }
153}
154
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000155static void net_socket_send(void *opaque)
156{
157 NetSocketState *s = opaque;
Daniel P. Berrangeb16a44e2016-03-07 20:36:03 +0000158 int size;
Zhang Chen16a3df42016-05-13 15:35:19 +0800159 int ret;
Scott Feldmand32fcad2013-03-18 11:43:44 -0700160 uint8_t buf1[NET_BUFSIZE];
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000161 const uint8_t *buf;
162
Marc-André Lureaue7b79422022-02-19 01:34:50 +0400163 size = recv(s->fd, buf1, sizeof(buf1), 0);
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000164 if (size < 0) {
Daniel P. Berrangeb16a44e2016-03-07 20:36:03 +0000165 if (errno != EWOULDBLOCK)
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000166 goto eoc;
167 } else if (size == 0) {
168 /* end of connection */
169 eoc:
Stefan Hajnoczi863f6782012-08-20 10:21:54 +0100170 net_socket_read_poll(s, false);
171 net_socket_write_poll(s, false);
Zhi Yong Wu011de2b2012-07-20 14:25:53 +0100172 if (s->listen_fd != -1) {
173 qemu_set_fd_handler(s->listen_fd, net_socket_accept, NULL, s);
174 }
Marc-André Lureau25657fc2023-02-21 16:48:01 +0400175 close(s->fd);
Zhi Yong Wu011de2b2012-07-20 14:25:53 +0100176
177 s->fd = -1;
Zhang Chen3cde5ea2017-07-04 14:53:46 +0800178 net_socket_rs_init(&s->rs, net_socket_rs_finalize, false);
Zhi Yong Wu011de2b2012-07-20 14:25:53 +0100179 s->nc.link_down = true;
Stefan Weil viaac149492022-11-26 16:25:07 +0100180 qemu_set_info_str(&s->nc, "%s", "");
Zhi Yong Wu011de2b2012-07-20 14:25:53 +0100181
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000182 return;
183 }
184 buf = buf1;
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000185
Zhang Chen16a3df42016-05-13 15:35:19 +0800186 ret = net_fill_rstate(&s->rs, buf, size);
187
188 if (ret == -1) {
189 goto eoc;
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000190 }
191}
192
193static void net_socket_send_dgram(void *opaque)
194{
195 NetSocketState *s = opaque;
196 int size;
197
Marc-André Lureaue7b79422022-02-19 01:34:50 +0400198 size = recv(s->fd, s->rs.buf, sizeof(s->rs.buf), 0);
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000199 if (size < 0)
200 return;
201 if (size == 0) {
202 /* end of connection */
Stefan Hajnoczi863f6782012-08-20 10:21:54 +0100203 net_socket_read_poll(s, false);
204 net_socket_write_poll(s, false);
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000205 return;
206 }
Zhang Chen16a3df42016-05-13 15:35:19 +0800207 if (qemu_send_packet_async(&s->nc, s->rs.buf, size,
Fam Zheng6e99c632015-06-04 14:45:16 +0800208 net_socket_send_completed) == 0) {
209 net_socket_read_poll(s, false);
210 }
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000211}
212
Mao Zhongyic37f0bb2017-09-04 22:35:38 +0800213static int net_socket_mcast_create(struct sockaddr_in *mcastaddr,
214 struct in_addr *localaddr,
215 Error **errp)
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000216{
217 struct ip_mreq imr;
218 int fd;
219 int val, ret;
Brad23ddf2b2011-08-07 11:06:43 +0000220#ifdef __OpenBSD__
221 unsigned char loop;
222#else
223 int loop;
224#endif
225
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000226 if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
Mao Zhongyic37f0bb2017-09-04 22:35:38 +0800227 error_setg(errp, "specified mcastaddr %s (0x%08x) "
228 "does not contain a multicast address",
229 inet_ntoa(mcastaddr->sin_addr),
230 (int)ntohl(mcastaddr->sin_addr.s_addr));
Stefan Hajnoczi842480d2011-12-07 15:01:48 +0000231 return -1;
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000232 }
Mao Zhongyic37f0bb2017-09-04 22:35:38 +0800233
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100234 fd = qemu_socket(PF_INET, SOCK_DGRAM, 0);
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000235 if (fd < 0) {
Mao Zhongyic37f0bb2017-09-04 22:35:38 +0800236 error_setg_errno(errp, errno, "can't create datagram socket");
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000237 return -1;
238 }
239
Sebastian Ottlikbcbe92f2013-10-02 12:23:14 +0200240 /* Allow multiple sockets to bind the same multicast ip and port by setting
241 * SO_REUSEADDR. This is the only situation where SO_REUSEADDR should be set
242 * on windows. Use socket_set_fast_reuse otherwise as it sets SO_REUSEADDR
243 * only on posix systems.
244 */
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000245 val = 1;
Marc-André Lureaue7b79422022-02-19 01:34:50 +0400246 ret = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000247 if (ret < 0) {
Mao Zhongyic37f0bb2017-09-04 22:35:38 +0800248 error_setg_errno(errp, errno,
249 "can't set socket option SO_REUSEADDR");
Stefan Hajnoczi842480d2011-12-07 15:01:48 +0000250 goto fail;
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000251 }
252
253 ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
254 if (ret < 0) {
Mao Zhongyic37f0bb2017-09-04 22:35:38 +0800255 error_setg_errno(errp, errno, "can't bind ip=%s to socket",
256 inet_ntoa(mcastaddr->sin_addr));
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000257 goto fail;
258 }
259
260 /* Add host to multicast group */
261 imr.imr_multiaddr = mcastaddr->sin_addr;
Mike Ryan3a75e742010-12-01 11:16:47 -0800262 if (localaddr) {
263 imr.imr_interface = *localaddr;
264 } else {
265 imr.imr_interface.s_addr = htonl(INADDR_ANY);
266 }
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000267
Marc-André Lureaue7b79422022-02-19 01:34:50 +0400268 ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
269 &imr, sizeof(struct ip_mreq));
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000270 if (ret < 0) {
Mao Zhongyic37f0bb2017-09-04 22:35:38 +0800271 error_setg_errno(errp, errno,
272 "can't add socket to multicast group %s",
273 inet_ntoa(imr.imr_multiaddr));
Stefan Hajnoczi842480d2011-12-07 15:01:48 +0000274 goto fail;
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000275 }
276
277 /* Force mcast msgs to loopback (eg. several QEMUs in same host */
Brad23ddf2b2011-08-07 11:06:43 +0000278 loop = 1;
Marc-André Lureaue7b79422022-02-19 01:34:50 +0400279 ret = setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
280 &loop, sizeof(loop));
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000281 if (ret < 0) {
Mao Zhongyic37f0bb2017-09-04 22:35:38 +0800282 error_setg_errno(errp, errno,
283 "can't force multicast message to loopback");
Stefan Hajnoczi842480d2011-12-07 15:01:48 +0000284 goto fail;
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000285 }
286
Mike Ryan3a75e742010-12-01 11:16:47 -0800287 /* If a bind address is given, only send packets from that address */
288 if (localaddr != NULL) {
Marc-André Lureaue7b79422022-02-19 01:34:50 +0400289 ret = setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF,
290 localaddr, sizeof(*localaddr));
Mike Ryan3a75e742010-12-01 11:16:47 -0800291 if (ret < 0) {
Mao Zhongyic37f0bb2017-09-04 22:35:38 +0800292 error_setg_errno(errp, errno,
293 "can't set the default network send interface");
Mike Ryan3a75e742010-12-01 11:16:47 -0800294 goto fail;
295 }
296 }
297
Marc-André Lureauff5927b2022-04-25 17:33:47 +0400298 qemu_socket_set_nonblock(fd);
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000299 return fd;
300fail:
301 if (fd >= 0)
Marc-André Lureau25657fc2023-02-21 16:48:01 +0400302 close(fd);
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000303 return -1;
304}
305
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100306static void net_socket_cleanup(NetClientState *nc)
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000307{
Mark McLoughlin564f63e2009-11-25 18:49:08 +0000308 NetSocketState *s = DO_UPCAST(NetSocketState, nc, nc);
Zhi Yong Wu011de2b2012-07-20 14:25:53 +0100309 if (s->fd != -1) {
Stefan Hajnoczi863f6782012-08-20 10:21:54 +0100310 net_socket_read_poll(s, false);
311 net_socket_write_poll(s, false);
Zhi Yong Wu011de2b2012-07-20 14:25:53 +0100312 close(s->fd);
313 s->fd = -1;
314 }
315 if (s->listen_fd != -1) {
316 qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
Marc-André Lureau25657fc2023-02-21 16:48:01 +0400317 close(s->listen_fd);
Zhi Yong Wu011de2b2012-07-20 14:25:53 +0100318 s->listen_fd = -1;
319 }
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000320}
321
Mark McLoughlin564f63e2009-11-25 18:49:08 +0000322static NetClientInfo net_dgram_socket_info = {
Eric Blakef394b2e2016-07-13 21:50:23 -0600323 .type = NET_CLIENT_DRIVER_SOCKET,
Mark McLoughlin564f63e2009-11-25 18:49:08 +0000324 .size = sizeof(NetSocketState),
325 .receive = net_socket_receive_dgram,
326 .cleanup = net_socket_cleanup,
327};
328
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100329static NetSocketState *net_socket_fd_init_dgram(NetClientState *peer,
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000330 const char *model,
331 const char *name,
Jens Freimann0f8c2892017-08-08 22:38:57 +0200332 int fd, int is_connected,
Mao Zhongyic37f0bb2017-09-04 22:35:38 +0800333 const char *mcast,
334 Error **errp)
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000335{
336 struct sockaddr_in saddr;
337 int newfd;
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100338 NetClientState *nc;
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000339 NetSocketState *s;
Marc-André Lureaufdec16e2019-03-11 18:25:05 +0100340 SocketAddress *sa;
341 SocketAddressType sa_type;
342
343 sa = socket_local_address(fd, errp);
344 if (!sa) {
345 return NULL;
346 }
347 sa_type = sa->type;
348 qapi_free_SocketAddress(sa);
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000349
350 /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
351 * Because this may be "shared" socket from a "master" process, datagrams would be recv()
352 * by ONLY ONE process: we must "clone" this dgram socket --jjo
353 */
354
Jens Freimann0f8c2892017-08-08 22:38:57 +0200355 if (is_connected && mcast != NULL) {
Mao Zhongyibcd4dfd2017-09-04 22:35:39 +0800356 if (parse_host_port(&saddr, mcast, errp) < 0) {
Jens Freimann0f8c2892017-08-08 22:38:57 +0200357 goto err;
358 }
Stefan Hajnoczi842480d2011-12-07 15:01:48 +0000359 /* must be bound */
360 if (saddr.sin_addr.s_addr == 0) {
Mao Zhongyic37f0bb2017-09-04 22:35:38 +0800361 error_setg(errp, "can't setup multicast destination address");
Stefan Hajnoczie5d1fca2011-12-07 15:01:49 +0000362 goto err;
Stefan Hajnoczi842480d2011-12-07 15:01:48 +0000363 }
364 /* clone dgram socket */
Mao Zhongyic37f0bb2017-09-04 22:35:38 +0800365 newfd = net_socket_mcast_create(&saddr, NULL, errp);
Stefan Hajnoczi842480d2011-12-07 15:01:48 +0000366 if (newfd < 0) {
Stefan Hajnoczie5d1fca2011-12-07 15:01:49 +0000367 goto err;
Stefan Hajnoczi842480d2011-12-07 15:01:48 +0000368 }
369 /* clone newfd to fd, close newfd */
370 dup2(newfd, fd);
371 close(newfd);
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000372
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000373 }
374
Stefan Hajnocziab5f3f82012-07-24 16:35:08 +0100375 nc = qemu_new_net_client(&net_dgram_socket_info, peer, model, name);
Mark McLoughlin564f63e2009-11-25 18:49:08 +0000376
Mark McLoughlin564f63e2009-11-25 18:49:08 +0000377 s = DO_UPCAST(NetSocketState, nc, nc);
378
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000379 s->fd = fd;
Zhi Yong Wu011de2b2012-07-20 14:25:53 +0100380 s->listen_fd = -1;
Stefan Hajnoczi863f6782012-08-20 10:21:54 +0100381 s->send_fn = net_socket_send_dgram;
Zhang Chen3cde5ea2017-07-04 14:53:46 +0800382 net_socket_rs_init(&s->rs, net_socket_rs_finalize, false);
Stefan Hajnoczi863f6782012-08-20 10:21:54 +0100383 net_socket_read_poll(s, true);
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000384
385 /* mcast: save bound address as dst */
Jens Freimannbb160b52017-11-06 15:05:46 +0100386 if (is_connected && mcast != NULL) {
Zhi Yong Wue34cde32012-07-20 14:25:52 +0100387 s->dgram_dst = saddr;
Laurent Vivier53b85d92022-10-21 11:09:10 +0200388 qemu_set_info_str(nc, "socket: fd=%d (cloned mcast=%s:%d)", fd,
389 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
Gonglei8db804a2014-11-20 19:35:01 +0800390 } else {
Marc-André Lureaufdec16e2019-03-11 18:25:05 +0100391 if (sa_type == SOCKET_ADDRESS_TYPE_UNIX) {
392 s->dgram_dst.sin_family = AF_UNIX;
393 }
Jason Wangd89b4f82021-04-02 11:03:12 +0800394
Laurent Vivier53b85d92022-10-21 11:09:10 +0200395 qemu_set_info_str(nc, "socket: fd=%d %s", fd,
396 SocketAddressType_str(sa_type));
Zhi Yong Wue34cde32012-07-20 14:25:52 +0100397 }
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000398
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000399 return s;
Stefan Hajnoczie5d1fca2011-12-07 15:01:49 +0000400
401err:
Marc-André Lureau25657fc2023-02-21 16:48:01 +0400402 close(fd);
Stefan Hajnoczie5d1fca2011-12-07 15:01:49 +0000403 return NULL;
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000404}
405
406static void net_socket_connect(void *opaque)
407{
408 NetSocketState *s = opaque;
Stefan Hajnoczi863f6782012-08-20 10:21:54 +0100409 s->send_fn = net_socket_send;
410 net_socket_read_poll(s, true);
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000411}
412
Mark McLoughlin564f63e2009-11-25 18:49:08 +0000413static NetClientInfo net_socket_info = {
Eric Blakef394b2e2016-07-13 21:50:23 -0600414 .type = NET_CLIENT_DRIVER_SOCKET,
Mark McLoughlin564f63e2009-11-25 18:49:08 +0000415 .size = sizeof(NetSocketState),
416 .receive = net_socket_receive,
417 .cleanup = net_socket_cleanup,
418};
419
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100420static NetSocketState *net_socket_fd_init_stream(NetClientState *peer,
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000421 const char *model,
422 const char *name,
423 int fd, int is_connected)
424{
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100425 NetClientState *nc;
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000426 NetSocketState *s;
Mark McLoughlin564f63e2009-11-25 18:49:08 +0000427
Stefan Hajnocziab5f3f82012-07-24 16:35:08 +0100428 nc = qemu_new_net_client(&net_socket_info, peer, model, name);
Mark McLoughlin564f63e2009-11-25 18:49:08 +0000429
Laurent Vivier53b85d92022-10-21 11:09:10 +0200430 qemu_set_info_str(nc, "socket: fd=%d", fd);
Jason Wangd89b4f82021-04-02 11:03:12 +0800431
Mark McLoughlin564f63e2009-11-25 18:49:08 +0000432 s = DO_UPCAST(NetSocketState, nc, nc);
433
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000434 s->fd = fd;
Zhi Yong Wu011de2b2012-07-20 14:25:53 +0100435 s->listen_fd = -1;
Zhang Chen3cde5ea2017-07-04 14:53:46 +0800436 net_socket_rs_init(&s->rs, net_socket_rs_finalize, false);
Mark McLoughlin564f63e2009-11-25 18:49:08 +0000437
Stefan Hajnoczi20048d02013-02-27 15:05:47 +0100438 /* Disable Nagle algorithm on TCP sockets to reduce latency */
439 socket_set_nodelay(fd);
440
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000441 if (is_connected) {
442 net_socket_connect(s);
443 } else {
444 qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
445 }
446 return s;
447}
448
Laurent Vivier23455ae2023-06-09 09:27:47 +0200449static int net_socket_fd_check(int fd, Error **errp)
450{
451 int so_type, optlen = sizeof(so_type);
452
453 if (getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type,
454 (socklen_t *)&optlen) < 0) {
455 error_setg(errp, "can't get socket option SO_TYPE");
456 return -1;
457 }
458 if (so_type != SOCK_DGRAM && so_type != SOCK_STREAM) {
459 error_setg(errp, "socket type=%d for fd=%d must be either"
460 " SOCK_DGRAM or SOCK_STREAM", so_type, fd);
461 return -1;
462 }
463 return so_type;
464}
465
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000466static void net_socket_accept(void *opaque)
467{
Zhi Yong Wu011de2b2012-07-20 14:25:53 +0100468 NetSocketState *s = opaque;
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000469 struct sockaddr_in saddr;
470 socklen_t len;
471 int fd;
472
473 for(;;) {
474 len = sizeof(saddr);
Zhi Yong Wu011de2b2012-07-20 14:25:53 +0100475 fd = qemu_accept(s->listen_fd, (struct sockaddr *)&saddr, &len);
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000476 if (fd < 0 && errno != EINTR) {
477 return;
478 } else if (fd >= 0) {
Zhi Yong Wu011de2b2012-07-20 14:25:53 +0100479 qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000480 break;
481 }
482 }
Zhi Yong Wu011de2b2012-07-20 14:25:53 +0100483
484 s->fd = fd;
485 s->nc.link_down = false;
486 net_socket_connect(s);
Laurent Vivier53b85d92022-10-21 11:09:10 +0200487 qemu_set_info_str(&s->nc, "socket: connection from %s:%d",
488 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000489}
490
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100491static int net_socket_listen_init(NetClientState *peer,
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000492 const char *model,
493 const char *name,
Mao Zhongyi0522a952017-09-04 22:35:40 +0800494 const char *host_str,
495 Error **errp)
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000496{
Zhi Yong Wu011de2b2012-07-20 14:25:53 +0100497 NetClientState *nc;
498 NetSocketState *s;
Daniel P. Berrange6701e552017-05-05 17:23:05 +0100499 struct sockaddr_in saddr;
500 int fd, ret;
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000501
Mao Zhongyi0522a952017-09-04 22:35:40 +0800502 if (parse_host_port(&saddr, host_str, errp) < 0) {
Daniel P. Berrange6701e552017-05-05 17:23:05 +0100503 return -1;
Mao Zhongyibcd4dfd2017-09-04 22:35:39 +0800504 }
Daniel P. Berrange6701e552017-05-05 17:23:05 +0100505
506 fd = qemu_socket(PF_INET, SOCK_STREAM, 0);
507 if (fd < 0) {
Mao Zhongyi0522a952017-09-04 22:35:40 +0800508 error_setg_errno(errp, errno, "can't create stream socket");
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000509 return -1;
510 }
Marc-André Lureauff5927b2022-04-25 17:33:47 +0400511 qemu_socket_set_nonblock(fd);
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000512
Daniel P. Berrange6701e552017-05-05 17:23:05 +0100513 socket_set_fast_reuse(fd);
514
515 ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000516 if (ret < 0) {
Mao Zhongyi0522a952017-09-04 22:35:40 +0800517 error_setg_errno(errp, errno, "can't bind ip=%s to socket",
518 inet_ntoa(saddr.sin_addr));
Marc-André Lureau25657fc2023-02-21 16:48:01 +0400519 close(fd);
Daniel P. Berrange6701e552017-05-05 17:23:05 +0100520 return -1;
521 }
522 ret = listen(fd, 0);
523 if (ret < 0) {
Mao Zhongyi0522a952017-09-04 22:35:40 +0800524 error_setg_errno(errp, errno, "can't listen on socket");
Marc-André Lureau25657fc2023-02-21 16:48:01 +0400525 close(fd);
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000526 return -1;
527 }
Zhi Yong Wu011de2b2012-07-20 14:25:53 +0100528
529 nc = qemu_new_net_client(&net_socket_info, peer, model, name);
530 s = DO_UPCAST(NetSocketState, nc, nc);
531 s->fd = -1;
Daniel P. Berrange6701e552017-05-05 17:23:05 +0100532 s->listen_fd = fd;
Zhi Yong Wu011de2b2012-07-20 14:25:53 +0100533 s->nc.link_down = true;
Zhang Chen3cde5ea2017-07-04 14:53:46 +0800534 net_socket_rs_init(&s->rs, net_socket_rs_finalize, false);
Zhi Yong Wu011de2b2012-07-20 14:25:53 +0100535
536 qemu_set_fd_handler(s->listen_fd, net_socket_accept, NULL, s);
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000537 return 0;
538}
539
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100540static int net_socket_connect_init(NetClientState *peer,
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000541 const char *model,
542 const char *name,
Mao Zhongyi0522a952017-09-04 22:35:40 +0800543 const char *host_str,
544 Error **errp)
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000545{
Daniel P. Berrange6701e552017-05-05 17:23:05 +0100546 NetSocketState *s;
547 int fd, connected, ret;
548 struct sockaddr_in saddr;
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000549
Mao Zhongyi0522a952017-09-04 22:35:40 +0800550 if (parse_host_port(&saddr, host_str, errp) < 0) {
Daniel P. Berrange6701e552017-05-05 17:23:05 +0100551 return -1;
Mao Zhongyibcd4dfd2017-09-04 22:35:39 +0800552 }
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000553
Daniel P. Berrange6701e552017-05-05 17:23:05 +0100554 fd = qemu_socket(PF_INET, SOCK_STREAM, 0);
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000555 if (fd < 0) {
Mao Zhongyi0522a952017-09-04 22:35:40 +0800556 error_setg_errno(errp, errno, "can't create stream socket");
Daniel P. Berrange6701e552017-05-05 17:23:05 +0100557 return -1;
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000558 }
Marc-André Lureauff5927b2022-04-25 17:33:47 +0400559 qemu_socket_set_nonblock(fd);
Paolo Bonzini61601832016-08-30 14:04:12 +0200560
Daniel P. Berrange6701e552017-05-05 17:23:05 +0100561 connected = 0;
562 for(;;) {
563 ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
564 if (ret < 0) {
565 if (errno == EINTR || errno == EWOULDBLOCK) {
566 /* continue */
567 } else if (errno == EINPROGRESS ||
Stefano Briviodaf188f2022-10-21 11:09:12 +0200568 errno == EALREADY) {
Daniel P. Berrange6701e552017-05-05 17:23:05 +0100569 break;
570 } else {
Mao Zhongyi0522a952017-09-04 22:35:40 +0800571 error_setg_errno(errp, errno, "can't connect socket");
Marc-André Lureau25657fc2023-02-21 16:48:01 +0400572 close(fd);
Daniel P. Berrange6701e552017-05-05 17:23:05 +0100573 return -1;
574 }
575 } else {
576 connected = 1;
577 break;
578 }
579 }
Laurent Vivier006c3fa2023-06-09 09:27:46 +0200580 s = net_socket_fd_init_stream(peer, model, name, fd, connected);
Mao Zhongyic37f0bb2017-09-04 22:35:38 +0800581 if (!s) {
Daniel P. Berrange6701e552017-05-05 17:23:05 +0100582 return -1;
Mao Zhongyic37f0bb2017-09-04 22:35:38 +0800583 }
584
Laurent Vivier53b85d92022-10-21 11:09:10 +0200585 qemu_set_info_str(&s->nc, "socket: connect to %s:%d",
586 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000587 return 0;
588}
589
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100590static int net_socket_mcast_init(NetClientState *peer,
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000591 const char *model,
592 const char *name,
Mike Ryan3a75e742010-12-01 11:16:47 -0800593 const char *host_str,
Mao Zhongyi0522a952017-09-04 22:35:40 +0800594 const char *localaddr_str,
595 Error **errp)
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000596{
597 NetSocketState *s;
598 int fd;
599 struct sockaddr_in saddr;
Mike Ryan3a75e742010-12-01 11:16:47 -0800600 struct in_addr localaddr, *param_localaddr;
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000601
Mao Zhongyi0522a952017-09-04 22:35:40 +0800602 if (parse_host_port(&saddr, host_str, errp) < 0) {
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000603 return -1;
Mao Zhongyibcd4dfd2017-09-04 22:35:39 +0800604 }
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000605
Mike Ryan3a75e742010-12-01 11:16:47 -0800606 if (localaddr_str != NULL) {
Mao Zhongyi0522a952017-09-04 22:35:40 +0800607 if (inet_aton(localaddr_str, &localaddr) == 0) {
608 error_setg(errp, "localaddr '%s' is not a valid IPv4 address",
609 localaddr_str);
Mike Ryan3a75e742010-12-01 11:16:47 -0800610 return -1;
Mao Zhongyi0522a952017-09-04 22:35:40 +0800611 }
Mike Ryan3a75e742010-12-01 11:16:47 -0800612 param_localaddr = &localaddr;
613 } else {
614 param_localaddr = NULL;
615 }
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000616
Mao Zhongyi0522a952017-09-04 22:35:40 +0800617 fd = net_socket_mcast_create(&saddr, param_localaddr, errp);
Mao Zhongyic37f0bb2017-09-04 22:35:38 +0800618 if (fd < 0) {
Stefan Hajnoczi842480d2011-12-07 15:01:48 +0000619 return -1;
Mao Zhongyic37f0bb2017-09-04 22:35:38 +0800620 }
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000621
Laurent Vivier006c3fa2023-06-09 09:27:46 +0200622 s = net_socket_fd_init_dgram(peer, model, name, fd, 0, NULL, errp);
Mao Zhongyic37f0bb2017-09-04 22:35:38 +0800623 if (!s) {
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000624 return -1;
Mao Zhongyic37f0bb2017-09-04 22:35:38 +0800625 }
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000626
627 s->dgram_dst = saddr;
628
Laurent Vivier53b85d92022-10-21 11:09:10 +0200629 qemu_set_info_str(&s->nc, "socket: mcast=%s:%d",
630 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000631 return 0;
Jason Wangd89b4f82021-04-02 11:03:12 +0800632
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000633}
634
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100635static int net_socket_udp_init(NetClientState *peer,
Benjamin0e0e7fa2012-01-11 09:20:54 +0900636 const char *model,
637 const char *name,
638 const char *rhost,
Mao Zhongyi0522a952017-09-04 22:35:40 +0800639 const char *lhost,
640 Error **errp)
Benjamin0e0e7fa2012-01-11 09:20:54 +0900641{
642 NetSocketState *s;
Sebastian Ottlikbcbe92f2013-10-02 12:23:14 +0200643 int fd, ret;
Benjamin0e0e7fa2012-01-11 09:20:54 +0900644 struct sockaddr_in laddr, raddr;
645
Mao Zhongyi0522a952017-09-04 22:35:40 +0800646 if (parse_host_port(&laddr, lhost, errp) < 0) {
Benjamin0e0e7fa2012-01-11 09:20:54 +0900647 return -1;
648 }
649
Mao Zhongyi0522a952017-09-04 22:35:40 +0800650 if (parse_host_port(&raddr, rhost, errp) < 0) {
Benjamin0e0e7fa2012-01-11 09:20:54 +0900651 return -1;
652 }
653
654 fd = qemu_socket(PF_INET, SOCK_DGRAM, 0);
655 if (fd < 0) {
Mao Zhongyi0522a952017-09-04 22:35:40 +0800656 error_setg_errno(errp, errno, "can't create datagram socket");
Benjamin0e0e7fa2012-01-11 09:20:54 +0900657 return -1;
658 }
Sebastian Ottlikbcbe92f2013-10-02 12:23:14 +0200659
660 ret = socket_set_fast_reuse(fd);
Benjamin0e0e7fa2012-01-11 09:20:54 +0900661 if (ret < 0) {
Mao Zhongyi0522a952017-09-04 22:35:40 +0800662 error_setg_errno(errp, errno,
663 "can't set socket option SO_REUSEADDR");
Marc-André Lureau25657fc2023-02-21 16:48:01 +0400664 close(fd);
Benjamin0e0e7fa2012-01-11 09:20:54 +0900665 return -1;
666 }
667 ret = bind(fd, (struct sockaddr *)&laddr, sizeof(laddr));
668 if (ret < 0) {
Mao Zhongyi0522a952017-09-04 22:35:40 +0800669 error_setg_errno(errp, errno, "can't bind ip=%s to socket",
670 inet_ntoa(laddr.sin_addr));
Marc-André Lureau25657fc2023-02-21 16:48:01 +0400671 close(fd);
Benjamin0e0e7fa2012-01-11 09:20:54 +0900672 return -1;
673 }
Marc-André Lureauff5927b2022-04-25 17:33:47 +0400674 qemu_socket_set_nonblock(fd);
Benjamin0e0e7fa2012-01-11 09:20:54 +0900675
Laurent Vivier006c3fa2023-06-09 09:27:46 +0200676 s = net_socket_fd_init_dgram(peer, model, name, fd, 0, NULL, errp);
Benjamin0e0e7fa2012-01-11 09:20:54 +0900677 if (!s) {
678 return -1;
679 }
680
681 s->dgram_dst = raddr;
682
Laurent Vivier53b85d92022-10-21 11:09:10 +0200683 qemu_set_info_str(&s->nc, "socket: udp=%s:%d", inet_ntoa(raddr.sin_addr),
684 ntohs(raddr.sin_port));
Benjamin0e0e7fa2012-01-11 09:20:54 +0900685 return 0;
686}
687
Kővágó, Zoltáncebea512016-07-13 21:50:12 -0600688int net_init_socket(const Netdev *netdev, const char *name,
Markus Armbrustera30ecde2015-05-15 13:58:50 +0200689 NetClientState *peer, Error **errp)
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000690{
Laszlo Ersekbef8e8f2012-07-17 16:17:17 +0200691 const NetdevSocketOptions *sock;
692
Eric Blakef394b2e2016-07-13 21:50:23 -0600693 assert(netdev->type == NET_CLIENT_DRIVER_SOCKET);
694 sock = &netdev->u.socket;
Laszlo Ersekbef8e8f2012-07-17 16:17:17 +0200695
Markus Armbruster74808742022-11-04 17:07:00 +0100696 if (!!sock->fd + !!sock->listen + !!sock->connect + !!sock->mcast +
697 !!sock->udp != 1) {
Mao Zhongyi0522a952017-09-04 22:35:40 +0800698 error_setg(errp, "exactly one of listen=, connect=, mcast= or udp="
699 " is required");
Laszlo Ersekbef8e8f2012-07-17 16:17:17 +0200700 return -1;
701 }
702
Markus Armbruster74808742022-11-04 17:07:00 +0100703 if (sock->localaddr && !sock->mcast && !sock->udp) {
Mao Zhongyi0522a952017-09-04 22:35:40 +0800704 error_setg(errp, "localaddr= is only valid with mcast= or udp=");
Laszlo Ersekbef8e8f2012-07-17 16:17:17 +0200705 return -1;
706 }
707
Markus Armbruster74808742022-11-04 17:07:00 +0100708 if (sock->fd) {
Laurent Vivierb6aeee02023-06-09 09:27:48 +0200709 int fd, ret, so_type;
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000710
Kevin Wolf947e4742020-10-05 17:58:44 +0200711 fd = monitor_fd_param(monitor_cur(), sock->fd, errp);
Stefan Hajnoczifc13fa02013-03-27 10:10:44 +0100712 if (fd == -1) {
713 return -1;
714 }
Laurent Vivierb6aeee02023-06-09 09:27:48 +0200715 so_type = net_socket_fd_check(fd, errp);
716 if (so_type < 0) {
717 return -1;
718 }
Marc-André Lureauff5927b2022-04-25 17:33:47 +0400719 ret = qemu_socket_try_set_nonblock(fd);
Laurent Vivier894022e2020-07-07 20:45:14 +0200720 if (ret < 0) {
721 error_setg_errno(errp, -ret, "%s: Can't use file descriptor %d",
722 name, fd);
723 return -1;
724 }
Laurent Vivierb6aeee02023-06-09 09:27:48 +0200725 switch (so_type) {
726 case SOCK_DGRAM:
727 if (!net_socket_fd_init_dgram(peer, "socket", name, fd, 1,
728 sock->mcast, errp)) {
729 return -1;
730 }
731 break;
732 case SOCK_STREAM:
733 if (!net_socket_fd_init_stream(peer, "socket", name, fd, 1)) {
734 return -1;
735 }
736 break;
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000737 }
Laszlo Ersekbef8e8f2012-07-17 16:17:17 +0200738 return 0;
739 }
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000740
Markus Armbruster74808742022-11-04 17:07:00 +0100741 if (sock->listen) {
Mao Zhongyi0522a952017-09-04 22:35:40 +0800742 if (net_socket_listen_init(peer, "socket", name, sock->listen, errp)
743 < 0) {
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000744 return -1;
745 }
Laszlo Ersekbef8e8f2012-07-17 16:17:17 +0200746 return 0;
747 }
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000748
Markus Armbruster74808742022-11-04 17:07:00 +0100749 if (sock->connect) {
Mao Zhongyi0522a952017-09-04 22:35:40 +0800750 if (net_socket_connect_init(peer, "socket", name, sock->connect, errp)
751 < 0) {
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000752 return -1;
753 }
Laszlo Ersekbef8e8f2012-07-17 16:17:17 +0200754 return 0;
755 }
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000756
Markus Armbruster74808742022-11-04 17:07:00 +0100757 if (sock->mcast) {
Laszlo Ersekbef8e8f2012-07-17 16:17:17 +0200758 /* if sock->localaddr is missing, it has been initialized to "all bits
759 * zero" */
Stefan Hajnoczid33d93b2012-07-24 16:35:05 +0100760 if (net_socket_mcast_init(peer, "socket", name, sock->mcast,
Mao Zhongyi0522a952017-09-04 22:35:40 +0800761 sock->localaddr, errp) < 0) {
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000762 return -1;
763 }
Laszlo Ersekbef8e8f2012-07-17 16:17:17 +0200764 return 0;
765 }
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000766
Markus Armbruster74808742022-11-04 17:07:00 +0100767 assert(sock->udp);
768 if (!sock->localaddr) {
Mao Zhongyi0522a952017-09-04 22:35:40 +0800769 error_setg(errp, "localaddr= is mandatory with udp=");
Laszlo Ersekbef8e8f2012-07-17 16:17:17 +0200770 return -1;
771 }
Mao Zhongyi0522a952017-09-04 22:35:40 +0800772 if (net_socket_udp_init(peer, "socket", name, sock->udp, sock->localaddr,
773 errp) < 0) {
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000774 return -1;
775 }
Mark McLoughlin42281ac2009-11-25 18:48:56 +0000776 return 0;
777}