net: purge queued rx packets on queue deletion
[qemu.git] / net / net.c
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 */
24
25 #include "qemu/osdep.h"
26
27 #include "net/net.h"
28 #include "clients.h"
29 #include "hub.h"
30 #include "hw/qdev-properties.h"
31 #include "net/slirp.h"
32 #include "net/eth.h"
33 #include "util.h"
34
35 #include "monitor/monitor.h"
36 #include "qemu/help_option.h"
37 #include "qapi/qapi-commands-net.h"
38 #include "qapi/qapi-visit-net.h"
39 #include "qapi/qmp/qdict.h"
40 #include "qapi/qmp/qerror.h"
41 #include "qemu/error-report.h"
42 #include "qemu/sockets.h"
43 #include "qemu/cutils.h"
44 #include "qemu/config-file.h"
45 #include "qemu/ctype.h"
46 #include "qemu/iov.h"
47 #include "qemu/qemu-print.h"
48 #include "qemu/main-loop.h"
49 #include "qemu/option.h"
50 #include "qapi/error.h"
51 #include "qapi/opts-visitor.h"
52 #include "sysemu/sysemu.h"
53 #include "sysemu/qtest.h"
54 #include "sysemu/runstate.h"
55 #include "sysemu/sysemu.h"
56 #include "net/filter.h"
57 #include "qapi/string-output-visitor.h"
58
59 /* Net bridge is currently not supported for W32. */
60 #if !defined(_WIN32)
61 # define CONFIG_NET_BRIDGE
62 #endif
63
64 static VMChangeStateEntry *net_change_state_entry;
65 static QTAILQ_HEAD(, NetClientState) net_clients;
66
67 /***********************************************************/
68 /* network device redirectors */
69
70 int parse_host_port(struct sockaddr_in *saddr, const char *str,
71 Error **errp)
72 {
73 gchar **substrings;
74 struct hostent *he;
75 const char *addr, *p, *r;
76 int port, ret = 0;
77
78 substrings = g_strsplit(str, ":", 2);
79 if (!substrings || !substrings[0] || !substrings[1]) {
80 error_setg(errp, "host address '%s' doesn't contain ':' "
81 "separating host from port", str);
82 ret = -1;
83 goto out;
84 }
85
86 addr = substrings[0];
87 p = substrings[1];
88
89 saddr->sin_family = AF_INET;
90 if (addr[0] == '\0') {
91 saddr->sin_addr.s_addr = 0;
92 } else {
93 if (qemu_isdigit(addr[0])) {
94 if (!inet_aton(addr, &saddr->sin_addr)) {
95 error_setg(errp, "host address '%s' is not a valid "
96 "IPv4 address", addr);
97 ret = -1;
98 goto out;
99 }
100 } else {
101 he = gethostbyname(addr);
102 if (he == NULL) {
103 error_setg(errp, "can't resolve host address '%s'", addr);
104 ret = -1;
105 goto out;
106 }
107 saddr->sin_addr = *(struct in_addr *)he->h_addr;
108 }
109 }
110 port = strtol(p, (char **)&r, 0);
111 if (r == p) {
112 error_setg(errp, "port number '%s' is invalid", p);
113 ret = -1;
114 goto out;
115 }
116 saddr->sin_port = htons(port);
117
118 out:
119 g_strfreev(substrings);
120 return ret;
121 }
122
123 char *qemu_mac_strdup_printf(const uint8_t *macaddr)
124 {
125 return g_strdup_printf("%.2x:%.2x:%.2x:%.2x:%.2x:%.2x",
126 macaddr[0], macaddr[1], macaddr[2],
127 macaddr[3], macaddr[4], macaddr[5]);
128 }
129
130 void qemu_format_nic_info_str(NetClientState *nc, uint8_t macaddr[6])
131 {
132 snprintf(nc->info_str, sizeof(nc->info_str),
133 "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
134 nc->model,
135 macaddr[0], macaddr[1], macaddr[2],
136 macaddr[3], macaddr[4], macaddr[5]);
137 }
138
139 static int mac_table[256] = {0};
140
141 static void qemu_macaddr_set_used(MACAddr *macaddr)
142 {
143 int index;
144
145 for (index = 0x56; index < 0xFF; index++) {
146 if (macaddr->a[5] == index) {
147 mac_table[index]++;
148 }
149 }
150 }
151
152 static void qemu_macaddr_set_free(MACAddr *macaddr)
153 {
154 int index;
155 static const MACAddr base = { .a = { 0x52, 0x54, 0x00, 0x12, 0x34, 0 } };
156
157 if (memcmp(macaddr->a, &base.a, (sizeof(base.a) - 1)) != 0) {
158 return;
159 }
160 for (index = 0x56; index < 0xFF; index++) {
161 if (macaddr->a[5] == index) {
162 mac_table[index]--;
163 }
164 }
165 }
166
167 static int qemu_macaddr_get_free(void)
168 {
169 int index;
170
171 for (index = 0x56; index < 0xFF; index++) {
172 if (mac_table[index] == 0) {
173 return index;
174 }
175 }
176
177 return -1;
178 }
179
180 void qemu_macaddr_default_if_unset(MACAddr *macaddr)
181 {
182 static const MACAddr zero = { .a = { 0,0,0,0,0,0 } };
183 static const MACAddr base = { .a = { 0x52, 0x54, 0x00, 0x12, 0x34, 0 } };
184
185 if (memcmp(macaddr, &zero, sizeof(zero)) != 0) {
186 if (memcmp(macaddr->a, &base.a, (sizeof(base.a) - 1)) != 0) {
187 return;
188 } else {
189 qemu_macaddr_set_used(macaddr);
190 return;
191 }
192 }
193
194 macaddr->a[0] = 0x52;
195 macaddr->a[1] = 0x54;
196 macaddr->a[2] = 0x00;
197 macaddr->a[3] = 0x12;
198 macaddr->a[4] = 0x34;
199 macaddr->a[5] = qemu_macaddr_get_free();
200 qemu_macaddr_set_used(macaddr);
201 }
202
203 /**
204 * Generate a name for net client
205 *
206 * Only net clients created with the legacy -net option and NICs need this.
207 */
208 static char *assign_name(NetClientState *nc1, const char *model)
209 {
210 NetClientState *nc;
211 int id = 0;
212
213 QTAILQ_FOREACH(nc, &net_clients, next) {
214 if (nc == nc1) {
215 continue;
216 }
217 if (strcmp(nc->model, model) == 0) {
218 id++;
219 }
220 }
221
222 return g_strdup_printf("%s.%d", model, id);
223 }
224
225 static void qemu_net_client_destructor(NetClientState *nc)
226 {
227 g_free(nc);
228 }
229 static ssize_t qemu_deliver_packet_iov(NetClientState *sender,
230 unsigned flags,
231 const struct iovec *iov,
232 int iovcnt,
233 void *opaque);
234
235 static void qemu_net_client_setup(NetClientState *nc,
236 NetClientInfo *info,
237 NetClientState *peer,
238 const char *model,
239 const char *name,
240 NetClientDestructor *destructor)
241 {
242 nc->info = info;
243 nc->model = g_strdup(model);
244 if (name) {
245 nc->name = g_strdup(name);
246 } else {
247 nc->name = assign_name(nc, model);
248 }
249
250 if (peer) {
251 assert(!peer->peer);
252 nc->peer = peer;
253 peer->peer = nc;
254 }
255 QTAILQ_INSERT_TAIL(&net_clients, nc, next);
256
257 nc->incoming_queue = qemu_new_net_queue(qemu_deliver_packet_iov, nc);
258 nc->destructor = destructor;
259 QTAILQ_INIT(&nc->filters);
260 }
261
262 NetClientState *qemu_new_net_client(NetClientInfo *info,
263 NetClientState *peer,
264 const char *model,
265 const char *name)
266 {
267 NetClientState *nc;
268
269 assert(info->size >= sizeof(NetClientState));
270
271 nc = g_malloc0(info->size);
272 qemu_net_client_setup(nc, info, peer, model, name,
273 qemu_net_client_destructor);
274
275 return nc;
276 }
277
278 NICState *qemu_new_nic(NetClientInfo *info,
279 NICConf *conf,
280 const char *model,
281 const char *name,
282 void *opaque)
283 {
284 NetClientState **peers = conf->peers.ncs;
285 NICState *nic;
286 int i, queues = MAX(1, conf->peers.queues);
287
288 assert(info->type == NET_CLIENT_DRIVER_NIC);
289 assert(info->size >= sizeof(NICState));
290
291 nic = g_malloc0(info->size + sizeof(NetClientState) * queues);
292 nic->ncs = (void *)nic + info->size;
293 nic->conf = conf;
294 nic->opaque = opaque;
295
296 for (i = 0; i < queues; i++) {
297 qemu_net_client_setup(&nic->ncs[i], info, peers[i], model, name,
298 NULL);
299 nic->ncs[i].queue_index = i;
300 }
301
302 return nic;
303 }
304
305 NetClientState *qemu_get_subqueue(NICState *nic, int queue_index)
306 {
307 return nic->ncs + queue_index;
308 }
309
310 NetClientState *qemu_get_queue(NICState *nic)
311 {
312 return qemu_get_subqueue(nic, 0);
313 }
314
315 NICState *qemu_get_nic(NetClientState *nc)
316 {
317 NetClientState *nc0 = nc - nc->queue_index;
318
319 return (NICState *)((void *)nc0 - nc->info->size);
320 }
321
322 void *qemu_get_nic_opaque(NetClientState *nc)
323 {
324 NICState *nic = qemu_get_nic(nc);
325
326 return nic->opaque;
327 }
328
329 NetClientState *qemu_get_peer(NetClientState *nc, int queue_index)
330 {
331 assert(nc != NULL);
332 NetClientState *ncs = nc + queue_index;
333 return ncs->peer;
334 }
335
336 static void qemu_cleanup_net_client(NetClientState *nc)
337 {
338 QTAILQ_REMOVE(&net_clients, nc, next);
339
340 if (nc->info->cleanup) {
341 nc->info->cleanup(nc);
342 }
343 }
344
345 static void qemu_free_net_client(NetClientState *nc)
346 {
347 if (nc->incoming_queue) {
348 qemu_del_net_queue(nc->incoming_queue);
349 }
350 if (nc->peer) {
351 nc->peer->peer = NULL;
352 }
353 g_free(nc->name);
354 g_free(nc->model);
355 if (nc->destructor) {
356 nc->destructor(nc);
357 }
358 }
359
360 void qemu_del_net_client(NetClientState *nc)
361 {
362 NetClientState *ncs[MAX_QUEUE_NUM];
363 int queues, i;
364 NetFilterState *nf, *next;
365
366 assert(nc->info->type != NET_CLIENT_DRIVER_NIC);
367
368 /* If the NetClientState belongs to a multiqueue backend, we will change all
369 * other NetClientStates also.
370 */
371 queues = qemu_find_net_clients_except(nc->name, ncs,
372 NET_CLIENT_DRIVER_NIC,
373 MAX_QUEUE_NUM);
374 assert(queues != 0);
375
376 QTAILQ_FOREACH_SAFE(nf, &nc->filters, next, next) {
377 object_unparent(OBJECT(nf));
378 }
379
380 /* If there is a peer NIC, delete and cleanup client, but do not free. */
381 if (nc->peer && nc->peer->info->type == NET_CLIENT_DRIVER_NIC) {
382 NICState *nic = qemu_get_nic(nc->peer);
383 if (nic->peer_deleted) {
384 return;
385 }
386 nic->peer_deleted = true;
387
388 for (i = 0; i < queues; i++) {
389 ncs[i]->peer->link_down = true;
390 }
391
392 if (nc->peer->info->link_status_changed) {
393 nc->peer->info->link_status_changed(nc->peer);
394 }
395
396 for (i = 0; i < queues; i++) {
397 qemu_cleanup_net_client(ncs[i]);
398 }
399
400 return;
401 }
402
403 for (i = 0; i < queues; i++) {
404 qemu_cleanup_net_client(ncs[i]);
405 qemu_free_net_client(ncs[i]);
406 }
407 }
408
409 void qemu_del_nic(NICState *nic)
410 {
411 int i, queues = MAX(nic->conf->peers.queues, 1);
412
413 qemu_macaddr_set_free(&nic->conf->macaddr);
414
415 for (i = 0; i < queues; i++) {
416 NetClientState *nc = qemu_get_subqueue(nic, i);
417 /* If this is a peer NIC and peer has already been deleted, free it now. */
418 if (nic->peer_deleted) {
419 qemu_free_net_client(nc->peer);
420 } else if (nc->peer) {
421 /* if there are RX packets pending, complete them */
422 qemu_purge_queued_packets(nc->peer);
423 }
424 }
425
426 for (i = queues - 1; i >= 0; i--) {
427 NetClientState *nc = qemu_get_subqueue(nic, i);
428
429 qemu_cleanup_net_client(nc);
430 qemu_free_net_client(nc);
431 }
432
433 g_free(nic);
434 }
435
436 void qemu_foreach_nic(qemu_nic_foreach func, void *opaque)
437 {
438 NetClientState *nc;
439
440 QTAILQ_FOREACH(nc, &net_clients, next) {
441 if (nc->info->type == NET_CLIENT_DRIVER_NIC) {
442 if (nc->queue_index == 0) {
443 func(qemu_get_nic(nc), opaque);
444 }
445 }
446 }
447 }
448
449 bool qemu_has_ufo(NetClientState *nc)
450 {
451 if (!nc || !nc->info->has_ufo) {
452 return false;
453 }
454
455 return nc->info->has_ufo(nc);
456 }
457
458 bool qemu_has_vnet_hdr(NetClientState *nc)
459 {
460 if (!nc || !nc->info->has_vnet_hdr) {
461 return false;
462 }
463
464 return nc->info->has_vnet_hdr(nc);
465 }
466
467 bool qemu_has_vnet_hdr_len(NetClientState *nc, int len)
468 {
469 if (!nc || !nc->info->has_vnet_hdr_len) {
470 return false;
471 }
472
473 return nc->info->has_vnet_hdr_len(nc, len);
474 }
475
476 void qemu_using_vnet_hdr(NetClientState *nc, bool enable)
477 {
478 if (!nc || !nc->info->using_vnet_hdr) {
479 return;
480 }
481
482 nc->info->using_vnet_hdr(nc, enable);
483 }
484
485 void qemu_set_offload(NetClientState *nc, int csum, int tso4, int tso6,
486 int ecn, int ufo)
487 {
488 if (!nc || !nc->info->set_offload) {
489 return;
490 }
491
492 nc->info->set_offload(nc, csum, tso4, tso6, ecn, ufo);
493 }
494
495 void qemu_set_vnet_hdr_len(NetClientState *nc, int len)
496 {
497 if (!nc || !nc->info->set_vnet_hdr_len) {
498 return;
499 }
500
501 nc->vnet_hdr_len = len;
502 nc->info->set_vnet_hdr_len(nc, len);
503 }
504
505 int qemu_set_vnet_le(NetClientState *nc, bool is_le)
506 {
507 #ifdef HOST_WORDS_BIGENDIAN
508 if (!nc || !nc->info->set_vnet_le) {
509 return -ENOSYS;
510 }
511
512 return nc->info->set_vnet_le(nc, is_le);
513 #else
514 return 0;
515 #endif
516 }
517
518 int qemu_set_vnet_be(NetClientState *nc, bool is_be)
519 {
520 #ifdef HOST_WORDS_BIGENDIAN
521 return 0;
522 #else
523 if (!nc || !nc->info->set_vnet_be) {
524 return -ENOSYS;
525 }
526
527 return nc->info->set_vnet_be(nc, is_be);
528 #endif
529 }
530
531 int qemu_can_send_packet(NetClientState *sender)
532 {
533 int vm_running = runstate_is_running();
534
535 if (!vm_running) {
536 return 0;
537 }
538
539 if (!sender->peer) {
540 return 1;
541 }
542
543 if (sender->peer->receive_disabled) {
544 return 0;
545 } else if (sender->peer->info->can_receive &&
546 !sender->peer->info->can_receive(sender->peer)) {
547 return 0;
548 }
549 return 1;
550 }
551
552 static ssize_t filter_receive_iov(NetClientState *nc,
553 NetFilterDirection direction,
554 NetClientState *sender,
555 unsigned flags,
556 const struct iovec *iov,
557 int iovcnt,
558 NetPacketSent *sent_cb)
559 {
560 ssize_t ret = 0;
561 NetFilterState *nf = NULL;
562
563 if (direction == NET_FILTER_DIRECTION_TX) {
564 QTAILQ_FOREACH(nf, &nc->filters, next) {
565 ret = qemu_netfilter_receive(nf, direction, sender, flags, iov,
566 iovcnt, sent_cb);
567 if (ret) {
568 return ret;
569 }
570 }
571 } else {
572 QTAILQ_FOREACH_REVERSE(nf, &nc->filters, next) {
573 ret = qemu_netfilter_receive(nf, direction, sender, flags, iov,
574 iovcnt, sent_cb);
575 if (ret) {
576 return ret;
577 }
578 }
579 }
580
581 return ret;
582 }
583
584 static ssize_t filter_receive(NetClientState *nc,
585 NetFilterDirection direction,
586 NetClientState *sender,
587 unsigned flags,
588 const uint8_t *data,
589 size_t size,
590 NetPacketSent *sent_cb)
591 {
592 struct iovec iov = {
593 .iov_base = (void *)data,
594 .iov_len = size
595 };
596
597 return filter_receive_iov(nc, direction, sender, flags, &iov, 1, sent_cb);
598 }
599
600 void qemu_purge_queued_packets(NetClientState *nc)
601 {
602 if (!nc->peer) {
603 return;
604 }
605
606 qemu_net_queue_purge(nc->peer->incoming_queue, nc);
607 }
608
609 void qemu_flush_or_purge_queued_packets(NetClientState *nc, bool purge)
610 {
611 nc->receive_disabled = 0;
612
613 if (nc->peer && nc->peer->info->type == NET_CLIENT_DRIVER_HUBPORT) {
614 if (net_hub_flush(nc->peer)) {
615 qemu_notify_event();
616 }
617 }
618 if (qemu_net_queue_flush(nc->incoming_queue)) {
619 /* We emptied the queue successfully, signal to the IO thread to repoll
620 * the file descriptor (for tap, for example).
621 */
622 qemu_notify_event();
623 } else if (purge) {
624 /* Unable to empty the queue, purge remaining packets */
625 qemu_net_queue_purge(nc->incoming_queue, nc->peer);
626 }
627 }
628
629 void qemu_flush_queued_packets(NetClientState *nc)
630 {
631 qemu_flush_or_purge_queued_packets(nc, false);
632 }
633
634 static ssize_t qemu_send_packet_async_with_flags(NetClientState *sender,
635 unsigned flags,
636 const uint8_t *buf, int size,
637 NetPacketSent *sent_cb)
638 {
639 NetQueue *queue;
640 int ret;
641
642 #ifdef DEBUG_NET
643 printf("qemu_send_packet_async:\n");
644 qemu_hexdump(stdout, "net", buf, size);
645 #endif
646
647 if (sender->link_down || !sender->peer) {
648 return size;
649 }
650
651 /* Let filters handle the packet first */
652 ret = filter_receive(sender, NET_FILTER_DIRECTION_TX,
653 sender, flags, buf, size, sent_cb);
654 if (ret) {
655 return ret;
656 }
657
658 ret = filter_receive(sender->peer, NET_FILTER_DIRECTION_RX,
659 sender, flags, buf, size, sent_cb);
660 if (ret) {
661 return ret;
662 }
663
664 queue = sender->peer->incoming_queue;
665
666 return qemu_net_queue_send(queue, sender, flags, buf, size, sent_cb);
667 }
668
669 ssize_t qemu_send_packet_async(NetClientState *sender,
670 const uint8_t *buf, int size,
671 NetPacketSent *sent_cb)
672 {
673 return qemu_send_packet_async_with_flags(sender, QEMU_NET_PACKET_FLAG_NONE,
674 buf, size, sent_cb);
675 }
676
677 ssize_t qemu_send_packet(NetClientState *nc, const uint8_t *buf, int size)
678 {
679 return qemu_send_packet_async(nc, buf, size, NULL);
680 }
681
682 ssize_t qemu_send_packet_raw(NetClientState *nc, const uint8_t *buf, int size)
683 {
684 return qemu_send_packet_async_with_flags(nc, QEMU_NET_PACKET_FLAG_RAW,
685 buf, size, NULL);
686 }
687
688 static ssize_t nc_sendv_compat(NetClientState *nc, const struct iovec *iov,
689 int iovcnt, unsigned flags)
690 {
691 uint8_t *buf = NULL;
692 uint8_t *buffer;
693 size_t offset;
694 ssize_t ret;
695
696 if (iovcnt == 1) {
697 buffer = iov[0].iov_base;
698 offset = iov[0].iov_len;
699 } else {
700 offset = iov_size(iov, iovcnt);
701 if (offset > NET_BUFSIZE) {
702 return -1;
703 }
704 buf = g_malloc(offset);
705 buffer = buf;
706 offset = iov_to_buf(iov, iovcnt, 0, buf, offset);
707 }
708
709 if (flags & QEMU_NET_PACKET_FLAG_RAW && nc->info->receive_raw) {
710 ret = nc->info->receive_raw(nc, buffer, offset);
711 } else {
712 ret = nc->info->receive(nc, buffer, offset);
713 }
714
715 g_free(buf);
716 return ret;
717 }
718
719 static ssize_t qemu_deliver_packet_iov(NetClientState *sender,
720 unsigned flags,
721 const struct iovec *iov,
722 int iovcnt,
723 void *opaque)
724 {
725 NetClientState *nc = opaque;
726 int ret;
727
728
729 if (nc->link_down) {
730 return iov_size(iov, iovcnt);
731 }
732
733 if (nc->receive_disabled) {
734 return 0;
735 }
736
737 if (nc->info->receive_iov && !(flags & QEMU_NET_PACKET_FLAG_RAW)) {
738 ret = nc->info->receive_iov(nc, iov, iovcnt);
739 } else {
740 ret = nc_sendv_compat(nc, iov, iovcnt, flags);
741 }
742
743 if (ret == 0) {
744 nc->receive_disabled = 1;
745 }
746
747 return ret;
748 }
749
750 ssize_t qemu_sendv_packet_async(NetClientState *sender,
751 const struct iovec *iov, int iovcnt,
752 NetPacketSent *sent_cb)
753 {
754 NetQueue *queue;
755 size_t size = iov_size(iov, iovcnt);
756 int ret;
757
758 if (size > NET_BUFSIZE) {
759 return size;
760 }
761
762 if (sender->link_down || !sender->peer) {
763 return size;
764 }
765
766 /* Let filters handle the packet first */
767 ret = filter_receive_iov(sender, NET_FILTER_DIRECTION_TX, sender,
768 QEMU_NET_PACKET_FLAG_NONE, iov, iovcnt, sent_cb);
769 if (ret) {
770 return ret;
771 }
772
773 ret = filter_receive_iov(sender->peer, NET_FILTER_DIRECTION_RX, sender,
774 QEMU_NET_PACKET_FLAG_NONE, iov, iovcnt, sent_cb);
775 if (ret) {
776 return ret;
777 }
778
779 queue = sender->peer->incoming_queue;
780
781 return qemu_net_queue_send_iov(queue, sender,
782 QEMU_NET_PACKET_FLAG_NONE,
783 iov, iovcnt, sent_cb);
784 }
785
786 ssize_t
787 qemu_sendv_packet(NetClientState *nc, const struct iovec *iov, int iovcnt)
788 {
789 return qemu_sendv_packet_async(nc, iov, iovcnt, NULL);
790 }
791
792 NetClientState *qemu_find_netdev(const char *id)
793 {
794 NetClientState *nc;
795
796 QTAILQ_FOREACH(nc, &net_clients, next) {
797 if (nc->info->type == NET_CLIENT_DRIVER_NIC)
798 continue;
799 if (!strcmp(nc->name, id)) {
800 return nc;
801 }
802 }
803
804 return NULL;
805 }
806
807 int qemu_find_net_clients_except(const char *id, NetClientState **ncs,
808 NetClientDriver type, int max)
809 {
810 NetClientState *nc;
811 int ret = 0;
812
813 QTAILQ_FOREACH(nc, &net_clients, next) {
814 if (nc->info->type == type) {
815 continue;
816 }
817 if (!id || !strcmp(nc->name, id)) {
818 if (ret < max) {
819 ncs[ret] = nc;
820 }
821 ret++;
822 }
823 }
824
825 return ret;
826 }
827
828 static int nic_get_free_idx(void)
829 {
830 int index;
831
832 for (index = 0; index < MAX_NICS; index++)
833 if (!nd_table[index].used)
834 return index;
835 return -1;
836 }
837
838 int qemu_show_nic_models(const char *arg, const char *const *models)
839 {
840 int i;
841
842 if (!arg || !is_help_option(arg)) {
843 return 0;
844 }
845
846 printf("Supported NIC models:\n");
847 for (i = 0 ; models[i]; i++) {
848 printf("%s\n", models[i]);
849 }
850 return 1;
851 }
852
853 void qemu_check_nic_model(NICInfo *nd, const char *model)
854 {
855 const char *models[2];
856
857 models[0] = model;
858 models[1] = NULL;
859
860 if (qemu_show_nic_models(nd->model, models))
861 exit(0);
862 if (qemu_find_nic_model(nd, models, model) < 0)
863 exit(1);
864 }
865
866 int qemu_find_nic_model(NICInfo *nd, const char * const *models,
867 const char *default_model)
868 {
869 int i;
870
871 if (!nd->model)
872 nd->model = g_strdup(default_model);
873
874 for (i = 0 ; models[i]; i++) {
875 if (strcmp(nd->model, models[i]) == 0)
876 return i;
877 }
878
879 error_report("Unsupported NIC model: %s", nd->model);
880 return -1;
881 }
882
883 static int net_init_nic(const Netdev *netdev, const char *name,
884 NetClientState *peer, Error **errp)
885 {
886 int idx;
887 NICInfo *nd;
888 const NetLegacyNicOptions *nic;
889
890 assert(netdev->type == NET_CLIENT_DRIVER_NIC);
891 nic = &netdev->u.nic;
892
893 idx = nic_get_free_idx();
894 if (idx == -1 || nb_nics >= MAX_NICS) {
895 error_setg(errp, "too many NICs");
896 return -1;
897 }
898
899 nd = &nd_table[idx];
900
901 memset(nd, 0, sizeof(*nd));
902
903 if (nic->has_netdev) {
904 nd->netdev = qemu_find_netdev(nic->netdev);
905 if (!nd->netdev) {
906 error_setg(errp, "netdev '%s' not found", nic->netdev);
907 return -1;
908 }
909 } else {
910 assert(peer);
911 nd->netdev = peer;
912 }
913 nd->name = g_strdup(name);
914 if (nic->has_model) {
915 nd->model = g_strdup(nic->model);
916 }
917 if (nic->has_addr) {
918 nd->devaddr = g_strdup(nic->addr);
919 }
920
921 if (nic->has_macaddr &&
922 net_parse_macaddr(nd->macaddr.a, nic->macaddr) < 0) {
923 error_setg(errp, "invalid syntax for ethernet address");
924 return -1;
925 }
926 if (nic->has_macaddr &&
927 is_multicast_ether_addr(nd->macaddr.a)) {
928 error_setg(errp,
929 "NIC cannot have multicast MAC address (odd 1st byte)");
930 return -1;
931 }
932 qemu_macaddr_default_if_unset(&nd->macaddr);
933
934 if (nic->has_vectors) {
935 if (nic->vectors > 0x7ffffff) {
936 error_setg(errp, "invalid # of vectors: %"PRIu32, nic->vectors);
937 return -1;
938 }
939 nd->nvectors = nic->vectors;
940 } else {
941 nd->nvectors = DEV_NVECTORS_UNSPECIFIED;
942 }
943
944 nd->used = 1;
945 nb_nics++;
946
947 return idx;
948 }
949
950
951 static int (* const net_client_init_fun[NET_CLIENT_DRIVER__MAX])(
952 const Netdev *netdev,
953 const char *name,
954 NetClientState *peer, Error **errp) = {
955 [NET_CLIENT_DRIVER_NIC] = net_init_nic,
956 #ifdef CONFIG_SLIRP
957 [NET_CLIENT_DRIVER_USER] = net_init_slirp,
958 #endif
959 [NET_CLIENT_DRIVER_TAP] = net_init_tap,
960 [NET_CLIENT_DRIVER_SOCKET] = net_init_socket,
961 #ifdef CONFIG_VDE
962 [NET_CLIENT_DRIVER_VDE] = net_init_vde,
963 #endif
964 #ifdef CONFIG_NETMAP
965 [NET_CLIENT_DRIVER_NETMAP] = net_init_netmap,
966 #endif
967 #ifdef CONFIG_NET_BRIDGE
968 [NET_CLIENT_DRIVER_BRIDGE] = net_init_bridge,
969 #endif
970 [NET_CLIENT_DRIVER_HUBPORT] = net_init_hubport,
971 #ifdef CONFIG_VHOST_NET_USER
972 [NET_CLIENT_DRIVER_VHOST_USER] = net_init_vhost_user,
973 #endif
974 #ifdef CONFIG_VHOST_NET_VDPA
975 [NET_CLIENT_DRIVER_VHOST_VDPA] = net_init_vhost_vdpa,
976 #endif
977 #ifdef CONFIG_L2TPV3
978 [NET_CLIENT_DRIVER_L2TPV3] = net_init_l2tpv3,
979 #endif
980 };
981
982
983 static int net_client_init1(const Netdev *netdev, bool is_netdev, Error **errp)
984 {
985 NetClientState *peer = NULL;
986
987 if (is_netdev) {
988 if (netdev->type == NET_CLIENT_DRIVER_NIC ||
989 !net_client_init_fun[netdev->type]) {
990 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "type",
991 "a netdev backend type");
992 return -1;
993 }
994 } else {
995 if (netdev->type == NET_CLIENT_DRIVER_NONE) {
996 return 0; /* nothing to do */
997 }
998 if (netdev->type == NET_CLIENT_DRIVER_HUBPORT ||
999 !net_client_init_fun[netdev->type]) {
1000 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "type",
1001 "a net backend type (maybe it is not compiled "
1002 "into this binary)");
1003 return -1;
1004 }
1005
1006 /* Do not add to a hub if it's a nic with a netdev= parameter. */
1007 if (netdev->type != NET_CLIENT_DRIVER_NIC ||
1008 !netdev->u.nic.has_netdev) {
1009 peer = net_hub_add_port(0, NULL, NULL);
1010 }
1011 }
1012
1013 if (net_client_init_fun[netdev->type](netdev, netdev->id, peer, errp) < 0) {
1014 /* FIXME drop when all init functions store an Error */
1015 if (errp && !*errp) {
1016 error_setg(errp, QERR_DEVICE_INIT_FAILED,
1017 NetClientDriver_str(netdev->type));
1018 }
1019 return -1;
1020 }
1021
1022 if (is_netdev) {
1023 NetClientState *nc;
1024
1025 nc = qemu_find_netdev(netdev->id);
1026 assert(nc);
1027 nc->is_netdev = true;
1028 }
1029
1030 return 0;
1031 }
1032
1033 void show_netdevs(void)
1034 {
1035 int idx;
1036 const char *available_netdevs[] = {
1037 "socket",
1038 "hubport",
1039 "tap",
1040 #ifdef CONFIG_SLIRP
1041 "user",
1042 #endif
1043 #ifdef CONFIG_L2TPV3
1044 "l2tpv3",
1045 #endif
1046 #ifdef CONFIG_VDE
1047 "vde",
1048 #endif
1049 #ifdef CONFIG_NET_BRIDGE
1050 "bridge",
1051 #endif
1052 #ifdef CONFIG_NETMAP
1053 "netmap",
1054 #endif
1055 #ifdef CONFIG_POSIX
1056 "vhost-user",
1057 #endif
1058 #ifdef CONFIG_VHOST_VDPA
1059 "vhost-vdpa",
1060 #endif
1061 };
1062
1063 qemu_printf("Available netdev backend types:\n");
1064 for (idx = 0; idx < ARRAY_SIZE(available_netdevs); idx++) {
1065 qemu_printf("%s\n", available_netdevs[idx]);
1066 }
1067 }
1068
1069 static int net_client_init(QemuOpts *opts, bool is_netdev, Error **errp)
1070 {
1071 gchar **substrings = NULL;
1072 Netdev *object = NULL;
1073 int ret = -1;
1074 Visitor *v = opts_visitor_new(opts);
1075
1076 /* Parse convenience option format ip6-net=fec0::0[/64] */
1077 const char *ip6_net = qemu_opt_get(opts, "ipv6-net");
1078
1079 if (ip6_net) {
1080 char *prefix_addr;
1081 unsigned long prefix_len = 64; /* Default 64bit prefix length. */
1082
1083 substrings = g_strsplit(ip6_net, "/", 2);
1084 if (!substrings || !substrings[0]) {
1085 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "ipv6-net",
1086 "a valid IPv6 prefix");
1087 goto out;
1088 }
1089
1090 prefix_addr = substrings[0];
1091
1092 /* Handle user-specified prefix length. */
1093 if (substrings[1] &&
1094 qemu_strtoul(substrings[1], NULL, 10, &prefix_len))
1095 {
1096 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1097 "ipv6-prefixlen", "a number");
1098 goto out;
1099 }
1100
1101 qemu_opt_set(opts, "ipv6-prefix", prefix_addr, &error_abort);
1102 qemu_opt_set_number(opts, "ipv6-prefixlen", prefix_len,
1103 &error_abort);
1104 qemu_opt_unset(opts, "ipv6-net");
1105 }
1106
1107 /* Create an ID for -net if the user did not specify one */
1108 if (!is_netdev && !qemu_opts_id(opts)) {
1109 static int idx;
1110 qemu_opts_set_id(opts, g_strdup_printf("__org.qemu.net%i", idx++));
1111 }
1112
1113 if (visit_type_Netdev(v, NULL, &object, errp)) {
1114 ret = net_client_init1(object, is_netdev, errp);
1115 }
1116
1117 qapi_free_Netdev(object);
1118
1119 out:
1120 g_strfreev(substrings);
1121 visit_free(v);
1122 return ret;
1123 }
1124
1125 void netdev_add(QemuOpts *opts, Error **errp)
1126 {
1127 net_client_init(opts, true, errp);
1128 }
1129
1130 void qmp_netdev_add(Netdev *netdev, Error **errp)
1131 {
1132 net_client_init1(netdev, true, errp);
1133 }
1134
1135 void qmp_netdev_del(const char *id, Error **errp)
1136 {
1137 NetClientState *nc;
1138
1139 nc = qemu_find_netdev(id);
1140 if (!nc) {
1141 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
1142 "Device '%s' not found", id);
1143 return;
1144 }
1145
1146 if (!nc->is_netdev) {
1147 error_setg(errp, "Device '%s' is not a netdev", id);
1148 return;
1149 }
1150
1151 qemu_del_net_client(nc);
1152 }
1153
1154 static void netfilter_print_info(Monitor *mon, NetFilterState *nf)
1155 {
1156 char *str;
1157 ObjectProperty *prop;
1158 ObjectPropertyIterator iter;
1159 Visitor *v;
1160
1161 /* generate info str */
1162 object_property_iter_init(&iter, OBJECT(nf));
1163 while ((prop = object_property_iter_next(&iter))) {
1164 if (!strcmp(prop->name, "type")) {
1165 continue;
1166 }
1167 v = string_output_visitor_new(false, &str);
1168 object_property_get(OBJECT(nf), prop->name, v, NULL);
1169 visit_complete(v, &str);
1170 visit_free(v);
1171 monitor_printf(mon, ",%s=%s", prop->name, str);
1172 g_free(str);
1173 }
1174 monitor_printf(mon, "\n");
1175 }
1176
1177 void print_net_client(Monitor *mon, NetClientState *nc)
1178 {
1179 NetFilterState *nf;
1180
1181 monitor_printf(mon, "%s: index=%d,type=%s,%s\n", nc->name,
1182 nc->queue_index,
1183 NetClientDriver_str(nc->info->type),
1184 nc->info_str);
1185 if (!QTAILQ_EMPTY(&nc->filters)) {
1186 monitor_printf(mon, "filters:\n");
1187 }
1188 QTAILQ_FOREACH(nf, &nc->filters, next) {
1189 monitor_printf(mon, " - %s: type=%s",
1190 object_get_canonical_path_component(OBJECT(nf)),
1191 object_get_typename(OBJECT(nf)));
1192 netfilter_print_info(mon, nf);
1193 }
1194 }
1195
1196 RxFilterInfoList *qmp_query_rx_filter(bool has_name, const char *name,
1197 Error **errp)
1198 {
1199 NetClientState *nc;
1200 RxFilterInfoList *filter_list = NULL, *last_entry = NULL;
1201
1202 QTAILQ_FOREACH(nc, &net_clients, next) {
1203 RxFilterInfoList *entry;
1204 RxFilterInfo *info;
1205
1206 if (has_name && strcmp(nc->name, name) != 0) {
1207 continue;
1208 }
1209
1210 /* only query rx-filter information of NIC */
1211 if (nc->info->type != NET_CLIENT_DRIVER_NIC) {
1212 if (has_name) {
1213 error_setg(errp, "net client(%s) isn't a NIC", name);
1214 return NULL;
1215 }
1216 continue;
1217 }
1218
1219 /* only query information on queue 0 since the info is per nic,
1220 * not per queue
1221 */
1222 if (nc->queue_index != 0)
1223 continue;
1224
1225 if (nc->info->query_rx_filter) {
1226 info = nc->info->query_rx_filter(nc);
1227 entry = g_malloc0(sizeof(*entry));
1228 entry->value = info;
1229
1230 if (!filter_list) {
1231 filter_list = entry;
1232 } else {
1233 last_entry->next = entry;
1234 }
1235 last_entry = entry;
1236 } else if (has_name) {
1237 error_setg(errp, "net client(%s) doesn't support"
1238 " rx-filter querying", name);
1239 return NULL;
1240 }
1241
1242 if (has_name) {
1243 break;
1244 }
1245 }
1246
1247 if (filter_list == NULL && has_name) {
1248 error_setg(errp, "invalid net client name: %s", name);
1249 }
1250
1251 return filter_list;
1252 }
1253
1254 void hmp_info_network(Monitor *mon, const QDict *qdict)
1255 {
1256 NetClientState *nc, *peer;
1257 NetClientDriver type;
1258
1259 net_hub_info(mon);
1260
1261 QTAILQ_FOREACH(nc, &net_clients, next) {
1262 peer = nc->peer;
1263 type = nc->info->type;
1264
1265 /* Skip if already printed in hub info */
1266 if (net_hub_id_for_client(nc, NULL) == 0) {
1267 continue;
1268 }
1269
1270 if (!peer || type == NET_CLIENT_DRIVER_NIC) {
1271 print_net_client(mon, nc);
1272 } /* else it's a netdev connected to a NIC, printed with the NIC */
1273 if (peer && type == NET_CLIENT_DRIVER_NIC) {
1274 monitor_printf(mon, " \\ ");
1275 print_net_client(mon, peer);
1276 }
1277 }
1278 }
1279
1280 void colo_notify_filters_event(int event, Error **errp)
1281 {
1282 NetClientState *nc;
1283 NetFilterState *nf;
1284 NetFilterClass *nfc = NULL;
1285 Error *local_err = NULL;
1286
1287 QTAILQ_FOREACH(nc, &net_clients, next) {
1288 QTAILQ_FOREACH(nf, &nc->filters, next) {
1289 nfc = NETFILTER_GET_CLASS(OBJECT(nf));
1290 nfc->handle_event(nf, event, &local_err);
1291 if (local_err) {
1292 error_propagate(errp, local_err);
1293 return;
1294 }
1295 }
1296 }
1297 }
1298
1299 void qmp_set_link(const char *name, bool up, Error **errp)
1300 {
1301 NetClientState *ncs[MAX_QUEUE_NUM];
1302 NetClientState *nc;
1303 int queues, i;
1304
1305 queues = qemu_find_net_clients_except(name, ncs,
1306 NET_CLIENT_DRIVER__MAX,
1307 MAX_QUEUE_NUM);
1308
1309 if (queues == 0) {
1310 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
1311 "Device '%s' not found", name);
1312 return;
1313 }
1314 nc = ncs[0];
1315
1316 for (i = 0; i < queues; i++) {
1317 ncs[i]->link_down = !up;
1318 }
1319
1320 if (nc->info->link_status_changed) {
1321 nc->info->link_status_changed(nc);
1322 }
1323
1324 if (nc->peer) {
1325 /* Change peer link only if the peer is NIC and then notify peer.
1326 * If the peer is a HUBPORT or a backend, we do not change the
1327 * link status.
1328 *
1329 * This behavior is compatible with qemu hubs where there could be
1330 * multiple clients that can still communicate with each other in
1331 * disconnected mode. For now maintain this compatibility.
1332 */
1333 if (nc->peer->info->type == NET_CLIENT_DRIVER_NIC) {
1334 for (i = 0; i < queues; i++) {
1335 ncs[i]->peer->link_down = !up;
1336 }
1337 }
1338 if (nc->peer->info->link_status_changed) {
1339 nc->peer->info->link_status_changed(nc->peer);
1340 }
1341 }
1342 }
1343
1344 static void net_vm_change_state_handler(void *opaque, int running,
1345 RunState state)
1346 {
1347 NetClientState *nc;
1348 NetClientState *tmp;
1349
1350 QTAILQ_FOREACH_SAFE(nc, &net_clients, next, tmp) {
1351 if (running) {
1352 /* Flush queued packets and wake up backends. */
1353 if (nc->peer && qemu_can_send_packet(nc)) {
1354 qemu_flush_queued_packets(nc->peer);
1355 }
1356 } else {
1357 /* Complete all queued packets, to guarantee we don't modify
1358 * state later when VM is not running.
1359 */
1360 qemu_flush_or_purge_queued_packets(nc, true);
1361 }
1362 }
1363 }
1364
1365 void net_cleanup(void)
1366 {
1367 NetClientState *nc;
1368
1369 /* We may del multiple entries during qemu_del_net_client(),
1370 * so QTAILQ_FOREACH_SAFE() is also not safe here.
1371 */
1372 while (!QTAILQ_EMPTY(&net_clients)) {
1373 nc = QTAILQ_FIRST(&net_clients);
1374 if (nc->info->type == NET_CLIENT_DRIVER_NIC) {
1375 qemu_del_nic(qemu_get_nic(nc));
1376 } else {
1377 qemu_del_net_client(nc);
1378 }
1379 }
1380
1381 qemu_del_vm_change_state_handler(net_change_state_entry);
1382 }
1383
1384 void net_check_clients(void)
1385 {
1386 NetClientState *nc;
1387 int i;
1388
1389 net_hub_check_clients();
1390
1391 QTAILQ_FOREACH(nc, &net_clients, next) {
1392 if (!nc->peer) {
1393 warn_report("%s %s has no peer",
1394 nc->info->type == NET_CLIENT_DRIVER_NIC
1395 ? "nic" : "netdev",
1396 nc->name);
1397 }
1398 }
1399
1400 /* Check that all NICs requested via -net nic actually got created.
1401 * NICs created via -device don't need to be checked here because
1402 * they are always instantiated.
1403 */
1404 for (i = 0; i < MAX_NICS; i++) {
1405 NICInfo *nd = &nd_table[i];
1406 if (nd->used && !nd->instantiated) {
1407 warn_report("requested NIC (%s, model %s) "
1408 "was not created (not supported by this machine?)",
1409 nd->name ? nd->name : "anonymous",
1410 nd->model ? nd->model : "unspecified");
1411 }
1412 }
1413 }
1414
1415 static int net_init_client(void *dummy, QemuOpts *opts, Error **errp)
1416 {
1417 return net_client_init(opts, false, errp);
1418 }
1419
1420 static int net_init_netdev(void *dummy, QemuOpts *opts, Error **errp)
1421 {
1422 const char *type = qemu_opt_get(opts, "type");
1423
1424 if (type && is_help_option(type)) {
1425 show_netdevs();
1426 exit(0);
1427 }
1428 return net_client_init(opts, true, errp);
1429 }
1430
1431 /* For the convenience "--nic" parameter */
1432 static int net_param_nic(void *dummy, QemuOpts *opts, Error **errp)
1433 {
1434 char *mac, *nd_id;
1435 int idx, ret;
1436 NICInfo *ni;
1437 const char *type;
1438
1439 type = qemu_opt_get(opts, "type");
1440 if (type && g_str_equal(type, "none")) {
1441 return 0; /* Nothing to do, default_net is cleared in vl.c */
1442 }
1443
1444 idx = nic_get_free_idx();
1445 if (idx == -1 || nb_nics >= MAX_NICS) {
1446 error_setg(errp, "no more on-board/default NIC slots available");
1447 return -1;
1448 }
1449
1450 if (!type) {
1451 qemu_opt_set(opts, "type", "user", &error_abort);
1452 }
1453
1454 ni = &nd_table[idx];
1455 memset(ni, 0, sizeof(*ni));
1456 ni->model = qemu_opt_get_del(opts, "model");
1457
1458 /* Create an ID if the user did not specify one */
1459 nd_id = g_strdup(qemu_opts_id(opts));
1460 if (!nd_id) {
1461 nd_id = g_strdup_printf("__org.qemu.nic%i", idx);
1462 qemu_opts_set_id(opts, nd_id);
1463 }
1464
1465 /* Handle MAC address */
1466 mac = qemu_opt_get_del(opts, "mac");
1467 if (mac) {
1468 ret = net_parse_macaddr(ni->macaddr.a, mac);
1469 g_free(mac);
1470 if (ret) {
1471 error_setg(errp, "invalid syntax for ethernet address");
1472 goto out;
1473 }
1474 if (is_multicast_ether_addr(ni->macaddr.a)) {
1475 error_setg(errp, "NIC cannot have multicast MAC address");
1476 ret = -1;
1477 goto out;
1478 }
1479 }
1480 qemu_macaddr_default_if_unset(&ni->macaddr);
1481
1482 ret = net_client_init(opts, true, errp);
1483 if (ret == 0) {
1484 ni->netdev = qemu_find_netdev(nd_id);
1485 ni->used = true;
1486 nb_nics++;
1487 }
1488
1489 out:
1490 g_free(nd_id);
1491 return ret;
1492 }
1493
1494 int net_init_clients(Error **errp)
1495 {
1496 net_change_state_entry =
1497 qemu_add_vm_change_state_handler(net_vm_change_state_handler, NULL);
1498
1499 QTAILQ_INIT(&net_clients);
1500
1501 if (qemu_opts_foreach(qemu_find_opts("netdev"),
1502 net_init_netdev, NULL, errp)) {
1503 return -1;
1504 }
1505
1506 if (qemu_opts_foreach(qemu_find_opts("nic"), net_param_nic, NULL, errp)) {
1507 return -1;
1508 }
1509
1510 if (qemu_opts_foreach(qemu_find_opts("net"), net_init_client, NULL, errp)) {
1511 return -1;
1512 }
1513
1514 return 0;
1515 }
1516
1517 int net_client_parse(QemuOptsList *opts_list, const char *optarg)
1518 {
1519 if (!qemu_opts_parse_noisily(opts_list, optarg, true)) {
1520 return -1;
1521 }
1522
1523 return 0;
1524 }
1525
1526 /* From FreeBSD */
1527 /* XXX: optimize */
1528 uint32_t net_crc32(const uint8_t *p, int len)
1529 {
1530 uint32_t crc;
1531 int carry, i, j;
1532 uint8_t b;
1533
1534 crc = 0xffffffff;
1535 for (i = 0; i < len; i++) {
1536 b = *p++;
1537 for (j = 0; j < 8; j++) {
1538 carry = ((crc & 0x80000000L) ? 1 : 0) ^ (b & 0x01);
1539 crc <<= 1;
1540 b >>= 1;
1541 if (carry) {
1542 crc = ((crc ^ POLYNOMIAL_BE) | carry);
1543 }
1544 }
1545 }
1546
1547 return crc;
1548 }
1549
1550 uint32_t net_crc32_le(const uint8_t *p, int len)
1551 {
1552 uint32_t crc;
1553 int carry, i, j;
1554 uint8_t b;
1555
1556 crc = 0xffffffff;
1557 for (i = 0; i < len; i++) {
1558 b = *p++;
1559 for (j = 0; j < 8; j++) {
1560 carry = (crc & 0x1) ^ (b & 0x01);
1561 crc >>= 1;
1562 b >>= 1;
1563 if (carry) {
1564 crc ^= POLYNOMIAL_LE;
1565 }
1566 }
1567 }
1568
1569 return crc;
1570 }
1571
1572 QemuOptsList qemu_netdev_opts = {
1573 .name = "netdev",
1574 .implied_opt_name = "type",
1575 .head = QTAILQ_HEAD_INITIALIZER(qemu_netdev_opts.head),
1576 .desc = {
1577 /*
1578 * no elements => accept any params
1579 * validation will happen later
1580 */
1581 { /* end of list */ }
1582 },
1583 };
1584
1585 QemuOptsList qemu_nic_opts = {
1586 .name = "nic",
1587 .implied_opt_name = "type",
1588 .head = QTAILQ_HEAD_INITIALIZER(qemu_nic_opts.head),
1589 .desc = {
1590 /*
1591 * no elements => accept any params
1592 * validation will happen later
1593 */
1594 { /* end of list */ }
1595 },
1596 };
1597
1598 QemuOptsList qemu_net_opts = {
1599 .name = "net",
1600 .implied_opt_name = "type",
1601 .head = QTAILQ_HEAD_INITIALIZER(qemu_net_opts.head),
1602 .desc = {
1603 /*
1604 * no elements => accept any params
1605 * validation will happen later
1606 */
1607 { /* end of list */ }
1608 },
1609 };
1610
1611 void net_socket_rs_init(SocketReadState *rs,
1612 SocketReadStateFinalize *finalize,
1613 bool vnet_hdr)
1614 {
1615 rs->state = 0;
1616 rs->vnet_hdr = vnet_hdr;
1617 rs->index = 0;
1618 rs->packet_len = 0;
1619 rs->vnet_hdr_len = 0;
1620 memset(rs->buf, 0, sizeof(rs->buf));
1621 rs->finalize = finalize;
1622 }
1623
1624 /*
1625 * Returns
1626 * 0: success
1627 * -1: error occurs
1628 */
1629 int net_fill_rstate(SocketReadState *rs, const uint8_t *buf, int size)
1630 {
1631 unsigned int l;
1632
1633 while (size > 0) {
1634 /* Reassemble a packet from the network.
1635 * 0 = getting length.
1636 * 1 = getting vnet header length.
1637 * 2 = getting data.
1638 */
1639 switch (rs->state) {
1640 case 0:
1641 l = 4 - rs->index;
1642 if (l > size) {
1643 l = size;
1644 }
1645 memcpy(rs->buf + rs->index, buf, l);
1646 buf += l;
1647 size -= l;
1648 rs->index += l;
1649 if (rs->index == 4) {
1650 /* got length */
1651 rs->packet_len = ntohl(*(uint32_t *)rs->buf);
1652 rs->index = 0;
1653 if (rs->vnet_hdr) {
1654 rs->state = 1;
1655 } else {
1656 rs->state = 2;
1657 rs->vnet_hdr_len = 0;
1658 }
1659 }
1660 break;
1661 case 1:
1662 l = 4 - rs->index;
1663 if (l > size) {
1664 l = size;
1665 }
1666 memcpy(rs->buf + rs->index, buf, l);
1667 buf += l;
1668 size -= l;
1669 rs->index += l;
1670 if (rs->index == 4) {
1671 /* got vnet header length */
1672 rs->vnet_hdr_len = ntohl(*(uint32_t *)rs->buf);
1673 rs->index = 0;
1674 rs->state = 2;
1675 }
1676 break;
1677 case 2:
1678 l = rs->packet_len - rs->index;
1679 if (l > size) {
1680 l = size;
1681 }
1682 if (rs->index + l <= sizeof(rs->buf)) {
1683 memcpy(rs->buf + rs->index, buf, l);
1684 } else {
1685 fprintf(stderr, "serious error: oversized packet received,"
1686 "connection terminated.\n");
1687 rs->index = rs->state = 0;
1688 return -1;
1689 }
1690
1691 rs->index += l;
1692 buf += l;
1693 size -= l;
1694 if (rs->index >= rs->packet_len) {
1695 rs->index = 0;
1696 rs->state = 0;
1697 assert(rs->finalize);
1698 rs->finalize(rs);
1699 }
1700 break;
1701 }
1702 }
1703
1704 assert(size == 0);
1705 return 0;
1706 }