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 <unistd.h> 25 #include <fcntl.h> 26 #include <signal.h> 27 #include <time.h> 28 #include <errno.h> 29 #include <sys/time.h> 30 #include <zlib.h> 31 32 #include "android/tcpdump.h" 33 34 /* Needed early for HOST_BSD etc. */ 35 #include "config-host.h" 36 37 #ifndef _WIN32 38 #include <sys/times.h> 39 #include <sys/wait.h> 40 #include <termios.h> 41 #include <sys/mman.h> 42 #include <sys/ioctl.h> 43 #include <sys/resource.h> 44 #include <sys/socket.h> 45 #include <netinet/in.h> 46 #include <net/if.h> 47 #ifdef __NetBSD__ 48 #include <net/if_tap.h> 49 #endif 50 #ifdef __linux__ 51 #include <linux/if_tun.h> 52 #endif 53 #include <arpa/inet.h> 54 #include <dirent.h> 55 #include <netdb.h> 56 #include <sys/select.h> 57 #ifdef CONFIG_BSD 58 #include <sys/stat.h> 59 #if defined(__FreeBSD__) || defined(__DragonFly__) 60 #include <libutil.h> 61 #else 62 #include <util.h> 63 #endif 64 #elif defined (__GLIBC__) && defined (__FreeBSD_kernel__) 65 #include <freebsd/stdlib.h> 66 #else 67 #ifdef __linux__ 68 #include <pty.h> 69 #include <malloc.h> 70 #include <linux/rtc.h> 71 72 /* For the benefit of older linux systems which don't supply it, 73 we use a local copy of hpet.h. */ 74 /* #include <linux/hpet.h> */ 75 #include "hw/timer/hpet.h" 76 77 #include <linux/ppdev.h> 78 #include <linux/parport.h> 79 #endif 80 #ifdef __sun__ 81 #include <sys/stat.h> 82 #include <sys/ethernet.h> 83 #include <sys/sockio.h> 84 #include <netinet/arp.h> 85 #include <netinet/in.h> 86 #include <netinet/in_systm.h> 87 #include <netinet/ip.h> 88 #include <netinet/ip_icmp.h> // must come after ip.h 89 #include <netinet/udp.h> 90 #include <netinet/tcp.h> 91 #include <net/if.h> 92 #include <syslog.h> 93 #include <stropts.h> 94 #endif 95 #endif 96 #endif 97 98 #if defined(__OpenBSD__) 99 #include <util.h> 100 #endif 101 102 #if defined(CONFIG_VDE) 103 #include <libvdeplug.h> 104 #endif 105 106 #ifdef _WIN32 107 #include <windows.h> 108 #include <malloc.h> 109 #include <sys/timeb.h> 110 #include <mmsystem.h> 111 #define getopt_long_only getopt_long 112 #define memalign(align, size) malloc(size) 113 #endif 114 115 #include "qemu-common.h" 116 #include "net/net.h" 117 #include "monitor/monitor.h" 118 #include "sysemu/sysemu.h" 119 #include "qemu/timer.h" 120 #include "sysemu/char.h" 121 #include "audio/audio.h" 122 #include "qemu/sockets.h" 123 #include "qemu/log.h" 124 125 #if defined(CONFIG_SLIRP) 126 #include "libslirp.h" 127 #endif 128 129 #if defined(CONFIG_ANDROID) 130 #include "android/shaper.h" 131 #endif 132 133 #include "android/android.h" 134 #include "telephony/modem_driver.h" 135 136 static VLANState *first_vlan; 137 138 /***********************************************************/ 139 /* network device redirectors */ 140 141 #if defined(DEBUG_NET) || defined(DEBUG_SLIRP) 142 static void hex_dump(FILE *f, const uint8_t *buf, int size) 143 { 144 int len, i, j, c; 145 146 for(i=0;i<size;i+=16) { 147 len = size - i; 148 if (len > 16) 149 len = 16; 150 fprintf(f, "%08x ", i); 151 for(j=0;j<16;j++) { 152 if (j < len) 153 fprintf(f, " %02x", buf[i+j]); 154 else 155 fprintf(f, " "); 156 } 157 fprintf(f, " "); 158 for(j=0;j<len;j++) { 159 c = buf[i+j]; 160 if (c < ' ' || c > '~') 161 c = '.'; 162 fprintf(f, "%c", c); 163 } 164 fprintf(f, "\n"); 165 } 166 } 167 #endif 168 169 static int parse_macaddr(uint8_t *macaddr, const char *p) 170 { 171 int i; 172 char *last_char; 173 long int offset; 174 175 errno = 0; 176 offset = strtol(p, &last_char, 0); 177 if (0 == errno && '\0' == *last_char && 178 offset >= 0 && offset <= 0xFFFFFF) { 179 macaddr[3] = (offset & 0xFF0000) >> 16; 180 macaddr[4] = (offset & 0xFF00) >> 8; 181 macaddr[5] = offset & 0xFF; 182 return 0; 183 } else { 184 for(i = 0; i < 6; i++) { 185 macaddr[i] = strtol(p, (char **)&p, 16); 186 if (i == 5) { 187 if (*p != '\0') 188 return -1; 189 } else { 190 if (*p != ':' && *p != '-') 191 return -1; 192 p++; 193 } 194 } 195 return 0; 196 } 197 198 return -1; 199 } 200 201 static int get_str_sep(char *buf, int buf_size, const char **pp, int sep) 202 { 203 const char *p, *p1; 204 int len; 205 p = *pp; 206 p1 = strchr(p, sep); 207 if (!p1) 208 return -1; 209 len = p1 - p; 210 p1++; 211 if (buf_size > 0) { 212 if (len > buf_size - 1) 213 len = buf_size - 1; 214 memcpy(buf, p, len); 215 buf[len] = '\0'; 216 } 217 *pp = p1; 218 return 0; 219 } 220 221 int parse_host_src_port(SockAddress *haddr, 222 SockAddress *saddr, 223 const char *input_str) 224 { 225 char *str = strdup(input_str); 226 char *host_str = str; 227 char *src_str; 228 const char *src_str2; 229 char *ptr; 230 231 /* 232 * Chop off any extra arguments at the end of the string which 233 * would start with a comma, then fill in the src port information 234 * if it was provided else use the "any address" and "any port". 235 */ 236 if ((ptr = strchr(str,','))) 237 *ptr = '\0'; 238 239 if ((src_str = strchr(input_str,'@'))) { 240 *src_str = '\0'; 241 src_str++; 242 } 243 244 if (parse_host_port(haddr, host_str) < 0) 245 goto fail; 246 247 src_str2 = src_str; 248 if (!src_str || *src_str == '\0') 249 src_str2 = ":0"; 250 251 if (parse_host_port(saddr, src_str2) < 0) 252 goto fail; 253 254 free(str); 255 return(0); 256 257 fail: 258 free(str); 259 return -1; 260 } 261 262 int parse_host_port(SockAddress *saddr, const char *str) 263 { 264 char buf[512]; 265 const char *p, *r; 266 uint32_t ip; 267 int port; 268 269 p = str; 270 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) 271 return -1; 272 273 if (buf[0] == '\0') { 274 ip = 0; 275 } else { 276 if (qemu_isdigit(buf[0])) { 277 if (inet_strtoip(buf, &ip) < 0) 278 return -1; 279 } else { 280 if (sock_address_init_resolve(saddr, buf, 0, 0) < 0) 281 return - 1; 282 ip = sock_address_get_ip(saddr); 283 } 284 } 285 port = strtol(p, (char **)&r, 0); 286 if (r == p) 287 return -1; 288 sock_address_init_inet(saddr, ip, port); 289 return 0; 290 } 291 292 #if !defined(_WIN32) && 0 293 static int parse_unix_path(struct sockaddr_un *uaddr, const char *str) 294 { 295 const char *p; 296 int len; 297 298 len = MIN(108, strlen(str)); 299 p = strchr(str, ','); 300 if (p) 301 len = MIN(len, p - str); 302 303 memset(uaddr, 0, sizeof(*uaddr)); 304 305 uaddr->sun_family = AF_UNIX; 306 memcpy(uaddr->sun_path, str, len); 307 308 return 0; 309 } 310 #endif 311 312 void qemu_format_nic_info_str(VLANClientState *vc, uint8_t macaddr[6]) 313 { 314 snprintf(vc->info_str, sizeof(vc->info_str), 315 "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x", 316 vc->model, 317 macaddr[0], macaddr[1], macaddr[2], 318 macaddr[3], macaddr[4], macaddr[5]); 319 } 320 321 static char *assign_name(VLANClientState *vc1, const char *model) 322 { 323 VLANState *vlan; 324 char buf[256]; 325 int id = 0; 326 327 for (vlan = first_vlan; vlan; vlan = vlan->next) { 328 VLANClientState *vc; 329 330 for (vc = vlan->first_client; vc; vc = vc->next) 331 if (vc != vc1 && strcmp(vc->model, model) == 0) 332 id++; 333 } 334 335 snprintf(buf, sizeof(buf), "%s.%d", model, id); 336 337 return strdup(buf); 338 } 339 340 VLANClientState *qemu_new_vlan_client(VLANState *vlan, 341 const char *model, 342 const char *name, 343 NetCanReceive *can_receive, 344 NetReceive *receive, 345 NetReceiveIOV *receive_iov, 346 NetCleanup *cleanup, 347 void *opaque) 348 { 349 VLANClientState *vc, **pvc; 350 vc = g_malloc0(sizeof(VLANClientState)); 351 vc->model = strdup(model); 352 if (name) 353 vc->name = strdup(name); 354 else 355 vc->name = assign_name(vc, model); 356 vc->can_receive = can_receive; 357 vc->receive = receive; 358 vc->receive_iov = receive_iov; 359 vc->cleanup = cleanup; 360 vc->opaque = opaque; 361 vc->vlan = vlan; 362 363 vc->next = NULL; 364 pvc = &vlan->first_client; 365 while (*pvc != NULL) 366 pvc = &(*pvc)->next; 367 *pvc = vc; 368 return vc; 369 } 370 371 void qemu_del_vlan_client(VLANClientState *vc) 372 { 373 VLANClientState **pvc = &vc->vlan->first_client; 374 375 while (*pvc != NULL) 376 if (*pvc == vc) { 377 *pvc = vc->next; 378 if (vc->cleanup) { 379 vc->cleanup(vc); 380 } 381 free(vc->name); 382 free(vc->model); 383 g_free(vc); 384 break; 385 } else 386 pvc = &(*pvc)->next; 387 } 388 389 VLANClientState *qemu_find_vlan_client(VLANState *vlan, void *opaque) 390 { 391 VLANClientState **pvc = &vlan->first_client; 392 393 while (*pvc != NULL) 394 if ((*pvc)->opaque == opaque) 395 return *pvc; 396 else 397 pvc = &(*pvc)->next; 398 399 return NULL; 400 } 401 402 int qemu_can_send_packet(VLANClientState *sender) 403 { 404 VLANState *vlan = sender->vlan; 405 VLANClientState *vc; 406 407 for (vc = vlan->first_client; vc != NULL; vc = vc->next) { 408 if (vc == sender) { 409 continue; 410 } 411 412 /* no can_receive() handler, they can always receive */ 413 if (!vc->can_receive || vc->can_receive(vc)) { 414 return 1; 415 } 416 } 417 return 0; 418 } 419 420 static int 421 qemu_deliver_packet(VLANClientState *sender, const uint8_t *buf, int size) 422 { 423 VLANClientState *vc; 424 int ret = -1; 425 426 sender->vlan->delivering = 1; 427 428 for (vc = sender->vlan->first_client; vc != NULL; vc = vc->next) { 429 ssize_t len; 430 431 if (vc == sender) { 432 continue; 433 } 434 435 if (vc->link_down) { 436 ret = size; 437 continue; 438 } 439 440 len = vc->receive(vc, buf, size); 441 442 ret = (ret >= 0) ? ret : len; 443 } 444 445 sender->vlan->delivering = 0; 446 447 return ret; 448 } 449 450 void qemu_flush_queued_packets(VLANClientState *vc) 451 { 452 VLANPacket *packet; 453 454 while ((packet = vc->vlan->send_queue) != NULL) { 455 int ret; 456 457 vc->vlan->send_queue = packet->next; 458 459 ret = qemu_deliver_packet(packet->sender, packet->data, packet->size); 460 if (ret == 0 && packet->sent_cb != NULL) { 461 packet->next = vc->vlan->send_queue; 462 vc->vlan->send_queue = packet; 463 break; 464 } 465 466 if (packet->sent_cb) 467 packet->sent_cb(packet->sender); 468 469 g_free(packet); 470 } 471 } 472 473 static void qemu_enqueue_packet(VLANClientState *sender, 474 const uint8_t *buf, int size, 475 NetPacketSent *sent_cb) 476 { 477 VLANPacket *packet; 478 479 packet = g_malloc(sizeof(VLANPacket) + size); 480 packet->next = sender->vlan->send_queue; 481 packet->sender = sender; 482 packet->size = size; 483 packet->sent_cb = sent_cb; 484 memcpy(packet->data, buf, size); 485 sender->vlan->send_queue = packet; 486 } 487 488 ssize_t qemu_send_packet_async(VLANClientState *sender, 489 const uint8_t *buf, int size, 490 NetPacketSent *sent_cb) 491 { 492 int ret; 493 494 if (sender->link_down) { 495 return size; 496 } 497 498 #ifdef DEBUG_NET 499 printf("vlan %d send:\n", sender->vlan->id); 500 hex_dump(stdout, buf, size); 501 #endif 502 503 if (sender->vlan->delivering) { 504 qemu_enqueue_packet(sender, buf, size, NULL); 505 return size; 506 } 507 508 ret = qemu_deliver_packet(sender, buf, size); 509 if (ret == 0 && sent_cb != NULL) { 510 qemu_enqueue_packet(sender, buf, size, sent_cb); 511 return 0; 512 } 513 514 qemu_flush_queued_packets(sender); 515 516 return ret; 517 } 518 519 void qemu_send_packet(VLANClientState *vc, const uint8_t *buf, int size) 520 { 521 qemu_send_packet_async(vc, buf, size, NULL); 522 } 523 524 static ssize_t vc_sendv_compat(VLANClientState *vc, const struct iovec *iov, 525 int iovcnt) 526 { 527 uint8_t buffer[4096]; 528 size_t offset = 0; 529 int i; 530 531 for (i = 0; i < iovcnt; i++) { 532 size_t len; 533 534 len = MIN(sizeof(buffer) - offset, iov[i].iov_len); 535 memcpy(buffer + offset, iov[i].iov_base, len); 536 offset += len; 537 } 538 539 return vc->receive(vc, buffer, offset); 540 } 541 542 static ssize_t calc_iov_length(const struct iovec *iov, int iovcnt) 543 { 544 size_t offset = 0; 545 int i; 546 547 for (i = 0; i < iovcnt; i++) 548 offset += iov[i].iov_len; 549 return offset; 550 } 551 552 static int qemu_deliver_packet_iov(VLANClientState *sender, 553 const struct iovec *iov, int iovcnt) 554 { 555 VLANClientState *vc; 556 int ret = -1; 557 558 sender->vlan->delivering = 1; 559 560 for (vc = sender->vlan->first_client; vc != NULL; vc = vc->next) { 561 ssize_t len; 562 563 if (vc == sender) { 564 continue; 565 } 566 567 if (vc->link_down) { 568 ret = calc_iov_length(iov, iovcnt); 569 continue; 570 } 571 572 if (vc->receive_iov) { 573 len = vc->receive_iov(vc, iov, iovcnt); 574 } else { 575 len = vc_sendv_compat(vc, iov, iovcnt); 576 } 577 578 ret = (ret >= 0) ? ret : len; 579 } 580 581 sender->vlan->delivering = 0; 582 583 return ret; 584 } 585 586 static ssize_t qemu_enqueue_packet_iov(VLANClientState *sender, 587 const struct iovec *iov, int iovcnt, 588 NetPacketSent *sent_cb) 589 { 590 VLANPacket *packet; 591 size_t max_len = 0; 592 int i; 593 594 max_len = calc_iov_length(iov, iovcnt); 595 596 packet = g_malloc(sizeof(VLANPacket) + max_len); 597 packet->next = sender->vlan->send_queue; 598 packet->sender = sender; 599 packet->sent_cb = sent_cb; 600 packet->size = 0; 601 602 for (i = 0; i < iovcnt; i++) { 603 size_t len = iov[i].iov_len; 604 605 memcpy(packet->data + packet->size, iov[i].iov_base, len); 606 packet->size += len; 607 } 608 609 sender->vlan->send_queue = packet; 610 611 return packet->size; 612 } 613 614 ssize_t qemu_sendv_packet_async(VLANClientState *sender, 615 const struct iovec *iov, int iovcnt, 616 NetPacketSent *sent_cb) 617 { 618 int ret; 619 620 if (sender->link_down) { 621 return calc_iov_length(iov, iovcnt); 622 } 623 624 if (sender->vlan->delivering) { 625 return qemu_enqueue_packet_iov(sender, iov, iovcnt, NULL); 626 } 627 628 ret = qemu_deliver_packet_iov(sender, iov, iovcnt); 629 if (ret == 0 && sent_cb != NULL) { 630 qemu_enqueue_packet_iov(sender, iov, iovcnt, sent_cb); 631 return 0; 632 } 633 634 qemu_flush_queued_packets(sender); 635 636 return ret; 637 } 638 639 ssize_t 640 qemu_sendv_packet(VLANClientState *vc, const struct iovec *iov, int iovcnt) 641 { 642 return qemu_sendv_packet_async(vc, iov, iovcnt, NULL); 643 } 644 645 static void config_error(Monitor *mon, const char *fmt, ...) 646 { 647 va_list ap; 648 649 va_start(ap, fmt); 650 if (mon) { 651 monitor_vprintf(mon, fmt, ap); 652 } else { 653 fprintf(stderr, "qemu: "); 654 vfprintf(stderr, fmt, ap); 655 exit(1); 656 } 657 va_end(ap); 658 } 659 660 #if defined(CONFIG_SLIRP) 661 662 /* slirp network adapter */ 663 664 struct slirp_config_str { 665 struct slirp_config_str *next; 666 const char *str; 667 }; 668 669 static int slirp_inited; 670 static struct slirp_config_str *slirp_redirs; 671 #ifndef _WIN32 672 static const char *slirp_smb_export; 673 #endif 674 static VLANClientState *slirp_vc; 675 676 #ifndef _WIN32 677 static void slirp_smb(const char *exported_dir); 678 #endif 679 static void slirp_redirection(Monitor *mon, const char *redir_str); 680 681 double qemu_net_upload_speed = 0.; 682 double qemu_net_download_speed = 0.; 683 int qemu_net_min_latency = 0; 684 int qemu_net_max_latency = 0; 685 int qemu_net_disable = 0; 686 687 int 688 ip_packet_is_internal( const uint8_t* data, size_t size ) 689 { 690 const uint8_t* end = data + size; 691 692 /* must have room for Mac + IP header */ 693 if (data + 40 > end) 694 return 0; 695 696 if (data[12] != 0x08 || data[13] != 0x00 ) 697 return 0; 698 699 /* must have valid IP header */ 700 data += 14; 701 if ((data[0] >> 4) != 4 || (data[0] & 15) < 5) 702 return 0; 703 704 /* internal if both source and dest addresses are in 10.x.x.x */ 705 return ( data[12] == 10 && data[16] == 10); 706 } 707 708 #ifdef CONFIG_ANDROID 709 710 NetShaper slirp_shaper_in; 711 NetShaper slirp_shaper_out; 712 NetDelay slirp_delay_in; 713 714 static void 715 slirp_delay_in_cb( void* data, 716 size_t size, 717 void* opaque ) 718 { 719 slirp_input( (const uint8_t*)data, (int)size ); 720 opaque = opaque; 721 } 722 723 static void 724 slirp_shaper_in_cb( void* data, 725 size_t size, 726 void* opaque ) 727 { 728 netdelay_send_aux( slirp_delay_in, data, size, opaque ); 729 } 730 731 static void 732 slirp_shaper_out_cb( void* data, 733 size_t size, 734 void* opaque ) 735 { 736 qemu_send_packet( slirp_vc, (const uint8_t*)data, (int)size ); 737 } 738 739 void 740 slirp_init_shapers( void ) 741 { 742 slirp_delay_in = netdelay_create( slirp_delay_in_cb ); 743 slirp_shaper_in = netshaper_create( 1, slirp_shaper_in_cb ); 744 slirp_shaper_out = netshaper_create( 1, slirp_shaper_out_cb ); 745 746 netdelay_set_latency( slirp_delay_in, qemu_net_min_latency, qemu_net_max_latency ); 747 netshaper_set_rate( slirp_shaper_out, qemu_net_download_speed ); 748 netshaper_set_rate( slirp_shaper_in, qemu_net_upload_speed ); 749 } 750 751 #endif /* CONFIG_ANDROID */ 752 753 754 int slirp_can_output(void) 755 { 756 #ifdef CONFIG_ANDROID 757 return !slirp_vc || 758 ( netshaper_can_send(slirp_shaper_out) && 759 qemu_can_send_packet(slirp_vc) ); 760 #else 761 return !slirp_vc || qemu_can_send_packet(slirp_vc); 762 #endif 763 } 764 765 void slirp_output(const uint8_t *pkt, int pkt_len) 766 { 767 #ifdef DEBUG_SLIRP 768 printf("slirp output:\n"); 769 hex_dump(stdout, pkt, pkt_len); 770 #endif 771 if (qemu_tcpdump_active) 772 qemu_tcpdump_packet(pkt, pkt_len); 773 774 if (!slirp_vc) 775 return; 776 777 #ifdef CONFIG_ANDROID 778 netshaper_send(slirp_shaper_out, (void*)pkt, pkt_len); 779 #else 780 qemu_send_packet(slirp_vc, pkt, pkt_len); 781 #endif 782 } 783 784 int slirp_is_inited(void) 785 { 786 return slirp_inited; 787 } 788 789 static ssize_t slirp_receive(VLANClientState *vc, const uint8_t *buf, size_t size) 790 { 791 #ifdef DEBUG_SLIRP 792 printf("slirp input:\n"); 793 hex_dump(stdout, buf, size); 794 #endif 795 if (qemu_tcpdump_active) 796 qemu_tcpdump_packet(buf, size); 797 798 #ifdef CONFIG_ANDROID 799 netshaper_send(slirp_shaper_in, (char*)buf, size); 800 #else 801 slirp_input(buf, size); 802 #endif 803 return size; 804 } 805 806 static int slirp_in_use; 807 808 static void net_slirp_cleanup(VLANClientState *vc) 809 { 810 slirp_in_use = 0; 811 } 812 813 static int net_slirp_init(VLANState *vlan, const char *model, const char *name, 814 int restricted, const char *ip) 815 { 816 if (slirp_in_use) { 817 /* slirp only supports a single instance so far */ 818 return -1; 819 } 820 if (!slirp_inited) { 821 slirp_inited = 1; 822 slirp_init(restricted, ip); 823 824 while (slirp_redirs) { 825 struct slirp_config_str *config = slirp_redirs; 826 827 slirp_redirection(NULL, config->str); 828 slirp_redirs = config->next; 829 g_free(config); 830 } 831 #ifndef _WIN32 832 if (slirp_smb_export) { 833 slirp_smb(slirp_smb_export); 834 } 835 #endif 836 slirp_init_shapers(); 837 } 838 839 slirp_vc = qemu_new_vlan_client(vlan, model, name, NULL, slirp_receive, 840 NULL, net_slirp_cleanup, NULL); 841 slirp_vc->info_str[0] = '\0'; 842 slirp_in_use = 1; 843 return 0; 844 } 845 846 static void net_slirp_redir_print(void *opaque, int is_udp, 847 const SockAddress *laddr, 848 const SockAddress *faddr) 849 { 850 Monitor *mon = (Monitor *)opaque; 851 uint32_t h_addr; 852 uint32_t g_addr; 853 char buf[16]; 854 855 h_addr = sock_address_get_ip(faddr); 856 g_addr = sock_address_get_ip(laddr); 857 858 monitor_printf(mon, " %s |", is_udp ? "udp" : "tcp" ); 859 snprintf(buf, 15, "%d.%d.%d.%d", (h_addr >> 24) & 0xff, 860 (h_addr >> 16) & 0xff, 861 (h_addr >> 8) & 0xff, 862 (h_addr) & 0xff); 863 monitor_printf(mon, " %15s |", buf); 864 monitor_printf(mon, " %5d |", sock_address_get_port(faddr)); 865 866 snprintf(buf, 15, "%d.%d.%d.%d", (g_addr >> 24) & 0xff, 867 (g_addr >> 16) & 0xff, 868 (g_addr >> 8) & 0xff, 869 (g_addr) & 0xff); 870 monitor_printf(mon, " %15s |", buf); 871 monitor_printf(mon, " %5d\n", sock_address_get_port(laddr)); 872 873 } 874 875 static void net_slirp_redir_list(Monitor *mon) 876 { 877 if (!mon) 878 return; 879 880 monitor_printf(mon, " Prot | Host Addr | HPort | Guest Addr | GPort\n"); 881 monitor_printf(mon, " | | | | \n"); 882 slirp_redir_loop(net_slirp_redir_print, mon); 883 } 884 885 static void net_slirp_redir_rm(Monitor *mon, const char *port_str) 886 { 887 int host_port; 888 char buf[256] = ""; 889 const char *p = port_str; 890 int is_udp = 0; 891 int n; 892 893 if (!mon) 894 return; 895 896 if (!port_str || !port_str[0]) 897 goto fail_syntax; 898 899 get_str_sep(buf, sizeof(buf), &p, ':'); 900 901 if (!strcmp(buf, "tcp") || buf[0] == '\0') { 902 is_udp = 0; 903 } else if (!strcmp(buf, "udp")) { 904 is_udp = 1; 905 } else { 906 goto fail_syntax; 907 } 908 909 host_port = atoi(p); 910 911 n = slirp_redir_rm(is_udp, host_port); 912 913 monitor_printf(mon, "removed %d redirections to %s port %d\n", n, 914 is_udp ? "udp" : "tcp", host_port); 915 return; 916 917 fail_syntax: 918 monitor_printf(mon, "invalid format\n"); 919 } 920 921 static void slirp_redirection(Monitor *mon, const char *redir_str) 922 { 923 uint32_t guest_addr; 924 int host_port, guest_port; 925 const char *p; 926 char buf[256], *r; 927 int is_udp; 928 929 p = redir_str; 930 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) { 931 goto fail_syntax; 932 } 933 if (!strcmp(buf, "tcp") || buf[0] == '\0') { 934 is_udp = 0; 935 } else if (!strcmp(buf, "udp")) { 936 is_udp = 1; 937 } else { 938 goto fail_syntax; 939 } 940 941 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) { 942 goto fail_syntax; 943 } 944 host_port = strtol(buf, &r, 0); 945 if (r == buf) { 946 goto fail_syntax; 947 } 948 949 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) { 950 goto fail_syntax; 951 } 952 if (buf[0] == '\0') { 953 pstrcpy(buf, sizeof(buf), "10.0.2.15"); 954 } 955 if (inet_strtoip(buf, &guest_addr) < 0) { 956 goto fail_syntax; 957 } 958 959 guest_port = strtol(p, &r, 0); 960 if (r == p) { 961 goto fail_syntax; 962 } 963 964 if (slirp_redir(is_udp, host_port, guest_addr, guest_port) < 0) { 965 config_error(mon, "could not set up redirection '%s'\n", redir_str); 966 } 967 return; 968 969 fail_syntax: 970 config_error(mon, "invalid redirection format '%s'\n", redir_str); 971 } 972 973 void net_slirp_redir(Monitor *mon, const char *redir_str, const char *redir_opt2) 974 { 975 struct slirp_config_str *config; 976 977 if (!slirp_inited) { 978 if (mon) { 979 monitor_printf(mon, "user mode network stack not in use\n"); 980 } else { 981 config = g_malloc(sizeof(*config)); 982 config->str = redir_str; 983 config->next = slirp_redirs; 984 slirp_redirs = config; 985 } 986 return; 987 } 988 989 if (!strcmp(redir_str, "remove")) { 990 net_slirp_redir_rm(mon, redir_opt2); 991 return; 992 } 993 994 if (!strcmp(redir_str, "list")) { 995 net_slirp_redir_list(mon); 996 return; 997 } 998 999 slirp_redirection(mon, redir_str); 1000 } 1001 1002 #ifndef _WIN32 1003 1004 static char smb_dir[1024]; 1005 1006 static void erase_dir(char *dir_name) 1007 { 1008 DIR *d; 1009 struct dirent *de; 1010 char filename[1024]; 1011 1012 /* erase all the files in the directory */ 1013 if ((d = opendir(dir_name)) != NULL) { 1014 for(;;) { 1015 de = readdir(d); 1016 if (!de) 1017 break; 1018 if (strcmp(de->d_name, ".") != 0 && 1019 strcmp(de->d_name, "..") != 0) { 1020 snprintf(filename, sizeof(filename), "%s/%s", 1021 smb_dir, de->d_name); 1022 if (unlink(filename) != 0) /* is it a directory? */ 1023 erase_dir(filename); 1024 } 1025 } 1026 closedir(d); 1027 rmdir(dir_name); 1028 } 1029 } 1030 1031 /* automatic user mode samba server configuration */ 1032 static void smb_exit(void) 1033 { 1034 erase_dir(smb_dir); 1035 } 1036 1037 static void slirp_smb(const char *exported_dir) 1038 { 1039 char smb_conf[1024]; 1040 char smb_cmdline[1024]; 1041 FILE *f; 1042 1043 /* XXX: better tmp dir construction */ 1044 snprintf(smb_dir, sizeof(smb_dir), "/tmp/qemu-smb.%ld", (long)getpid()); 1045 if (mkdir(smb_dir, 0700) < 0) { 1046 fprintf(stderr, "qemu: could not create samba server dir '%s'\n", smb_dir); 1047 exit(1); 1048 } 1049 snprintf(smb_conf, sizeof(smb_conf), "%s/%s", smb_dir, "smb.conf"); 1050 1051 f = fopen(smb_conf, "w"); 1052 if (!f) { 1053 fprintf(stderr, "qemu: could not create samba server configuration file '%s'\n", smb_conf); 1054 exit(1); 1055 } 1056 fprintf(f, 1057 "[global]\n" 1058 "private dir=%s\n" 1059 "smb ports=0\n" 1060 "socket address=127.0.0.1\n" 1061 "pid directory=%s\n" 1062 "lock directory=%s\n" 1063 "log file=%s/log.smbd\n" 1064 "smb passwd file=%s/smbpasswd\n" 1065 "security = share\n" 1066 "[qemu]\n" 1067 "path=%s\n" 1068 "read only=no\n" 1069 "guest ok=yes\n", 1070 smb_dir, 1071 smb_dir, 1072 smb_dir, 1073 smb_dir, 1074 smb_dir, 1075 exported_dir 1076 ); 1077 fclose(f); 1078 atexit(smb_exit); 1079 1080 snprintf(smb_cmdline, sizeof(smb_cmdline), "%s -s %s", 1081 SMBD_COMMAND, smb_conf); 1082 1083 slirp_add_exec(0, smb_cmdline, 4, 139); 1084 } 1085 1086 /* automatic user mode samba server configuration */ 1087 void net_slirp_smb(const char *exported_dir) 1088 { 1089 if (slirp_smb_export) { 1090 fprintf(stderr, "-smb given twice\n"); 1091 exit(1); 1092 } 1093 slirp_smb_export = exported_dir; 1094 if (slirp_inited) { 1095 slirp_smb(exported_dir); 1096 } 1097 } 1098 1099 #endif /* !defined(_WIN32) */ 1100 1101 void do_info_slirp(Monitor *mon) 1102 { 1103 //slirp_stats(); 1104 } 1105 1106 struct VMChannel { 1107 CharDriverState *hd; 1108 int port; 1109 }; 1110 1111 static int vmchannel_can_read(void *opaque) 1112 { 1113 struct VMChannel *vmc = (struct VMChannel*)opaque; 1114 return slirp_socket_can_recv(4, vmc->port); 1115 } 1116 1117 static void vmchannel_read(void *opaque, const uint8_t *buf, int size) 1118 { 1119 struct VMChannel *vmc = (struct VMChannel*)opaque; 1120 slirp_socket_recv(4, vmc->port, buf, size); 1121 } 1122 1123 #endif /* CONFIG_SLIRP */ 1124 1125 #if !defined(_WIN32) 1126 1127 typedef struct TAPState { 1128 VLANClientState *vc; 1129 int fd; 1130 char down_script[1024]; 1131 char down_script_arg[128]; 1132 uint8_t buf[4096]; 1133 } TAPState; 1134 1135 static int launch_script(const char *setup_script, const char *ifname, int fd); 1136 1137 static ssize_t tap_receive_iov(VLANClientState *vc, const struct iovec *iov, 1138 int iovcnt) 1139 { 1140 TAPState *s = vc->opaque; 1141 ssize_t len; 1142 1143 do { 1144 len = writev(s->fd, iov, iovcnt); 1145 } while (len == -1 && (errno == EINTR || errno == EAGAIN)); 1146 1147 return len; 1148 } 1149 1150 static ssize_t tap_receive(VLANClientState *vc, const uint8_t *buf, size_t size) 1151 { 1152 TAPState *s = vc->opaque; 1153 ssize_t len; 1154 1155 do { 1156 len = write(s->fd, buf, size); 1157 } while (len == -1 && (errno == EINTR || errno == EAGAIN)); 1158 1159 return len; 1160 } 1161 1162 static int tap_can_send(void *opaque) 1163 { 1164 TAPState *s = opaque; 1165 1166 return qemu_can_send_packet(s->vc); 1167 } 1168 1169 #ifdef __sun__ 1170 static ssize_t tap_read_packet(int tapfd, uint8_t *buf, int maxlen) 1171 { 1172 struct strbuf sbuf; 1173 int f = 0; 1174 1175 sbuf.maxlen = maxlen; 1176 sbuf.buf = (char *)buf; 1177 1178 return getmsg(tapfd, NULL, &sbuf, &f) >= 0 ? sbuf.len : -1; 1179 } 1180 #else 1181 static ssize_t tap_read_packet(int tapfd, uint8_t *buf, int maxlen) 1182 { 1183 return read(tapfd, buf, maxlen); 1184 } 1185 #endif 1186 1187 static void tap_send(void *opaque); 1188 1189 static void tap_send_completed(VLANClientState *vc) 1190 { 1191 TAPState *s = vc->opaque; 1192 1193 qemu_set_fd_handler2(s->fd, tap_can_send, tap_send, NULL, s); 1194 } 1195 1196 static void tap_send(void *opaque) 1197 { 1198 TAPState *s = opaque; 1199 int size; 1200 1201 do { 1202 size = tap_read_packet(s->fd, s->buf, sizeof(s->buf)); 1203 if (size <= 0) { 1204 break; 1205 } 1206 1207 size = qemu_send_packet_async(s->vc, s->buf, size, tap_send_completed); 1208 if (size == 0) { 1209 qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL); 1210 } 1211 } while (size > 0); 1212 } 1213 1214 static void tap_cleanup(VLANClientState *vc) 1215 { 1216 TAPState *s = vc->opaque; 1217 1218 if (s->down_script[0]) 1219 launch_script(s->down_script, s->down_script_arg, s->fd); 1220 1221 qemu_set_fd_handler(s->fd, NULL, NULL, NULL); 1222 close(s->fd); 1223 g_free(s); 1224 } 1225 1226 /* fd support */ 1227 1228 static TAPState *net_tap_fd_init(VLANState *vlan, 1229 const char *model, 1230 const char *name, 1231 int fd) 1232 { 1233 TAPState *s; 1234 1235 s = g_malloc0(sizeof(TAPState)); 1236 s->fd = fd; 1237 s->vc = qemu_new_vlan_client(vlan, model, name, NULL, tap_receive, 1238 tap_receive_iov, tap_cleanup, s); 1239 qemu_set_fd_handler2(s->fd, tap_can_send, tap_send, NULL, s); 1240 snprintf(s->vc->info_str, sizeof(s->vc->info_str), "fd=%d", fd); 1241 return s; 1242 } 1243 1244 #if defined (CONFIG_BSD) || defined (__FreeBSD_kernel__) 1245 static int tap_open(char *ifname, int ifname_size) 1246 { 1247 int fd; 1248 char *dev; 1249 struct stat s; 1250 1251 TFR(fd = open("/dev/tap", O_RDWR)); 1252 if (fd < 0) { 1253 fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n"); 1254 return -1; 1255 } 1256 1257 fstat(fd, &s); 1258 dev = devname(s.st_rdev, S_IFCHR); 1259 pstrcpy(ifname, ifname_size, dev); 1260 1261 fcntl(fd, F_SETFL, O_NONBLOCK); 1262 return fd; 1263 } 1264 #elif defined(__sun__) 1265 #define TUNNEWPPA (('T'<<16) | 0x0001) 1266 /* 1267 * Allocate TAP device, returns opened fd. 1268 * Stores dev name in the first arg(must be large enough). 1269 */ 1270 static int tap_alloc(char *dev, size_t dev_size) 1271 { 1272 int tap_fd, if_fd, ppa = -1; 1273 static int ip_fd = 0; 1274 char *ptr; 1275 1276 static int arp_fd = 0; 1277 int ip_muxid, arp_muxid; 1278 struct strioctl strioc_if, strioc_ppa; 1279 int link_type = I_PLINK;; 1280 struct lifreq ifr; 1281 char actual_name[32] = ""; 1282 1283 memset(&ifr, 0x0, sizeof(ifr)); 1284 1285 if( *dev ){ 1286 ptr = dev; 1287 while( *ptr && !qemu_isdigit((int)*ptr) ) ptr++; 1288 ppa = atoi(ptr); 1289 } 1290 1291 /* Check if IP device was opened */ 1292 if( ip_fd ) 1293 close(ip_fd); 1294 1295 TFR(ip_fd = open("/dev/udp", O_RDWR, 0)); 1296 if (ip_fd < 0) { 1297 syslog(LOG_ERR, "Can't open /dev/ip (actually /dev/udp)"); 1298 return -1; 1299 } 1300 1301 TFR(tap_fd = open("/dev/tap", O_RDWR, 0)); 1302 if (tap_fd < 0) { 1303 syslog(LOG_ERR, "Can't open /dev/tap"); 1304 return -1; 1305 } 1306 1307 /* Assign a new PPA and get its unit number. */ 1308 strioc_ppa.ic_cmd = TUNNEWPPA; 1309 strioc_ppa.ic_timout = 0; 1310 strioc_ppa.ic_len = sizeof(ppa); 1311 strioc_ppa.ic_dp = (char *)&ppa; 1312 if ((ppa = ioctl (tap_fd, I_STR, &strioc_ppa)) < 0) 1313 syslog (LOG_ERR, "Can't assign new interface"); 1314 1315 TFR(if_fd = open("/dev/tap", O_RDWR, 0)); 1316 if (if_fd < 0) { 1317 syslog(LOG_ERR, "Can't open /dev/tap (2)"); 1318 return -1; 1319 } 1320 if(ioctl(if_fd, I_PUSH, "ip") < 0){ 1321 syslog(LOG_ERR, "Can't push IP module"); 1322 return -1; 1323 } 1324 1325 if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) < 0) 1326 syslog(LOG_ERR, "Can't get flags\n"); 1327 1328 snprintf (actual_name, 32, "tap%d", ppa); 1329 pstrcpy(ifr.lifr_name, sizeof(ifr.lifr_name), actual_name); 1330 1331 ifr.lifr_ppa = ppa; 1332 /* Assign ppa according to the unit number returned by tun device */ 1333 1334 if (ioctl (if_fd, SIOCSLIFNAME, &ifr) < 0) 1335 syslog (LOG_ERR, "Can't set PPA %d", ppa); 1336 if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) <0) 1337 syslog (LOG_ERR, "Can't get flags\n"); 1338 /* Push arp module to if_fd */ 1339 if (ioctl (if_fd, I_PUSH, "arp") < 0) 1340 syslog (LOG_ERR, "Can't push ARP module (2)"); 1341 1342 /* Push arp module to ip_fd */ 1343 if (ioctl (ip_fd, I_POP, NULL) < 0) 1344 syslog (LOG_ERR, "I_POP failed\n"); 1345 if (ioctl (ip_fd, I_PUSH, "arp") < 0) 1346 syslog (LOG_ERR, "Can't push ARP module (3)\n"); 1347 /* Open arp_fd */ 1348 TFR(arp_fd = open ("/dev/tap", O_RDWR, 0)); 1349 if (arp_fd < 0) 1350 syslog (LOG_ERR, "Can't open %s\n", "/dev/tap"); 1351 1352 /* Set ifname to arp */ 1353 strioc_if.ic_cmd = SIOCSLIFNAME; 1354 strioc_if.ic_timout = 0; 1355 strioc_if.ic_len = sizeof(ifr); 1356 strioc_if.ic_dp = (char *)𝔦 1357 if (ioctl(arp_fd, I_STR, &strioc_if) < 0){ 1358 syslog (LOG_ERR, "Can't set ifname to arp\n"); 1359 } 1360 1361 if((ip_muxid = ioctl(ip_fd, I_LINK, if_fd)) < 0){ 1362 syslog(LOG_ERR, "Can't link TAP device to IP"); 1363 return -1; 1364 } 1365 1366 if ((arp_muxid = ioctl (ip_fd, link_type, arp_fd)) < 0) 1367 syslog (LOG_ERR, "Can't link TAP device to ARP"); 1368 1369 close (if_fd); 1370 1371 memset(&ifr, 0x0, sizeof(ifr)); 1372 pstrcpy(ifr.lifr_name, sizeof(ifr.lifr_name), actual_name); 1373 ifr.lifr_ip_muxid = ip_muxid; 1374 ifr.lifr_arp_muxid = arp_muxid; 1375 1376 if (ioctl (ip_fd, SIOCSLIFMUXID, &ifr) < 0) 1377 { 1378 ioctl (ip_fd, I_PUNLINK , arp_muxid); 1379 ioctl (ip_fd, I_PUNLINK, ip_muxid); 1380 syslog (LOG_ERR, "Can't set multiplexor id"); 1381 } 1382 1383 snprintf(dev, dev_size, "tap%d", ppa); 1384 return tap_fd; 1385 } 1386 1387 static int tap_open(char *ifname, int ifname_size) 1388 { 1389 char dev[10]=""; 1390 int fd; 1391 if( (fd = tap_alloc(dev, sizeof(dev))) < 0 ){ 1392 fprintf(stderr, "Cannot allocate TAP device\n"); 1393 return -1; 1394 } 1395 pstrcpy(ifname, ifname_size, dev); 1396 fcntl(fd, F_SETFL, O_NONBLOCK); 1397 return fd; 1398 } 1399 #elif defined (_AIX) 1400 static int tap_open(char *ifname, int ifname_size) 1401 { 1402 fprintf (stderr, "no tap on AIX\n"); 1403 return -1; 1404 } 1405 #else 1406 static int tap_open(char *ifname, int ifname_size) 1407 { 1408 struct ifreq ifr; 1409 int fd, ret; 1410 1411 TFR(fd = open("/dev/net/tun", O_RDWR)); 1412 if (fd < 0) { 1413 fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n"); 1414 return -1; 1415 } 1416 memset(&ifr, 0, sizeof(ifr)); 1417 ifr.ifr_flags = IFF_TAP | IFF_NO_PI; 1418 if (ifname[0] != '\0') 1419 pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname); 1420 else 1421 pstrcpy(ifr.ifr_name, IFNAMSIZ, "tap%d"); 1422 ret = ioctl(fd, TUNSETIFF, (void *) &ifr); 1423 if (ret != 0) { 1424 fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n"); 1425 close(fd); 1426 return -1; 1427 } 1428 pstrcpy(ifname, ifname_size, ifr.ifr_name); 1429 fcntl(fd, F_SETFL, O_NONBLOCK); 1430 return fd; 1431 } 1432 #endif 1433 1434 static int launch_script(const char *setup_script, const char *ifname, int fd) 1435 { 1436 sigset_t oldmask, mask; 1437 int pid, status; 1438 char *args[3]; 1439 char **parg; 1440 1441 sigemptyset(&mask); 1442 sigaddset(&mask, SIGCHLD); 1443 sigprocmask(SIG_BLOCK, &mask, &oldmask); 1444 1445 /* try to launch network script */ 1446 pid = fork(); 1447 if (pid == 0) { 1448 int open_max = sysconf(_SC_OPEN_MAX), i; 1449 1450 for (i = 0; i < open_max; i++) { 1451 if (i != STDIN_FILENO && 1452 i != STDOUT_FILENO && 1453 i != STDERR_FILENO && 1454 i != fd) { 1455 close(i); 1456 } 1457 } 1458 parg = args; 1459 *parg++ = (char *)setup_script; 1460 *parg++ = (char *)ifname; 1461 *parg++ = NULL; 1462 execv(setup_script, args); 1463 exit(1); 1464 } else if (pid > 0) { 1465 while (waitpid(pid, &status, 0) != pid) { 1466 /* loop */ 1467 } 1468 sigprocmask(SIG_SETMASK, &oldmask, NULL); 1469 1470 if (WIFEXITED(status) && WEXITSTATUS(status) == 0) { 1471 return 0; 1472 } 1473 } 1474 fprintf(stderr, "%s: could not launch network script\n", setup_script); 1475 return -1; 1476 } 1477 1478 static int net_tap_init(VLANState *vlan, const char *model, 1479 const char *name, const char *ifname1, 1480 const char *setup_script, const char *down_script) 1481 { 1482 TAPState *s; 1483 int fd; 1484 char ifname[128]; 1485 1486 if (ifname1 != NULL) 1487 pstrcpy(ifname, sizeof(ifname), ifname1); 1488 else 1489 ifname[0] = '\0'; 1490 TFR(fd = tap_open(ifname, sizeof(ifname))); 1491 if (fd < 0) 1492 return -1; 1493 1494 if (!setup_script || !strcmp(setup_script, "no")) 1495 setup_script = ""; 1496 if (setup_script[0] != '\0') { 1497 if (launch_script(setup_script, ifname, fd)) 1498 return -1; 1499 } 1500 s = net_tap_fd_init(vlan, model, name, fd); 1501 snprintf(s->vc->info_str, sizeof(s->vc->info_str), 1502 "ifname=%s,script=%s,downscript=%s", 1503 ifname, setup_script, down_script); 1504 if (down_script && strcmp(down_script, "no")) { 1505 snprintf(s->down_script, sizeof(s->down_script), "%s", down_script); 1506 snprintf(s->down_script_arg, sizeof(s->down_script_arg), "%s", ifname); 1507 } 1508 return 0; 1509 } 1510 1511 #endif /* !_WIN32 */ 1512 1513 #if defined(CONFIG_VDE) 1514 typedef struct VDEState { 1515 VLANClientState *vc; 1516 VDECONN *vde; 1517 } VDEState; 1518 1519 static void vde_to_qemu(void *opaque) 1520 { 1521 VDEState *s = opaque; 1522 uint8_t buf[4096]; 1523 int size; 1524 1525 size = vde_recv(s->vde, (char *)buf, sizeof(buf), 0); 1526 if (size > 0) { 1527 qemu_send_packet(s->vc, buf, size); 1528 } 1529 } 1530 1531 static ssize_t vde_receive(VLANClientState *vc, const uint8_t *buf, size_t size) 1532 { 1533 VDEState *s = vc->opaque; 1534 ssize_t ret; 1535 1536 do { 1537 ret = vde_send(s->vde, (const char *)buf, size, 0); 1538 } while (ret < 0 && errno == EINTR); 1539 1540 return ret; 1541 } 1542 1543 static void vde_cleanup(VLANClientState *vc) 1544 { 1545 VDEState *s = vc->opaque; 1546 qemu_set_fd_handler(vde_datafd(s->vde), NULL, NULL, NULL); 1547 vde_close(s->vde); 1548 g_free(s); 1549 } 1550 1551 static int net_vde_init(VLANState *vlan, const char *model, 1552 const char *name, const char *sock, 1553 int port, const char *group, int mode) 1554 { 1555 VDEState *s; 1556 char *init_group = strlen(group) ? (char *)group : NULL; 1557 char *init_sock = strlen(sock) ? (char *)sock : NULL; 1558 1559 struct vde_open_args args = { 1560 .port = port, 1561 .group = init_group, 1562 .mode = mode, 1563 }; 1564 1565 s = g_malloc0(sizeof(VDEState)); 1566 s->vde = vde_open(init_sock, (char *)"QEMU", &args); 1567 if (!s->vde){ 1568 free(s); 1569 return -1; 1570 } 1571 s->vc = qemu_new_vlan_client(vlan, model, name, NULL, vde_receive, 1572 NULL, vde_cleanup, s); 1573 qemu_set_fd_handler(vde_datafd(s->vde), vde_to_qemu, NULL, s); 1574 snprintf(s->vc->info_str, sizeof(s->vc->info_str), "sock=%s,fd=%d", 1575 sock, vde_datafd(s->vde)); 1576 return 0; 1577 } 1578 #endif 1579 1580 /* network connection */ 1581 typedef struct NetSocketState { 1582 VLANClientState *vc; 1583 int fd; 1584 int state; /* 0 = getting length, 1 = getting data */ 1585 unsigned int index; 1586 unsigned int packet_len; 1587 uint8_t buf[4096]; 1588 SockAddress dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */ 1589 } NetSocketState; 1590 1591 typedef struct NetSocketListenState { 1592 VLANState *vlan; 1593 char *model; 1594 char *name; 1595 int fd; 1596 } NetSocketListenState; 1597 1598 /* XXX: we consider we can send the whole packet without blocking */ 1599 static ssize_t net_socket_receive(VLANClientState *vc, const uint8_t *buf, size_t size) 1600 { 1601 NetSocketState *s = vc->opaque; 1602 uint32_t len; 1603 len = htonl(size); 1604 1605 socket_send(s->fd, (const uint8_t *)&len, sizeof(len)); 1606 return socket_send(s->fd, buf, size); 1607 } 1608 1609 static ssize_t net_socket_receive_dgram(VLANClientState *vc, const uint8_t *buf, size_t size) 1610 { 1611 NetSocketState *s = vc->opaque; 1612 1613 return socket_sendto(s->fd, buf, size, &s->dgram_dst); 1614 } 1615 1616 static void net_socket_send(void *opaque) 1617 { 1618 NetSocketState *s = opaque; 1619 int size, err; 1620 unsigned l; 1621 uint8_t buf1[4096]; 1622 const uint8_t *buf; 1623 1624 size = recv(s->fd, (void *)buf1, sizeof(buf1), 0); 1625 if (size < 0) { 1626 err = socket_error(); 1627 if (err != EWOULDBLOCK && err != EAGAIN) 1628 goto eoc; 1629 } else if (size == 0) { 1630 /* end of connection */ 1631 eoc: 1632 qemu_set_fd_handler(s->fd, NULL, NULL, NULL); 1633 closesocket(s->fd); 1634 return; 1635 } 1636 buf = buf1; 1637 while (size > 0) { 1638 /* reassemble a packet from the network */ 1639 switch(s->state) { 1640 case 0: 1641 l = 4 - s->index; 1642 if (l > size) 1643 l = size; 1644 memcpy(s->buf + s->index, buf, l); 1645 buf += l; 1646 size -= l; 1647 s->index += l; 1648 if (s->index == 4) { 1649 /* got length */ 1650 s->packet_len = ntohl(*(uint32_t *)s->buf); 1651 s->index = 0; 1652 s->state = 1; 1653 } 1654 break; 1655 case 1: 1656 l = s->packet_len - s->index; 1657 if (l > size) 1658 l = size; 1659 if (s->index + l <= sizeof(s->buf)) { 1660 memcpy(s->buf + s->index, buf, l); 1661 } else { 1662 fprintf(stderr, "serious error: oversized packet received," 1663 "connection terminated.\n"); 1664 s->state = 0; 1665 goto eoc; 1666 } 1667 1668 s->index += l; 1669 buf += l; 1670 size -= l; 1671 if (s->index >= s->packet_len) { 1672 qemu_send_packet(s->vc, s->buf, s->packet_len); 1673 s->index = 0; 1674 s->state = 0; 1675 } 1676 break; 1677 } 1678 } 1679 } 1680 1681 static void net_socket_send_dgram(void *opaque) 1682 { 1683 NetSocketState *s = opaque; 1684 int size; 1685 1686 size = recv(s->fd, (void *)s->buf, sizeof(s->buf), 0); 1687 if (size < 0) 1688 return; 1689 if (size == 0) { 1690 /* end of connection */ 1691 qemu_set_fd_handler(s->fd, NULL, NULL, NULL); 1692 return; 1693 } 1694 qemu_send_packet(s->vc, s->buf, size); 1695 } 1696 1697 static int net_socket_mcast_create(SockAddress *mcastaddr) 1698 { 1699 int fd; 1700 int ret; 1701 if (!IN_MULTICAST(sock_address_get_ip(mcastaddr))) { 1702 fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n", 1703 sock_address_to_string(mcastaddr), 1704 sock_address_get_ip(mcastaddr)); 1705 return -1; 1706 1707 } 1708 fd = socket_create_inet(SOCKET_DGRAM); 1709 if (fd < 0) { 1710 perror("socket(PF_INET, SOCK_DGRAM)"); 1711 return -1; 1712 } 1713 1714 ret = socket_set_xreuseaddr(fd); 1715 if (ret < 0) { 1716 perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)"); 1717 goto fail; 1718 } 1719 1720 ret = socket_bind(fd, mcastaddr); 1721 if (ret < 0) { 1722 perror("bind"); 1723 goto fail; 1724 } 1725 1726 /* Add host to multicast group */ 1727 ret = socket_mcast_inet_add_membership(fd, sock_address_get_ip(mcastaddr)); 1728 if (ret < 0) { 1729 perror("setsockopt(IP_ADD_MEMBERSHIP)"); 1730 goto fail; 1731 } 1732 1733 /* Force mcast msgs to loopback (eg. several QEMUs in same host */ 1734 ret = socket_mcast_inet_set_loop(fd, 1); 1735 if (ret < 0) { 1736 perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)"); 1737 goto fail; 1738 } 1739 1740 socket_set_nonblock(fd); 1741 return fd; 1742 fail: 1743 if (fd >= 0) 1744 socket_close(fd); 1745 return -1; 1746 } 1747 1748 static void net_socket_cleanup(VLANClientState *vc) 1749 { 1750 NetSocketState *s = vc->opaque; 1751 qemu_set_fd_handler(s->fd, NULL, NULL, NULL); 1752 socket_close(s->fd); 1753 g_free(s); 1754 } 1755 1756 static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, 1757 const char *model, 1758 const char *name, 1759 int fd, int is_connected) 1760 { 1761 SockAddress saddr; 1762 int newfd; 1763 NetSocketState *s; 1764 1765 /* fd passed: multicast: "learn" dgram_dst address from bound address and save it 1766 * Because this may be "shared" socket from a "master" process, datagrams would be recv() 1767 * by ONLY ONE process: we must "clone" this dgram socket --jjo 1768 */ 1769 1770 if (is_connected) { 1771 if (socket_get_address(fd, &saddr) == 0) { 1772 /* must be bound */ 1773 if (sock_address_get_ip(&saddr) == 0) { 1774 fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n", 1775 fd); 1776 return NULL; 1777 } 1778 /* clone dgram socket */ 1779 newfd = net_socket_mcast_create(&saddr); 1780 if (newfd < 0) { 1781 /* error already reported by net_socket_mcast_create() */ 1782 socket_close(fd); 1783 return NULL; 1784 } 1785 /* clone newfd to fd, close newfd */ 1786 dup2(newfd, fd); 1787 socket_close(newfd); 1788 1789 } else { 1790 fprintf(stderr, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n", 1791 fd, strerror(errno)); 1792 return NULL; 1793 } 1794 } 1795 1796 s = g_malloc0(sizeof(NetSocketState)); 1797 s->fd = fd; 1798 1799 s->vc = qemu_new_vlan_client(vlan, model, name, NULL, net_socket_receive_dgram, 1800 NULL, net_socket_cleanup, s); 1801 qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s); 1802 1803 /* mcast: save bound address as dst */ 1804 if (is_connected) s->dgram_dst=saddr; 1805 1806 snprintf(s->vc->info_str, sizeof(s->vc->info_str), 1807 "socket: fd=%d (%s mcast=%s)", 1808 fd, is_connected? "cloned" : "", 1809 sock_address_to_string(&saddr)); 1810 return s; 1811 } 1812 1813 static void net_socket_connect(void *opaque) 1814 { 1815 NetSocketState *s = opaque; 1816 qemu_set_fd_handler(s->fd, net_socket_send, NULL, s); 1817 } 1818 1819 static NetSocketState *net_socket_fd_init_stream(VLANState *vlan, 1820 const char *model, 1821 const char *name, 1822 int fd, int is_connected) 1823 { 1824 NetSocketState *s; 1825 s = g_malloc0(sizeof(NetSocketState)); 1826 s->fd = fd; 1827 s->vc = qemu_new_vlan_client(vlan, model, name, NULL, net_socket_receive, 1828 NULL, net_socket_cleanup, s); 1829 snprintf(s->vc->info_str, sizeof(s->vc->info_str), 1830 "socket: fd=%d", fd); 1831 if (is_connected) { 1832 net_socket_connect(s); 1833 } else { 1834 qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s); 1835 } 1836 return s; 1837 } 1838 1839 static NetSocketState *net_socket_fd_init(VLANState *vlan, 1840 const char *model, const char *name, 1841 int fd, int is_connected) 1842 { 1843 SocketType so_type = socket_get_type(fd); 1844 1845 switch(so_type) { 1846 case SOCKET_DGRAM: 1847 return net_socket_fd_init_dgram(vlan, model, name, fd, is_connected); 1848 case SOCKET_STREAM: 1849 return net_socket_fd_init_stream(vlan, model, name, fd, is_connected); 1850 default: 1851 /* who knows ... this could be a eg. a pty, do warn and continue as stream */ 1852 fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd); 1853 return net_socket_fd_init_stream(vlan, model, name, fd, is_connected); 1854 } 1855 return NULL; 1856 } 1857 1858 static void net_socket_accept(void *opaque) 1859 { 1860 NetSocketListenState *s = opaque; 1861 NetSocketState *s1; 1862 SockAddress saddr; 1863 int fd; 1864 1865 for(;;) { 1866 fd = socket_accept(s->fd, &saddr); 1867 if (fd < 0) { 1868 return; 1869 } else if (fd >= 0) { 1870 break; 1871 } 1872 } 1873 s1 = net_socket_fd_init(s->vlan, s->model, s->name, fd, 1); 1874 if (!s1) { 1875 socket_close(fd); 1876 } else { 1877 snprintf(s1->vc->info_str, sizeof(s1->vc->info_str), 1878 "socket: connection from %s", sock_address_to_string(&saddr)); 1879 } 1880 } 1881 1882 static int net_socket_listen_init(VLANState *vlan, 1883 const char *model, 1884 const char *name, 1885 const char *host_str) 1886 { 1887 NetSocketListenState *s; 1888 int fd, ret; 1889 SockAddress saddr; 1890 1891 if (parse_host_port(&saddr, host_str) < 0) 1892 return -1; 1893 1894 s = g_malloc0(sizeof(NetSocketListenState)); 1895 1896 fd = socket_create_inet(SOCKET_STREAM); 1897 if (fd < 0) { 1898 perror("socket"); 1899 return -1; 1900 } 1901 socket_set_nonblock(fd); 1902 1903 /* allow fast reuse */ 1904 socket_set_xreuseaddr(fd); 1905 1906 ret = socket_bind(fd, &saddr); 1907 if (ret < 0) { 1908 perror("bind"); 1909 return -1; 1910 } 1911 ret = socket_listen(fd, 0); 1912 if (ret < 0) { 1913 perror("listen"); 1914 return -1; 1915 } 1916 s->vlan = vlan; 1917 s->model = strdup(model); 1918 s->name = name ? strdup(name) : NULL; 1919 s->fd = fd; 1920 qemu_set_fd_handler(fd, net_socket_accept, NULL, s); 1921 return 0; 1922 } 1923 1924 static int net_socket_connect_init(VLANState *vlan, 1925 const char *model, 1926 const char *name, 1927 const char *host_str) 1928 { 1929 NetSocketState *s; 1930 int fd, connected, ret, err; 1931 SockAddress saddr; 1932 1933 if (parse_host_port(&saddr, host_str) < 0) 1934 return -1; 1935 1936 fd = socket_create_inet(SOCKET_STREAM); 1937 if (fd < 0) { 1938 perror("socket"); 1939 return -1; 1940 } 1941 socket_set_nonblock(fd); 1942 1943 connected = 0; 1944 for(;;) { 1945 ret = socket_connect(fd, &saddr); 1946 if (ret < 0) { 1947 err = socket_error(); 1948 if (err == EWOULDBLOCK || err == EAGAIN) { 1949 } else if (err == EINPROGRESS || err == EALREADY) { 1950 break; 1951 } else { 1952 perror("connect"); 1953 socket_close(fd); 1954 return -1; 1955 } 1956 } else { 1957 connected = 1; 1958 break; 1959 } 1960 } 1961 s = net_socket_fd_init(vlan, model, name, fd, connected); 1962 if (!s) 1963 return -1; 1964 snprintf(s->vc->info_str, sizeof(s->vc->info_str), 1965 "socket: connect to %s", 1966 sock_address_to_string(&saddr)); 1967 return 0; 1968 } 1969 1970 static int net_socket_mcast_init(VLANState *vlan, 1971 const char *model, 1972 const char *name, 1973 const char *host_str) 1974 { 1975 NetSocketState *s; 1976 int fd; 1977 SockAddress saddr; 1978 1979 if (parse_host_port(&saddr, host_str) < 0) 1980 return -1; 1981 1982 1983 fd = net_socket_mcast_create(&saddr); 1984 if (fd < 0) 1985 return -1; 1986 1987 s = net_socket_fd_init(vlan, model, name, fd, 0); 1988 if (!s) 1989 return -1; 1990 1991 s->dgram_dst = saddr; 1992 1993 snprintf(s->vc->info_str, sizeof(s->vc->info_str), 1994 "socket: mcast=%s", 1995 sock_address_to_string(&saddr)); 1996 return 0; 1997 1998 } 1999 2000 typedef struct DumpState { 2001 VLANClientState *pcap_vc; 2002 int fd; 2003 int pcap_caplen; 2004 } DumpState; 2005 2006 #define PCAP_MAGIC 0xa1b2c3d4 2007 2008 struct pcap_file_hdr { 2009 uint32_t magic; 2010 uint16_t version_major; 2011 uint16_t version_minor; 2012 int32_t thiszone; 2013 uint32_t sigfigs; 2014 uint32_t snaplen; 2015 uint32_t linktype; 2016 }; 2017 2018 struct pcap_sf_pkthdr { 2019 struct { 2020 int32_t tv_sec; 2021 int32_t tv_usec; 2022 } ts; 2023 uint32_t caplen; 2024 uint32_t len; 2025 }; 2026 2027 static ssize_t dump_receive(VLANClientState *vc, const uint8_t *buf, size_t size) 2028 { 2029 DumpState *s = vc->opaque; 2030 struct pcap_sf_pkthdr hdr; 2031 int64_t ts; 2032 int caplen; 2033 2034 /* Early return in case of previous error. */ 2035 if (s->fd < 0) { 2036 return size; 2037 } 2038 2039 ts = muldiv64(qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL), 1000000, get_ticks_per_sec()); 2040 caplen = size > s->pcap_caplen ? s->pcap_caplen : size; 2041 2042 hdr.ts.tv_sec = ts / 1000000; 2043 hdr.ts.tv_usec = ts % 1000000; 2044 hdr.caplen = caplen; 2045 hdr.len = size; 2046 if (write(s->fd, &hdr, sizeof(hdr)) != sizeof(hdr) || 2047 write(s->fd, buf, caplen) != caplen) { 2048 qemu_log("-net dump write error - stop dump\n"); 2049 close(s->fd); 2050 s->fd = -1; 2051 } 2052 2053 return size; 2054 } 2055 2056 static void net_dump_cleanup(VLANClientState *vc) 2057 { 2058 DumpState *s = vc->opaque; 2059 2060 close(s->fd); 2061 g_free(s); 2062 } 2063 2064 static int net_dump_init(Monitor *mon, VLANState *vlan, const char *device, 2065 const char *name, const char *filename, int len) 2066 { 2067 struct pcap_file_hdr hdr; 2068 DumpState *s; 2069 2070 s = g_malloc(sizeof(DumpState)); 2071 2072 s->fd = open(filename, O_CREAT | O_WRONLY, 0644); 2073 if (s->fd < 0) { 2074 config_error(mon, "-net dump: can't open %s\n", filename); 2075 return -1; 2076 } 2077 2078 s->pcap_caplen = len; 2079 2080 hdr.magic = PCAP_MAGIC; 2081 hdr.version_major = 2; 2082 hdr.version_minor = 4; 2083 hdr.thiszone = 0; 2084 hdr.sigfigs = 0; 2085 hdr.snaplen = s->pcap_caplen; 2086 hdr.linktype = 1; 2087 2088 if (write(s->fd, &hdr, sizeof(hdr)) < sizeof(hdr)) { 2089 config_error(mon, "-net dump write error: %s\n", strerror(errno)); 2090 close(s->fd); 2091 g_free(s); 2092 return -1; 2093 } 2094 2095 s->pcap_vc = qemu_new_vlan_client(vlan, device, name, NULL, dump_receive, NULL, 2096 net_dump_cleanup, s); 2097 snprintf(s->pcap_vc->info_str, sizeof(s->pcap_vc->info_str), 2098 "dump to %s (len=%d)", filename, len); 2099 return 0; 2100 } 2101 2102 /* find or alloc a new VLAN */ 2103 VLANState *qemu_find_vlan(int id) 2104 { 2105 VLANState **pvlan, *vlan; 2106 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) { 2107 if (vlan->id == id) 2108 return vlan; 2109 } 2110 vlan = g_malloc0(sizeof(VLANState)); 2111 vlan->id = id; 2112 vlan->next = NULL; 2113 pvlan = &first_vlan; 2114 while (*pvlan != NULL) 2115 pvlan = &(*pvlan)->next; 2116 *pvlan = vlan; 2117 return vlan; 2118 } 2119 2120 static int nic_get_free_idx(void) 2121 { 2122 int index; 2123 2124 for (index = 0; index < MAX_NICS; index++) 2125 if (!nd_table[index].used) 2126 return index; 2127 return -1; 2128 } 2129 2130 void qemu_check_nic_model(NICInfo *nd, const char *model) 2131 { 2132 const char *models[2]; 2133 2134 models[0] = model; 2135 models[1] = NULL; 2136 2137 qemu_check_nic_model_list(nd, models, model); 2138 } 2139 2140 void qemu_check_nic_model_list(NICInfo *nd, const char * const *models, 2141 const char *default_model) 2142 { 2143 int i, exit_status = 0; 2144 2145 if (!nd->model) 2146 nd->model = strdup(default_model); 2147 2148 if (strcmp(nd->model, "?") != 0) { 2149 for (i = 0 ; models[i]; i++) 2150 if (strcmp(nd->model, models[i]) == 0) 2151 return; 2152 2153 fprintf(stderr, "qemu: Unsupported NIC model: %s\n", nd->model); 2154 exit_status = 1; 2155 } 2156 2157 fprintf(stderr, "qemu: Supported NIC models: "); 2158 for (i = 0 ; models[i]; i++) 2159 fprintf(stderr, "%s%c", models[i], models[i+1] ? ',' : '\n'); 2160 2161 exit(exit_status); 2162 } 2163 2164 int net_client_init(Monitor *mon, const char *device, const char *p) 2165 { 2166 static const char * const fd_params[] = { 2167 "vlan", "name", "fd", NULL 2168 }; 2169 char buf[1024]; 2170 int vlan_id, ret; 2171 VLANState *vlan; 2172 char *name = NULL; 2173 2174 vlan_id = 0; 2175 if (get_param_value(buf, sizeof(buf), "vlan", p)) { 2176 vlan_id = strtol(buf, NULL, 0); 2177 } 2178 vlan = qemu_find_vlan(vlan_id); 2179 2180 if (get_param_value(buf, sizeof(buf), "name", p)) { 2181 name = g_strdup(buf); 2182 } 2183 if (!strcmp(device, "nic")) { 2184 static const char * const nic_params[] = { 2185 "vlan", "name", "macaddr", "model", NULL 2186 }; 2187 NICInfo *nd; 2188 uint8_t *macaddr; 2189 int idx = nic_get_free_idx(); 2190 2191 if (check_params(buf, sizeof(buf), nic_params, p) < 0) { 2192 config_error(mon, "invalid parameter '%s' in '%s'\n", buf, p); 2193 ret = -1; 2194 goto out; 2195 } 2196 if (idx == -1 || nb_nics >= MAX_NICS) { 2197 config_error(mon, "Too Many NICs\n"); 2198 ret = -1; 2199 goto out; 2200 } 2201 nd = &nd_table[idx]; 2202 macaddr = nd->macaddr; 2203 macaddr[0] = 0x52; 2204 macaddr[1] = 0x54; 2205 macaddr[2] = 0x00; 2206 macaddr[3] = 0x12; 2207 macaddr[4] = 0x34; 2208 macaddr[5] = 0x56 + idx; 2209 2210 if (get_param_value(buf, sizeof(buf), "macaddr", p)) { 2211 if (parse_macaddr(macaddr, buf) < 0) { 2212 config_error(mon, "invalid syntax for ethernet address\n"); 2213 ret = -1; 2214 goto out; 2215 } 2216 } 2217 if (get_param_value(buf, sizeof(buf), "model", p)) { 2218 nd->model = strdup(buf); 2219 } 2220 nd->vlan = vlan; 2221 nd->name = name; 2222 nd->used = 1; 2223 name = NULL; 2224 nb_nics++; 2225 vlan->nb_guest_devs++; 2226 ret = idx; 2227 } else 2228 if (!strcmp(device, "none")) { 2229 if (*p != '\0') { 2230 config_error(mon, "'none' takes no parameters\n"); 2231 ret = -1; 2232 goto out; 2233 } 2234 /* does nothing. It is needed to signal that no network cards 2235 are wanted */ 2236 ret = 0; 2237 } else 2238 #ifdef CONFIG_SLIRP 2239 if (!strcmp(device, "user")) { 2240 static const char * const slirp_params[] = { 2241 "vlan", "name", "hostname", "restrict", "ip", NULL 2242 }; 2243 int restricted = 0; 2244 char *ip = NULL; 2245 2246 if (check_params(buf, sizeof(buf), slirp_params, p) < 0) { 2247 config_error(mon, "invalid parameter '%s' in '%s'\n", buf, p); 2248 ret = -1; 2249 goto out; 2250 } 2251 if (get_param_value(buf, sizeof(buf), "hostname", p)) { 2252 pstrcpy(slirp_hostname, sizeof(slirp_hostname), buf); 2253 } 2254 if (get_param_value(buf, sizeof(buf), "restrict", p)) { 2255 restricted = (buf[0] == 'y') ? 1 : 0; 2256 } 2257 if (get_param_value(buf, sizeof(buf), "ip", p)) { 2258 ip = g_strdup(buf); 2259 } 2260 vlan->nb_host_devs++; 2261 ret = net_slirp_init(vlan, device, name, restricted, ip); 2262 g_free(ip); 2263 } else if (!strcmp(device, "channel")) { 2264 long port; 2265 char name[20], *devname; 2266 struct VMChannel *vmc; 2267 2268 port = strtol(p, &devname, 10); 2269 devname++; 2270 if (port < 1 || port > 65535) { 2271 config_error(mon, "vmchannel wrong port number\n"); 2272 ret = -1; 2273 goto out; 2274 } 2275 vmc = malloc(sizeof(struct VMChannel)); 2276 snprintf(name, 20, "vmchannel%ld", port); 2277 vmc->hd = qemu_chr_open(name, devname, NULL); 2278 if (!vmc->hd) { 2279 config_error(mon, "could not open vmchannel device '%s'\n", 2280 devname); 2281 ret = -1; 2282 goto out; 2283 } 2284 vmc->port = port; 2285 slirp_add_exec(3, vmc->hd, 4, port); 2286 qemu_chr_add_handlers(vmc->hd, vmchannel_can_read, vmchannel_read, 2287 NULL, vmc); 2288 ret = 0; 2289 } else 2290 #endif 2291 #ifdef _WIN32 2292 if (!strcmp(device, "tap")) { 2293 static const char * const tap_params[] = { 2294 "vlan", "name", "ifname", NULL 2295 }; 2296 char ifname[64]; 2297 2298 if (check_params(buf, sizeof(buf), tap_params, p) < 0) { 2299 config_error(mon, "invalid parameter '%s' in '%s'\n", buf, p); 2300 ret = -1; 2301 goto out; 2302 } 2303 if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) { 2304 config_error(mon, "tap: no interface name\n"); 2305 ret = -1; 2306 goto out; 2307 } 2308 vlan->nb_host_devs++; 2309 ret = tap_win32_init(vlan, device, name, ifname); 2310 } else 2311 #elif defined (_AIX) 2312 #else 2313 if (!strcmp(device, "tap")) { 2314 char ifname[64], chkbuf[64]; 2315 char setup_script[1024], down_script[1024]; 2316 int fd; 2317 vlan->nb_host_devs++; 2318 if (get_param_value(buf, sizeof(buf), "fd", p) > 0) { 2319 if (check_params(chkbuf, sizeof(chkbuf), fd_params, p) < 0) { 2320 config_error(mon, "invalid parameter '%s' in '%s'\n", chkbuf, p); 2321 ret = -1; 2322 goto out; 2323 } 2324 fd = strtol(buf, NULL, 0); 2325 fcntl(fd, F_SETFL, O_NONBLOCK); 2326 net_tap_fd_init(vlan, device, name, fd); 2327 ret = 0; 2328 } else { 2329 static const char * const tap_params[] = { 2330 "vlan", "name", "ifname", "script", "downscript", NULL 2331 }; 2332 if (check_params(chkbuf, sizeof(chkbuf), tap_params, p) < 0) { 2333 config_error(mon, "invalid parameter '%s' in '%s'\n", chkbuf, p); 2334 ret = -1; 2335 goto out; 2336 } 2337 if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) { 2338 ifname[0] = '\0'; 2339 } 2340 if (get_param_value(setup_script, sizeof(setup_script), "script", p) == 0) { 2341 pstrcpy(setup_script, sizeof(setup_script), DEFAULT_NETWORK_SCRIPT); 2342 } 2343 if (get_param_value(down_script, sizeof(down_script), "downscript", p) == 0) { 2344 pstrcpy(down_script, sizeof(down_script), DEFAULT_NETWORK_DOWN_SCRIPT); 2345 } 2346 ret = net_tap_init(vlan, device, name, ifname, setup_script, down_script); 2347 } 2348 } else 2349 #endif 2350 if (!strcmp(device, "socket")) { 2351 char chkbuf[64]; 2352 if (get_param_value(buf, sizeof(buf), "fd", p) > 0) { 2353 int fd; 2354 if (check_params(chkbuf, sizeof(chkbuf), fd_params, p) < 0) { 2355 config_error(mon, "invalid parameter '%s' in '%s'\n", chkbuf, p); 2356 ret = -1; 2357 goto out; 2358 } 2359 fd = strtol(buf, NULL, 0); 2360 ret = -1; 2361 if (net_socket_fd_init(vlan, device, name, fd, 1)) 2362 ret = 0; 2363 } else if (get_param_value(buf, sizeof(buf), "listen", p) > 0) { 2364 static const char * const listen_params[] = { 2365 "vlan", "name", "listen", NULL 2366 }; 2367 if (check_params(chkbuf, sizeof(chkbuf), listen_params, p) < 0) { 2368 config_error(mon, "invalid parameter '%s' in '%s'\n", chkbuf, p); 2369 ret = -1; 2370 goto out; 2371 } 2372 ret = net_socket_listen_init(vlan, device, name, buf); 2373 } else if (get_param_value(buf, sizeof(buf), "connect", p) > 0) { 2374 static const char * const connect_params[] = { 2375 "vlan", "name", "connect", NULL 2376 }; 2377 if (check_params(chkbuf, sizeof(chkbuf), connect_params, p) < 0) { 2378 config_error(mon, "invalid parameter '%s' in '%s'\n", chkbuf, p); 2379 ret = -1; 2380 goto out; 2381 } 2382 ret = net_socket_connect_init(vlan, device, name, buf); 2383 } else if (get_param_value(buf, sizeof(buf), "mcast", p) > 0) { 2384 static const char * const mcast_params[] = { 2385 "vlan", "name", "mcast", NULL 2386 }; 2387 if (check_params(chkbuf, sizeof(chkbuf), mcast_params, p) < 0) { 2388 config_error(mon, "invalid parameter '%s' in '%s'\n", chkbuf, p); 2389 ret = -1; 2390 goto out; 2391 } 2392 ret = net_socket_mcast_init(vlan, device, name, buf); 2393 } else { 2394 config_error(mon, "Unknown socket options: %s\n", p); 2395 ret = -1; 2396 goto out; 2397 } 2398 vlan->nb_host_devs++; 2399 } else 2400 #ifdef CONFIG_VDE 2401 if (!strcmp(device, "vde")) { 2402 static const char * const vde_params[] = { 2403 "vlan", "name", "sock", "port", "group", "mode", NULL 2404 }; 2405 char vde_sock[1024], vde_group[512]; 2406 int vde_port, vde_mode; 2407 2408 if (check_params(buf, sizeof(buf), vde_params, p) < 0) { 2409 config_error(mon, "invalid parameter '%s' in '%s'\n", buf, p); 2410 ret = -1; 2411 goto out; 2412 } 2413 vlan->nb_host_devs++; 2414 if (get_param_value(vde_sock, sizeof(vde_sock), "sock", p) <= 0) { 2415 vde_sock[0] = '\0'; 2416 } 2417 if (get_param_value(buf, sizeof(buf), "port", p) > 0) { 2418 vde_port = strtol(buf, NULL, 10); 2419 } else { 2420 vde_port = 0; 2421 } 2422 if (get_param_value(vde_group, sizeof(vde_group), "group", p) <= 0) { 2423 vde_group[0] = '\0'; 2424 } 2425 if (get_param_value(buf, sizeof(buf), "mode", p) > 0) { 2426 vde_mode = strtol(buf, NULL, 8); 2427 } else { 2428 vde_mode = 0700; 2429 } 2430 ret = net_vde_init(vlan, device, name, vde_sock, vde_port, vde_group, vde_mode); 2431 } else 2432 #endif 2433 if (!strcmp(device, "dump")) { 2434 int len = 65536; 2435 2436 if (get_param_value(buf, sizeof(buf), "len", p) > 0) { 2437 len = strtol(buf, NULL, 0); 2438 } 2439 if (!get_param_value(buf, sizeof(buf), "file", p)) { 2440 snprintf(buf, sizeof(buf), "qemu-vlan%d.pcap", vlan_id); 2441 } 2442 ret = net_dump_init(mon, vlan, device, name, buf, len); 2443 } else { 2444 config_error(mon, "Unknown network device: %s\n", device); 2445 ret = -1; 2446 goto out; 2447 } 2448 if (ret < 0) { 2449 config_error(mon, "Could not initialize device '%s'\n", device); 2450 } 2451 out: 2452 g_free(name); 2453 return ret; 2454 } 2455 2456 void net_client_uninit(NICInfo *nd) 2457 { 2458 nd->vlan->nb_guest_devs--; 2459 nb_nics--; 2460 nd->used = 0; 2461 free((void *)nd->model); 2462 } 2463 2464 static int net_host_check_device(const char *device) 2465 { 2466 int i; 2467 const char *valid_param_list[] = { "tap", "socket", "dump" 2468 #ifdef CONFIG_SLIRP 2469 ,"user" 2470 #endif 2471 #ifdef CONFIG_VDE 2472 ,"vde" 2473 #endif 2474 }; 2475 for (i = 0; i < sizeof(valid_param_list) / sizeof(char *); i++) { 2476 if (!strncmp(valid_param_list[i], device, 2477 strlen(valid_param_list[i]))) 2478 return 1; 2479 } 2480 2481 return 0; 2482 } 2483 2484 void net_host_device_add(Monitor *mon, const char *device, const char *opts) 2485 { 2486 if (!net_host_check_device(device)) { 2487 monitor_printf(mon, "invalid host network device %s\n", device); 2488 return; 2489 } 2490 if (net_client_init(mon, device, opts ? opts : "") < 0) { 2491 monitor_printf(mon, "adding host network device %s failed\n", device); 2492 } 2493 } 2494 2495 void net_host_device_remove(Monitor *mon, int vlan_id, const char *device) 2496 { 2497 VLANState *vlan; 2498 VLANClientState *vc; 2499 2500 vlan = qemu_find_vlan(vlan_id); 2501 2502 for (vc = vlan->first_client; vc != NULL; vc = vc->next) { 2503 if (!strcmp(vc->name, device)) { 2504 break; 2505 } 2506 } 2507 2508 if (!vc) { 2509 monitor_printf(mon, "can't find device %s\n", device); 2510 return; 2511 } 2512 if (!net_host_check_device(vc->model)) { 2513 monitor_printf(mon, "invalid host network device %s\n", device); 2514 return; 2515 } 2516 qemu_del_vlan_client(vc); 2517 } 2518 2519 int net_client_parse(const char *str) 2520 { 2521 const char *p; 2522 char *q; 2523 char device[64]; 2524 2525 p = str; 2526 q = device; 2527 while (*p != '\0' && *p != ',') { 2528 if ((q - device) < sizeof(device) - 1) 2529 *q++ = *p; 2530 p++; 2531 } 2532 *q = '\0'; 2533 if (*p == ',') 2534 p++; 2535 2536 return net_client_init(NULL, device, p); 2537 } 2538 2539 void do_info_network(Monitor *mon) 2540 { 2541 VLANState *vlan; 2542 VLANClientState *vc; 2543 2544 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) { 2545 monitor_printf(mon, "VLAN %d devices:\n", vlan->id); 2546 for(vc = vlan->first_client; vc != NULL; vc = vc->next) 2547 monitor_printf(mon, " %s: %s\n", vc->name, vc->info_str); 2548 } 2549 } 2550 2551 int do_set_link(Monitor *mon, const char *name, const char *up_or_down) 2552 { 2553 VLANState *vlan; 2554 VLANClientState *vc = NULL; 2555 2556 for (vlan = first_vlan; vlan != NULL; vlan = vlan->next) 2557 for (vc = vlan->first_client; vc != NULL; vc = vc->next) 2558 if (strcmp(vc->name, name) == 0) 2559 goto done; 2560 done: 2561 2562 if (!vc) { 2563 monitor_printf(mon, "could not find network device '%s'", name); 2564 return 0; 2565 } 2566 2567 if (strcmp(up_or_down, "up") == 0) 2568 vc->link_down = 0; 2569 else if (strcmp(up_or_down, "down") == 0) 2570 vc->link_down = 1; 2571 else 2572 monitor_printf(mon, "invalid link status '%s'; only 'up' or 'down' " 2573 "valid\n", up_or_down); 2574 2575 if (vc->link_status_changed) 2576 vc->link_status_changed(vc); 2577 2578 return 1; 2579 } 2580 2581 void net_cleanup(void) 2582 { 2583 VLANState *vlan; 2584 2585 /* close network clients */ 2586 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) { 2587 VLANClientState *vc = vlan->first_client; 2588 2589 while (vc) { 2590 VLANClientState *next = vc->next; 2591 2592 qemu_del_vlan_client(vc); 2593 2594 vc = next; 2595 } 2596 } 2597 } 2598 2599 void net_client_check(void) 2600 { 2601 VLANState *vlan; 2602 2603 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) { 2604 if (vlan->nb_guest_devs == 0 && vlan->nb_host_devs == 0) 2605 continue; 2606 if (vlan->nb_guest_devs == 0) 2607 fprintf(stderr, "Warning: vlan %d with no nics\n", vlan->id); 2608 if (vlan->nb_host_devs == 0) 2609 fprintf(stderr, 2610 "Warning: vlan %d is not connected to host network\n", 2611 vlan->id); 2612 } 2613 } 2614 2615 int 2616 android_parse_network_speed(const char* speed) 2617 { 2618 int n; 2619 char* end; 2620 double sp; 2621 2622 if (speed == NULL || speed[0] == 0) { 2623 speed = DEFAULT_NETSPEED; 2624 } 2625 2626 for (n = 0; android_netspeeds[n].name != NULL; n++) { 2627 if (!strcmp(android_netspeeds[n].name, speed)) { 2628 qemu_net_download_speed = android_netspeeds[n].download; 2629 qemu_net_upload_speed = android_netspeeds[n].upload; 2630 return 0; 2631 } 2632 } 2633 2634 /* is this a number ? */ 2635 sp = strtod(speed, &end); 2636 if (end == speed) { 2637 return -1; 2638 } 2639 2640 qemu_net_download_speed = qemu_net_upload_speed = sp*1000.; 2641 if (*end == ':') { 2642 speed = end+1; 2643 sp = strtod(speed, &end); 2644 if (end > speed) { 2645 qemu_net_download_speed = sp*1000.; 2646 } 2647 } 2648 2649 if (android_modem) 2650 amodem_set_data_network_type( android_modem, 2651 android_parse_network_type(speed) ); 2652 return 0; 2653 } 2654 2655 2656 int 2657 android_parse_network_latency(const char* delay) 2658 { 2659 int n; 2660 char* end; 2661 double sp; 2662 2663 if (delay == NULL || delay[0] == 0) 2664 delay = DEFAULT_NETDELAY; 2665 2666 for (n = 0; android_netdelays[n].name != NULL; n++) { 2667 if ( !strcmp( android_netdelays[n].name, delay ) ) { 2668 qemu_net_min_latency = android_netdelays[n].min_ms; 2669 qemu_net_max_latency = android_netdelays[n].max_ms; 2670 return 0; 2671 } 2672 } 2673 2674 /* is this a number ? */ 2675 sp = strtod(delay, &end); 2676 if (end == delay) { 2677 return -1; 2678 } 2679 2680 qemu_net_min_latency = qemu_net_max_latency = (int)sp; 2681 if (*end == ':') { 2682 delay = (const char*)end+1; 2683 sp = strtod(delay, &end); 2684 if (end > delay) { 2685 qemu_net_max_latency = (int)sp; 2686 } 2687 } 2688 return 0; 2689 } 2690
