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
24 #include "config-host.h"
29 #include "net/slirp.h"
32 #include "monitor/monitor.h"
33 #include "qemu-common.h"
34 #include "qemu/sockets.h"
35 #include "qemu/config-file.h"
36 #include "qmp-commands.h"
39 #include "qapi-visit.h"
40 #include "qapi/opts-visitor.h"
41 #include "qapi/dealloc-visitor.h"
43 /* Net bridge is currently not supported for W32. */
45 # define CONFIG_NET_BRIDGE
48 static QTAILQ_HEAD(, NetClientState
) net_clients
;
52 /***********************************************************/
53 /* network device redirectors */
55 #if defined(DEBUG_NET)
56 static void hex_dump(FILE *f
, const uint8_t *buf
, int size
)
60 for(i
=0;i
<size
;i
+=16) {
64 fprintf(f
, "%08x ", i
);
67 fprintf(f
, " %02x", buf
[i
+j
]);
74 if (c
< ' ' || c
> '~')
83 static int get_str_sep(char *buf
, int buf_size
, const char **pp
, int sep
)
94 if (len
> buf_size
- 1)
103 int parse_host_port(struct sockaddr_in
*saddr
, const char *str
)
111 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0)
113 saddr
->sin_family
= AF_INET
;
114 if (buf
[0] == '\0') {
115 saddr
->sin_addr
.s_addr
= 0;
117 if (qemu_isdigit(buf
[0])) {
118 if (!inet_aton(buf
, &saddr
->sin_addr
))
121 if ((he
= gethostbyname(buf
)) == NULL
)
123 saddr
->sin_addr
= *(struct in_addr
*)he
->h_addr
;
126 port
= strtol(p
, (char **)&r
, 0);
129 saddr
->sin_port
= htons(port
);
133 void qemu_format_nic_info_str(NetClientState
*nc
, uint8_t macaddr
[6])
135 snprintf(nc
->info_str
, sizeof(nc
->info_str
),
136 "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
138 macaddr
[0], macaddr
[1], macaddr
[2],
139 macaddr
[3], macaddr
[4], macaddr
[5]);
142 void qemu_macaddr_default_if_unset(MACAddr
*macaddr
)
144 static int index
= 0;
145 static const MACAddr zero
= { .a
= { 0,0,0,0,0,0 } };
147 if (memcmp(macaddr
, &zero
, sizeof(zero
)) != 0)
149 macaddr
->a
[0] = 0x52;
150 macaddr
->a
[1] = 0x54;
151 macaddr
->a
[2] = 0x00;
152 macaddr
->a
[3] = 0x12;
153 macaddr
->a
[4] = 0x34;
154 macaddr
->a
[5] = 0x56 + index
++;
158 * Generate a name for net client
160 * Only net clients created with the legacy -net option need this. Naming is
161 * mandatory for net clients created with -netdev.
163 static char *assign_name(NetClientState
*nc1
, const char *model
)
169 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
173 /* For compatibility only bump id for net clients on a vlan */
174 if (strcmp(nc
->model
, model
) == 0 &&
175 net_hub_id_for_client(nc
, NULL
) == 0) {
180 snprintf(buf
, sizeof(buf
), "%s.%d", model
, id
);
182 return g_strdup(buf
);
185 NetClientState
*qemu_new_net_client(NetClientInfo
*info
,
186 NetClientState
*peer
,
192 assert(info
->size
>= sizeof(NetClientState
));
194 nc
= g_malloc0(info
->size
);
197 nc
->model
= g_strdup(model
);
199 nc
->name
= g_strdup(name
);
201 nc
->name
= assign_name(nc
, model
);
209 QTAILQ_INSERT_TAIL(&net_clients
, nc
, next
);
211 nc
->send_queue
= qemu_new_net_queue(nc
);
216 NICState
*qemu_new_nic(NetClientInfo
*info
,
225 assert(info
->type
== NET_CLIENT_OPTIONS_KIND_NIC
);
226 assert(info
->size
>= sizeof(NICState
));
228 nc
= qemu_new_net_client(info
, conf
->peer
, model
, name
);
230 nic
= qemu_get_nic(nc
);
232 nic
->opaque
= opaque
;
237 NetClientState
*qemu_get_queue(NICState
*nic
)
242 NICState
*qemu_get_nic(NetClientState
*nc
)
244 return DO_UPCAST(NICState
, nc
, nc
);
247 void *qemu_get_nic_opaque(NetClientState
*nc
)
249 NICState
*nic
= qemu_get_nic(nc
);
254 static void qemu_cleanup_net_client(NetClientState
*nc
)
256 QTAILQ_REMOVE(&net_clients
, nc
, next
);
258 if (nc
->info
->cleanup
) {
259 nc
->info
->cleanup(nc
);
263 static void qemu_free_net_client(NetClientState
*nc
)
265 if (nc
->send_queue
) {
266 qemu_del_net_queue(nc
->send_queue
);
269 nc
->peer
->peer
= NULL
;
276 void qemu_del_net_client(NetClientState
*nc
)
278 /* If there is a peer NIC, delete and cleanup client, but do not free. */
279 if (nc
->peer
&& nc
->peer
->info
->type
== NET_CLIENT_OPTIONS_KIND_NIC
) {
280 NICState
*nic
= qemu_get_nic(nc
->peer
);
281 if (nic
->peer_deleted
) {
284 nic
->peer_deleted
= true;
285 /* Let NIC know peer is gone. */
286 nc
->peer
->link_down
= true;
287 if (nc
->peer
->info
->link_status_changed
) {
288 nc
->peer
->info
->link_status_changed(nc
->peer
);
290 qemu_cleanup_net_client(nc
);
294 assert(nc
->info
->type
!= NET_CLIENT_OPTIONS_KIND_NIC
);
296 qemu_cleanup_net_client(nc
);
297 qemu_free_net_client(nc
);
300 void qemu_del_nic(NICState
*nic
)
302 NetClientState
*nc
= qemu_get_queue(nic
);
303 /* If this is a peer NIC and peer has already been deleted, free it now. */
304 if (nc
->peer
&& nc
->info
->type
== NET_CLIENT_OPTIONS_KIND_NIC
) {
305 NICState
*nic
= qemu_get_nic(nc
);
306 if (nic
->peer_deleted
) {
307 qemu_free_net_client(nc
->peer
);
311 qemu_cleanup_net_client(nc
);
312 qemu_free_net_client(nc
);
315 void qemu_foreach_nic(qemu_nic_foreach func
, void *opaque
)
319 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
320 if (nc
->info
->type
== NET_CLIENT_OPTIONS_KIND_NIC
) {
321 func(qemu_get_nic(nc
), opaque
);
326 int qemu_can_send_packet(NetClientState
*sender
)
332 if (sender
->peer
->receive_disabled
) {
334 } else if (sender
->peer
->info
->can_receive
&&
335 !sender
->peer
->info
->can_receive(sender
->peer
)) {
341 ssize_t
qemu_deliver_packet(NetClientState
*sender
,
347 NetClientState
*nc
= opaque
;
354 if (nc
->receive_disabled
) {
358 if (flags
& QEMU_NET_PACKET_FLAG_RAW
&& nc
->info
->receive_raw
) {
359 ret
= nc
->info
->receive_raw(nc
, data
, size
);
361 ret
= nc
->info
->receive(nc
, data
, size
);
365 nc
->receive_disabled
= 1;
371 void qemu_purge_queued_packets(NetClientState
*nc
)
377 qemu_net_queue_purge(nc
->peer
->send_queue
, nc
);
380 void qemu_flush_queued_packets(NetClientState
*nc
)
382 nc
->receive_disabled
= 0;
384 if (qemu_net_queue_flush(nc
->send_queue
)) {
385 /* We emptied the queue successfully, signal to the IO thread to repoll
386 * the file descriptor (for tap, for example).
392 static ssize_t
qemu_send_packet_async_with_flags(NetClientState
*sender
,
394 const uint8_t *buf
, int size
,
395 NetPacketSent
*sent_cb
)
400 printf("qemu_send_packet_async:\n");
401 hex_dump(stdout
, buf
, size
);
404 if (sender
->link_down
|| !sender
->peer
) {
408 queue
= sender
->peer
->send_queue
;
410 return qemu_net_queue_send(queue
, sender
, flags
, buf
, size
, sent_cb
);
413 ssize_t
qemu_send_packet_async(NetClientState
*sender
,
414 const uint8_t *buf
, int size
,
415 NetPacketSent
*sent_cb
)
417 return qemu_send_packet_async_with_flags(sender
, QEMU_NET_PACKET_FLAG_NONE
,
421 void qemu_send_packet(NetClientState
*nc
, const uint8_t *buf
, int size
)
423 qemu_send_packet_async(nc
, buf
, size
, NULL
);
426 ssize_t
qemu_send_packet_raw(NetClientState
*nc
, const uint8_t *buf
, int size
)
428 return qemu_send_packet_async_with_flags(nc
, QEMU_NET_PACKET_FLAG_RAW
,
432 static ssize_t
nc_sendv_compat(NetClientState
*nc
, const struct iovec
*iov
,
435 uint8_t buffer
[4096];
438 offset
= iov_to_buf(iov
, iovcnt
, 0, buffer
, sizeof(buffer
));
440 return nc
->info
->receive(nc
, buffer
, offset
);
443 ssize_t
qemu_deliver_packet_iov(NetClientState
*sender
,
445 const struct iovec
*iov
,
449 NetClientState
*nc
= opaque
;
453 return iov_size(iov
, iovcnt
);
456 if (nc
->receive_disabled
) {
460 if (nc
->info
->receive_iov
) {
461 ret
= nc
->info
->receive_iov(nc
, iov
, iovcnt
);
463 ret
= nc_sendv_compat(nc
, iov
, iovcnt
);
467 nc
->receive_disabled
= 1;
473 ssize_t
qemu_sendv_packet_async(NetClientState
*sender
,
474 const struct iovec
*iov
, int iovcnt
,
475 NetPacketSent
*sent_cb
)
479 if (sender
->link_down
|| !sender
->peer
) {
480 return iov_size(iov
, iovcnt
);
483 queue
= sender
->peer
->send_queue
;
485 return qemu_net_queue_send_iov(queue
, sender
,
486 QEMU_NET_PACKET_FLAG_NONE
,
487 iov
, iovcnt
, sent_cb
);
491 qemu_sendv_packet(NetClientState
*nc
, const struct iovec
*iov
, int iovcnt
)
493 return qemu_sendv_packet_async(nc
, iov
, iovcnt
, NULL
);
496 NetClientState
*qemu_find_netdev(const char *id
)
500 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
501 if (nc
->info
->type
== NET_CLIENT_OPTIONS_KIND_NIC
)
503 if (!strcmp(nc
->name
, id
)) {
511 int qemu_find_net_clients_except(const char *id
, NetClientState
**ncs
,
512 NetClientOptionsKind type
, int max
)
517 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
518 if (nc
->info
->type
== type
) {
521 if (!strcmp(nc
->name
, id
)) {
532 static int nic_get_free_idx(void)
536 for (index
= 0; index
< MAX_NICS
; index
++)
537 if (!nd_table
[index
].used
)
542 int qemu_show_nic_models(const char *arg
, const char *const *models
)
546 if (!arg
|| !is_help_option(arg
)) {
550 fprintf(stderr
, "qemu: Supported NIC models: ");
551 for (i
= 0 ; models
[i
]; i
++)
552 fprintf(stderr
, "%s%c", models
[i
], models
[i
+1] ? ',' : '\n');
556 void qemu_check_nic_model(NICInfo
*nd
, const char *model
)
558 const char *models
[2];
563 if (qemu_show_nic_models(nd
->model
, models
))
565 if (qemu_find_nic_model(nd
, models
, model
) < 0)
569 int qemu_find_nic_model(NICInfo
*nd
, const char * const *models
,
570 const char *default_model
)
575 nd
->model
= g_strdup(default_model
);
577 for (i
= 0 ; models
[i
]; i
++) {
578 if (strcmp(nd
->model
, models
[i
]) == 0)
582 error_report("Unsupported NIC model: %s", nd
->model
);
586 static int net_init_nic(const NetClientOptions
*opts
, const char *name
,
587 NetClientState
*peer
)
591 const NetLegacyNicOptions
*nic
;
593 assert(opts
->kind
== NET_CLIENT_OPTIONS_KIND_NIC
);
596 idx
= nic_get_free_idx();
597 if (idx
== -1 || nb_nics
>= MAX_NICS
) {
598 error_report("Too Many NICs");
604 memset(nd
, 0, sizeof(*nd
));
606 if (nic
->has_netdev
) {
607 nd
->netdev
= qemu_find_netdev(nic
->netdev
);
609 error_report("netdev '%s' not found", nic
->netdev
);
616 nd
->name
= g_strdup(name
);
617 if (nic
->has_model
) {
618 nd
->model
= g_strdup(nic
->model
);
621 nd
->devaddr
= g_strdup(nic
->addr
);
624 if (nic
->has_macaddr
&&
625 net_parse_macaddr(nd
->macaddr
.a
, nic
->macaddr
) < 0) {
626 error_report("invalid syntax for ethernet address");
629 qemu_macaddr_default_if_unset(&nd
->macaddr
);
631 if (nic
->has_vectors
) {
632 if (nic
->vectors
> 0x7ffffff) {
633 error_report("invalid # of vectors: %"PRIu32
, nic
->vectors
);
636 nd
->nvectors
= nic
->vectors
;
638 nd
->nvectors
= DEV_NVECTORS_UNSPECIFIED
;
648 static int (* const net_client_init_fun
[NET_CLIENT_OPTIONS_KIND_MAX
])(
649 const NetClientOptions
*opts
,
651 NetClientState
*peer
) = {
652 [NET_CLIENT_OPTIONS_KIND_NIC
] = net_init_nic
,
654 [NET_CLIENT_OPTIONS_KIND_USER
] = net_init_slirp
,
656 [NET_CLIENT_OPTIONS_KIND_TAP
] = net_init_tap
,
657 [NET_CLIENT_OPTIONS_KIND_SOCKET
] = net_init_socket
,
659 [NET_CLIENT_OPTIONS_KIND_VDE
] = net_init_vde
,
661 [NET_CLIENT_OPTIONS_KIND_DUMP
] = net_init_dump
,
662 #ifdef CONFIG_NET_BRIDGE
663 [NET_CLIENT_OPTIONS_KIND_BRIDGE
] = net_init_bridge
,
665 [NET_CLIENT_OPTIONS_KIND_HUBPORT
] = net_init_hubport
,
669 static int net_client_init1(const void *object
, int is_netdev
, Error
**errp
)
672 const Netdev
*netdev
;
673 const NetLegacy
*net
;
675 const NetClientOptions
*opts
;
680 opts
= u
.netdev
->opts
;
683 switch (opts
->kind
) {
685 case NET_CLIENT_OPTIONS_KIND_USER
:
687 case NET_CLIENT_OPTIONS_KIND_TAP
:
688 case NET_CLIENT_OPTIONS_KIND_SOCKET
:
690 case NET_CLIENT_OPTIONS_KIND_VDE
:
692 #ifdef CONFIG_NET_BRIDGE
693 case NET_CLIENT_OPTIONS_KIND_BRIDGE
:
695 case NET_CLIENT_OPTIONS_KIND_HUBPORT
:
699 error_set(errp
, QERR_INVALID_PARAMETER_VALUE
, "type",
700 "a netdev backend type");
706 /* missing optional values have been initialized to "all bits zero" */
707 name
= u
.net
->has_id
? u
.net
->id
: u
.net
->name
;
710 if (net_client_init_fun
[opts
->kind
]) {
711 NetClientState
*peer
= NULL
;
713 /* Do not add to a vlan if it's a -netdev or a nic with a netdev=
716 (opts
->kind
!= NET_CLIENT_OPTIONS_KIND_NIC
||
717 !opts
->nic
->has_netdev
)) {
718 peer
= net_hub_add_port(u
.net
->has_vlan
? u
.net
->vlan
: 0, NULL
);
721 if (net_client_init_fun
[opts
->kind
](opts
, name
, peer
) < 0) {
722 /* TODO push error reporting into init() methods */
723 error_set(errp
, QERR_DEVICE_INIT_FAILED
,
724 NetClientOptionsKind_lookup
[opts
->kind
]);
732 static void net_visit(Visitor
*v
, int is_netdev
, void **object
, Error
**errp
)
735 visit_type_Netdev(v
, (Netdev
**)object
, NULL
, errp
);
737 visit_type_NetLegacy(v
, (NetLegacy
**)object
, NULL
, errp
);
742 int net_client_init(QemuOpts
*opts
, int is_netdev
, Error
**errp
)
749 OptsVisitor
*ov
= opts_visitor_new(opts
);
751 net_visit(opts_get_visitor(ov
), is_netdev
, &object
, &err
);
752 opts_visitor_cleanup(ov
);
756 ret
= net_client_init1(object
, is_netdev
, &err
);
760 QapiDeallocVisitor
*dv
= qapi_dealloc_visitor_new();
762 net_visit(qapi_dealloc_get_visitor(dv
), is_netdev
, &object
, NULL
);
763 qapi_dealloc_visitor_cleanup(dv
);
766 error_propagate(errp
, err
);
771 static int net_host_check_device(const char *device
)
774 const char *valid_param_list
[] = { "tap", "socket", "dump"
775 #ifdef CONFIG_NET_BRIDGE
785 for (i
= 0; i
< sizeof(valid_param_list
) / sizeof(char *); i
++) {
786 if (!strncmp(valid_param_list
[i
], device
,
787 strlen(valid_param_list
[i
])))
794 void net_host_device_add(Monitor
*mon
, const QDict
*qdict
)
796 const char *device
= qdict_get_str(qdict
, "device");
797 const char *opts_str
= qdict_get_try_str(qdict
, "opts");
798 Error
*local_err
= NULL
;
801 if (!net_host_check_device(device
)) {
802 monitor_printf(mon
, "invalid host network device %s\n", device
);
806 opts
= qemu_opts_parse(qemu_find_opts("net"), opts_str
? opts_str
: "", 0);
811 qemu_opt_set(opts
, "type", device
);
813 net_client_init(opts
, 0, &local_err
);
814 if (error_is_set(&local_err
)) {
815 qerror_report_err(local_err
);
816 error_free(local_err
);
817 monitor_printf(mon
, "adding host network device %s failed\n", device
);
821 void net_host_device_remove(Monitor
*mon
, const QDict
*qdict
)
824 int vlan_id
= qdict_get_int(qdict
, "vlan_id");
825 const char *device
= qdict_get_str(qdict
, "device");
827 nc
= net_hub_find_client_by_name(vlan_id
, device
);
831 if (!net_host_check_device(nc
->model
)) {
832 monitor_printf(mon
, "invalid host network device %s\n", device
);
835 qemu_del_net_client(nc
);
838 void netdev_add(QemuOpts
*opts
, Error
**errp
)
840 net_client_init(opts
, 1, errp
);
843 int qmp_netdev_add(Monitor
*mon
, const QDict
*qdict
, QObject
**ret
)
845 Error
*local_err
= NULL
;
846 QemuOptsList
*opts_list
;
849 opts_list
= qemu_find_opts_err("netdev", &local_err
);
850 if (error_is_set(&local_err
)) {
854 opts
= qemu_opts_from_qdict(opts_list
, qdict
, &local_err
);
855 if (error_is_set(&local_err
)) {
859 netdev_add(opts
, &local_err
);
860 if (error_is_set(&local_err
)) {
868 qerror_report_err(local_err
);
869 error_free(local_err
);
873 void qmp_netdev_del(const char *id
, Error
**errp
)
878 nc
= qemu_find_netdev(id
);
880 error_set(errp
, QERR_DEVICE_NOT_FOUND
, id
);
884 opts
= qemu_opts_find(qemu_find_opts_err("netdev", NULL
), id
);
886 error_setg(errp
, "Device '%s' is not a netdev", id
);
890 qemu_del_net_client(nc
);
894 void print_net_client(Monitor
*mon
, NetClientState
*nc
)
896 monitor_printf(mon
, "%s: type=%s,%s\n", nc
->name
,
897 NetClientOptionsKind_lookup
[nc
->info
->type
], nc
->info_str
);
900 void do_info_network(Monitor
*mon
, const QDict
*qdict
)
902 NetClientState
*nc
, *peer
;
903 NetClientOptionsKind type
;
907 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
909 type
= nc
->info
->type
;
911 /* Skip if already printed in hub info */
912 if (net_hub_id_for_client(nc
, NULL
) == 0) {
916 if (!peer
|| type
== NET_CLIENT_OPTIONS_KIND_NIC
) {
917 print_net_client(mon
, nc
);
918 } /* else it's a netdev connected to a NIC, printed with the NIC */
919 if (peer
&& type
== NET_CLIENT_OPTIONS_KIND_NIC
) {
920 monitor_printf(mon
, " \\ ");
921 print_net_client(mon
, peer
);
926 void qmp_set_link(const char *name
, bool up
, Error
**errp
)
928 NetClientState
*nc
= NULL
;
930 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
931 if (!strcmp(nc
->name
, name
)) {
937 error_set(errp
, QERR_DEVICE_NOT_FOUND
, name
);
943 if (nc
->info
->link_status_changed
) {
944 nc
->info
->link_status_changed(nc
);
947 /* Notify peer. Don't update peer link status: this makes it possible to
948 * disconnect from host network without notifying the guest.
949 * FIXME: is disconnected link status change operation useful?
951 * Current behaviour is compatible with qemu vlans where there could be
952 * multiple clients that can still communicate with each other in
953 * disconnected mode. For now maintain this compatibility. */
954 if (nc
->peer
&& nc
->peer
->info
->link_status_changed
) {
955 nc
->peer
->info
->link_status_changed(nc
->peer
);
959 void net_cleanup(void)
961 NetClientState
*nc
, *next_vc
;
963 QTAILQ_FOREACH_SAFE(nc
, &net_clients
, next
, next_vc
) {
964 if (nc
->info
->type
== NET_CLIENT_OPTIONS_KIND_NIC
) {
965 qemu_del_nic(qemu_get_nic(nc
));
967 qemu_del_net_client(nc
);
972 void net_check_clients(void)
977 /* Don't warn about the default network setup that you get if
978 * no command line -net or -netdev options are specified. There
979 * are two cases that we would otherwise complain about:
980 * (1) board doesn't support a NIC but the implicit "-net nic"
982 * (2) CONFIG_SLIRP not set, in which case the implicit "-net nic"
983 * sets up a nic that isn't connected to anything.
989 net_hub_check_clients();
991 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
993 fprintf(stderr
, "Warning: %s %s has no peer\n",
994 nc
->info
->type
== NET_CLIENT_OPTIONS_KIND_NIC
?
995 "nic" : "netdev", nc
->name
);
999 /* Check that all NICs requested via -net nic actually got created.
1000 * NICs created via -device don't need to be checked here because
1001 * they are always instantiated.
1003 for (i
= 0; i
< MAX_NICS
; i
++) {
1004 NICInfo
*nd
= &nd_table
[i
];
1005 if (nd
->used
&& !nd
->instantiated
) {
1006 fprintf(stderr
, "Warning: requested NIC (%s, model %s) "
1007 "was not created (not supported by this machine?)\n",
1008 nd
->name
? nd
->name
: "anonymous",
1009 nd
->model
? nd
->model
: "unspecified");
1014 static int net_init_client(QemuOpts
*opts
, void *dummy
)
1016 Error
*local_err
= NULL
;
1018 net_client_init(opts
, 0, &local_err
);
1019 if (error_is_set(&local_err
)) {
1020 qerror_report_err(local_err
);
1021 error_free(local_err
);
1028 static int net_init_netdev(QemuOpts
*opts
, void *dummy
)
1030 Error
*local_err
= NULL
;
1033 ret
= net_client_init(opts
, 1, &local_err
);
1034 if (error_is_set(&local_err
)) {
1035 qerror_report_err(local_err
);
1036 error_free(local_err
);
1043 int net_init_clients(void)
1045 QemuOptsList
*net
= qemu_find_opts("net");
1048 /* if no clients, we use a default config */
1049 qemu_opts_set(net
, NULL
, "type", "nic");
1051 qemu_opts_set(net
, NULL
, "type", "user");
1055 QTAILQ_INIT(&net_clients
);
1057 if (qemu_opts_foreach(qemu_find_opts("netdev"), net_init_netdev
, NULL
, 1) == -1)
1060 if (qemu_opts_foreach(net
, net_init_client
, NULL
, 1) == -1) {
1067 int net_client_parse(QemuOptsList
*opts_list
, const char *optarg
)
1069 #if defined(CONFIG_SLIRP)
1071 if (net_slirp_parse_legacy(opts_list
, optarg
, &ret
)) {
1076 if (!qemu_opts_parse(opts_list
, optarg
, 1)) {
1086 unsigned compute_mcast_idx(const uint8_t *ep
)
1093 for (i
= 0; i
< 6; i
++) {
1095 for (j
= 0; j
< 8; j
++) {
1096 carry
= ((crc
& 0x80000000L
) ? 1 : 0) ^ (b
& 0x01);
1100 crc
= ((crc
^ POLYNOMIAL
) | carry
);
1107 QemuOptsList qemu_netdev_opts
= {
1109 .implied_opt_name
= "type",
1110 .head
= QTAILQ_HEAD_INITIALIZER(qemu_netdev_opts
.head
),
1113 * no elements => accept any params
1114 * validation will happen later
1116 { /* end of list */ }
1120 QemuOptsList qemu_net_opts
= {
1122 .implied_opt_name
= "type",
1123 .head
= QTAILQ_HEAD_INITIALIZER(qemu_net_opts
.head
),
1126 * no elements => accept any params
1127 * validation will happen later
1129 { /* end of list */ }