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