eepro100: Fix alignment requirement for statistical counters
[qemu.git] / net.c
blobcb52050bfd3f261798ca6fec80e7d09f2f350e4e
1 /*
2 * QEMU System Emulator
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
22 * THE SOFTWARE.
24 #include "net.h"
26 #include "config-host.h"
28 #include "net/tap.h"
29 #include "net/socket.h"
30 #include "net/dump.h"
31 #include "net/slirp.h"
32 #include "net/vde.h"
33 #include "net/util.h"
34 #include "monitor.h"
35 #include "qemu-common.h"
36 #include "qemu_socket.h"
37 #include "hw/qdev.h"
38 #include "iov.h"
40 static QTAILQ_HEAD(, VLANState) vlans;
41 static QTAILQ_HEAD(, VLANClientState) non_vlan_clients;
43 int default_net = 1;
45 /***********************************************************/
46 /* network device redirectors */
48 #if defined(DEBUG_NET)
49 static void hex_dump(FILE *f, const uint8_t *buf, int size)
51 int len, i, j, c;
53 for(i=0;i<size;i+=16) {
54 len = size - i;
55 if (len > 16)
56 len = 16;
57 fprintf(f, "%08x ", i);
58 for(j=0;j<16;j++) {
59 if (j < len)
60 fprintf(f, " %02x", buf[i+j]);
61 else
62 fprintf(f, " ");
64 fprintf(f, " ");
65 for(j=0;j<len;j++) {
66 c = buf[i+j];
67 if (c < ' ' || c > '~')
68 c = '.';
69 fprintf(f, "%c", c);
71 fprintf(f, "\n");
74 #endif
76 static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
78 const char *p, *p1;
79 int len;
80 p = *pp;
81 p1 = strchr(p, sep);
82 if (!p1)
83 return -1;
84 len = p1 - p;
85 p1++;
86 if (buf_size > 0) {
87 if (len > buf_size - 1)
88 len = buf_size - 1;
89 memcpy(buf, p, len);
90 buf[len] = '\0';
92 *pp = p1;
93 return 0;
96 int parse_host_port(struct sockaddr_in *saddr, const char *str)
98 char buf[512];
99 struct hostent *he;
100 const char *p, *r;
101 int port;
103 p = str;
104 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
105 return -1;
106 saddr->sin_family = AF_INET;
107 if (buf[0] == '\0') {
108 saddr->sin_addr.s_addr = 0;
109 } else {
110 if (qemu_isdigit(buf[0])) {
111 if (!inet_aton(buf, &saddr->sin_addr))
112 return -1;
113 } else {
114 if ((he = gethostbyname(buf)) == NULL)
115 return - 1;
116 saddr->sin_addr = *(struct in_addr *)he->h_addr;
119 port = strtol(p, (char **)&r, 0);
120 if (r == p)
121 return -1;
122 saddr->sin_port = htons(port);
123 return 0;
126 void qemu_format_nic_info_str(VLANClientState *vc, uint8_t macaddr[6])
128 snprintf(vc->info_str, sizeof(vc->info_str),
129 "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
130 vc->model,
131 macaddr[0], macaddr[1], macaddr[2],
132 macaddr[3], macaddr[4], macaddr[5]);
135 void qemu_macaddr_default_if_unset(MACAddr *macaddr)
137 static int index = 0;
138 static const MACAddr zero = { .a = { 0,0,0,0,0,0 } };
140 if (memcmp(macaddr, &zero, sizeof(zero)) != 0)
141 return;
142 macaddr->a[0] = 0x52;
143 macaddr->a[1] = 0x54;
144 macaddr->a[2] = 0x00;
145 macaddr->a[3] = 0x12;
146 macaddr->a[4] = 0x34;
147 macaddr->a[5] = 0x56 + index++;
150 static char *assign_name(VLANClientState *vc1, const char *model)
152 VLANState *vlan;
153 VLANClientState *vc;
154 char buf[256];
155 int id = 0;
157 QTAILQ_FOREACH(vlan, &vlans, next) {
158 QTAILQ_FOREACH(vc, &vlan->clients, next) {
159 if (vc != vc1 && strcmp(vc->model, model) == 0) {
160 id++;
165 QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
166 if (vc != vc1 && strcmp(vc->model, model) == 0) {
167 id++;
171 snprintf(buf, sizeof(buf), "%s.%d", model, id);
173 return g_strdup(buf);
176 static ssize_t qemu_deliver_packet(VLANClientState *sender,
177 unsigned flags,
178 const uint8_t *data,
179 size_t size,
180 void *opaque);
181 static ssize_t qemu_deliver_packet_iov(VLANClientState *sender,
182 unsigned flags,
183 const struct iovec *iov,
184 int iovcnt,
185 void *opaque);
187 VLANClientState *qemu_new_net_client(NetClientInfo *info,
188 VLANState *vlan,
189 VLANClientState *peer,
190 const char *model,
191 const char *name)
193 VLANClientState *vc;
195 assert(info->size >= sizeof(VLANClientState));
197 vc = g_malloc0(info->size);
199 vc->info = info;
200 vc->model = g_strdup(model);
201 if (name) {
202 vc->name = g_strdup(name);
203 } else {
204 vc->name = assign_name(vc, model);
207 if (vlan) {
208 assert(!peer);
209 vc->vlan = vlan;
210 QTAILQ_INSERT_TAIL(&vc->vlan->clients, vc, next);
211 } else {
212 if (peer) {
213 assert(!peer->peer);
214 vc->peer = peer;
215 peer->peer = vc;
217 QTAILQ_INSERT_TAIL(&non_vlan_clients, vc, next);
219 vc->send_queue = qemu_new_net_queue(qemu_deliver_packet,
220 qemu_deliver_packet_iov,
221 vc);
224 return vc;
227 NICState *qemu_new_nic(NetClientInfo *info,
228 NICConf *conf,
229 const char *model,
230 const char *name,
231 void *opaque)
233 VLANClientState *nc;
234 NICState *nic;
236 assert(info->type == NET_CLIENT_TYPE_NIC);
237 assert(info->size >= sizeof(NICState));
239 nc = qemu_new_net_client(info, conf->vlan, conf->peer, model, name);
241 nic = DO_UPCAST(NICState, nc, nc);
242 nic->conf = conf;
243 nic->opaque = opaque;
245 return nic;
248 static void qemu_cleanup_vlan_client(VLANClientState *vc)
250 if (vc->vlan) {
251 QTAILQ_REMOVE(&vc->vlan->clients, vc, next);
252 } else {
253 QTAILQ_REMOVE(&non_vlan_clients, vc, next);
256 if (vc->info->cleanup) {
257 vc->info->cleanup(vc);
261 static void qemu_free_vlan_client(VLANClientState *vc)
263 if (!vc->vlan) {
264 if (vc->send_queue) {
265 qemu_del_net_queue(vc->send_queue);
267 if (vc->peer) {
268 vc->peer->peer = NULL;
271 g_free(vc->name);
272 g_free(vc->model);
273 g_free(vc);
276 void qemu_del_vlan_client(VLANClientState *vc)
278 /* If there is a peer NIC, delete and cleanup client, but do not free. */
279 if (!vc->vlan && vc->peer && vc->peer->info->type == NET_CLIENT_TYPE_NIC) {
280 NICState *nic = DO_UPCAST(NICState, nc, vc->peer);
281 if (nic->peer_deleted) {
282 return;
284 nic->peer_deleted = true;
285 /* Let NIC know peer is gone. */
286 vc->peer->link_down = true;
287 if (vc->peer->info->link_status_changed) {
288 vc->peer->info->link_status_changed(vc->peer);
290 qemu_cleanup_vlan_client(vc);
291 return;
294 /* If this is a peer NIC and peer has already been deleted, free it now. */
295 if (!vc->vlan && vc->peer && vc->info->type == NET_CLIENT_TYPE_NIC) {
296 NICState *nic = DO_UPCAST(NICState, nc, vc);
297 if (nic->peer_deleted) {
298 qemu_free_vlan_client(vc->peer);
302 qemu_cleanup_vlan_client(vc);
303 qemu_free_vlan_client(vc);
306 VLANClientState *
307 qemu_find_vlan_client_by_name(Monitor *mon, int vlan_id,
308 const char *client_str)
310 VLANState *vlan;
311 VLANClientState *vc;
313 vlan = qemu_find_vlan(vlan_id, 0);
314 if (!vlan) {
315 monitor_printf(mon, "unknown VLAN %d\n", vlan_id);
316 return NULL;
319 QTAILQ_FOREACH(vc, &vlan->clients, next) {
320 if (!strcmp(vc->name, client_str)) {
321 break;
324 if (!vc) {
325 monitor_printf(mon, "can't find device %s on VLAN %d\n",
326 client_str, vlan_id);
329 return vc;
332 void qemu_foreach_nic(qemu_nic_foreach func, void *opaque)
334 VLANClientState *nc;
335 VLANState *vlan;
337 QTAILQ_FOREACH(nc, &non_vlan_clients, next) {
338 if (nc->info->type == NET_CLIENT_TYPE_NIC) {
339 func(DO_UPCAST(NICState, nc, nc), opaque);
343 QTAILQ_FOREACH(vlan, &vlans, next) {
344 QTAILQ_FOREACH(nc, &vlan->clients, next) {
345 if (nc->info->type == NET_CLIENT_TYPE_NIC) {
346 func(DO_UPCAST(NICState, nc, nc), opaque);
352 int qemu_can_send_packet(VLANClientState *sender)
354 VLANState *vlan = sender->vlan;
355 VLANClientState *vc;
357 if (sender->peer) {
358 if (sender->peer->receive_disabled) {
359 return 0;
360 } else if (sender->peer->info->can_receive &&
361 !sender->peer->info->can_receive(sender->peer)) {
362 return 0;
363 } else {
364 return 1;
368 if (!sender->vlan) {
369 return 1;
372 QTAILQ_FOREACH(vc, &vlan->clients, next) {
373 if (vc == sender) {
374 continue;
377 /* no can_receive() handler, they can always receive */
378 if (vc->info->can_receive && !vc->info->can_receive(vc)) {
379 return 0;
382 return 1;
385 static ssize_t qemu_deliver_packet(VLANClientState *sender,
386 unsigned flags,
387 const uint8_t *data,
388 size_t size,
389 void *opaque)
391 VLANClientState *vc = opaque;
392 ssize_t ret;
394 if (vc->link_down) {
395 return size;
398 if (vc->receive_disabled) {
399 return 0;
402 if (flags & QEMU_NET_PACKET_FLAG_RAW && vc->info->receive_raw) {
403 ret = vc->info->receive_raw(vc, data, size);
404 } else {
405 ret = vc->info->receive(vc, data, size);
408 if (ret == 0) {
409 vc->receive_disabled = 1;
412 return ret;
415 static ssize_t qemu_vlan_deliver_packet(VLANClientState *sender,
416 unsigned flags,
417 const uint8_t *buf,
418 size_t size,
419 void *opaque)
421 VLANState *vlan = opaque;
422 VLANClientState *vc;
423 ssize_t ret = -1;
425 QTAILQ_FOREACH(vc, &vlan->clients, next) {
426 ssize_t len;
428 if (vc == sender) {
429 continue;
432 if (vc->link_down) {
433 ret = size;
434 continue;
437 if (vc->receive_disabled) {
438 ret = 0;
439 continue;
442 if (flags & QEMU_NET_PACKET_FLAG_RAW && vc->info->receive_raw) {
443 len = vc->info->receive_raw(vc, buf, size);
444 } else {
445 len = vc->info->receive(vc, buf, size);
448 if (len == 0) {
449 vc->receive_disabled = 1;
452 ret = (ret >= 0) ? ret : len;
456 return ret;
459 void qemu_purge_queued_packets(VLANClientState *vc)
461 NetQueue *queue;
463 if (!vc->peer && !vc->vlan) {
464 return;
467 if (vc->peer) {
468 queue = vc->peer->send_queue;
469 } else {
470 queue = vc->vlan->send_queue;
473 qemu_net_queue_purge(queue, vc);
476 void qemu_flush_queued_packets(VLANClientState *vc)
478 NetQueue *queue;
480 vc->receive_disabled = 0;
482 if (vc->vlan) {
483 queue = vc->vlan->send_queue;
484 } else {
485 queue = vc->send_queue;
488 qemu_net_queue_flush(queue);
491 static ssize_t qemu_send_packet_async_with_flags(VLANClientState *sender,
492 unsigned flags,
493 const uint8_t *buf, int size,
494 NetPacketSent *sent_cb)
496 NetQueue *queue;
498 #ifdef DEBUG_NET
499 printf("qemu_send_packet_async:\n");
500 hex_dump(stdout, buf, size);
501 #endif
503 if (sender->link_down || (!sender->peer && !sender->vlan)) {
504 return size;
507 if (sender->peer) {
508 queue = sender->peer->send_queue;
509 } else {
510 queue = sender->vlan->send_queue;
513 return qemu_net_queue_send(queue, sender, flags, buf, size, sent_cb);
516 ssize_t qemu_send_packet_async(VLANClientState *sender,
517 const uint8_t *buf, int size,
518 NetPacketSent *sent_cb)
520 return qemu_send_packet_async_with_flags(sender, QEMU_NET_PACKET_FLAG_NONE,
521 buf, size, sent_cb);
524 void qemu_send_packet(VLANClientState *vc, const uint8_t *buf, int size)
526 qemu_send_packet_async(vc, buf, size, NULL);
529 ssize_t qemu_send_packet_raw(VLANClientState *vc, const uint8_t *buf, int size)
531 return qemu_send_packet_async_with_flags(vc, QEMU_NET_PACKET_FLAG_RAW,
532 buf, size, NULL);
535 static ssize_t vc_sendv_compat(VLANClientState *vc, const struct iovec *iov,
536 int iovcnt)
538 uint8_t buffer[4096];
539 size_t offset;
541 offset = iov_to_buf(iov, iovcnt, buffer, 0, sizeof(buffer));
543 return vc->info->receive(vc, buffer, offset);
546 static ssize_t qemu_deliver_packet_iov(VLANClientState *sender,
547 unsigned flags,
548 const struct iovec *iov,
549 int iovcnt,
550 void *opaque)
552 VLANClientState *vc = opaque;
554 if (vc->link_down) {
555 return iov_size(iov, iovcnt);
558 if (vc->info->receive_iov) {
559 return vc->info->receive_iov(vc, iov, iovcnt);
560 } else {
561 return vc_sendv_compat(vc, iov, iovcnt);
565 static ssize_t qemu_vlan_deliver_packet_iov(VLANClientState *sender,
566 unsigned flags,
567 const struct iovec *iov,
568 int iovcnt,
569 void *opaque)
571 VLANState *vlan = opaque;
572 VLANClientState *vc;
573 ssize_t ret = -1;
575 QTAILQ_FOREACH(vc, &vlan->clients, next) {
576 ssize_t len;
578 if (vc == sender) {
579 continue;
582 if (vc->link_down) {
583 ret = iov_size(iov, iovcnt);
584 continue;
587 assert(!(flags & QEMU_NET_PACKET_FLAG_RAW));
589 if (vc->info->receive_iov) {
590 len = vc->info->receive_iov(vc, iov, iovcnt);
591 } else {
592 len = vc_sendv_compat(vc, iov, iovcnt);
595 ret = (ret >= 0) ? ret : len;
598 return ret;
601 ssize_t qemu_sendv_packet_async(VLANClientState *sender,
602 const struct iovec *iov, int iovcnt,
603 NetPacketSent *sent_cb)
605 NetQueue *queue;
607 if (sender->link_down || (!sender->peer && !sender->vlan)) {
608 return iov_size(iov, iovcnt);
611 if (sender->peer) {
612 queue = sender->peer->send_queue;
613 } else {
614 queue = sender->vlan->send_queue;
617 return qemu_net_queue_send_iov(queue, sender,
618 QEMU_NET_PACKET_FLAG_NONE,
619 iov, iovcnt, sent_cb);
622 ssize_t
623 qemu_sendv_packet(VLANClientState *vc, const struct iovec *iov, int iovcnt)
625 return qemu_sendv_packet_async(vc, iov, iovcnt, NULL);
628 /* find or alloc a new VLAN */
629 VLANState *qemu_find_vlan(int id, int allocate)
631 VLANState *vlan;
633 QTAILQ_FOREACH(vlan, &vlans, next) {
634 if (vlan->id == id) {
635 return vlan;
639 if (!allocate) {
640 return NULL;
643 vlan = g_malloc0(sizeof(VLANState));
644 vlan->id = id;
645 QTAILQ_INIT(&vlan->clients);
647 vlan->send_queue = qemu_new_net_queue(qemu_vlan_deliver_packet,
648 qemu_vlan_deliver_packet_iov,
649 vlan);
651 QTAILQ_INSERT_TAIL(&vlans, vlan, next);
653 return vlan;
656 VLANClientState *qemu_find_netdev(const char *id)
658 VLANClientState *vc;
660 QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
661 if (vc->info->type == NET_CLIENT_TYPE_NIC)
662 continue;
663 if (!strcmp(vc->name, id)) {
664 return vc;
668 return NULL;
671 static int nic_get_free_idx(void)
673 int index;
675 for (index = 0; index < MAX_NICS; index++)
676 if (!nd_table[index].used)
677 return index;
678 return -1;
681 int qemu_show_nic_models(const char *arg, const char *const *models)
683 int i;
685 if (!arg || strcmp(arg, "?"))
686 return 0;
688 fprintf(stderr, "qemu: Supported NIC models: ");
689 for (i = 0 ; models[i]; i++)
690 fprintf(stderr, "%s%c", models[i], models[i+1] ? ',' : '\n');
691 return 1;
694 void qemu_check_nic_model(NICInfo *nd, const char *model)
696 const char *models[2];
698 models[0] = model;
699 models[1] = NULL;
701 if (qemu_show_nic_models(nd->model, models))
702 exit(0);
703 if (qemu_find_nic_model(nd, models, model) < 0)
704 exit(1);
707 int qemu_find_nic_model(NICInfo *nd, const char * const *models,
708 const char *default_model)
710 int i;
712 if (!nd->model)
713 nd->model = g_strdup(default_model);
715 for (i = 0 ; models[i]; i++) {
716 if (strcmp(nd->model, models[i]) == 0)
717 return i;
720 error_report("Unsupported NIC model: %s", nd->model);
721 return -1;
724 int net_handle_fd_param(Monitor *mon, const char *param)
726 int fd;
728 if (!qemu_isdigit(param[0]) && mon) {
730 fd = monitor_get_fd(mon, param);
731 if (fd == -1) {
732 error_report("No file descriptor named %s found", param);
733 return -1;
735 } else {
736 fd = qemu_parse_fd(param);
739 return fd;
742 static int net_init_nic(QemuOpts *opts,
743 Monitor *mon,
744 const char *name,
745 VLANState *vlan)
747 int idx;
748 NICInfo *nd;
749 const char *netdev;
751 idx = nic_get_free_idx();
752 if (idx == -1 || nb_nics >= MAX_NICS) {
753 error_report("Too Many NICs");
754 return -1;
757 nd = &nd_table[idx];
759 memset(nd, 0, sizeof(*nd));
761 if ((netdev = qemu_opt_get(opts, "netdev"))) {
762 nd->netdev = qemu_find_netdev(netdev);
763 if (!nd->netdev) {
764 error_report("netdev '%s' not found", netdev);
765 return -1;
767 } else {
768 assert(vlan);
769 nd->vlan = vlan;
771 if (name) {
772 nd->name = g_strdup(name);
774 if (qemu_opt_get(opts, "model")) {
775 nd->model = g_strdup(qemu_opt_get(opts, "model"));
777 if (qemu_opt_get(opts, "addr")) {
778 nd->devaddr = g_strdup(qemu_opt_get(opts, "addr"));
781 if (qemu_opt_get(opts, "macaddr") &&
782 net_parse_macaddr(nd->macaddr.a, qemu_opt_get(opts, "macaddr")) < 0) {
783 error_report("invalid syntax for ethernet address");
784 return -1;
786 qemu_macaddr_default_if_unset(&nd->macaddr);
788 nd->nvectors = qemu_opt_get_number(opts, "vectors",
789 DEV_NVECTORS_UNSPECIFIED);
790 if (nd->nvectors != DEV_NVECTORS_UNSPECIFIED &&
791 (nd->nvectors < 0 || nd->nvectors > 0x7ffffff)) {
792 error_report("invalid # of vectors: %d", nd->nvectors);
793 return -1;
796 nd->used = 1;
797 nb_nics++;
799 return idx;
802 #define NET_COMMON_PARAMS_DESC \
804 .name = "type", \
805 .type = QEMU_OPT_STRING, \
806 .help = "net client type (nic, tap etc.)", \
807 }, { \
808 .name = "vlan", \
809 .type = QEMU_OPT_NUMBER, \
810 .help = "vlan number", \
811 }, { \
812 .name = "name", \
813 .type = QEMU_OPT_STRING, \
814 .help = "identifier for monitor commands", \
817 typedef int (*net_client_init_func)(QemuOpts *opts,
818 Monitor *mon,
819 const char *name,
820 VLANState *vlan);
822 /* magic number, but compiler will warn if too small */
823 #define NET_MAX_DESC 20
825 static const struct {
826 const char *type;
827 net_client_init_func init;
828 QemuOptDesc desc[NET_MAX_DESC];
829 } net_client_types[NET_CLIENT_TYPE_MAX] = {
830 [NET_CLIENT_TYPE_NONE] = {
831 .type = "none",
832 .desc = {
833 NET_COMMON_PARAMS_DESC,
834 { /* end of list */ }
837 [NET_CLIENT_TYPE_NIC] = {
838 .type = "nic",
839 .init = net_init_nic,
840 .desc = {
841 NET_COMMON_PARAMS_DESC,
843 .name = "netdev",
844 .type = QEMU_OPT_STRING,
845 .help = "id of -netdev to connect to",
848 .name = "macaddr",
849 .type = QEMU_OPT_STRING,
850 .help = "MAC address",
851 }, {
852 .name = "model",
853 .type = QEMU_OPT_STRING,
854 .help = "device model (e1000, rtl8139, virtio etc.)",
855 }, {
856 .name = "addr",
857 .type = QEMU_OPT_STRING,
858 .help = "PCI device address",
859 }, {
860 .name = "vectors",
861 .type = QEMU_OPT_NUMBER,
862 .help = "number of MSI-x vectors, 0 to disable MSI-X",
864 { /* end of list */ }
867 #ifdef CONFIG_SLIRP
868 [NET_CLIENT_TYPE_USER] = {
869 .type = "user",
870 .init = net_init_slirp,
871 .desc = {
872 NET_COMMON_PARAMS_DESC,
874 .name = "hostname",
875 .type = QEMU_OPT_STRING,
876 .help = "client hostname reported by the builtin DHCP server",
877 }, {
878 .name = "restrict",
879 .type = QEMU_OPT_STRING,
880 .help = "isolate the guest from the host (y|yes|n|no)",
881 }, {
882 .name = "ip",
883 .type = QEMU_OPT_STRING,
884 .help = "legacy parameter, use net= instead",
885 }, {
886 .name = "net",
887 .type = QEMU_OPT_STRING,
888 .help = "IP address and optional netmask",
889 }, {
890 .name = "host",
891 .type = QEMU_OPT_STRING,
892 .help = "guest-visible address of the host",
893 }, {
894 .name = "tftp",
895 .type = QEMU_OPT_STRING,
896 .help = "root directory of the built-in TFTP server",
897 }, {
898 .name = "bootfile",
899 .type = QEMU_OPT_STRING,
900 .help = "BOOTP filename, for use with tftp=",
901 }, {
902 .name = "dhcpstart",
903 .type = QEMU_OPT_STRING,
904 .help = "the first of the 16 IPs the built-in DHCP server can assign",
905 }, {
906 .name = "dns",
907 .type = QEMU_OPT_STRING,
908 .help = "guest-visible address of the virtual nameserver",
909 }, {
910 .name = "smb",
911 .type = QEMU_OPT_STRING,
912 .help = "root directory of the built-in SMB server",
913 }, {
914 .name = "smbserver",
915 .type = QEMU_OPT_STRING,
916 .help = "IP address of the built-in SMB server",
917 }, {
918 .name = "hostfwd",
919 .type = QEMU_OPT_STRING,
920 .help = "guest port number to forward incoming TCP or UDP connections",
921 }, {
922 .name = "guestfwd",
923 .type = QEMU_OPT_STRING,
924 .help = "IP address and port to forward guest TCP connections",
926 { /* end of list */ }
929 #endif
930 [NET_CLIENT_TYPE_TAP] = {
931 .type = "tap",
932 .init = net_init_tap,
933 .desc = {
934 NET_COMMON_PARAMS_DESC,
936 .name = "ifname",
937 .type = QEMU_OPT_STRING,
938 .help = "interface name",
940 #ifndef _WIN32
942 .name = "fd",
943 .type = QEMU_OPT_STRING,
944 .help = "file descriptor of an already opened tap",
945 }, {
946 .name = "script",
947 .type = QEMU_OPT_STRING,
948 .help = "script to initialize the interface",
949 }, {
950 .name = "downscript",
951 .type = QEMU_OPT_STRING,
952 .help = "script to shut down the interface",
953 }, {
954 .name = "sndbuf",
955 .type = QEMU_OPT_SIZE,
956 .help = "send buffer limit"
957 }, {
958 .name = "vnet_hdr",
959 .type = QEMU_OPT_BOOL,
960 .help = "enable the IFF_VNET_HDR flag on the tap interface"
961 }, {
962 .name = "vhost",
963 .type = QEMU_OPT_BOOL,
964 .help = "enable vhost-net network accelerator",
965 }, {
966 .name = "vhostfd",
967 .type = QEMU_OPT_STRING,
968 .help = "file descriptor of an already opened vhost net device",
969 }, {
970 .name = "vhostforce",
971 .type = QEMU_OPT_BOOL,
972 .help = "force vhost on for non-MSIX virtio guests",
974 #endif /* _WIN32 */
975 { /* end of list */ }
978 [NET_CLIENT_TYPE_SOCKET] = {
979 .type = "socket",
980 .init = net_init_socket,
981 .desc = {
982 NET_COMMON_PARAMS_DESC,
984 .name = "fd",
985 .type = QEMU_OPT_STRING,
986 .help = "file descriptor of an already opened socket",
987 }, {
988 .name = "listen",
989 .type = QEMU_OPT_STRING,
990 .help = "port number, and optional hostname, to listen on",
991 }, {
992 .name = "connect",
993 .type = QEMU_OPT_STRING,
994 .help = "port number, and optional hostname, to connect to",
995 }, {
996 .name = "mcast",
997 .type = QEMU_OPT_STRING,
998 .help = "UDP multicast address and port number",
999 }, {
1000 .name = "localaddr",
1001 .type = QEMU_OPT_STRING,
1002 .help = "source address for multicast packets",
1004 { /* end of list */ }
1007 #ifdef CONFIG_VDE
1008 [NET_CLIENT_TYPE_VDE] = {
1009 .type = "vde",
1010 .init = net_init_vde,
1011 .desc = {
1012 NET_COMMON_PARAMS_DESC,
1014 .name = "sock",
1015 .type = QEMU_OPT_STRING,
1016 .help = "socket path",
1017 }, {
1018 .name = "port",
1019 .type = QEMU_OPT_NUMBER,
1020 .help = "port number",
1021 }, {
1022 .name = "group",
1023 .type = QEMU_OPT_STRING,
1024 .help = "group owner of socket",
1025 }, {
1026 .name = "mode",
1027 .type = QEMU_OPT_NUMBER,
1028 .help = "permissions for socket",
1030 { /* end of list */ }
1033 #endif
1034 [NET_CLIENT_TYPE_DUMP] = {
1035 .type = "dump",
1036 .init = net_init_dump,
1037 .desc = {
1038 NET_COMMON_PARAMS_DESC,
1040 .name = "len",
1041 .type = QEMU_OPT_SIZE,
1042 .help = "per-packet size limit (64k default)",
1043 }, {
1044 .name = "file",
1045 .type = QEMU_OPT_STRING,
1046 .help = "dump file path (default is qemu-vlan0.pcap)",
1048 { /* end of list */ }
1053 int net_client_init(Monitor *mon, QemuOpts *opts, int is_netdev)
1055 const char *name;
1056 const char *type;
1057 int i;
1059 type = qemu_opt_get(opts, "type");
1060 if (!type) {
1061 qerror_report(QERR_MISSING_PARAMETER, "type");
1062 return -1;
1065 if (is_netdev) {
1066 if (strcmp(type, "tap") != 0 &&
1067 #ifdef CONFIG_SLIRP
1068 strcmp(type, "user") != 0 &&
1069 #endif
1070 #ifdef CONFIG_VDE
1071 strcmp(type, "vde") != 0 &&
1072 #endif
1073 strcmp(type, "socket") != 0) {
1074 qerror_report(QERR_INVALID_PARAMETER_VALUE, "type",
1075 "a netdev backend type");
1076 return -1;
1079 if (qemu_opt_get(opts, "vlan")) {
1080 qerror_report(QERR_INVALID_PARAMETER, "vlan");
1081 return -1;
1083 if (qemu_opt_get(opts, "name")) {
1084 qerror_report(QERR_INVALID_PARAMETER, "name");
1085 return -1;
1087 if (!qemu_opts_id(opts)) {
1088 qerror_report(QERR_MISSING_PARAMETER, "id");
1089 return -1;
1093 name = qemu_opts_id(opts);
1094 if (!name) {
1095 name = qemu_opt_get(opts, "name");
1098 for (i = 0; i < NET_CLIENT_TYPE_MAX; i++) {
1099 if (net_client_types[i].type != NULL &&
1100 !strcmp(net_client_types[i].type, type)) {
1101 VLANState *vlan = NULL;
1102 int ret;
1104 if (qemu_opts_validate(opts, &net_client_types[i].desc[0]) == -1) {
1105 return -1;
1108 /* Do not add to a vlan if it's a -netdev or a nic with a
1109 * netdev= parameter. */
1110 if (!(is_netdev ||
1111 (strcmp(type, "nic") == 0 && qemu_opt_get(opts, "netdev")))) {
1112 vlan = qemu_find_vlan(qemu_opt_get_number(opts, "vlan", 0), 1);
1115 ret = 0;
1116 if (net_client_types[i].init) {
1117 ret = net_client_types[i].init(opts, mon, name, vlan);
1118 if (ret < 0) {
1119 /* TODO push error reporting into init() methods */
1120 qerror_report(QERR_DEVICE_INIT_FAILED, type);
1121 return -1;
1124 return ret;
1128 qerror_report(QERR_INVALID_PARAMETER_VALUE, "type",
1129 "a network client type");
1130 return -1;
1133 static int net_host_check_device(const char *device)
1135 int i;
1136 const char *valid_param_list[] = { "tap", "socket", "dump"
1137 #ifdef CONFIG_SLIRP
1138 ,"user"
1139 #endif
1140 #ifdef CONFIG_VDE
1141 ,"vde"
1142 #endif
1144 for (i = 0; i < sizeof(valid_param_list) / sizeof(char *); i++) {
1145 if (!strncmp(valid_param_list[i], device,
1146 strlen(valid_param_list[i])))
1147 return 1;
1150 return 0;
1153 void net_host_device_add(Monitor *mon, const QDict *qdict)
1155 const char *device = qdict_get_str(qdict, "device");
1156 const char *opts_str = qdict_get_try_str(qdict, "opts");
1157 QemuOpts *opts;
1159 if (!net_host_check_device(device)) {
1160 monitor_printf(mon, "invalid host network device %s\n", device);
1161 return;
1164 opts = qemu_opts_parse(qemu_find_opts("net"), opts_str ? opts_str : "", 0);
1165 if (!opts) {
1166 return;
1169 qemu_opt_set(opts, "type", device);
1171 if (net_client_init(mon, opts, 0) < 0) {
1172 monitor_printf(mon, "adding host network device %s failed\n", device);
1176 void net_host_device_remove(Monitor *mon, const QDict *qdict)
1178 VLANClientState *vc;
1179 int vlan_id = qdict_get_int(qdict, "vlan_id");
1180 const char *device = qdict_get_str(qdict, "device");
1182 vc = qemu_find_vlan_client_by_name(mon, vlan_id, device);
1183 if (!vc) {
1184 return;
1186 if (!net_host_check_device(vc->model)) {
1187 monitor_printf(mon, "invalid host network device %s\n", device);
1188 return;
1190 qemu_del_vlan_client(vc);
1193 int do_netdev_add(Monitor *mon, const QDict *qdict, QObject **ret_data)
1195 QemuOpts *opts;
1196 int res;
1198 opts = qemu_opts_from_qdict(qemu_find_opts("netdev"), qdict);
1199 if (!opts) {
1200 return -1;
1203 res = net_client_init(mon, opts, 1);
1204 if (res < 0) {
1205 qemu_opts_del(opts);
1208 return res;
1211 int do_netdev_del(Monitor *mon, const QDict *qdict, QObject **ret_data)
1213 const char *id = qdict_get_str(qdict, "id");
1214 VLANClientState *vc;
1216 vc = qemu_find_netdev(id);
1217 if (!vc) {
1218 qerror_report(QERR_DEVICE_NOT_FOUND, id);
1219 return -1;
1221 qemu_del_vlan_client(vc);
1222 qemu_opts_del(qemu_opts_find(qemu_find_opts("netdev"), id));
1223 return 0;
1226 static void print_net_client(Monitor *mon, VLANClientState *vc)
1228 monitor_printf(mon, "%s: type=%s,%s\n", vc->name,
1229 net_client_types[vc->info->type].type, vc->info_str);
1232 void do_info_network(Monitor *mon)
1234 VLANState *vlan;
1235 VLANClientState *vc, *peer;
1236 net_client_type type;
1238 QTAILQ_FOREACH(vlan, &vlans, next) {
1239 monitor_printf(mon, "VLAN %d devices:\n", vlan->id);
1241 QTAILQ_FOREACH(vc, &vlan->clients, next) {
1242 monitor_printf(mon, " ");
1243 print_net_client(mon, vc);
1246 monitor_printf(mon, "Devices not on any VLAN:\n");
1247 QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
1248 peer = vc->peer;
1249 type = vc->info->type;
1250 if (!peer || type == NET_CLIENT_TYPE_NIC) {
1251 monitor_printf(mon, " ");
1252 print_net_client(mon, vc);
1253 } /* else it's a netdev connected to a NIC, printed with the NIC */
1254 if (peer && type == NET_CLIENT_TYPE_NIC) {
1255 monitor_printf(mon, " \\ ");
1256 print_net_client(mon, peer);
1261 int do_set_link(Monitor *mon, const QDict *qdict, QObject **ret_data)
1263 VLANState *vlan;
1264 VLANClientState *vc = NULL;
1265 const char *name = qdict_get_str(qdict, "name");
1266 int up = qdict_get_bool(qdict, "up");
1268 QTAILQ_FOREACH(vlan, &vlans, next) {
1269 QTAILQ_FOREACH(vc, &vlan->clients, next) {
1270 if (strcmp(vc->name, name) == 0) {
1271 goto done;
1275 QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
1276 if (!strcmp(vc->name, name)) {
1277 goto done;
1280 done:
1282 if (!vc) {
1283 qerror_report(QERR_DEVICE_NOT_FOUND, name);
1284 return -1;
1287 vc->link_down = !up;
1289 if (vc->info->link_status_changed) {
1290 vc->info->link_status_changed(vc);
1293 /* Notify peer. Don't update peer link status: this makes it possible to
1294 * disconnect from host network without notifying the guest.
1295 * FIXME: is disconnected link status change operation useful?
1297 * Current behaviour is compatible with qemu vlans where there could be
1298 * multiple clients that can still communicate with each other in
1299 * disconnected mode. For now maintain this compatibility. */
1300 if (vc->peer && vc->peer->info->link_status_changed) {
1301 vc->peer->info->link_status_changed(vc->peer);
1303 return 0;
1306 void net_cleanup(void)
1308 VLANState *vlan;
1309 VLANClientState *vc, *next_vc;
1311 QTAILQ_FOREACH(vlan, &vlans, next) {
1312 QTAILQ_FOREACH_SAFE(vc, &vlan->clients, next, next_vc) {
1313 qemu_del_vlan_client(vc);
1317 QTAILQ_FOREACH_SAFE(vc, &non_vlan_clients, next, next_vc) {
1318 qemu_del_vlan_client(vc);
1322 void net_check_clients(void)
1324 VLANState *vlan;
1325 VLANClientState *vc;
1326 int i;
1328 /* Don't warn about the default network setup that you get if
1329 * no command line -net or -netdev options are specified. There
1330 * are two cases that we would otherwise complain about:
1331 * (1) board doesn't support a NIC but the implicit "-net nic"
1332 * requested one
1333 * (2) CONFIG_SLIRP not set, in which case the implicit "-net nic"
1334 * sets up a nic that isn't connected to anything.
1336 if (default_net) {
1337 return;
1340 QTAILQ_FOREACH(vlan, &vlans, next) {
1341 int has_nic = 0, has_host_dev = 0;
1343 QTAILQ_FOREACH(vc, &vlan->clients, next) {
1344 switch (vc->info->type) {
1345 case NET_CLIENT_TYPE_NIC:
1346 has_nic = 1;
1347 break;
1348 case NET_CLIENT_TYPE_USER:
1349 case NET_CLIENT_TYPE_TAP:
1350 case NET_CLIENT_TYPE_SOCKET:
1351 case NET_CLIENT_TYPE_VDE:
1352 has_host_dev = 1;
1353 break;
1354 default: ;
1357 if (has_host_dev && !has_nic)
1358 fprintf(stderr, "Warning: vlan %d with no nics\n", vlan->id);
1359 if (has_nic && !has_host_dev)
1360 fprintf(stderr,
1361 "Warning: vlan %d is not connected to host network\n",
1362 vlan->id);
1364 QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
1365 if (!vc->peer) {
1366 fprintf(stderr, "Warning: %s %s has no peer\n",
1367 vc->info->type == NET_CLIENT_TYPE_NIC ? "nic" : "netdev",
1368 vc->name);
1372 /* Check that all NICs requested via -net nic actually got created.
1373 * NICs created via -device don't need to be checked here because
1374 * they are always instantiated.
1376 for (i = 0; i < MAX_NICS; i++) {
1377 NICInfo *nd = &nd_table[i];
1378 if (nd->used && !nd->instantiated) {
1379 fprintf(stderr, "Warning: requested NIC (%s, model %s) "
1380 "was not created (not supported by this machine?)\n",
1381 nd->name ? nd->name : "anonymous",
1382 nd->model ? nd->model : "unspecified");
1387 static int net_init_client(QemuOpts *opts, void *dummy)
1389 if (net_client_init(NULL, opts, 0) < 0)
1390 return -1;
1391 return 0;
1394 static int net_init_netdev(QemuOpts *opts, void *dummy)
1396 return net_client_init(NULL, opts, 1);
1399 int net_init_clients(void)
1401 QemuOptsList *net = qemu_find_opts("net");
1403 if (default_net) {
1404 /* if no clients, we use a default config */
1405 qemu_opts_set(net, NULL, "type", "nic");
1406 #ifdef CONFIG_SLIRP
1407 qemu_opts_set(net, NULL, "type", "user");
1408 #endif
1411 QTAILQ_INIT(&vlans);
1412 QTAILQ_INIT(&non_vlan_clients);
1414 if (qemu_opts_foreach(qemu_find_opts("netdev"), net_init_netdev, NULL, 1) == -1)
1415 return -1;
1417 if (qemu_opts_foreach(net, net_init_client, NULL, 1) == -1) {
1418 return -1;
1421 return 0;
1424 int net_client_parse(QemuOptsList *opts_list, const char *optarg)
1426 #if defined(CONFIG_SLIRP)
1427 int ret;
1428 if (net_slirp_parse_legacy(opts_list, optarg, &ret)) {
1429 return ret;
1431 #endif
1433 if (!qemu_opts_parse(opts_list, optarg, 1)) {
1434 return -1;
1437 default_net = 0;
1438 return 0;