4 * Copyright (c) 2003-2008 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
26 #include "config-host.h"
29 #include "net/socket.h"
31 #include "net/slirp.h"
36 #include "qemu-common.h"
37 #include "qemu_socket.h"
38 #include "qmp-commands.h"
41 #include "qapi-visit.h"
42 #include "qapi/opts-visitor.h"
43 #include "qapi/qapi-dealloc-visitor.h"
45 /* Net bridge is currently not supported for W32. */
47 # define CONFIG_NET_BRIDGE
50 static QTAILQ_HEAD(, VLANState) vlans;
51 static QTAILQ_HEAD(, VLANClientState) non_vlan_clients;
55 /***********************************************************/
56 /* network device redirectors */
58 #if defined(DEBUG_NET)
59 static void hex_dump(FILE *f, const uint8_t *buf, int size)
63 for(i=0;i<size;i+=16) {
67 fprintf(f, "%08x ", i);
70 fprintf(f, " %02x", buf[i+j]);
77 if (c < ' ' || c > '~')
86 static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
97 if (len > buf_size - 1)
106 int parse_host_port(struct sockaddr_in *saddr, const char *str)
114 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
116 saddr->sin_family = AF_INET;
117 if (buf[0] == '\0') {
118 saddr->sin_addr.s_addr = 0;
120 if (qemu_isdigit(buf[0])) {
121 if (!inet_aton(buf, &saddr->sin_addr))
124 if ((he = gethostbyname(buf)) == NULL)
126 saddr->sin_addr = *(struct in_addr *)he->h_addr;
129 port = strtol(p, (char **)&r, 0);
132 saddr->sin_port = htons(port);
136 void qemu_format_nic_info_str(VLANClientState *vc, uint8_t macaddr[6])
138 snprintf(vc->info_str, sizeof(vc->info_str),
139 "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
141 macaddr[0], macaddr[1], macaddr[2],
142 macaddr[3], macaddr[4], macaddr[5]);
145 void qemu_macaddr_default_if_unset(MACAddr *macaddr)
147 static int index = 0;
148 static const MACAddr zero = { .a = { 0,0,0,0,0,0 } };
150 if (memcmp(macaddr, &zero, sizeof(zero)) != 0)
152 macaddr->a[0] = 0x52;
153 macaddr->a[1] = 0x54;
154 macaddr->a[2] = 0x00;
155 macaddr->a[3] = 0x12;
156 macaddr->a[4] = 0x34;
157 macaddr->a[5] = 0x56 + index++;
161 * Generate a name for net client
163 * Only net clients created with the legacy -net option need this. Naming is
164 * mandatory for net clients created with -netdev.
166 static char *assign_name(VLANClientState *vc1, const char *model)
172 QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
176 /* For compatibility only bump id for net clients on a vlan */
177 if (strcmp(vc->model, model) == 0 &&
178 net_hub_id_for_client(vc, NULL) == 0) {
183 snprintf(buf, sizeof(buf), "%s.%d", model, id);
185 return g_strdup(buf);
188 static ssize_t qemu_deliver_packet(VLANClientState *sender,
193 static ssize_t qemu_deliver_packet_iov(VLANClientState *sender,
195 const struct iovec *iov,
199 VLANClientState *qemu_new_net_client(NetClientInfo *info,
200 VLANClientState *peer,
206 assert(info->size >= sizeof(VLANClientState));
208 vc = g_malloc0(info->size);
211 vc->model = g_strdup(model);
213 vc->name = g_strdup(name);
215 vc->name = assign_name(vc, model);
223 QTAILQ_INSERT_TAIL(&non_vlan_clients, vc, next);
225 vc->send_queue = qemu_new_net_queue(qemu_deliver_packet,
226 qemu_deliver_packet_iov,
232 NICState *qemu_new_nic(NetClientInfo *info,
241 assert(info->type == NET_CLIENT_OPTIONS_KIND_NIC);
242 assert(info->size >= sizeof(NICState));
244 nc = qemu_new_net_client(info, conf->peer, model, name);
246 nic = DO_UPCAST(NICState, nc, nc);
248 nic->opaque = opaque;
253 static void qemu_cleanup_vlan_client(VLANClientState *vc)
256 QTAILQ_REMOVE(&vc->vlan->clients, vc, next);
258 QTAILQ_REMOVE(&non_vlan_clients, vc, next);
261 if (vc->info->cleanup) {
262 vc->info->cleanup(vc);
266 static void qemu_free_vlan_client(VLANClientState *vc)
269 if (vc->send_queue) {
270 qemu_del_net_queue(vc->send_queue);
273 vc->peer->peer = NULL;
281 void qemu_del_vlan_client(VLANClientState *vc)
283 /* If there is a peer NIC, delete and cleanup client, but do not free. */
284 if (!vc->vlan && vc->peer && vc->peer->info->type == NET_CLIENT_OPTIONS_KIND_NIC) {
285 NICState *nic = DO_UPCAST(NICState, nc, vc->peer);
286 if (nic->peer_deleted) {
289 nic->peer_deleted = true;
290 /* Let NIC know peer is gone. */
291 vc->peer->link_down = true;
292 if (vc->peer->info->link_status_changed) {
293 vc->peer->info->link_status_changed(vc->peer);
295 qemu_cleanup_vlan_client(vc);
299 /* If this is a peer NIC and peer has already been deleted, free it now. */
300 if (!vc->vlan && vc->peer && vc->info->type == NET_CLIENT_OPTIONS_KIND_NIC) {
301 NICState *nic = DO_UPCAST(NICState, nc, vc);
302 if (nic->peer_deleted) {
303 qemu_free_vlan_client(vc->peer);
307 qemu_cleanup_vlan_client(vc);
308 qemu_free_vlan_client(vc);
311 void qemu_foreach_nic(qemu_nic_foreach func, void *opaque)
316 QTAILQ_FOREACH(nc, &non_vlan_clients, next) {
317 if (nc->info->type == NET_CLIENT_OPTIONS_KIND_NIC) {
318 func(DO_UPCAST(NICState, nc, nc), opaque);
322 QTAILQ_FOREACH(vlan, &vlans, next) {
323 QTAILQ_FOREACH(nc, &vlan->clients, next) {
324 if (nc->info->type == NET_CLIENT_OPTIONS_KIND_NIC) {
325 func(DO_UPCAST(NICState, nc, nc), opaque);
331 int qemu_can_send_packet(VLANClientState *sender)
333 VLANState *vlan = sender->vlan;
337 if (sender->peer->receive_disabled) {
339 } else if (sender->peer->info->can_receive &&
340 !sender->peer->info->can_receive(sender->peer)) {
351 QTAILQ_FOREACH(vc, &vlan->clients, next) {
356 /* no can_receive() handler, they can always receive */
357 if (vc->info->can_receive && !vc->info->can_receive(vc)) {
364 static ssize_t qemu_deliver_packet(VLANClientState *sender,
370 VLANClientState *vc = opaque;
377 if (vc->receive_disabled) {
381 if (flags & QEMU_NET_PACKET_FLAG_RAW && vc->info->receive_raw) {
382 ret = vc->info->receive_raw(vc, data, size);
384 ret = vc->info->receive(vc, data, size);
388 vc->receive_disabled = 1;
394 void qemu_purge_queued_packets(VLANClientState *vc)
398 if (!vc->peer && !vc->vlan) {
403 queue = vc->peer->send_queue;
405 queue = vc->vlan->send_queue;
408 qemu_net_queue_purge(queue, vc);
411 void qemu_flush_queued_packets(VLANClientState *vc)
415 vc->receive_disabled = 0;
418 queue = vc->vlan->send_queue;
420 queue = vc->send_queue;
423 qemu_net_queue_flush(queue);
426 static ssize_t qemu_send_packet_async_with_flags(VLANClientState *sender,
428 const uint8_t *buf, int size,
429 NetPacketSent *sent_cb)
434 printf("qemu_send_packet_async:\n");
435 hex_dump(stdout, buf, size);
438 if (sender->link_down || (!sender->peer && !sender->vlan)) {
443 queue = sender->peer->send_queue;
445 queue = sender->vlan->send_queue;
448 return qemu_net_queue_send(queue, sender, flags, buf, size, sent_cb);
451 ssize_t qemu_send_packet_async(VLANClientState *sender,
452 const uint8_t *buf, int size,
453 NetPacketSent *sent_cb)
455 return qemu_send_packet_async_with_flags(sender, QEMU_NET_PACKET_FLAG_NONE,
459 void qemu_send_packet(VLANClientState *vc, const uint8_t *buf, int size)
461 qemu_send_packet_async(vc, buf, size, NULL);
464 ssize_t qemu_send_packet_raw(VLANClientState *vc, const uint8_t *buf, int size)
466 return qemu_send_packet_async_with_flags(vc, QEMU_NET_PACKET_FLAG_RAW,
470 static ssize_t vc_sendv_compat(VLANClientState *vc, const struct iovec *iov,
473 uint8_t buffer[4096];
476 offset = iov_to_buf(iov, iovcnt, 0, buffer, sizeof(buffer));
478 return vc->info->receive(vc, buffer, offset);
481 static ssize_t qemu_deliver_packet_iov(VLANClientState *sender,
483 const struct iovec *iov,
487 VLANClientState *vc = opaque;
490 return iov_size(iov, iovcnt);
493 if (vc->info->receive_iov) {
494 return vc->info->receive_iov(vc, iov, iovcnt);
496 return vc_sendv_compat(vc, iov, iovcnt);
500 ssize_t qemu_sendv_packet_async(VLANClientState *sender,
501 const struct iovec *iov, int iovcnt,
502 NetPacketSent *sent_cb)
506 if (sender->link_down || (!sender->peer && !sender->vlan)) {
507 return iov_size(iov, iovcnt);
511 queue = sender->peer->send_queue;
513 queue = sender->vlan->send_queue;
516 return qemu_net_queue_send_iov(queue, sender,
517 QEMU_NET_PACKET_FLAG_NONE,
518 iov, iovcnt, sent_cb);
522 qemu_sendv_packet(VLANClientState *vc, const struct iovec *iov, int iovcnt)
524 return qemu_sendv_packet_async(vc, iov, iovcnt, NULL);
527 VLANClientState *qemu_find_netdev(const char *id)
531 QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
532 if (vc->info->type == NET_CLIENT_OPTIONS_KIND_NIC)
534 if (!strcmp(vc->name, id)) {
542 static int nic_get_free_idx(void)
546 for (index = 0; index < MAX_NICS; index++)
547 if (!nd_table[index].used)
552 int qemu_show_nic_models(const char *arg, const char *const *models)
556 if (!arg || strcmp(arg, "?"))
559 fprintf(stderr, "qemu: Supported NIC models: ");
560 for (i = 0 ; models[i]; i++)
561 fprintf(stderr, "%s%c", models[i], models[i+1] ? ',' : '\n');
565 void qemu_check_nic_model(NICInfo *nd, const char *model)
567 const char *models[2];
572 if (qemu_show_nic_models(nd->model, models))
574 if (qemu_find_nic_model(nd, models, model) < 0)
578 int qemu_find_nic_model(NICInfo *nd, const char * const *models,
579 const char *default_model)
584 nd->model = g_strdup(default_model);
586 for (i = 0 ; models[i]; i++) {
587 if (strcmp(nd->model, models[i]) == 0)
591 error_report("Unsupported NIC model: %s", nd->model);
595 int net_handle_fd_param(Monitor *mon, const char *param)
599 if (!qemu_isdigit(param[0]) && mon) {
601 fd = monitor_get_fd(mon, param);
603 error_report("No file descriptor named %s found", param);
607 fd = qemu_parse_fd(param);
613 static int net_init_nic(const NetClientOptions *opts, const char *name,
614 VLANClientState *peer)
618 const NetLegacyNicOptions *nic;
620 assert(opts->kind == NET_CLIENT_OPTIONS_KIND_NIC);
623 idx = nic_get_free_idx();
624 if (idx == -1 || nb_nics >= MAX_NICS) {
625 error_report("Too Many NICs");
631 memset(nd, 0, sizeof(*nd));
633 if (nic->has_netdev) {
634 nd->netdev = qemu_find_netdev(nic->netdev);
636 error_report("netdev '%s' not found", nic->netdev);
644 nd->name = g_strdup(name);
646 if (nic->has_model) {
647 nd->model = g_strdup(nic->model);
650 nd->devaddr = g_strdup(nic->addr);
653 if (nic->has_macaddr &&
654 net_parse_macaddr(nd->macaddr.a, nic->macaddr) < 0) {
655 error_report("invalid syntax for ethernet address");
658 qemu_macaddr_default_if_unset(&nd->macaddr);
660 if (nic->has_vectors) {
661 if (nic->vectors > 0x7ffffff) {
662 error_report("invalid # of vectors: %"PRIu32, nic->vectors);
665 nd->nvectors = nic->vectors;
667 nd->nvectors = DEV_NVECTORS_UNSPECIFIED;
677 static int (* const net_client_init_fun[NET_CLIENT_OPTIONS_KIND_MAX])(
678 const NetClientOptions *opts,
680 VLANClientState *peer) = {
681 [NET_CLIENT_OPTIONS_KIND_NIC] = net_init_nic,
683 [NET_CLIENT_OPTIONS_KIND_USER] = net_init_slirp,
685 [NET_CLIENT_OPTIONS_KIND_TAP] = net_init_tap,
686 [NET_CLIENT_OPTIONS_KIND_SOCKET] = net_init_socket,
688 [NET_CLIENT_OPTIONS_KIND_VDE] = net_init_vde,
690 [NET_CLIENT_OPTIONS_KIND_DUMP] = net_init_dump,
691 #ifdef CONFIG_NET_BRIDGE
692 [NET_CLIENT_OPTIONS_KIND_BRIDGE] = net_init_bridge,
694 [NET_CLIENT_OPTIONS_KIND_HUBPORT] = net_init_hubport,
698 static int net_client_init1(const void *object, int is_netdev, Error **errp)
701 const Netdev *netdev;
702 const NetLegacy *net;
704 const NetClientOptions *opts;
709 opts = u.netdev->opts;
712 switch (opts->kind) {
714 case NET_CLIENT_OPTIONS_KIND_USER:
716 case NET_CLIENT_OPTIONS_KIND_TAP:
717 case NET_CLIENT_OPTIONS_KIND_SOCKET:
719 case NET_CLIENT_OPTIONS_KIND_VDE:
721 #ifdef CONFIG_NET_BRIDGE
722 case NET_CLIENT_OPTIONS_KIND_BRIDGE:
724 case NET_CLIENT_OPTIONS_KIND_HUBPORT:
728 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "type",
729 "a netdev backend type");
735 /* missing optional values have been initialized to "all bits zero" */
736 name = u.net->has_id ? u.net->id : u.net->name;
739 if (net_client_init_fun[opts->kind]) {
740 VLANClientState *peer = NULL;
742 /* Do not add to a vlan if it's a -netdev or a nic with a netdev=
745 (opts->kind != NET_CLIENT_OPTIONS_KIND_NIC ||
746 !opts->nic->has_netdev)) {
747 peer = net_hub_add_port(u.net->has_vlan ? u.net->vlan : 0, NULL);
750 if (net_client_init_fun[opts->kind](opts, name, peer) < 0) {
751 /* TODO push error reporting into init() methods */
752 error_set(errp, QERR_DEVICE_INIT_FAILED,
753 NetClientOptionsKind_lookup[opts->kind]);
761 static void net_visit(Visitor *v, int is_netdev, void **object, Error **errp)
764 visit_type_Netdev(v, (Netdev **)object, NULL, errp);
766 visit_type_NetLegacy(v, (NetLegacy **)object, NULL, errp);
771 int net_client_init(QemuOpts *opts, int is_netdev, Error **errp)
778 OptsVisitor *ov = opts_visitor_new(opts);
780 net_visit(opts_get_visitor(ov), is_netdev, &object, &err);
781 opts_visitor_cleanup(ov);
785 ret = net_client_init1(object, is_netdev, &err);
789 QapiDeallocVisitor *dv = qapi_dealloc_visitor_new();
791 net_visit(qapi_dealloc_get_visitor(dv), is_netdev, &object, NULL);
792 qapi_dealloc_visitor_cleanup(dv);
795 error_propagate(errp, err);
800 static int net_host_check_device(const char *device)
803 const char *valid_param_list[] = { "tap", "socket", "dump"
804 #ifdef CONFIG_NET_BRIDGE
814 for (i = 0; i < sizeof(valid_param_list) / sizeof(char *); i++) {
815 if (!strncmp(valid_param_list[i], device,
816 strlen(valid_param_list[i])))
823 void net_host_device_add(Monitor *mon, const QDict *qdict)
825 const char *device = qdict_get_str(qdict, "device");
826 const char *opts_str = qdict_get_try_str(qdict, "opts");
827 Error *local_err = NULL;
830 if (!net_host_check_device(device)) {
831 monitor_printf(mon, "invalid host network device %s\n", device);
835 opts = qemu_opts_parse(qemu_find_opts("net"), opts_str ? opts_str : "", 0);
840 qemu_opt_set(opts, "type", device);
842 net_client_init(opts, 0, &local_err);
843 if (error_is_set(&local_err)) {
844 qerror_report_err(local_err);
845 error_free(local_err);
846 monitor_printf(mon, "adding host network device %s failed\n", device);
850 void net_host_device_remove(Monitor *mon, const QDict *qdict)
853 int vlan_id = qdict_get_int(qdict, "vlan_id");
854 const char *device = qdict_get_str(qdict, "device");
856 vc = net_hub_find_client_by_name(vlan_id, device);
860 if (!net_host_check_device(vc->model)) {
861 monitor_printf(mon, "invalid host network device %s\n", device);
864 qemu_del_vlan_client(vc);
867 void netdev_add(QemuOpts *opts, Error **errp)
869 net_client_init(opts, 1, errp);
872 int qmp_netdev_add(Monitor *mon, const QDict *qdict, QObject **ret)
874 Error *local_err = NULL;
875 QemuOptsList *opts_list;
878 opts_list = qemu_find_opts_err("netdev", &local_err);
879 if (error_is_set(&local_err)) {
883 opts = qemu_opts_from_qdict(opts_list, qdict, &local_err);
884 if (error_is_set(&local_err)) {
888 netdev_add(opts, &local_err);
889 if (error_is_set(&local_err)) {
897 qerror_report_err(local_err);
898 error_free(local_err);
902 void qmp_netdev_del(const char *id, Error **errp)
906 vc = qemu_find_netdev(id);
908 error_set(errp, QERR_DEVICE_NOT_FOUND, id);
912 qemu_del_vlan_client(vc);
913 qemu_opts_del(qemu_opts_find(qemu_find_opts_err("netdev", errp), id));
916 static void print_net_client(Monitor *mon, VLANClientState *vc)
918 monitor_printf(mon, "%s: type=%s,%s\n", vc->name,
919 NetClientOptionsKind_lookup[vc->info->type], vc->info_str);
922 void do_info_network(Monitor *mon)
925 VLANClientState *vc, *peer;
926 NetClientOptionsKind type;
928 QTAILQ_FOREACH(vlan, &vlans, next) {
929 monitor_printf(mon, "VLAN %d devices:\n", vlan->id);
931 QTAILQ_FOREACH(vc, &vlan->clients, next) {
932 monitor_printf(mon, " ");
933 print_net_client(mon, vc);
936 monitor_printf(mon, "Devices not on any VLAN:\n");
937 QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
939 type = vc->info->type;
940 if (!peer || type == NET_CLIENT_OPTIONS_KIND_NIC) {
941 monitor_printf(mon, " ");
942 print_net_client(mon, vc);
943 } /* else it's a netdev connected to a NIC, printed with the NIC */
944 if (peer && type == NET_CLIENT_OPTIONS_KIND_NIC) {
945 monitor_printf(mon, " \\ ");
946 print_net_client(mon, peer);
952 void qmp_set_link(const char *name, bool up, Error **errp)
955 VLANClientState *vc = NULL;
957 QTAILQ_FOREACH(vlan, &vlans, next) {
958 QTAILQ_FOREACH(vc, &vlan->clients, next) {
959 if (strcmp(vc->name, name) == 0) {
964 QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
965 if (!strcmp(vc->name, name)) {
972 error_set(errp, QERR_DEVICE_NOT_FOUND, name);
978 if (vc->info->link_status_changed) {
979 vc->info->link_status_changed(vc);
982 /* Notify peer. Don't update peer link status: this makes it possible to
983 * disconnect from host network without notifying the guest.
984 * FIXME: is disconnected link status change operation useful?
986 * Current behaviour is compatible with qemu vlans where there could be
987 * multiple clients that can still communicate with each other in
988 * disconnected mode. For now maintain this compatibility. */
989 if (vc->peer && vc->peer->info->link_status_changed) {
990 vc->peer->info->link_status_changed(vc->peer);
994 void net_cleanup(void)
997 VLANClientState *vc, *next_vc;
999 QTAILQ_FOREACH(vlan, &vlans, next) {
1000 QTAILQ_FOREACH_SAFE(vc, &vlan->clients, next, next_vc) {
1001 qemu_del_vlan_client(vc);
1005 QTAILQ_FOREACH_SAFE(vc, &non_vlan_clients, next, next_vc) {
1006 qemu_del_vlan_client(vc);
1010 void net_check_clients(void)
1012 VLANClientState *vc;
1015 /* Don't warn about the default network setup that you get if
1016 * no command line -net or -netdev options are specified. There
1017 * are two cases that we would otherwise complain about:
1018 * (1) board doesn't support a NIC but the implicit "-net nic"
1020 * (2) CONFIG_SLIRP not set, in which case the implicit "-net nic"
1021 * sets up a nic that isn't connected to anything.
1027 net_hub_check_clients();
1029 QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
1031 fprintf(stderr, "Warning: %s %s has no peer\n",
1032 vc->info->type == NET_CLIENT_OPTIONS_KIND_NIC ? "nic" : "netdev",
1037 /* Check that all NICs requested via -net nic actually got created.
1038 * NICs created via -device don't need to be checked here because
1039 * they are always instantiated.
1041 for (i = 0; i < MAX_NICS; i++) {
1042 NICInfo *nd = &nd_table[i];
1043 if (nd->used && !nd->instantiated) {
1044 fprintf(stderr, "Warning: requested NIC (%s, model %s) "
1045 "was not created (not supported by this machine?)\n",
1046 nd->name ? nd->name : "anonymous",
1047 nd->model ? nd->model : "unspecified");
1052 static int net_init_client(QemuOpts *opts, void *dummy)
1054 Error *local_err = NULL;
1056 net_client_init(opts, 0, &local_err);
1057 if (error_is_set(&local_err)) {
1058 qerror_report_err(local_err);
1059 error_free(local_err);
1066 static int net_init_netdev(QemuOpts *opts, void *dummy)
1068 Error *local_err = NULL;
1071 ret = net_client_init(opts, 1, &local_err);
1072 if (error_is_set(&local_err)) {
1073 qerror_report_err(local_err);
1074 error_free(local_err);
1081 int net_init_clients(void)
1083 QemuOptsList *net = qemu_find_opts("net");
1086 /* if no clients, we use a default config */
1087 qemu_opts_set(net, NULL, "type", "nic");
1089 qemu_opts_set(net, NULL, "type", "user");
1093 QTAILQ_INIT(&vlans);
1094 QTAILQ_INIT(&non_vlan_clients);
1096 if (qemu_opts_foreach(qemu_find_opts("netdev"), net_init_netdev, NULL, 1) == -1)
1099 if (qemu_opts_foreach(net, net_init_client, NULL, 1) == -1) {
1106 int net_client_parse(QemuOptsList *opts_list, const char *optarg)
1108 #if defined(CONFIG_SLIRP)
1110 if (net_slirp_parse_legacy(opts_list, optarg, &ret)) {
1115 if (!qemu_opts_parse(opts_list, optarg, 1)) {
1125 unsigned compute_mcast_idx(const uint8_t *ep)
1132 for (i = 0; i < 6; i++) {
1134 for (j = 0; j < 8; j++) {
1135 carry = ((crc & 0x80000000L) ? 1 : 0) ^ (b & 0x01);
1139 crc = ((crc ^ POLYNOMIAL) | carry);