]> git.proxmox.com Git - qemu.git/blob - net.c
net: net_client_init(): use error_set()
[qemu.git] / net.c
1 /*
2 * QEMU System Emulator
3 *
4 * Copyright (c) 2003-2008 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24 #include "net.h"
25
26 #include "config-host.h"
27
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 "qmp-commands.h"
38 #include "hw/qdev.h"
39 #include "iov.h"
40
41 /* Net bridge is currently not supported for W32. */
42 #if !defined(_WIN32)
43 # define CONFIG_NET_BRIDGE
44 #endif
45
46 static QTAILQ_HEAD(, VLANState) vlans;
47 static QTAILQ_HEAD(, VLANClientState) non_vlan_clients;
48
49 int default_net = 1;
50
51 /***********************************************************/
52 /* network device redirectors */
53
54 #if defined(DEBUG_NET)
55 static void hex_dump(FILE *f, const uint8_t *buf, int size)
56 {
57 int len, i, j, c;
58
59 for(i=0;i<size;i+=16) {
60 len = size - i;
61 if (len > 16)
62 len = 16;
63 fprintf(f, "%08x ", i);
64 for(j=0;j<16;j++) {
65 if (j < len)
66 fprintf(f, " %02x", buf[i+j]);
67 else
68 fprintf(f, " ");
69 }
70 fprintf(f, " ");
71 for(j=0;j<len;j++) {
72 c = buf[i+j];
73 if (c < ' ' || c > '~')
74 c = '.';
75 fprintf(f, "%c", c);
76 }
77 fprintf(f, "\n");
78 }
79 }
80 #endif
81
82 static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
83 {
84 const char *p, *p1;
85 int len;
86 p = *pp;
87 p1 = strchr(p, sep);
88 if (!p1)
89 return -1;
90 len = p1 - p;
91 p1++;
92 if (buf_size > 0) {
93 if (len > buf_size - 1)
94 len = buf_size - 1;
95 memcpy(buf, p, len);
96 buf[len] = '\0';
97 }
98 *pp = p1;
99 return 0;
100 }
101
102 int parse_host_port(struct sockaddr_in *saddr, const char *str)
103 {
104 char buf[512];
105 struct hostent *he;
106 const char *p, *r;
107 int port;
108
109 p = str;
110 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
111 return -1;
112 saddr->sin_family = AF_INET;
113 if (buf[0] == '\0') {
114 saddr->sin_addr.s_addr = 0;
115 } else {
116 if (qemu_isdigit(buf[0])) {
117 if (!inet_aton(buf, &saddr->sin_addr))
118 return -1;
119 } else {
120 if ((he = gethostbyname(buf)) == NULL)
121 return - 1;
122 saddr->sin_addr = *(struct in_addr *)he->h_addr;
123 }
124 }
125 port = strtol(p, (char **)&r, 0);
126 if (r == p)
127 return -1;
128 saddr->sin_port = htons(port);
129 return 0;
130 }
131
132 void qemu_format_nic_info_str(VLANClientState *vc, uint8_t macaddr[6])
133 {
134 snprintf(vc->info_str, sizeof(vc->info_str),
135 "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
136 vc->model,
137 macaddr[0], macaddr[1], macaddr[2],
138 macaddr[3], macaddr[4], macaddr[5]);
139 }
140
141 void qemu_macaddr_default_if_unset(MACAddr *macaddr)
142 {
143 static int index = 0;
144 static const MACAddr zero = { .a = { 0,0,0,0,0,0 } };
145
146 if (memcmp(macaddr, &zero, sizeof(zero)) != 0)
147 return;
148 macaddr->a[0] = 0x52;
149 macaddr->a[1] = 0x54;
150 macaddr->a[2] = 0x00;
151 macaddr->a[3] = 0x12;
152 macaddr->a[4] = 0x34;
153 macaddr->a[5] = 0x56 + index++;
154 }
155
156 static char *assign_name(VLANClientState *vc1, const char *model)
157 {
158 VLANState *vlan;
159 VLANClientState *vc;
160 char buf[256];
161 int id = 0;
162
163 QTAILQ_FOREACH(vlan, &vlans, next) {
164 QTAILQ_FOREACH(vc, &vlan->clients, next) {
165 if (vc != vc1 && strcmp(vc->model, model) == 0) {
166 id++;
167 }
168 }
169 }
170
171 QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
172 if (vc != vc1 && strcmp(vc->model, model) == 0) {
173 id++;
174 }
175 }
176
177 snprintf(buf, sizeof(buf), "%s.%d", model, id);
178
179 return g_strdup(buf);
180 }
181
182 static ssize_t qemu_deliver_packet(VLANClientState *sender,
183 unsigned flags,
184 const uint8_t *data,
185 size_t size,
186 void *opaque);
187 static ssize_t qemu_deliver_packet_iov(VLANClientState *sender,
188 unsigned flags,
189 const struct iovec *iov,
190 int iovcnt,
191 void *opaque);
192
193 VLANClientState *qemu_new_net_client(NetClientInfo *info,
194 VLANState *vlan,
195 VLANClientState *peer,
196 const char *model,
197 const char *name)
198 {
199 VLANClientState *vc;
200
201 assert(info->size >= sizeof(VLANClientState));
202
203 vc = g_malloc0(info->size);
204
205 vc->info = info;
206 vc->model = g_strdup(model);
207 if (name) {
208 vc->name = g_strdup(name);
209 } else {
210 vc->name = assign_name(vc, model);
211 }
212
213 if (vlan) {
214 assert(!peer);
215 vc->vlan = vlan;
216 QTAILQ_INSERT_TAIL(&vc->vlan->clients, vc, next);
217 } else {
218 if (peer) {
219 assert(!peer->peer);
220 vc->peer = peer;
221 peer->peer = vc;
222 }
223 QTAILQ_INSERT_TAIL(&non_vlan_clients, vc, next);
224
225 vc->send_queue = qemu_new_net_queue(qemu_deliver_packet,
226 qemu_deliver_packet_iov,
227 vc);
228 }
229
230 return vc;
231 }
232
233 NICState *qemu_new_nic(NetClientInfo *info,
234 NICConf *conf,
235 const char *model,
236 const char *name,
237 void *opaque)
238 {
239 VLANClientState *nc;
240 NICState *nic;
241
242 assert(info->type == NET_CLIENT_TYPE_NIC);
243 assert(info->size >= sizeof(NICState));
244
245 nc = qemu_new_net_client(info, conf->vlan, conf->peer, model, name);
246
247 nic = DO_UPCAST(NICState, nc, nc);
248 nic->conf = conf;
249 nic->opaque = opaque;
250
251 return nic;
252 }
253
254 static void qemu_cleanup_vlan_client(VLANClientState *vc)
255 {
256 if (vc->vlan) {
257 QTAILQ_REMOVE(&vc->vlan->clients, vc, next);
258 } else {
259 QTAILQ_REMOVE(&non_vlan_clients, vc, next);
260 }
261
262 if (vc->info->cleanup) {
263 vc->info->cleanup(vc);
264 }
265 }
266
267 static void qemu_free_vlan_client(VLANClientState *vc)
268 {
269 if (!vc->vlan) {
270 if (vc->send_queue) {
271 qemu_del_net_queue(vc->send_queue);
272 }
273 if (vc->peer) {
274 vc->peer->peer = NULL;
275 }
276 }
277 g_free(vc->name);
278 g_free(vc->model);
279 g_free(vc);
280 }
281
282 void qemu_del_vlan_client(VLANClientState *vc)
283 {
284 /* If there is a peer NIC, delete and cleanup client, but do not free. */
285 if (!vc->vlan && vc->peer && vc->peer->info->type == NET_CLIENT_TYPE_NIC) {
286 NICState *nic = DO_UPCAST(NICState, nc, vc->peer);
287 if (nic->peer_deleted) {
288 return;
289 }
290 nic->peer_deleted = true;
291 /* Let NIC know peer is gone. */
292 vc->peer->link_down = true;
293 if (vc->peer->info->link_status_changed) {
294 vc->peer->info->link_status_changed(vc->peer);
295 }
296 qemu_cleanup_vlan_client(vc);
297 return;
298 }
299
300 /* If this is a peer NIC and peer has already been deleted, free it now. */
301 if (!vc->vlan && vc->peer && vc->info->type == NET_CLIENT_TYPE_NIC) {
302 NICState *nic = DO_UPCAST(NICState, nc, vc);
303 if (nic->peer_deleted) {
304 qemu_free_vlan_client(vc->peer);
305 }
306 }
307
308 qemu_cleanup_vlan_client(vc);
309 qemu_free_vlan_client(vc);
310 }
311
312 VLANClientState *
313 qemu_find_vlan_client_by_name(Monitor *mon, int vlan_id,
314 const char *client_str)
315 {
316 VLANState *vlan;
317 VLANClientState *vc;
318
319 vlan = qemu_find_vlan(vlan_id, 0);
320 if (!vlan) {
321 monitor_printf(mon, "unknown VLAN %d\n", vlan_id);
322 return NULL;
323 }
324
325 QTAILQ_FOREACH(vc, &vlan->clients, next) {
326 if (!strcmp(vc->name, client_str)) {
327 break;
328 }
329 }
330 if (!vc) {
331 monitor_printf(mon, "can't find device %s on VLAN %d\n",
332 client_str, vlan_id);
333 }
334
335 return vc;
336 }
337
338 void qemu_foreach_nic(qemu_nic_foreach func, void *opaque)
339 {
340 VLANClientState *nc;
341 VLANState *vlan;
342
343 QTAILQ_FOREACH(nc, &non_vlan_clients, next) {
344 if (nc->info->type == NET_CLIENT_TYPE_NIC) {
345 func(DO_UPCAST(NICState, nc, nc), opaque);
346 }
347 }
348
349 QTAILQ_FOREACH(vlan, &vlans, next) {
350 QTAILQ_FOREACH(nc, &vlan->clients, next) {
351 if (nc->info->type == NET_CLIENT_TYPE_NIC) {
352 func(DO_UPCAST(NICState, nc, nc), opaque);
353 }
354 }
355 }
356 }
357
358 int qemu_can_send_packet(VLANClientState *sender)
359 {
360 VLANState *vlan = sender->vlan;
361 VLANClientState *vc;
362
363 if (sender->peer) {
364 if (sender->peer->receive_disabled) {
365 return 0;
366 } else if (sender->peer->info->can_receive &&
367 !sender->peer->info->can_receive(sender->peer)) {
368 return 0;
369 } else {
370 return 1;
371 }
372 }
373
374 if (!sender->vlan) {
375 return 1;
376 }
377
378 QTAILQ_FOREACH(vc, &vlan->clients, next) {
379 if (vc == sender) {
380 continue;
381 }
382
383 /* no can_receive() handler, they can always receive */
384 if (vc->info->can_receive && !vc->info->can_receive(vc)) {
385 return 0;
386 }
387 }
388 return 1;
389 }
390
391 static ssize_t qemu_deliver_packet(VLANClientState *sender,
392 unsigned flags,
393 const uint8_t *data,
394 size_t size,
395 void *opaque)
396 {
397 VLANClientState *vc = opaque;
398 ssize_t ret;
399
400 if (vc->link_down) {
401 return size;
402 }
403
404 if (vc->receive_disabled) {
405 return 0;
406 }
407
408 if (flags & QEMU_NET_PACKET_FLAG_RAW && vc->info->receive_raw) {
409 ret = vc->info->receive_raw(vc, data, size);
410 } else {
411 ret = vc->info->receive(vc, data, size);
412 }
413
414 if (ret == 0) {
415 vc->receive_disabled = 1;
416 };
417
418 return ret;
419 }
420
421 static ssize_t qemu_vlan_deliver_packet(VLANClientState *sender,
422 unsigned flags,
423 const uint8_t *buf,
424 size_t size,
425 void *opaque)
426 {
427 VLANState *vlan = opaque;
428 VLANClientState *vc;
429 ssize_t ret = -1;
430
431 QTAILQ_FOREACH(vc, &vlan->clients, next) {
432 ssize_t len;
433
434 if (vc == sender) {
435 continue;
436 }
437
438 if (vc->link_down) {
439 ret = size;
440 continue;
441 }
442
443 if (vc->receive_disabled) {
444 ret = 0;
445 continue;
446 }
447
448 if (flags & QEMU_NET_PACKET_FLAG_RAW && vc->info->receive_raw) {
449 len = vc->info->receive_raw(vc, buf, size);
450 } else {
451 len = vc->info->receive(vc, buf, size);
452 }
453
454 if (len == 0) {
455 vc->receive_disabled = 1;
456 }
457
458 ret = (ret >= 0) ? ret : len;
459
460 }
461
462 return ret;
463 }
464
465 void qemu_purge_queued_packets(VLANClientState *vc)
466 {
467 NetQueue *queue;
468
469 if (!vc->peer && !vc->vlan) {
470 return;
471 }
472
473 if (vc->peer) {
474 queue = vc->peer->send_queue;
475 } else {
476 queue = vc->vlan->send_queue;
477 }
478
479 qemu_net_queue_purge(queue, vc);
480 }
481
482 void qemu_flush_queued_packets(VLANClientState *vc)
483 {
484 NetQueue *queue;
485
486 vc->receive_disabled = 0;
487
488 if (vc->vlan) {
489 queue = vc->vlan->send_queue;
490 } else {
491 queue = vc->send_queue;
492 }
493
494 qemu_net_queue_flush(queue);
495 }
496
497 static ssize_t qemu_send_packet_async_with_flags(VLANClientState *sender,
498 unsigned flags,
499 const uint8_t *buf, int size,
500 NetPacketSent *sent_cb)
501 {
502 NetQueue *queue;
503
504 #ifdef DEBUG_NET
505 printf("qemu_send_packet_async:\n");
506 hex_dump(stdout, buf, size);
507 #endif
508
509 if (sender->link_down || (!sender->peer && !sender->vlan)) {
510 return size;
511 }
512
513 if (sender->peer) {
514 queue = sender->peer->send_queue;
515 } else {
516 queue = sender->vlan->send_queue;
517 }
518
519 return qemu_net_queue_send(queue, sender, flags, buf, size, sent_cb);
520 }
521
522 ssize_t qemu_send_packet_async(VLANClientState *sender,
523 const uint8_t *buf, int size,
524 NetPacketSent *sent_cb)
525 {
526 return qemu_send_packet_async_with_flags(sender, QEMU_NET_PACKET_FLAG_NONE,
527 buf, size, sent_cb);
528 }
529
530 void qemu_send_packet(VLANClientState *vc, const uint8_t *buf, int size)
531 {
532 qemu_send_packet_async(vc, buf, size, NULL);
533 }
534
535 ssize_t qemu_send_packet_raw(VLANClientState *vc, const uint8_t *buf, int size)
536 {
537 return qemu_send_packet_async_with_flags(vc, QEMU_NET_PACKET_FLAG_RAW,
538 buf, size, NULL);
539 }
540
541 static ssize_t vc_sendv_compat(VLANClientState *vc, const struct iovec *iov,
542 int iovcnt)
543 {
544 uint8_t buffer[4096];
545 size_t offset;
546
547 offset = iov_to_buf(iov, iovcnt, buffer, 0, sizeof(buffer));
548
549 return vc->info->receive(vc, buffer, offset);
550 }
551
552 static ssize_t qemu_deliver_packet_iov(VLANClientState *sender,
553 unsigned flags,
554 const struct iovec *iov,
555 int iovcnt,
556 void *opaque)
557 {
558 VLANClientState *vc = opaque;
559
560 if (vc->link_down) {
561 return iov_size(iov, iovcnt);
562 }
563
564 if (vc->info->receive_iov) {
565 return vc->info->receive_iov(vc, iov, iovcnt);
566 } else {
567 return vc_sendv_compat(vc, iov, iovcnt);
568 }
569 }
570
571 static ssize_t qemu_vlan_deliver_packet_iov(VLANClientState *sender,
572 unsigned flags,
573 const struct iovec *iov,
574 int iovcnt,
575 void *opaque)
576 {
577 VLANState *vlan = opaque;
578 VLANClientState *vc;
579 ssize_t ret = -1;
580
581 QTAILQ_FOREACH(vc, &vlan->clients, next) {
582 ssize_t len;
583
584 if (vc == sender) {
585 continue;
586 }
587
588 if (vc->link_down) {
589 ret = iov_size(iov, iovcnt);
590 continue;
591 }
592
593 assert(!(flags & QEMU_NET_PACKET_FLAG_RAW));
594
595 if (vc->info->receive_iov) {
596 len = vc->info->receive_iov(vc, iov, iovcnt);
597 } else {
598 len = vc_sendv_compat(vc, iov, iovcnt);
599 }
600
601 ret = (ret >= 0) ? ret : len;
602 }
603
604 return ret;
605 }
606
607 ssize_t qemu_sendv_packet_async(VLANClientState *sender,
608 const struct iovec *iov, int iovcnt,
609 NetPacketSent *sent_cb)
610 {
611 NetQueue *queue;
612
613 if (sender->link_down || (!sender->peer && !sender->vlan)) {
614 return iov_size(iov, iovcnt);
615 }
616
617 if (sender->peer) {
618 queue = sender->peer->send_queue;
619 } else {
620 queue = sender->vlan->send_queue;
621 }
622
623 return qemu_net_queue_send_iov(queue, sender,
624 QEMU_NET_PACKET_FLAG_NONE,
625 iov, iovcnt, sent_cb);
626 }
627
628 ssize_t
629 qemu_sendv_packet(VLANClientState *vc, const struct iovec *iov, int iovcnt)
630 {
631 return qemu_sendv_packet_async(vc, iov, iovcnt, NULL);
632 }
633
634 /* find or alloc a new VLAN */
635 VLANState *qemu_find_vlan(int id, int allocate)
636 {
637 VLANState *vlan;
638
639 QTAILQ_FOREACH(vlan, &vlans, next) {
640 if (vlan->id == id) {
641 return vlan;
642 }
643 }
644
645 if (!allocate) {
646 return NULL;
647 }
648
649 vlan = g_malloc0(sizeof(VLANState));
650 vlan->id = id;
651 QTAILQ_INIT(&vlan->clients);
652
653 vlan->send_queue = qemu_new_net_queue(qemu_vlan_deliver_packet,
654 qemu_vlan_deliver_packet_iov,
655 vlan);
656
657 QTAILQ_INSERT_TAIL(&vlans, vlan, next);
658
659 return vlan;
660 }
661
662 VLANClientState *qemu_find_netdev(const char *id)
663 {
664 VLANClientState *vc;
665
666 QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
667 if (vc->info->type == NET_CLIENT_TYPE_NIC)
668 continue;
669 if (!strcmp(vc->name, id)) {
670 return vc;
671 }
672 }
673
674 return NULL;
675 }
676
677 static int nic_get_free_idx(void)
678 {
679 int index;
680
681 for (index = 0; index < MAX_NICS; index++)
682 if (!nd_table[index].used)
683 return index;
684 return -1;
685 }
686
687 int qemu_show_nic_models(const char *arg, const char *const *models)
688 {
689 int i;
690
691 if (!arg || strcmp(arg, "?"))
692 return 0;
693
694 fprintf(stderr, "qemu: Supported NIC models: ");
695 for (i = 0 ; models[i]; i++)
696 fprintf(stderr, "%s%c", models[i], models[i+1] ? ',' : '\n');
697 return 1;
698 }
699
700 void qemu_check_nic_model(NICInfo *nd, const char *model)
701 {
702 const char *models[2];
703
704 models[0] = model;
705 models[1] = NULL;
706
707 if (qemu_show_nic_models(nd->model, models))
708 exit(0);
709 if (qemu_find_nic_model(nd, models, model) < 0)
710 exit(1);
711 }
712
713 int qemu_find_nic_model(NICInfo *nd, const char * const *models,
714 const char *default_model)
715 {
716 int i;
717
718 if (!nd->model)
719 nd->model = g_strdup(default_model);
720
721 for (i = 0 ; models[i]; i++) {
722 if (strcmp(nd->model, models[i]) == 0)
723 return i;
724 }
725
726 error_report("Unsupported NIC model: %s", nd->model);
727 return -1;
728 }
729
730 int net_handle_fd_param(Monitor *mon, const char *param)
731 {
732 int fd;
733
734 if (!qemu_isdigit(param[0]) && mon) {
735
736 fd = monitor_get_fd(mon, param);
737 if (fd == -1) {
738 error_report("No file descriptor named %s found", param);
739 return -1;
740 }
741 } else {
742 fd = qemu_parse_fd(param);
743 }
744
745 return fd;
746 }
747
748 static int net_init_nic(QemuOpts *opts, const char *name, VLANState *vlan)
749 {
750 int idx;
751 NICInfo *nd;
752 const char *netdev;
753
754 idx = nic_get_free_idx();
755 if (idx == -1 || nb_nics >= MAX_NICS) {
756 error_report("Too Many NICs");
757 return -1;
758 }
759
760 nd = &nd_table[idx];
761
762 memset(nd, 0, sizeof(*nd));
763
764 if ((netdev = qemu_opt_get(opts, "netdev"))) {
765 nd->netdev = qemu_find_netdev(netdev);
766 if (!nd->netdev) {
767 error_report("netdev '%s' not found", netdev);
768 return -1;
769 }
770 } else {
771 assert(vlan);
772 nd->vlan = vlan;
773 }
774 if (name) {
775 nd->name = g_strdup(name);
776 }
777 if (qemu_opt_get(opts, "model")) {
778 nd->model = g_strdup(qemu_opt_get(opts, "model"));
779 }
780 if (qemu_opt_get(opts, "addr")) {
781 nd->devaddr = g_strdup(qemu_opt_get(opts, "addr"));
782 }
783
784 if (qemu_opt_get(opts, "macaddr") &&
785 net_parse_macaddr(nd->macaddr.a, qemu_opt_get(opts, "macaddr")) < 0) {
786 error_report("invalid syntax for ethernet address");
787 return -1;
788 }
789 qemu_macaddr_default_if_unset(&nd->macaddr);
790
791 nd->nvectors = qemu_opt_get_number(opts, "vectors",
792 DEV_NVECTORS_UNSPECIFIED);
793 if (nd->nvectors != DEV_NVECTORS_UNSPECIFIED &&
794 (nd->nvectors < 0 || nd->nvectors > 0x7ffffff)) {
795 error_report("invalid # of vectors: %d", nd->nvectors);
796 return -1;
797 }
798
799 nd->used = 1;
800 nb_nics++;
801
802 return idx;
803 }
804
805 #define NET_COMMON_PARAMS_DESC \
806 { \
807 .name = "type", \
808 .type = QEMU_OPT_STRING, \
809 .help = "net client type (nic, tap etc.)", \
810 }, { \
811 .name = "vlan", \
812 .type = QEMU_OPT_NUMBER, \
813 .help = "vlan number", \
814 }, { \
815 .name = "name", \
816 .type = QEMU_OPT_STRING, \
817 .help = "identifier for monitor commands", \
818 }
819
820 typedef int (*net_client_init_func)(QemuOpts *opts,
821 const char *name,
822 VLANState *vlan);
823
824 /* magic number, but compiler will warn if too small */
825 #define NET_MAX_DESC 20
826
827 static const struct {
828 const char *type;
829 net_client_init_func init;
830 QemuOptDesc desc[NET_MAX_DESC];
831 } net_client_types[NET_CLIENT_TYPE_MAX] = {
832 [NET_CLIENT_TYPE_NONE] = {
833 .type = "none",
834 .desc = {
835 NET_COMMON_PARAMS_DESC,
836 { /* end of list */ }
837 },
838 },
839 [NET_CLIENT_TYPE_NIC] = {
840 .type = "nic",
841 .init = net_init_nic,
842 .desc = {
843 NET_COMMON_PARAMS_DESC,
844 {
845 .name = "netdev",
846 .type = QEMU_OPT_STRING,
847 .help = "id of -netdev to connect to",
848 },
849 {
850 .name = "macaddr",
851 .type = QEMU_OPT_STRING,
852 .help = "MAC address",
853 }, {
854 .name = "model",
855 .type = QEMU_OPT_STRING,
856 .help = "device model (e1000, rtl8139, virtio etc.)",
857 }, {
858 .name = "addr",
859 .type = QEMU_OPT_STRING,
860 .help = "PCI device address",
861 }, {
862 .name = "vectors",
863 .type = QEMU_OPT_NUMBER,
864 .help = "number of MSI-x vectors, 0 to disable MSI-X",
865 },
866 { /* end of list */ }
867 },
868 },
869 #ifdef CONFIG_SLIRP
870 [NET_CLIENT_TYPE_USER] = {
871 .type = "user",
872 .init = net_init_slirp,
873 .desc = {
874 NET_COMMON_PARAMS_DESC,
875 {
876 .name = "hostname",
877 .type = QEMU_OPT_STRING,
878 .help = "client hostname reported by the builtin DHCP server",
879 }, {
880 .name = "restrict",
881 .type = QEMU_OPT_STRING,
882 .help = "isolate the guest from the host (y|yes|n|no)",
883 }, {
884 .name = "ip",
885 .type = QEMU_OPT_STRING,
886 .help = "legacy parameter, use net= instead",
887 }, {
888 .name = "net",
889 .type = QEMU_OPT_STRING,
890 .help = "IP address and optional netmask",
891 }, {
892 .name = "host",
893 .type = QEMU_OPT_STRING,
894 .help = "guest-visible address of the host",
895 }, {
896 .name = "tftp",
897 .type = QEMU_OPT_STRING,
898 .help = "root directory of the built-in TFTP server",
899 }, {
900 .name = "bootfile",
901 .type = QEMU_OPT_STRING,
902 .help = "BOOTP filename, for use with tftp=",
903 }, {
904 .name = "dhcpstart",
905 .type = QEMU_OPT_STRING,
906 .help = "the first of the 16 IPs the built-in DHCP server can assign",
907 }, {
908 .name = "dns",
909 .type = QEMU_OPT_STRING,
910 .help = "guest-visible address of the virtual nameserver",
911 }, {
912 .name = "smb",
913 .type = QEMU_OPT_STRING,
914 .help = "root directory of the built-in SMB server",
915 }, {
916 .name = "smbserver",
917 .type = QEMU_OPT_STRING,
918 .help = "IP address of the built-in SMB server",
919 }, {
920 .name = "hostfwd",
921 .type = QEMU_OPT_STRING,
922 .help = "guest port number to forward incoming TCP or UDP connections",
923 }, {
924 .name = "guestfwd",
925 .type = QEMU_OPT_STRING,
926 .help = "IP address and port to forward guest TCP connections",
927 },
928 { /* end of list */ }
929 },
930 },
931 #endif
932 [NET_CLIENT_TYPE_TAP] = {
933 .type = "tap",
934 .init = net_init_tap,
935 .desc = {
936 NET_COMMON_PARAMS_DESC,
937 {
938 .name = "ifname",
939 .type = QEMU_OPT_STRING,
940 .help = "interface name",
941 },
942 #ifndef _WIN32
943 {
944 .name = "fd",
945 .type = QEMU_OPT_STRING,
946 .help = "file descriptor of an already opened tap",
947 }, {
948 .name = "script",
949 .type = QEMU_OPT_STRING,
950 .help = "script to initialize the interface",
951 }, {
952 .name = "downscript",
953 .type = QEMU_OPT_STRING,
954 .help = "script to shut down the interface",
955 }, {
956 #ifdef CONFIG_NET_BRIDGE
957 .name = "helper",
958 .type = QEMU_OPT_STRING,
959 .help = "command to execute to configure bridge",
960 }, {
961 #endif
962 .name = "sndbuf",
963 .type = QEMU_OPT_SIZE,
964 .help = "send buffer limit"
965 }, {
966 .name = "vnet_hdr",
967 .type = QEMU_OPT_BOOL,
968 .help = "enable the IFF_VNET_HDR flag on the tap interface"
969 }, {
970 .name = "vhost",
971 .type = QEMU_OPT_BOOL,
972 .help = "enable vhost-net network accelerator",
973 }, {
974 .name = "vhostfd",
975 .type = QEMU_OPT_STRING,
976 .help = "file descriptor of an already opened vhost net device",
977 }, {
978 .name = "vhostforce",
979 .type = QEMU_OPT_BOOL,
980 .help = "force vhost on for non-MSIX virtio guests",
981 },
982 #endif /* _WIN32 */
983 { /* end of list */ }
984 },
985 },
986 [NET_CLIENT_TYPE_SOCKET] = {
987 .type = "socket",
988 .init = net_init_socket,
989 .desc = {
990 NET_COMMON_PARAMS_DESC,
991 {
992 .name = "fd",
993 .type = QEMU_OPT_STRING,
994 .help = "file descriptor of an already opened socket",
995 }, {
996 .name = "listen",
997 .type = QEMU_OPT_STRING,
998 .help = "port number, and optional hostname, to listen on",
999 }, {
1000 .name = "connect",
1001 .type = QEMU_OPT_STRING,
1002 .help = "port number, and optional hostname, to connect to",
1003 }, {
1004 .name = "mcast",
1005 .type = QEMU_OPT_STRING,
1006 .help = "UDP multicast address and port number",
1007 }, {
1008 .name = "localaddr",
1009 .type = QEMU_OPT_STRING,
1010 .help = "source address and port for multicast and udp packets",
1011 }, {
1012 .name = "udp",
1013 .type = QEMU_OPT_STRING,
1014 .help = "UDP unicast address and port number",
1015 },
1016 { /* end of list */ }
1017 },
1018 },
1019 #ifdef CONFIG_VDE
1020 [NET_CLIENT_TYPE_VDE] = {
1021 .type = "vde",
1022 .init = net_init_vde,
1023 .desc = {
1024 NET_COMMON_PARAMS_DESC,
1025 {
1026 .name = "sock",
1027 .type = QEMU_OPT_STRING,
1028 .help = "socket path",
1029 }, {
1030 .name = "port",
1031 .type = QEMU_OPT_NUMBER,
1032 .help = "port number",
1033 }, {
1034 .name = "group",
1035 .type = QEMU_OPT_STRING,
1036 .help = "group owner of socket",
1037 }, {
1038 .name = "mode",
1039 .type = QEMU_OPT_NUMBER,
1040 .help = "permissions for socket",
1041 },
1042 { /* end of list */ }
1043 },
1044 },
1045 #endif
1046 [NET_CLIENT_TYPE_DUMP] = {
1047 .type = "dump",
1048 .init = net_init_dump,
1049 .desc = {
1050 NET_COMMON_PARAMS_DESC,
1051 {
1052 .name = "len",
1053 .type = QEMU_OPT_SIZE,
1054 .help = "per-packet size limit (64k default)",
1055 }, {
1056 .name = "file",
1057 .type = QEMU_OPT_STRING,
1058 .help = "dump file path (default is qemu-vlan0.pcap)",
1059 },
1060 { /* end of list */ }
1061 },
1062 },
1063 #ifdef CONFIG_NET_BRIDGE
1064 [NET_CLIENT_TYPE_BRIDGE] = {
1065 .type = "bridge",
1066 .init = net_init_bridge,
1067 .desc = {
1068 NET_COMMON_PARAMS_DESC,
1069 {
1070 .name = "br",
1071 .type = QEMU_OPT_STRING,
1072 .help = "bridge name",
1073 }, {
1074 .name = "helper",
1075 .type = QEMU_OPT_STRING,
1076 .help = "command to execute to configure bridge",
1077 },
1078 { /* end of list */ }
1079 },
1080 },
1081 #endif /* CONFIG_NET_BRIDGE */
1082 };
1083
1084 int net_client_init(QemuOpts *opts, int is_netdev, Error **errp)
1085 {
1086 const char *name;
1087 const char *type;
1088 int i;
1089
1090 type = qemu_opt_get(opts, "type");
1091 if (!type) {
1092 error_set(errp, QERR_MISSING_PARAMETER, "type");
1093 return -1;
1094 }
1095
1096 if (is_netdev) {
1097 if (strcmp(type, "tap") != 0 &&
1098 #ifdef CONFIG_NET_BRIDGE
1099 strcmp(type, "bridge") != 0 &&
1100 #endif
1101 #ifdef CONFIG_SLIRP
1102 strcmp(type, "user") != 0 &&
1103 #endif
1104 #ifdef CONFIG_VDE
1105 strcmp(type, "vde") != 0 &&
1106 #endif
1107 strcmp(type, "socket") != 0) {
1108 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "type",
1109 "a netdev backend type");
1110 return -1;
1111 }
1112
1113 if (qemu_opt_get(opts, "vlan")) {
1114 error_set(errp, QERR_INVALID_PARAMETER, "vlan");
1115 return -1;
1116 }
1117 if (qemu_opt_get(opts, "name")) {
1118 error_set(errp, QERR_INVALID_PARAMETER, "name");
1119 return -1;
1120 }
1121 if (!qemu_opts_id(opts)) {
1122 error_set(errp, QERR_MISSING_PARAMETER, "id");
1123 return -1;
1124 }
1125 }
1126
1127 name = qemu_opts_id(opts);
1128 if (!name) {
1129 name = qemu_opt_get(opts, "name");
1130 }
1131
1132 for (i = 0; i < NET_CLIENT_TYPE_MAX; i++) {
1133 if (net_client_types[i].type != NULL &&
1134 !strcmp(net_client_types[i].type, type)) {
1135 Error *local_err = NULL;
1136 VLANState *vlan = NULL;
1137 int ret;
1138
1139 qemu_opts_validate(opts, &net_client_types[i].desc[0], &local_err);
1140 if (error_is_set(&local_err)) {
1141 error_propagate(errp, local_err);
1142 return -1;
1143 }
1144
1145 /* Do not add to a vlan if it's a -netdev or a nic with a
1146 * netdev= parameter. */
1147 if (!(is_netdev ||
1148 (strcmp(type, "nic") == 0 && qemu_opt_get(opts, "netdev")))) {
1149 vlan = qemu_find_vlan(qemu_opt_get_number(opts, "vlan", 0), 1);
1150 }
1151
1152 ret = 0;
1153 if (net_client_types[i].init) {
1154 ret = net_client_types[i].init(opts, name, vlan);
1155 if (ret < 0) {
1156 /* TODO push error reporting into init() methods */
1157 error_set(errp, QERR_DEVICE_INIT_FAILED, type);
1158 return -1;
1159 }
1160 }
1161 return ret;
1162 }
1163 }
1164
1165 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "type",
1166 "a network client type");
1167 return -1;
1168 }
1169
1170 static int net_host_check_device(const char *device)
1171 {
1172 int i;
1173 const char *valid_param_list[] = { "tap", "socket", "dump"
1174 #ifdef CONFIG_NET_BRIDGE
1175 , "bridge"
1176 #endif
1177 #ifdef CONFIG_SLIRP
1178 ,"user"
1179 #endif
1180 #ifdef CONFIG_VDE
1181 ,"vde"
1182 #endif
1183 };
1184 for (i = 0; i < sizeof(valid_param_list) / sizeof(char *); i++) {
1185 if (!strncmp(valid_param_list[i], device,
1186 strlen(valid_param_list[i])))
1187 return 1;
1188 }
1189
1190 return 0;
1191 }
1192
1193 void net_host_device_add(Monitor *mon, const QDict *qdict)
1194 {
1195 const char *device = qdict_get_str(qdict, "device");
1196 const char *opts_str = qdict_get_try_str(qdict, "opts");
1197 Error *local_err = NULL;
1198 QemuOpts *opts;
1199
1200 if (!net_host_check_device(device)) {
1201 monitor_printf(mon, "invalid host network device %s\n", device);
1202 return;
1203 }
1204
1205 opts = qemu_opts_parse(qemu_find_opts("net"), opts_str ? opts_str : "", 0);
1206 if (!opts) {
1207 return;
1208 }
1209
1210 qemu_opt_set(opts, "type", device);
1211
1212 net_client_init(opts, 0, &local_err);
1213 if (error_is_set(&local_err)) {
1214 qerror_report_err(local_err);
1215 error_free(local_err);
1216 monitor_printf(mon, "adding host network device %s failed\n", device);
1217 }
1218 }
1219
1220 void net_host_device_remove(Monitor *mon, const QDict *qdict)
1221 {
1222 VLANClientState *vc;
1223 int vlan_id = qdict_get_int(qdict, "vlan_id");
1224 const char *device = qdict_get_str(qdict, "device");
1225
1226 vc = qemu_find_vlan_client_by_name(mon, vlan_id, device);
1227 if (!vc) {
1228 return;
1229 }
1230 if (!net_host_check_device(vc->model)) {
1231 monitor_printf(mon, "invalid host network device %s\n", device);
1232 return;
1233 }
1234 qemu_del_vlan_client(vc);
1235 }
1236
1237 int do_netdev_add(Monitor *mon, const QDict *qdict, QObject **ret_data)
1238 {
1239 Error *local_err = NULL;
1240 QemuOpts *opts;
1241 int res;
1242
1243 opts = qemu_opts_from_qdict(qemu_find_opts("netdev"), qdict, &local_err);
1244 if (!opts) {
1245 qerror_report_err(local_err);
1246 error_free(local_err);
1247 return -1;
1248 }
1249
1250 res = net_client_init(opts, 1, &local_err);
1251 if (res < 0) {
1252 qerror_report_err(local_err);
1253 error_free(local_err);
1254 qemu_opts_del(opts);
1255 }
1256
1257 return res;
1258 }
1259
1260 int do_netdev_del(Monitor *mon, const QDict *qdict, QObject **ret_data)
1261 {
1262 const char *id = qdict_get_str(qdict, "id");
1263 VLANClientState *vc;
1264
1265 vc = qemu_find_netdev(id);
1266 if (!vc) {
1267 qerror_report(QERR_DEVICE_NOT_FOUND, id);
1268 return -1;
1269 }
1270 qemu_del_vlan_client(vc);
1271 qemu_opts_del(qemu_opts_find(qemu_find_opts("netdev"), id));
1272 return 0;
1273 }
1274
1275 static void print_net_client(Monitor *mon, VLANClientState *vc)
1276 {
1277 monitor_printf(mon, "%s: type=%s,%s\n", vc->name,
1278 net_client_types[vc->info->type].type, vc->info_str);
1279 }
1280
1281 void do_info_network(Monitor *mon)
1282 {
1283 VLANState *vlan;
1284 VLANClientState *vc, *peer;
1285 net_client_type type;
1286
1287 QTAILQ_FOREACH(vlan, &vlans, next) {
1288 monitor_printf(mon, "VLAN %d devices:\n", vlan->id);
1289
1290 QTAILQ_FOREACH(vc, &vlan->clients, next) {
1291 monitor_printf(mon, " ");
1292 print_net_client(mon, vc);
1293 }
1294 }
1295 monitor_printf(mon, "Devices not on any VLAN:\n");
1296 QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
1297 peer = vc->peer;
1298 type = vc->info->type;
1299 if (!peer || type == NET_CLIENT_TYPE_NIC) {
1300 monitor_printf(mon, " ");
1301 print_net_client(mon, vc);
1302 } /* else it's a netdev connected to a NIC, printed with the NIC */
1303 if (peer && type == NET_CLIENT_TYPE_NIC) {
1304 monitor_printf(mon, " \\ ");
1305 print_net_client(mon, peer);
1306 }
1307 }
1308 }
1309
1310 void qmp_set_link(const char *name, bool up, Error **errp)
1311 {
1312 VLANState *vlan;
1313 VLANClientState *vc = NULL;
1314
1315 QTAILQ_FOREACH(vlan, &vlans, next) {
1316 QTAILQ_FOREACH(vc, &vlan->clients, next) {
1317 if (strcmp(vc->name, name) == 0) {
1318 goto done;
1319 }
1320 }
1321 }
1322 QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
1323 if (!strcmp(vc->name, name)) {
1324 goto done;
1325 }
1326 }
1327 done:
1328
1329 if (!vc) {
1330 error_set(errp, QERR_DEVICE_NOT_FOUND, name);
1331 return;
1332 }
1333
1334 vc->link_down = !up;
1335
1336 if (vc->info->link_status_changed) {
1337 vc->info->link_status_changed(vc);
1338 }
1339
1340 /* Notify peer. Don't update peer link status: this makes it possible to
1341 * disconnect from host network without notifying the guest.
1342 * FIXME: is disconnected link status change operation useful?
1343 *
1344 * Current behaviour is compatible with qemu vlans where there could be
1345 * multiple clients that can still communicate with each other in
1346 * disconnected mode. For now maintain this compatibility. */
1347 if (vc->peer && vc->peer->info->link_status_changed) {
1348 vc->peer->info->link_status_changed(vc->peer);
1349 }
1350 }
1351
1352 void net_cleanup(void)
1353 {
1354 VLANState *vlan;
1355 VLANClientState *vc, *next_vc;
1356
1357 QTAILQ_FOREACH(vlan, &vlans, next) {
1358 QTAILQ_FOREACH_SAFE(vc, &vlan->clients, next, next_vc) {
1359 qemu_del_vlan_client(vc);
1360 }
1361 }
1362
1363 QTAILQ_FOREACH_SAFE(vc, &non_vlan_clients, next, next_vc) {
1364 qemu_del_vlan_client(vc);
1365 }
1366 }
1367
1368 void net_check_clients(void)
1369 {
1370 VLANState *vlan;
1371 VLANClientState *vc;
1372 int i;
1373
1374 /* Don't warn about the default network setup that you get if
1375 * no command line -net or -netdev options are specified. There
1376 * are two cases that we would otherwise complain about:
1377 * (1) board doesn't support a NIC but the implicit "-net nic"
1378 * requested one
1379 * (2) CONFIG_SLIRP not set, in which case the implicit "-net nic"
1380 * sets up a nic that isn't connected to anything.
1381 */
1382 if (default_net) {
1383 return;
1384 }
1385
1386 QTAILQ_FOREACH(vlan, &vlans, next) {
1387 int has_nic = 0, has_host_dev = 0;
1388
1389 QTAILQ_FOREACH(vc, &vlan->clients, next) {
1390 switch (vc->info->type) {
1391 case NET_CLIENT_TYPE_NIC:
1392 has_nic = 1;
1393 break;
1394 case NET_CLIENT_TYPE_USER:
1395 case NET_CLIENT_TYPE_TAP:
1396 case NET_CLIENT_TYPE_SOCKET:
1397 case NET_CLIENT_TYPE_VDE:
1398 has_host_dev = 1;
1399 break;
1400 default: ;
1401 }
1402 }
1403 if (has_host_dev && !has_nic)
1404 fprintf(stderr, "Warning: vlan %d with no nics\n", vlan->id);
1405 if (has_nic && !has_host_dev)
1406 fprintf(stderr,
1407 "Warning: vlan %d is not connected to host network\n",
1408 vlan->id);
1409 }
1410 QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
1411 if (!vc->peer) {
1412 fprintf(stderr, "Warning: %s %s has no peer\n",
1413 vc->info->type == NET_CLIENT_TYPE_NIC ? "nic" : "netdev",
1414 vc->name);
1415 }
1416 }
1417
1418 /* Check that all NICs requested via -net nic actually got created.
1419 * NICs created via -device don't need to be checked here because
1420 * they are always instantiated.
1421 */
1422 for (i = 0; i < MAX_NICS; i++) {
1423 NICInfo *nd = &nd_table[i];
1424 if (nd->used && !nd->instantiated) {
1425 fprintf(stderr, "Warning: requested NIC (%s, model %s) "
1426 "was not created (not supported by this machine?)\n",
1427 nd->name ? nd->name : "anonymous",
1428 nd->model ? nd->model : "unspecified");
1429 }
1430 }
1431 }
1432
1433 static int net_init_client(QemuOpts *opts, void *dummy)
1434 {
1435 Error *local_err = NULL;
1436
1437 net_client_init(opts, 0, &local_err);
1438 if (error_is_set(&local_err)) {
1439 qerror_report_err(local_err);
1440 error_free(local_err);
1441 return -1;
1442 }
1443
1444 return 0;
1445 }
1446
1447 static int net_init_netdev(QemuOpts *opts, void *dummy)
1448 {
1449 Error *local_err = NULL;
1450 int ret;
1451
1452 ret = net_client_init(opts, 1, &local_err);
1453 if (error_is_set(&local_err)) {
1454 qerror_report_err(local_err);
1455 error_free(local_err);
1456 return -1;
1457 }
1458
1459 return ret;
1460 }
1461
1462 int net_init_clients(void)
1463 {
1464 QemuOptsList *net = qemu_find_opts("net");
1465
1466 if (default_net) {
1467 /* if no clients, we use a default config */
1468 qemu_opts_set(net, NULL, "type", "nic");
1469 #ifdef CONFIG_SLIRP
1470 qemu_opts_set(net, NULL, "type", "user");
1471 #endif
1472 }
1473
1474 QTAILQ_INIT(&vlans);
1475 QTAILQ_INIT(&non_vlan_clients);
1476
1477 if (qemu_opts_foreach(qemu_find_opts("netdev"), net_init_netdev, NULL, 1) == -1)
1478 return -1;
1479
1480 if (qemu_opts_foreach(net, net_init_client, NULL, 1) == -1) {
1481 return -1;
1482 }
1483
1484 return 0;
1485 }
1486
1487 int net_client_parse(QemuOptsList *opts_list, const char *optarg)
1488 {
1489 #if defined(CONFIG_SLIRP)
1490 int ret;
1491 if (net_slirp_parse_legacy(opts_list, optarg, &ret)) {
1492 return ret;
1493 }
1494 #endif
1495
1496 if (!qemu_opts_parse(opts_list, optarg, 1)) {
1497 return -1;
1498 }
1499
1500 default_net = 0;
1501 return 0;
1502 }
1503
1504 /* From FreeBSD */
1505 /* XXX: optimize */
1506 unsigned compute_mcast_idx(const uint8_t *ep)
1507 {
1508 uint32_t crc;
1509 int carry, i, j;
1510 uint8_t b;
1511
1512 crc = 0xffffffff;
1513 for (i = 0; i < 6; i++) {
1514 b = *ep++;
1515 for (j = 0; j < 8; j++) {
1516 carry = ((crc & 0x80000000L) ? 1 : 0) ^ (b & 0x01);
1517 crc <<= 1;
1518 b >>= 1;
1519 if (carry) {
1520 crc = ((crc ^ POLYNOMIAL) | carry);
1521 }
1522 }
1523 }
1524 return crc >> 26;
1525 }