]> git.proxmox.com Git - mirror_qemu.git/blame - net.c
target-mips: Pass MIPSCPU to mips_vpe_is_wfi()
[mirror_qemu.git] / net.c
CommitLineData
63a01ef8
AL
1/*
2 * QEMU System Emulator
3 *
4 * Copyright (c) 2003-2008 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
d40cdb10
BS
24#include "config-host.h"
25
a245fc18
PB
26#include "net.h"
27#include "net/clients.h"
f6c874e3 28#include "net/hub.h"
a245fc18 29#include "net/slirp.h"
f1d078c3 30#include "net/util.h"
a245fc18 31
511d2b14 32#include "monitor.h"
1df49e04 33#include "qemu-common.h"
511d2b14 34#include "qemu_socket.h"
4b37156c 35#include "qmp-commands.h"
75422b0d 36#include "hw/qdev.h"
ce053661 37#include "iov.h"
6687b79d
LE
38#include "qapi-visit.h"
39#include "qapi/opts-visitor.h"
40#include "qapi/qapi-dealloc-visitor.h"
511d2b14 41
2944e4ec
SW
42/* Net bridge is currently not supported for W32. */
43#if !defined(_WIN32)
44# define CONFIG_NET_BRIDGE
45#endif
46
4e68f7a0 47static QTAILQ_HEAD(, NetClientState) net_clients;
63a01ef8 48
cb4522cc
GH
49int default_net = 1;
50
63a01ef8
AL
51/***********************************************************/
52/* network device redirectors */
53
68ac40d2 54#if defined(DEBUG_NET)
63a01ef8
AL
55static void hex_dump(FILE *f, const uint8_t *buf, int size)
56{
57 int len, i, j, c;
58
59 for(i=0;i<size;i+=16) {
60 len = size - i;
61 if (len > 16)
62 len = 16;
63 fprintf(f, "%08x ", i);
64 for(j=0;j<16;j++) {
65 if (j < len)
66 fprintf(f, " %02x", buf[i+j]);
67 else
68 fprintf(f, " ");
69 }
70 fprintf(f, " ");
71 for(j=0;j<len;j++) {
72 c = buf[i+j];
73 if (c < ' ' || c > '~')
74 c = '.';
75 fprintf(f, "%c", c);
76 }
77 fprintf(f, "\n");
78 }
79}
80#endif
81
63a01ef8
AL
82static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
83{
84 const char *p, *p1;
85 int len;
86 p = *pp;
87 p1 = strchr(p, sep);
88 if (!p1)
89 return -1;
90 len = p1 - p;
91 p1++;
92 if (buf_size > 0) {
93 if (len > buf_size - 1)
94 len = buf_size - 1;
95 memcpy(buf, p, len);
96 buf[len] = '\0';
97 }
98 *pp = p1;
99 return 0;
100}
101
63a01ef8
AL
102int parse_host_port(struct sockaddr_in *saddr, const char *str)
103{
104 char buf[512];
105 struct hostent *he;
106 const char *p, *r;
107 int port;
108
109 p = str;
110 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
111 return -1;
112 saddr->sin_family = AF_INET;
113 if (buf[0] == '\0') {
114 saddr->sin_addr.s_addr = 0;
115 } else {
cd390083 116 if (qemu_isdigit(buf[0])) {
63a01ef8
AL
117 if (!inet_aton(buf, &saddr->sin_addr))
118 return -1;
119 } else {
120 if ((he = gethostbyname(buf)) == NULL)
121 return - 1;
122 saddr->sin_addr = *(struct in_addr *)he->h_addr;
123 }
124 }
125 port = strtol(p, (char **)&r, 0);
126 if (r == p)
127 return -1;
128 saddr->sin_port = htons(port);
129 return 0;
130}
131
35277d14 132void qemu_format_nic_info_str(NetClientState *nc, uint8_t macaddr[6])
7cb7434b 133{
35277d14 134 snprintf(nc->info_str, sizeof(nc->info_str),
4dda4063 135 "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
35277d14 136 nc->model,
7cb7434b
AL
137 macaddr[0], macaddr[1], macaddr[2],
138 macaddr[3], macaddr[4], macaddr[5]);
139}
140
76d32cba
GH
141void qemu_macaddr_default_if_unset(MACAddr *macaddr)
142{
143 static int index = 0;
144 static const MACAddr zero = { .a = { 0,0,0,0,0,0 } };
145
146 if (memcmp(macaddr, &zero, sizeof(zero)) != 0)
147 return;
148 macaddr->a[0] = 0x52;
149 macaddr->a[1] = 0x54;
150 macaddr->a[2] = 0x00;
151 macaddr->a[3] = 0x12;
152 macaddr->a[4] = 0x34;
153 macaddr->a[5] = 0x56 + index++;
154}
155
d33d93b2
SH
156/**
157 * Generate a name for net client
158 *
159 * Only net clients created with the legacy -net option need this. Naming is
160 * mandatory for net clients created with -netdev.
161 */
35277d14 162static char *assign_name(NetClientState *nc1, const char *model)
676cff29 163{
35277d14 164 NetClientState *nc;
676cff29
AL
165 char buf[256];
166 int id = 0;
167
35277d14
SH
168 QTAILQ_FOREACH(nc, &net_clients, next) {
169 if (nc == nc1) {
d33d93b2 170 continue;
5610c3aa 171 }
d33d93b2 172 /* For compatibility only bump id for net clients on a vlan */
35277d14
SH
173 if (strcmp(nc->model, model) == 0 &&
174 net_hub_id_for_client(nc, NULL) == 0) {
53e51d85
MA
175 id++;
176 }
177 }
178
676cff29
AL
179 snprintf(buf, sizeof(buf), "%s.%d", model, id);
180
7267c094 181 return g_strdup(buf);
676cff29
AL
182}
183
4e68f7a0
SH
184NetClientState *qemu_new_net_client(NetClientInfo *info,
185 NetClientState *peer,
186 const char *model,
187 const char *name)
63a01ef8 188{
35277d14 189 NetClientState *nc;
5610c3aa 190
4e68f7a0 191 assert(info->size >= sizeof(NetClientState));
45460d1a 192
35277d14 193 nc = g_malloc0(info->size);
5610c3aa 194
35277d14
SH
195 nc->info = info;
196 nc->model = g_strdup(model);
45460d1a 197 if (name) {
35277d14 198 nc->name = g_strdup(name);
45460d1a 199 } else {
35277d14 200 nc->name = assign_name(nc, model);
45460d1a 201 }
5610c3aa 202
ab5f3f84
SH
203 if (peer) {
204 assert(!peer->peer);
35277d14
SH
205 nc->peer = peer;
206 peer->peer = nc;
d80b9fc6 207 }
35277d14 208 QTAILQ_INSERT_TAIL(&net_clients, nc, next);
63a01ef8 209
86a77c38 210 nc->send_queue = qemu_new_net_queue(nc);
63a01ef8 211
35277d14 212 return nc;
63a01ef8
AL
213}
214
ebef2c09
MM
215NICState *qemu_new_nic(NetClientInfo *info,
216 NICConf *conf,
217 const char *model,
218 const char *name,
219 void *opaque)
220{
4e68f7a0 221 NetClientState *nc;
ebef2c09
MM
222 NICState *nic;
223
2be64a68 224 assert(info->type == NET_CLIENT_OPTIONS_KIND_NIC);
ebef2c09
MM
225 assert(info->size >= sizeof(NICState));
226
ab5f3f84 227 nc = qemu_new_net_client(info, conf->peer, model, name);
ebef2c09
MM
228
229 nic = DO_UPCAST(NICState, nc, nc);
230 nic->conf = conf;
231 nic->opaque = opaque;
232
233 return nic;
234}
235
b20c6b9e 236static void qemu_cleanup_net_client(NetClientState *nc)
63a01ef8 237{
35277d14 238 QTAILQ_REMOVE(&net_clients, nc, next);
63a01ef8 239
35277d14
SH
240 if (nc->info->cleanup) {
241 nc->info->cleanup(nc);
5610c3aa 242 }
a083a89d 243}
5610c3aa 244
b20c6b9e 245static void qemu_free_net_client(NetClientState *nc)
a083a89d 246{
35277d14
SH
247 if (nc->send_queue) {
248 qemu_del_net_queue(nc->send_queue);
a005d073 249 }
35277d14
SH
250 if (nc->peer) {
251 nc->peer->peer = NULL;
a083a89d 252 }
35277d14
SH
253 g_free(nc->name);
254 g_free(nc->model);
255 g_free(nc);
63a01ef8
AL
256}
257
b20c6b9e 258void qemu_del_net_client(NetClientState *nc)
a083a89d
MT
259{
260 /* If there is a peer NIC, delete and cleanup client, but do not free. */
35277d14
SH
261 if (nc->peer && nc->peer->info->type == NET_CLIENT_OPTIONS_KIND_NIC) {
262 NICState *nic = DO_UPCAST(NICState, nc, nc->peer);
a083a89d
MT
263 if (nic->peer_deleted) {
264 return;
265 }
266 nic->peer_deleted = true;
267 /* Let NIC know peer is gone. */
35277d14
SH
268 nc->peer->link_down = true;
269 if (nc->peer->info->link_status_changed) {
270 nc->peer->info->link_status_changed(nc->peer);
a083a89d 271 }
b20c6b9e 272 qemu_cleanup_net_client(nc);
a083a89d
MT
273 return;
274 }
275
276 /* If this is a peer NIC and peer has already been deleted, free it now. */
35277d14
SH
277 if (nc->peer && nc->info->type == NET_CLIENT_OPTIONS_KIND_NIC) {
278 NICState *nic = DO_UPCAST(NICState, nc, nc);
a083a89d 279 if (nic->peer_deleted) {
b20c6b9e 280 qemu_free_net_client(nc->peer);
1a609520
JK
281 }
282 }
1a609520 283
b20c6b9e
SH
284 qemu_cleanup_net_client(nc);
285 qemu_free_net_client(nc);
1a609520
JK
286}
287
57f9ef17
MM
288void qemu_foreach_nic(qemu_nic_foreach func, void *opaque)
289{
4e68f7a0 290 NetClientState *nc;
57f9ef17 291
94878994 292 QTAILQ_FOREACH(nc, &net_clients, next) {
2be64a68 293 if (nc->info->type == NET_CLIENT_OPTIONS_KIND_NIC) {
57f9ef17
MM
294 func(DO_UPCAST(NICState, nc, nc), opaque);
295 }
296 }
57f9ef17
MM
297}
298
4e68f7a0 299int qemu_can_send_packet(NetClientState *sender)
63a01ef8 300{
a005d073 301 if (!sender->peer) {
d80b9fc6
MM
302 return 1;
303 }
304
a005d073
SH
305 if (sender->peer->receive_disabled) {
306 return 0;
307 } else if (sender->peer->info->can_receive &&
308 !sender->peer->info->can_receive(sender->peer)) {
309 return 0;
63a01ef8 310 }
60c07d93 311 return 1;
63a01ef8
AL
312}
313
86a77c38
ZYW
314ssize_t qemu_deliver_packet(NetClientState *sender,
315 unsigned flags,
316 const uint8_t *data,
317 size_t size,
318 void *opaque)
9a6ecb30 319{
35277d14 320 NetClientState *nc = opaque;
893379ef 321 ssize_t ret;
9a6ecb30 322
35277d14 323 if (nc->link_down) {
9a6ecb30
MM
324 return size;
325 }
326
35277d14 327 if (nc->receive_disabled) {
893379ef
MM
328 return 0;
329 }
330
35277d14
SH
331 if (flags & QEMU_NET_PACKET_FLAG_RAW && nc->info->receive_raw) {
332 ret = nc->info->receive_raw(nc, data, size);
893379ef 333 } else {
35277d14 334 ret = nc->info->receive(nc, data, size);
893379ef
MM
335 }
336
337 if (ret == 0) {
35277d14 338 nc->receive_disabled = 1;
893379ef
MM
339 };
340
341 return ret;
9a6ecb30
MM
342}
343
35277d14 344void qemu_purge_queued_packets(NetClientState *nc)
8cad5516 345{
35277d14 346 if (!nc->peer) {
d80b9fc6 347 return;
9a6ecb30 348 }
d80b9fc6 349
35277d14 350 qemu_net_queue_purge(nc->peer->send_queue, nc);
8cad5516
MM
351}
352
35277d14 353void qemu_flush_queued_packets(NetClientState *nc)
e94667b9 354{
35277d14 355 nc->receive_disabled = 0;
9a6ecb30 356
987a9b48
PB
357 if (qemu_net_queue_flush(nc->send_queue)) {
358 /* We emptied the queue successfully, signal to the IO thread to repoll
359 * the file descriptor (for tap, for example).
360 */
361 qemu_notify_event();
362 }
e94667b9
MM
363}
364
4e68f7a0 365static ssize_t qemu_send_packet_async_with_flags(NetClientState *sender,
ca77d175
MM
366 unsigned flags,
367 const uint8_t *buf, int size,
368 NetPacketSent *sent_cb)
764a4d1d 369{
9a6ecb30 370 NetQueue *queue;
436e5e53 371
63a01ef8 372#ifdef DEBUG_NET
d80b9fc6 373 printf("qemu_send_packet_async:\n");
63a01ef8
AL
374 hex_dump(stdout, buf, size);
375#endif
f3b6c7fc 376
a005d073 377 if (sender->link_down || !sender->peer) {
9a6ecb30
MM
378 return size;
379 }
380
a005d073 381 queue = sender->peer->send_queue;
9a6ecb30 382
ca77d175
MM
383 return qemu_net_queue_send(queue, sender, flags, buf, size, sent_cb);
384}
385
4e68f7a0 386ssize_t qemu_send_packet_async(NetClientState *sender,
ca77d175
MM
387 const uint8_t *buf, int size,
388 NetPacketSent *sent_cb)
389{
390 return qemu_send_packet_async_with_flags(sender, QEMU_NET_PACKET_FLAG_NONE,
391 buf, size, sent_cb);
f3b6c7fc
MM
392}
393
35277d14 394void qemu_send_packet(NetClientState *nc, const uint8_t *buf, int size)
f3b6c7fc 395{
35277d14 396 qemu_send_packet_async(nc, buf, size, NULL);
63a01ef8
AL
397}
398
35277d14 399ssize_t qemu_send_packet_raw(NetClientState *nc, const uint8_t *buf, int size)
ca77d175 400{
35277d14 401 return qemu_send_packet_async_with_flags(nc, QEMU_NET_PACKET_FLAG_RAW,
ca77d175
MM
402 buf, size, NULL);
403}
404
35277d14 405static ssize_t nc_sendv_compat(NetClientState *nc, const struct iovec *iov,
fbe78f4f
AL
406 int iovcnt)
407{
408 uint8_t buffer[4096];
ce053661 409 size_t offset;
fbe78f4f 410
dcf6f5e1 411 offset = iov_to_buf(iov, iovcnt, 0, buffer, sizeof(buffer));
fbe78f4f 412
35277d14 413 return nc->info->receive(nc, buffer, offset);
fbe78f4f
AL
414}
415
86a77c38
ZYW
416ssize_t qemu_deliver_packet_iov(NetClientState *sender,
417 unsigned flags,
418 const struct iovec *iov,
419 int iovcnt,
420 void *opaque)
9a6ecb30 421{
35277d14 422 NetClientState *nc = opaque;
c67f5dc1 423 int ret;
9a6ecb30 424
35277d14 425 if (nc->link_down) {
ce053661 426 return iov_size(iov, iovcnt);
9a6ecb30
MM
427 }
428
c67f5dc1
SH
429 if (nc->receive_disabled) {
430 return 0;
431 }
432
35277d14 433 if (nc->info->receive_iov) {
c67f5dc1 434 ret = nc->info->receive_iov(nc, iov, iovcnt);
9a6ecb30 435 } else {
c67f5dc1
SH
436 ret = nc_sendv_compat(nc, iov, iovcnt);
437 }
438
439 if (ret == 0) {
440 nc->receive_disabled = 1;
e94667b9 441 }
c67f5dc1
SH
442
443 return ret;
e94667b9
MM
444}
445
4e68f7a0 446ssize_t qemu_sendv_packet_async(NetClientState *sender,
f3b6c7fc
MM
447 const struct iovec *iov, int iovcnt,
448 NetPacketSent *sent_cb)
e94667b9 449{
9a6ecb30
MM
450 NetQueue *queue;
451
a005d073 452 if (sender->link_down || !sender->peer) {
ce053661 453 return iov_size(iov, iovcnt);
e94667b9
MM
454 }
455
a005d073 456 queue = sender->peer->send_queue;
9a6ecb30 457
c0b8e49c
MM
458 return qemu_net_queue_send_iov(queue, sender,
459 QEMU_NET_PACKET_FLAG_NONE,
460 iov, iovcnt, sent_cb);
fbe78f4f
AL
461}
462
f3b6c7fc 463ssize_t
35277d14 464qemu_sendv_packet(NetClientState *nc, const struct iovec *iov, int iovcnt)
f3b6c7fc 465{
35277d14 466 return qemu_sendv_packet_async(nc, iov, iovcnt, NULL);
63a01ef8
AL
467}
468
4e68f7a0 469NetClientState *qemu_find_netdev(const char *id)
5869c4d5 470{
35277d14 471 NetClientState *nc;
5869c4d5 472
35277d14
SH
473 QTAILQ_FOREACH(nc, &net_clients, next) {
474 if (nc->info->type == NET_CLIENT_OPTIONS_KIND_NIC)
85dde9a9 475 continue;
35277d14
SH
476 if (!strcmp(nc->name, id)) {
477 return nc;
5869c4d5
MM
478 }
479 }
480
481 return NULL;
482}
483
7697079b
AL
484static int nic_get_free_idx(void)
485{
486 int index;
487
488 for (index = 0; index < MAX_NICS; index++)
489 if (!nd_table[index].used)
490 return index;
491 return -1;
492}
493
07caea31
MA
494int qemu_show_nic_models(const char *arg, const char *const *models)
495{
496 int i;
497
c8057f95 498 if (!arg || !is_help_option(arg)) {
07caea31 499 return 0;
c8057f95 500 }
07caea31
MA
501
502 fprintf(stderr, "qemu: Supported NIC models: ");
503 for (i = 0 ; models[i]; i++)
504 fprintf(stderr, "%s%c", models[i], models[i+1] ? ',' : '\n');
505 return 1;
506}
507
d07f22c5
AL
508void qemu_check_nic_model(NICInfo *nd, const char *model)
509{
510 const char *models[2];
511
512 models[0] = model;
513 models[1] = NULL;
514
07caea31
MA
515 if (qemu_show_nic_models(nd->model, models))
516 exit(0);
517 if (qemu_find_nic_model(nd, models, model) < 0)
518 exit(1);
d07f22c5
AL
519}
520
07caea31
MA
521int qemu_find_nic_model(NICInfo *nd, const char * const *models,
522 const char *default_model)
d07f22c5 523{
07caea31 524 int i;
d07f22c5
AL
525
526 if (!nd->model)
7267c094 527 nd->model = g_strdup(default_model);
d07f22c5 528
07caea31
MA
529 for (i = 0 ; models[i]; i++) {
530 if (strcmp(nd->model, models[i]) == 0)
531 return i;
d07f22c5
AL
532 }
533
6daf194d 534 error_report("Unsupported NIC model: %s", nd->model);
07caea31 535 return -1;
d07f22c5
AL
536}
537
1a0c0958 538static int net_init_nic(const NetClientOptions *opts, const char *name,
4e68f7a0 539 NetClientState *peer)
f83c6e10
MM
540{
541 int idx;
542 NICInfo *nd;
2456f36f
LE
543 const NetLegacyNicOptions *nic;
544
545 assert(opts->kind == NET_CLIENT_OPTIONS_KIND_NIC);
546 nic = opts->nic;
f83c6e10
MM
547
548 idx = nic_get_free_idx();
549 if (idx == -1 || nb_nics >= MAX_NICS) {
1ecda02b 550 error_report("Too Many NICs");
f83c6e10
MM
551 return -1;
552 }
553
554 nd = &nd_table[idx];
555
556 memset(nd, 0, sizeof(*nd));
557
2456f36f
LE
558 if (nic->has_netdev) {
559 nd->netdev = qemu_find_netdev(nic->netdev);
5869c4d5 560 if (!nd->netdev) {
2456f36f 561 error_report("netdev '%s' not found", nic->netdev);
5869c4d5
MM
562 return -1;
563 }
564 } else {
d33d93b2
SH
565 assert(peer);
566 nd->netdev = peer;
5869c4d5 567 }
6d952ebe 568 if (name) {
7267c094 569 nd->name = g_strdup(name);
6d952ebe 570 }
2456f36f
LE
571 if (nic->has_model) {
572 nd->model = g_strdup(nic->model);
f83c6e10 573 }
2456f36f
LE
574 if (nic->has_addr) {
575 nd->devaddr = g_strdup(nic->addr);
f83c6e10
MM
576 }
577
2456f36f
LE
578 if (nic->has_macaddr &&
579 net_parse_macaddr(nd->macaddr.a, nic->macaddr) < 0) {
1ecda02b 580 error_report("invalid syntax for ethernet address");
f83c6e10
MM
581 return -1;
582 }
6eed1856 583 qemu_macaddr_default_if_unset(&nd->macaddr);
f83c6e10 584
2456f36f
LE
585 if (nic->has_vectors) {
586 if (nic->vectors > 0x7ffffff) {
587 error_report("invalid # of vectors: %"PRIu32, nic->vectors);
588 return -1;
589 }
590 nd->nvectors = nic->vectors;
591 } else {
592 nd->nvectors = DEV_NVECTORS_UNSPECIFIED;
f83c6e10
MM
593 }
594
595 nd->used = 1;
f83c6e10
MM
596 nb_nics++;
597
598 return idx;
599}
600
6687b79d
LE
601
602static int (* const net_client_init_fun[NET_CLIENT_OPTIONS_KIND_MAX])(
1a0c0958 603 const NetClientOptions *opts,
6687b79d 604 const char *name,
4e68f7a0 605 NetClientState *peer) = {
f6c874e3 606 [NET_CLIENT_OPTIONS_KIND_NIC] = net_init_nic,
ec302ffd 607#ifdef CONFIG_SLIRP
f6c874e3 608 [NET_CLIENT_OPTIONS_KIND_USER] = net_init_slirp,
2944e4ec 609#endif
f6c874e3
SH
610 [NET_CLIENT_OPTIONS_KIND_TAP] = net_init_tap,
611 [NET_CLIENT_OPTIONS_KIND_SOCKET] = net_init_socket,
dd51058d 612#ifdef CONFIG_VDE
f6c874e3 613 [NET_CLIENT_OPTIONS_KIND_VDE] = net_init_vde,
dd51058d 614#endif
f6c874e3 615 [NET_CLIENT_OPTIONS_KIND_DUMP] = net_init_dump,
2944e4ec 616#ifdef CONFIG_NET_BRIDGE
f6c874e3 617 [NET_CLIENT_OPTIONS_KIND_BRIDGE] = net_init_bridge,
6687b79d 618#endif
f6c874e3 619 [NET_CLIENT_OPTIONS_KIND_HUBPORT] = net_init_hubport,
f83c6e10
MM
620};
621
6687b79d 622
1a0c0958 623static int net_client_init1(const void *object, int is_netdev, Error **errp)
f83c6e10 624{
6687b79d
LE
625 union {
626 const Netdev *netdev;
627 const NetLegacy *net;
628 } u;
629 const NetClientOptions *opts;
6d952ebe 630 const char *name;
f83c6e10 631
5294e2c7 632 if (is_netdev) {
6687b79d
LE
633 u.netdev = object;
634 opts = u.netdev->opts;
635 name = u.netdev->id;
636
637 switch (opts->kind) {
f6b134ac 638#ifdef CONFIG_SLIRP
6687b79d 639 case NET_CLIENT_OPTIONS_KIND_USER:
f6b134ac 640#endif
6687b79d
LE
641 case NET_CLIENT_OPTIONS_KIND_TAP:
642 case NET_CLIENT_OPTIONS_KIND_SOCKET:
f6b134ac 643#ifdef CONFIG_VDE
6687b79d
LE
644 case NET_CLIENT_OPTIONS_KIND_VDE:
645#endif
646#ifdef CONFIG_NET_BRIDGE
647 case NET_CLIENT_OPTIONS_KIND_BRIDGE:
f6b134ac 648#endif
f6c874e3 649 case NET_CLIENT_OPTIONS_KIND_HUBPORT:
6687b79d
LE
650 break;
651
652 default:
4559a1db
LC
653 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "type",
654 "a netdev backend type");
f6b134ac
MM
655 return -1;
656 }
6687b79d
LE
657 } else {
658 u.net = object;
659 opts = u.net->opts;
660 /* missing optional values have been initialized to "all bits zero" */
661 name = u.net->has_id ? u.net->id : u.net->name;
662 }
f6b134ac 663
6687b79d 664 if (net_client_init_fun[opts->kind]) {
4e68f7a0 665 NetClientState *peer = NULL;
6687b79d
LE
666
667 /* Do not add to a vlan if it's a -netdev or a nic with a netdev=
668 * parameter. */
669 if (!is_netdev &&
670 (opts->kind != NET_CLIENT_OPTIONS_KIND_NIC ||
671 !opts->nic->has_netdev)) {
d33d93b2 672 peer = net_hub_add_port(u.net->has_vlan ? u.net->vlan : 0, NULL);
f6b134ac 673 }
6687b79d 674
d33d93b2 675 if (net_client_init_fun[opts->kind](opts, name, peer) < 0) {
6687b79d
LE
676 /* TODO push error reporting into init() methods */
677 error_set(errp, QERR_DEVICE_INIT_FAILED,
678 NetClientOptionsKind_lookup[opts->kind]);
f6b134ac
MM
679 return -1;
680 }
681 }
6687b79d
LE
682 return 0;
683}
684
f6b134ac 685
6687b79d
LE
686static void net_visit(Visitor *v, int is_netdev, void **object, Error **errp)
687{
688 if (is_netdev) {
689 visit_type_Netdev(v, (Netdev **)object, NULL, errp);
690 } else {
691 visit_type_NetLegacy(v, (NetLegacy **)object, NULL, errp);
6d952ebe 692 }
6687b79d 693}
6d952ebe 694
f6b134ac 695
6687b79d
LE
696int net_client_init(QemuOpts *opts, int is_netdev, Error **errp)
697{
698 void *object = NULL;
699 Error *err = NULL;
700 int ret = -1;
f83c6e10 701
6687b79d
LE
702 {
703 OptsVisitor *ov = opts_visitor_new(opts);
f6b134ac 704
6687b79d
LE
705 net_visit(opts_get_visitor(ov), is_netdev, &object, &err);
706 opts_visitor_cleanup(ov);
f83c6e10
MM
707 }
708
6687b79d 709 if (!err) {
1a0c0958 710 ret = net_client_init1(object, is_netdev, &err);
6687b79d
LE
711 }
712
713 if (object) {
714 QapiDeallocVisitor *dv = qapi_dealloc_visitor_new();
715
716 net_visit(qapi_dealloc_get_visitor(dv), is_netdev, &object, NULL);
717 qapi_dealloc_visitor_cleanup(dv);
718 }
719
720 error_propagate(errp, err);
721 return ret;
f83c6e10
MM
722}
723
6687b79d 724
6f338c34
AL
725static int net_host_check_device(const char *device)
726{
727 int i;
bb9ea79e 728 const char *valid_param_list[] = { "tap", "socket", "dump"
2944e4ec
SW
729#ifdef CONFIG_NET_BRIDGE
730 , "bridge"
731#endif
6f338c34
AL
732#ifdef CONFIG_SLIRP
733 ,"user"
734#endif
735#ifdef CONFIG_VDE
736 ,"vde"
737#endif
738 };
739 for (i = 0; i < sizeof(valid_param_list) / sizeof(char *); i++) {
740 if (!strncmp(valid_param_list[i], device,
741 strlen(valid_param_list[i])))
742 return 1;
743 }
744
745 return 0;
746}
747
f18c16de 748void net_host_device_add(Monitor *mon, const QDict *qdict)
6f338c34 749{
f18c16de 750 const char *device = qdict_get_str(qdict, "device");
7f1c9d20 751 const char *opts_str = qdict_get_try_str(qdict, "opts");
4559a1db 752 Error *local_err = NULL;
7f1c9d20 753 QemuOpts *opts;
f18c16de 754
6f338c34 755 if (!net_host_check_device(device)) {
376253ec 756 monitor_printf(mon, "invalid host network device %s\n", device);
6f338c34
AL
757 return;
758 }
7f1c9d20 759
3329f07b 760 opts = qemu_opts_parse(qemu_find_opts("net"), opts_str ? opts_str : "", 0);
7f1c9d20 761 if (!opts) {
7f1c9d20
MM
762 return;
763 }
764
765 qemu_opt_set(opts, "type", device);
766
4559a1db
LC
767 net_client_init(opts, 0, &local_err);
768 if (error_is_set(&local_err)) {
769 qerror_report_err(local_err);
770 error_free(local_err);
5c8be678
AL
771 monitor_printf(mon, "adding host network device %s failed\n", device);
772 }
6f338c34
AL
773}
774
f18c16de 775void net_host_device_remove(Monitor *mon, const QDict *qdict)
6f338c34 776{
35277d14 777 NetClientState *nc;
f18c16de
LC
778 int vlan_id = qdict_get_int(qdict, "vlan_id");
779 const char *device = qdict_get_str(qdict, "device");
6f338c34 780
35277d14
SH
781 nc = net_hub_find_client_by_name(vlan_id, device);
782 if (!nc) {
6f338c34
AL
783 return;
784 }
35277d14 785 if (!net_host_check_device(nc->model)) {
e8f1f9db
AL
786 monitor_printf(mon, "invalid host network device %s\n", device);
787 return;
788 }
b20c6b9e 789 qemu_del_net_client(nc);
6f338c34
AL
790}
791
928059a3
LC
792void netdev_add(QemuOpts *opts, Error **errp)
793{
794 net_client_init(opts, 1, errp);
795}
796
797int qmp_netdev_add(Monitor *mon, const QDict *qdict, QObject **ret)
ae82d324 798{
4e89978e 799 Error *local_err = NULL;
928059a3 800 QemuOptsList *opts_list;
ae82d324 801 QemuOpts *opts;
ae82d324 802
928059a3
LC
803 opts_list = qemu_find_opts_err("netdev", &local_err);
804 if (error_is_set(&local_err)) {
805 goto exit_err;
ae82d324
MA
806 }
807
928059a3
LC
808 opts = qemu_opts_from_qdict(opts_list, qdict, &local_err);
809 if (error_is_set(&local_err)) {
810 goto exit_err;
811 }
812
813 netdev_add(opts, &local_err);
814 if (error_is_set(&local_err)) {
410cbafe 815 qemu_opts_del(opts);
928059a3 816 goto exit_err;
410cbafe
YT
817 }
818
928059a3
LC
819 return 0;
820
821exit_err:
822 qerror_report_err(local_err);
823 error_free(local_err);
824 return -1;
ae82d324
MA
825}
826
5f964155 827void qmp_netdev_del(const char *id, Error **errp)
ae82d324 828{
35277d14 829 NetClientState *nc;
ae82d324 830
35277d14
SH
831 nc = qemu_find_netdev(id);
832 if (!nc) {
5f964155
LC
833 error_set(errp, QERR_DEVICE_NOT_FOUND, id);
834 return;
ae82d324 835 }
5f964155 836
b20c6b9e 837 qemu_del_net_client(nc);
5f964155 838 qemu_opts_del(qemu_opts_find(qemu_find_opts_err("netdev", errp), id));
ae82d324
MA
839}
840
1a859593 841void print_net_client(Monitor *mon, NetClientState *nc)
44e798d3 842{
35277d14
SH
843 monitor_printf(mon, "%s: type=%s,%s\n", nc->name,
844 NetClientOptionsKind_lookup[nc->info->type], nc->info_str);
44e798d3
JK
845}
846
376253ec 847void do_info_network(Monitor *mon)
63a01ef8 848{
35277d14 849 NetClientState *nc, *peer;
2be64a68 850 NetClientOptionsKind type;
63a01ef8 851
1a859593
ZYW
852 net_hub_info(mon);
853
35277d14
SH
854 QTAILQ_FOREACH(nc, &net_clients, next) {
855 peer = nc->peer;
856 type = nc->info->type;
5610c3aa 857
1a859593
ZYW
858 /* Skip if already printed in hub info */
859 if (net_hub_id_for_client(nc, NULL) == 0) {
860 continue;
5610c3aa 861 }
1a859593 862
2be64a68 863 if (!peer || type == NET_CLIENT_OPTIONS_KIND_NIC) {
35277d14 864 print_net_client(mon, nc);
19061e63 865 } /* else it's a netdev connected to a NIC, printed with the NIC */
2be64a68 866 if (peer && type == NET_CLIENT_OPTIONS_KIND_NIC) {
1a859593 867 monitor_printf(mon, " \\ ");
44e798d3 868 print_net_client(mon, peer);
a0104e0e 869 }
a0104e0e 870 }
63a01ef8
AL
871}
872
4b37156c 873void qmp_set_link(const char *name, bool up, Error **errp)
436e5e53 874{
35277d14 875 NetClientState *nc = NULL;
436e5e53 876
35277d14
SH
877 QTAILQ_FOREACH(nc, &net_clients, next) {
878 if (!strcmp(nc->name, name)) {
85dde9a9
MA
879 goto done;
880 }
881 }
dd5de373 882done:
35277d14 883 if (!nc) {
4b37156c
LC
884 error_set(errp, QERR_DEVICE_NOT_FOUND, name);
885 return;
436e5e53
AL
886 }
887
35277d14 888 nc->link_down = !up;
436e5e53 889
35277d14
SH
890 if (nc->info->link_status_changed) {
891 nc->info->link_status_changed(nc);
665a3b07 892 }
ab1cbe1c
MT
893
894 /* Notify peer. Don't update peer link status: this makes it possible to
895 * disconnect from host network without notifying the guest.
896 * FIXME: is disconnected link status change operation useful?
897 *
898 * Current behaviour is compatible with qemu vlans where there could be
899 * multiple clients that can still communicate with each other in
900 * disconnected mode. For now maintain this compatibility. */
35277d14
SH
901 if (nc->peer && nc->peer->info->link_status_changed) {
902 nc->peer->info->link_status_changed(nc->peer);
ab1cbe1c 903 }
436e5e53
AL
904}
905
63a01ef8
AL
906void net_cleanup(void)
907{
35277d14 908 NetClientState *nc, *next_vc;
577c4af9 909
35277d14 910 QTAILQ_FOREACH_SAFE(nc, &net_clients, next, next_vc) {
b20c6b9e 911 qemu_del_net_client(nc);
577c4af9 912 }
63a01ef8
AL
913}
914
668680f7 915void net_check_clients(void)
63a01ef8 916{
35277d14 917 NetClientState *nc;
48e2faf2 918 int i;
63a01ef8 919
641f6eae
PM
920 /* Don't warn about the default network setup that you get if
921 * no command line -net or -netdev options are specified. There
922 * are two cases that we would otherwise complain about:
923 * (1) board doesn't support a NIC but the implicit "-net nic"
924 * requested one
925 * (2) CONFIG_SLIRP not set, in which case the implicit "-net nic"
926 * sets up a nic that isn't connected to anything.
927 */
928 if (default_net) {
929 return;
930 }
931
81017645 932 net_hub_check_clients();
ac60cc18 933
35277d14
SH
934 QTAILQ_FOREACH(nc, &net_clients, next) {
935 if (!nc->peer) {
efe32fdd 936 fprintf(stderr, "Warning: %s %s has no peer\n",
35277d14
SH
937 nc->info->type == NET_CLIENT_OPTIONS_KIND_NIC ?
938 "nic" : "netdev", nc->name);
efe32fdd
MA
939 }
940 }
48e2faf2
PM
941
942 /* Check that all NICs requested via -net nic actually got created.
943 * NICs created via -device don't need to be checked here because
944 * they are always instantiated.
945 */
946 for (i = 0; i < MAX_NICS; i++) {
947 NICInfo *nd = &nd_table[i];
948 if (nd->used && !nd->instantiated) {
949 fprintf(stderr, "Warning: requested NIC (%s, model %s) "
950 "was not created (not supported by this machine?)\n",
951 nd->name ? nd->name : "anonymous",
952 nd->model ? nd->model : "unspecified");
953 }
954 }
63a01ef8 955}
dc1c9fe8
MM
956
957static int net_init_client(QemuOpts *opts, void *dummy)
958{
4559a1db
LC
959 Error *local_err = NULL;
960
961 net_client_init(opts, 0, &local_err);
962 if (error_is_set(&local_err)) {
963 qerror_report_err(local_err);
964 error_free(local_err);
c1671a08 965 return -1;
4559a1db
LC
966 }
967
c1671a08 968 return 0;
f6b134ac
MM
969}
970
971static int net_init_netdev(QemuOpts *opts, void *dummy)
972{
4559a1db
LC
973 Error *local_err = NULL;
974 int ret;
975
976 ret = net_client_init(opts, 1, &local_err);
977 if (error_is_set(&local_err)) {
978 qerror_report_err(local_err);
979 error_free(local_err);
980 return -1;
981 }
982
983 return ret;
dc1c9fe8
MM
984}
985
986int net_init_clients(void)
987{
3329f07b
GH
988 QemuOptsList *net = qemu_find_opts("net");
989
cb4522cc 990 if (default_net) {
dc1c9fe8 991 /* if no clients, we use a default config */
3329f07b 992 qemu_opts_set(net, NULL, "type", "nic");
dc1c9fe8 993#ifdef CONFIG_SLIRP
3329f07b 994 qemu_opts_set(net, NULL, "type", "user");
dc1c9fe8
MM
995#endif
996 }
997
94878994 998 QTAILQ_INIT(&net_clients);
5610c3aa 999
3329f07b 1000 if (qemu_opts_foreach(qemu_find_opts("netdev"), net_init_netdev, NULL, 1) == -1)
f6b134ac
MM
1001 return -1;
1002
3329f07b 1003 if (qemu_opts_foreach(net, net_init_client, NULL, 1) == -1) {
dc1c9fe8
MM
1004 return -1;
1005 }
1006
dc1c9fe8
MM
1007 return 0;
1008}
1009
7f161aae 1010int net_client_parse(QemuOptsList *opts_list, const char *optarg)
dc1c9fe8 1011{
a3a766e7 1012#if defined(CONFIG_SLIRP)
68ac40d2
MM
1013 int ret;
1014 if (net_slirp_parse_legacy(opts_list, optarg, &ret)) {
dc1c9fe8
MM
1015 return ret;
1016 }
a3a766e7 1017#endif
68ac40d2 1018
8212c64f 1019 if (!qemu_opts_parse(opts_list, optarg, 1)) {
dc1c9fe8
MM
1020 return -1;
1021 }
1022
cb4522cc 1023 default_net = 0;
dc1c9fe8
MM
1024 return 0;
1025}
7fc8d918
JW
1026
1027/* From FreeBSD */
1028/* XXX: optimize */
1029unsigned compute_mcast_idx(const uint8_t *ep)
1030{
1031 uint32_t crc;
1032 int carry, i, j;
1033 uint8_t b;
1034
1035 crc = 0xffffffff;
1036 for (i = 0; i < 6; i++) {
1037 b = *ep++;
1038 for (j = 0; j < 8; j++) {
1039 carry = ((crc & 0x80000000L) ? 1 : 0) ^ (b & 0x01);
1040 crc <<= 1;
1041 b >>= 1;
1042 if (carry) {
1043 crc = ((crc ^ POLYNOMIAL) | carry);
1044 }
1045 }
1046 }
1047 return crc >> 26;
1048}