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