1 /* 2 * QEMU Guest Agent POSIX-specific command implementations 3 * 4 * Copyright IBM Corp. 2011 5 * 6 * Authors: 7 * Michael Roth <mdroth@linux.vnet.ibm.com> 8 * Michal Privoznik <mprivozn@redhat.com> 9 * 10 * This work is licensed under the terms of the GNU GPL, version 2 or later. 11 * See the COPYING file in the top-level directory. 12 */ 13 14 #include <glib.h> 15 #include <sys/types.h> 16 #include <sys/ioctl.h> 17 #include "qga/guest-agent-core.h" 18 #include "qga-qmp-commands.h" 19 #include "qerror.h" 20 #include "qemu-queue.h" 21 #include "host-utils.h" 22 23 #if defined(__linux__) 24 #include <mntent.h> 25 #include <linux/fs.h> 26 #include <ifaddrs.h> 27 #include <arpa/inet.h> 28 #include <sys/socket.h> 29 #include <net/if.h> 30 #include <sys/wait.h> 31 32 #if defined(__linux__) && defined(FIFREEZE) 33 #define CONFIG_FSFREEZE 34 #endif 35 #endif 36 37 #if defined(__linux__) 38 /* TODO: use this in place of all post-fork() fclose(std*) callers */ 39 static void reopen_fd_to_null(int fd) 40 { 41 int nullfd; 42 43 nullfd = open("/dev/null", O_RDWR); 44 if (nullfd < 0) { 45 return; 46 } 47 48 dup2(nullfd, fd); 49 50 if (nullfd != fd) { 51 close(nullfd); 52 } 53 } 54 #endif /* defined(__linux__) */ 55 56 void qmp_guest_shutdown(bool has_mode, const char *mode, Error **err) 57 { 58 int ret; 59 const char *shutdown_flag; 60 61 slog("guest-shutdown called, mode: %s", mode); 62 if (!has_mode || strcmp(mode, "powerdown") == 0) { 63 shutdown_flag = "-P"; 64 } else if (strcmp(mode, "halt") == 0) { 65 shutdown_flag = "-H"; 66 } else if (strcmp(mode, "reboot") == 0) { 67 shutdown_flag = "-r"; 68 } else { 69 error_set(err, QERR_INVALID_PARAMETER_VALUE, "mode", 70 "halt|powerdown|reboot"); 71 return; 72 } 73 74 ret = fork(); 75 if (ret == 0) { 76 /* child, start the shutdown */ 77 setsid(); 78 fclose(stdin); 79 fclose(stdout); 80 fclose(stderr); 81 82 ret = execl("/sbin/shutdown", "shutdown", shutdown_flag, "+0", 83 "hypervisor initiated shutdown", (char*)NULL); 84 if (ret) { 85 slog("guest-shutdown failed: %s", strerror(errno)); 86 } 87 exit(!!ret); 88 } else if (ret < 0) { 89 error_set(err, QERR_UNDEFINED_ERROR); 90 } 91 } 92 93 typedef struct GuestFileHandle { 94 uint64_t id; 95 FILE *fh; 96 QTAILQ_ENTRY(GuestFileHandle) next; 97 } GuestFileHandle; 98 99 static struct { 100 QTAILQ_HEAD(, GuestFileHandle) filehandles; 101 } guest_file_state; 102 103 static void guest_file_handle_add(FILE *fh) 104 { 105 GuestFileHandle *gfh; 106 107 gfh = g_malloc0(sizeof(GuestFileHandle)); 108 gfh->id = fileno(fh); 109 gfh->fh = fh; 110 QTAILQ_INSERT_TAIL(&guest_file_state.filehandles, gfh, next); 111 } 112 113 static GuestFileHandle *guest_file_handle_find(int64_t id) 114 { 115 GuestFileHandle *gfh; 116 117 QTAILQ_FOREACH(gfh, &guest_file_state.filehandles, next) 118 { 119 if (gfh->id == id) { 120 return gfh; 121 } 122 } 123 124 return NULL; 125 } 126 127 int64_t qmp_guest_file_open(const char *path, bool has_mode, const char *mode, Error **err) 128 { 129 FILE *fh; 130 int fd; 131 int64_t ret = -1; 132 133 if (!has_mode) { 134 mode = "r"; 135 } 136 slog("guest-file-open called, filepath: %s, mode: %s", path, mode); 137 fh = fopen(path, mode); 138 if (!fh) { 139 error_set(err, QERR_OPEN_FILE_FAILED, path); 140 return -1; 141 } 142 143 /* set fd non-blocking to avoid common use cases (like reading from a 144 * named pipe) from hanging the agent 145 */ 146 fd = fileno(fh); 147 ret = fcntl(fd, F_GETFL); 148 ret = fcntl(fd, F_SETFL, ret | O_NONBLOCK); 149 if (ret == -1) { 150 error_set(err, QERR_QGA_COMMAND_FAILED, "fcntl() failed"); 151 fclose(fh); 152 return -1; 153 } 154 155 guest_file_handle_add(fh); 156 slog("guest-file-open, handle: %d", fd); 157 return fd; 158 } 159 160 void qmp_guest_file_close(int64_t handle, Error **err) 161 { 162 GuestFileHandle *gfh = guest_file_handle_find(handle); 163 int ret; 164 165 slog("guest-file-close called, handle: %ld", handle); 166 if (!gfh) { 167 error_set(err, QERR_FD_NOT_FOUND, "handle"); 168 return; 169 } 170 171 ret = fclose(gfh->fh); 172 if (ret == -1) { 173 error_set(err, QERR_QGA_COMMAND_FAILED, "fclose() failed"); 174 return; 175 } 176 177 QTAILQ_REMOVE(&guest_file_state.filehandles, gfh, next); 178 g_free(gfh); 179 } 180 181 struct GuestFileRead *qmp_guest_file_read(int64_t handle, bool has_count, 182 int64_t count, Error **err) 183 { 184 GuestFileHandle *gfh = guest_file_handle_find(handle); 185 GuestFileRead *read_data = NULL; 186 guchar *buf; 187 FILE *fh; 188 size_t read_count; 189 190 if (!gfh) { 191 error_set(err, QERR_FD_NOT_FOUND, "handle"); 192 return NULL; 193 } 194 195 if (!has_count) { 196 count = QGA_READ_COUNT_DEFAULT; 197 } else if (count < 0) { 198 error_set(err, QERR_INVALID_PARAMETER, "count"); 199 return NULL; 200 } 201 202 fh = gfh->fh; 203 buf = g_malloc0(count+1); 204 read_count = fread(buf, 1, count, fh); 205 if (ferror(fh)) { 206 slog("guest-file-read failed, handle: %ld", handle); 207 error_set(err, QERR_QGA_COMMAND_FAILED, "fread() failed"); 208 } else { 209 buf[read_count] = 0; 210 read_data = g_malloc0(sizeof(GuestFileRead)); 211 read_data->count = read_count; 212 read_data->eof = feof(fh); 213 if (read_count) { 214 read_data->buf_b64 = g_base64_encode(buf, read_count); 215 } 216 } 217 g_free(buf); 218 clearerr(fh); 219 220 return read_data; 221 } 222 223 GuestFileWrite *qmp_guest_file_write(int64_t handle, const char *buf_b64, 224 bool has_count, int64_t count, Error **err) 225 { 226 GuestFileWrite *write_data = NULL; 227 guchar *buf; 228 gsize buf_len; 229 int write_count; 230 GuestFileHandle *gfh = guest_file_handle_find(handle); 231 FILE *fh; 232 233 if (!gfh) { 234 error_set(err, QERR_FD_NOT_FOUND, "handle"); 235 return NULL; 236 } 237 238 fh = gfh->fh; 239 buf = g_base64_decode(buf_b64, &buf_len); 240 241 if (!has_count) { 242 count = buf_len; 243 } else if (count < 0 || count > buf_len) { 244 g_free(buf); 245 error_set(err, QERR_INVALID_PARAMETER, "count"); 246 return NULL; 247 } 248 249 write_count = fwrite(buf, 1, count, fh); 250 if (ferror(fh)) { 251 slog("guest-file-write failed, handle: %ld", handle); 252 error_set(err, QERR_QGA_COMMAND_FAILED, "fwrite() error"); 253 } else { 254 write_data = g_malloc0(sizeof(GuestFileWrite)); 255 write_data->count = write_count; 256 write_data->eof = feof(fh); 257 } 258 g_free(buf); 259 clearerr(fh); 260 261 return write_data; 262 } 263 264 struct GuestFileSeek *qmp_guest_file_seek(int64_t handle, int64_t offset, 265 int64_t whence, Error **err) 266 { 267 GuestFileHandle *gfh = guest_file_handle_find(handle); 268 GuestFileSeek *seek_data = NULL; 269 FILE *fh; 270 int ret; 271 272 if (!gfh) { 273 error_set(err, QERR_FD_NOT_FOUND, "handle"); 274 return NULL; 275 } 276 277 fh = gfh->fh; 278 ret = fseek(fh, offset, whence); 279 if (ret == -1) { 280 error_set(err, QERR_QGA_COMMAND_FAILED, strerror(errno)); 281 } else { 282 seek_data = g_malloc0(sizeof(GuestFileRead)); 283 seek_data->position = ftell(fh); 284 seek_data->eof = feof(fh); 285 } 286 clearerr(fh); 287 288 return seek_data; 289 } 290 291 void qmp_guest_file_flush(int64_t handle, Error **err) 292 { 293 GuestFileHandle *gfh = guest_file_handle_find(handle); 294 FILE *fh; 295 int ret; 296 297 if (!gfh) { 298 error_set(err, QERR_FD_NOT_FOUND, "handle"); 299 return; 300 } 301 302 fh = gfh->fh; 303 ret = fflush(fh); 304 if (ret == EOF) { 305 error_set(err, QERR_QGA_COMMAND_FAILED, strerror(errno)); 306 } 307 } 308 309 static void guest_file_init(void) 310 { 311 QTAILQ_INIT(&guest_file_state.filehandles); 312 } 313 314 /* linux-specific implementations. avoid this if at all possible. */ 315 #if defined(__linux__) 316 317 #if defined(CONFIG_FSFREEZE) 318 319 static void disable_logging(void) 320 { 321 ga_disable_logging(ga_state); 322 } 323 324 static void enable_logging(void) 325 { 326 ga_enable_logging(ga_state); 327 } 328 329 typedef struct GuestFsfreezeMount { 330 char *dirname; 331 char *devtype; 332 QTAILQ_ENTRY(GuestFsfreezeMount) next; 333 } GuestFsfreezeMount; 334 335 struct { 336 GuestFsfreezeStatus status; 337 QTAILQ_HEAD(, GuestFsfreezeMount) mount_list; 338 } guest_fsfreeze_state; 339 340 /* 341 * Walk the mount table and build a list of local file systems 342 */ 343 static int guest_fsfreeze_build_mount_list(void) 344 { 345 struct mntent *ment; 346 GuestFsfreezeMount *mount, *temp; 347 char const *mtab = MOUNTED; 348 FILE *fp; 349 350 QTAILQ_FOREACH_SAFE(mount, &guest_fsfreeze_state.mount_list, next, temp) { 351 QTAILQ_REMOVE(&guest_fsfreeze_state.mount_list, mount, next); 352 g_free(mount->dirname); 353 g_free(mount->devtype); 354 g_free(mount); 355 } 356 357 fp = setmntent(mtab, "r"); 358 if (!fp) { 359 g_warning("fsfreeze: unable to read mtab"); 360 return -1; 361 } 362 363 while ((ment = getmntent(fp))) { 364 /* 365 * An entry which device name doesn't start with a '/' is 366 * either a dummy file system or a network file system. 367 * Add special handling for smbfs and cifs as is done by 368 * coreutils as well. 369 */ 370 if ((ment->mnt_fsname[0] != '/') || 371 (strcmp(ment->mnt_type, "smbfs") == 0) || 372 (strcmp(ment->mnt_type, "cifs") == 0)) { 373 continue; 374 } 375 376 mount = g_malloc0(sizeof(GuestFsfreezeMount)); 377 mount->dirname = g_strdup(ment->mnt_dir); 378 mount->devtype = g_strdup(ment->mnt_type); 379 380 QTAILQ_INSERT_TAIL(&guest_fsfreeze_state.mount_list, mount, next); 381 } 382 383 endmntent(fp); 384 385 return 0; 386 } 387 388 /* 389 * Return status of freeze/thaw 390 */ 391 GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **err) 392 { 393 return guest_fsfreeze_state.status; 394 } 395 396 /* 397 * Walk list of mounted file systems in the guest, and freeze the ones which 398 * are real local file systems. 399 */ 400 int64_t qmp_guest_fsfreeze_freeze(Error **err) 401 { 402 int ret = 0, i = 0; 403 struct GuestFsfreezeMount *mount, *temp; 404 int fd; 405 char err_msg[512]; 406 407 slog("guest-fsfreeze called"); 408 409 if (guest_fsfreeze_state.status == GUEST_FSFREEZE_STATUS_FROZEN) { 410 return 0; 411 } 412 413 ret = guest_fsfreeze_build_mount_list(); 414 if (ret < 0) { 415 return ret; 416 } 417 418 /* cannot risk guest agent blocking itself on a write in this state */ 419 disable_logging(); 420 421 QTAILQ_FOREACH_SAFE(mount, &guest_fsfreeze_state.mount_list, next, temp) { 422 fd = qemu_open(mount->dirname, O_RDONLY); 423 if (fd == -1) { 424 sprintf(err_msg, "failed to open %s, %s", mount->dirname, strerror(errno)); 425 error_set(err, QERR_QGA_COMMAND_FAILED, err_msg); 426 goto error; 427 } 428 429 /* we try to cull filesytems we know won't work in advance, but other 430 * filesytems may not implement fsfreeze for less obvious reasons. 431 * these will report EOPNOTSUPP, so we simply ignore them. when 432 * thawing, these filesystems will return an EINVAL instead, due to 433 * not being in a frozen state. Other filesystem-specific 434 * errors may result in EINVAL, however, so the user should check the 435 * number * of filesystems returned here against those returned by the 436 * thaw operation to determine whether everything completed 437 * successfully 438 */ 439 ret = ioctl(fd, FIFREEZE); 440 if (ret < 0 && errno != EOPNOTSUPP) { 441 sprintf(err_msg, "failed to freeze %s, %s", mount->dirname, strerror(errno)); 442 error_set(err, QERR_QGA_COMMAND_FAILED, err_msg); 443 close(fd); 444 goto error; 445 } 446 close(fd); 447 448 i++; 449 } 450 451 guest_fsfreeze_state.status = GUEST_FSFREEZE_STATUS_FROZEN; 452 return i; 453 454 error: 455 if (i > 0) { 456 qmp_guest_fsfreeze_thaw(NULL); 457 } 458 return 0; 459 } 460 461 /* 462 * Walk list of frozen file systems in the guest, and thaw them. 463 */ 464 int64_t qmp_guest_fsfreeze_thaw(Error **err) 465 { 466 int ret; 467 GuestFsfreezeMount *mount, *temp; 468 int fd, i = 0; 469 bool has_error = false; 470 471 QTAILQ_FOREACH_SAFE(mount, &guest_fsfreeze_state.mount_list, next, temp) { 472 fd = qemu_open(mount->dirname, O_RDONLY); 473 if (fd == -1) { 474 has_error = true; 475 continue; 476 } 477 ret = ioctl(fd, FITHAW); 478 if (ret < 0 && errno != EOPNOTSUPP && errno != EINVAL) { 479 has_error = true; 480 close(fd); 481 continue; 482 } 483 close(fd); 484 i++; 485 } 486 487 if (has_error) { 488 guest_fsfreeze_state.status = GUEST_FSFREEZE_STATUS_ERROR; 489 } else { 490 guest_fsfreeze_state.status = GUEST_FSFREEZE_STATUS_THAWED; 491 } 492 enable_logging(); 493 return i; 494 } 495 496 static void guest_fsfreeze_init(void) 497 { 498 guest_fsfreeze_state.status = GUEST_FSFREEZE_STATUS_THAWED; 499 QTAILQ_INIT(&guest_fsfreeze_state.mount_list); 500 } 501 502 static void guest_fsfreeze_cleanup(void) 503 { 504 int64_t ret; 505 Error *err = NULL; 506 507 if (guest_fsfreeze_state.status == GUEST_FSFREEZE_STATUS_FROZEN) { 508 ret = qmp_guest_fsfreeze_thaw(&err); 509 if (ret < 0 || err) { 510 slog("failed to clean up frozen filesystems"); 511 } 512 } 513 } 514 #endif /* CONFIG_FSFREEZE */ 515 516 #define LINUX_SYS_STATE_FILE "/sys/power/state" 517 #define SUSPEND_SUPPORTED 0 518 #define SUSPEND_NOT_SUPPORTED 1 519 520 /** 521 * This function forks twice and the information about the mode support 522 * status is passed to the qemu-ga process via a pipe. 523 * 524 * This approach allows us to keep the way we reap terminated children 525 * in qemu-ga quite simple. 526 */ 527 static void bios_supports_mode(const char *pmutils_bin, const char *pmutils_arg, 528 const char *sysfile_str, Error **err) 529 { 530 pid_t pid; 531 ssize_t ret; 532 char *pmutils_path; 533 int status, pipefds[2]; 534 535 if (pipe(pipefds) < 0) { 536 error_set(err, QERR_UNDEFINED_ERROR); 537 return; 538 } 539 540 pmutils_path = g_find_program_in_path(pmutils_bin); 541 542 pid = fork(); 543 if (!pid) { 544 struct sigaction act; 545 546 memset(&act, 0, sizeof(act)); 547 act.sa_handler = SIG_DFL; 548 sigaction(SIGCHLD, &act, NULL); 549 550 setsid(); 551 close(pipefds[0]); 552 reopen_fd_to_null(0); 553 reopen_fd_to_null(1); 554 reopen_fd_to_null(2); 555 556 pid = fork(); 557 if (!pid) { 558 int fd; 559 char buf[32]; /* hopefully big enough */ 560 561 if (pmutils_path) { 562 execle(pmutils_path, pmutils_bin, pmutils_arg, NULL, environ); 563 } 564 565 /* 566 * If we get here either pm-utils is not installed or execle() has 567 * failed. Let's try the manual method if the caller wants it. 568 */ 569 570 if (!sysfile_str) { 571 _exit(SUSPEND_NOT_SUPPORTED); 572 } 573 574 fd = open(LINUX_SYS_STATE_FILE, O_RDONLY); 575 if (fd < 0) { 576 _exit(SUSPEND_NOT_SUPPORTED); 577 } 578 579 ret = read(fd, buf, sizeof(buf)-1); 580 if (ret <= 0) { 581 _exit(SUSPEND_NOT_SUPPORTED); 582 } 583 buf[ret] = '\0'; 584 585 if (strstr(buf, sysfile_str)) { 586 _exit(SUSPEND_SUPPORTED); 587 } 588 589 _exit(SUSPEND_NOT_SUPPORTED); 590 } 591 592 if (pid > 0) { 593 wait(&status); 594 } else { 595 status = SUSPEND_NOT_SUPPORTED; 596 } 597 598 ret = write(pipefds[1], &status, sizeof(status)); 599 if (ret != sizeof(status)) { 600 _exit(EXIT_FAILURE); 601 } 602 603 _exit(EXIT_SUCCESS); 604 } 605 606 close(pipefds[1]); 607 g_free(pmutils_path); 608 609 if (pid < 0) { 610 error_set(err, QERR_UNDEFINED_ERROR); 611 goto out; 612 } 613 614 ret = read(pipefds[0], &status, sizeof(status)); 615 if (ret == sizeof(status) && WIFEXITED(status) && 616 WEXITSTATUS(status) == SUSPEND_SUPPORTED) { 617 goto out; 618 } 619 620 error_set(err, QERR_UNSUPPORTED); 621 622 out: 623 close(pipefds[0]); 624 } 625 626 static void guest_suspend(const char *pmutils_bin, const char *sysfile_str, 627 Error **err) 628 { 629 pid_t pid; 630 char *pmutils_path; 631 632 pmutils_path = g_find_program_in_path(pmutils_bin); 633 634 pid = fork(); 635 if (pid == 0) { 636 /* child */ 637 int fd; 638 639 setsid(); 640 reopen_fd_to_null(0); 641 reopen_fd_to_null(1); 642 reopen_fd_to_null(2); 643 644 if (pmutils_path) { 645 execle(pmutils_path, pmutils_bin, NULL, environ); 646 } 647 648 /* 649 * If we get here either pm-utils is not installed or execle() has 650 * failed. Let's try the manual method if the caller wants it. 651 */ 652 653 if (!sysfile_str) { 654 _exit(EXIT_FAILURE); 655 } 656 657 fd = open(LINUX_SYS_STATE_FILE, O_WRONLY); 658 if (fd < 0) { 659 _exit(EXIT_FAILURE); 660 } 661 662 if (write(fd, sysfile_str, strlen(sysfile_str)) < 0) { 663 _exit(EXIT_FAILURE); 664 } 665 666 _exit(EXIT_SUCCESS); 667 } 668 669 g_free(pmutils_path); 670 671 if (pid < 0) { 672 error_set(err, QERR_UNDEFINED_ERROR); 673 return; 674 } 675 } 676 677 void qmp_guest_suspend_disk(Error **err) 678 { 679 bios_supports_mode("pm-is-supported", "--hibernate", "disk", err); 680 if (error_is_set(err)) { 681 return; 682 } 683 684 guest_suspend("pm-hibernate", "disk", err); 685 } 686 687 void qmp_guest_suspend_ram(Error **err) 688 { 689 bios_supports_mode("pm-is-supported", "--suspend", "mem", err); 690 if (error_is_set(err)) { 691 return; 692 } 693 694 guest_suspend("pm-suspend", "mem", err); 695 } 696 697 void qmp_guest_suspend_hybrid(Error **err) 698 { 699 bios_supports_mode("pm-is-supported", "--suspend-hybrid", NULL, err); 700 if (error_is_set(err)) { 701 return; 702 } 703 704 guest_suspend("pm-suspend-hybrid", NULL, err); 705 } 706 707 static GuestNetworkInterfaceList * 708 guest_find_interface(GuestNetworkInterfaceList *head, 709 const char *name) 710 { 711 for (; head; head = head->next) { 712 if (strcmp(head->value->name, name) == 0) { 713 break; 714 } 715 } 716 717 return head; 718 } 719 720 /* 721 * Build information about guest interfaces 722 */ 723 GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp) 724 { 725 GuestNetworkInterfaceList *head = NULL, *cur_item = NULL; 726 struct ifaddrs *ifap, *ifa; 727 char err_msg[512]; 728 729 if (getifaddrs(&ifap) < 0) { 730 snprintf(err_msg, sizeof(err_msg), 731 "getifaddrs failed: %s", strerror(errno)); 732 error_set(errp, QERR_QGA_COMMAND_FAILED, err_msg); 733 goto error; 734 } 735 736 for (ifa = ifap; ifa; ifa = ifa->ifa_next) { 737 GuestNetworkInterfaceList *info; 738 GuestIpAddressList **address_list = NULL, *address_item = NULL; 739 char addr4[INET_ADDRSTRLEN]; 740 char addr6[INET6_ADDRSTRLEN]; 741 int sock; 742 struct ifreq ifr; 743 unsigned char *mac_addr; 744 void *p; 745 746 g_debug("Processing %s interface", ifa->ifa_name); 747 748 info = guest_find_interface(head, ifa->ifa_name); 749 750 if (!info) { 751 info = g_malloc0(sizeof(*info)); 752 info->value = g_malloc0(sizeof(*info->value)); 753 info->value->name = g_strdup(ifa->ifa_name); 754 755 if (!cur_item) { 756 head = cur_item = info; 757 } else { 758 cur_item->next = info; 759 cur_item = info; 760 } 761 } 762 763 if (!info->value->has_hardware_address && 764 ifa->ifa_flags & SIOCGIFHWADDR) { 765 /* we haven't obtained HW address yet */ 766 sock = socket(PF_INET, SOCK_STREAM, 0); 767 if (sock == -1) { 768 snprintf(err_msg, sizeof(err_msg), 769 "failed to create socket: %s", strerror(errno)); 770 error_set(errp, QERR_QGA_COMMAND_FAILED, err_msg); 771 goto error; 772 } 773 774 memset(&ifr, 0, sizeof(ifr)); 775 strncpy(ifr.ifr_name, info->value->name, IF_NAMESIZE); 776 if (ioctl(sock, SIOCGIFHWADDR, &ifr) == -1) { 777 snprintf(err_msg, sizeof(err_msg), 778 "failed to get MAC addres of %s: %s", 779 ifa->ifa_name, 780 strerror(errno)); 781 error_set(errp, QERR_QGA_COMMAND_FAILED, err_msg); 782 goto error; 783 } 784 785 mac_addr = (unsigned char *) &ifr.ifr_hwaddr.sa_data; 786 787 if (asprintf(&info->value->hardware_address, 788 "%02x:%02x:%02x:%02x:%02x:%02x", 789 (int) mac_addr[0], (int) mac_addr[1], 790 (int) mac_addr[2], (int) mac_addr[3], 791 (int) mac_addr[4], (int) mac_addr[5]) == -1) { 792 snprintf(err_msg, sizeof(err_msg), 793 "failed to format MAC: %s", strerror(errno)); 794 error_set(errp, QERR_QGA_COMMAND_FAILED, err_msg); 795 goto error; 796 } 797 798 info->value->has_hardware_address = true; 799 close(sock); 800 } 801 802 if (ifa->ifa_addr && 803 ifa->ifa_addr->sa_family == AF_INET) { 804 /* interface with IPv4 address */ 805 address_item = g_malloc0(sizeof(*address_item)); 806 address_item->value = g_malloc0(sizeof(*address_item->value)); 807 p = &((struct sockaddr_in *)ifa->ifa_addr)->sin_addr; 808 if (!inet_ntop(AF_INET, p, addr4, sizeof(addr4))) { 809 snprintf(err_msg, sizeof(err_msg), 810 "inet_ntop failed : %s", strerror(errno)); 811 error_set(errp, QERR_QGA_COMMAND_FAILED, err_msg); 812 goto error; 813 } 814 815 address_item->value->ip_address = g_strdup(addr4); 816 address_item->value->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV4; 817 818 if (ifa->ifa_netmask) { 819 /* Count the number of set bits in netmask. 820 * This is safe as '1' and '0' cannot be shuffled in netmask. */ 821 p = &((struct sockaddr_in *)ifa->ifa_netmask)->sin_addr; 822 address_item->value->prefix = ctpop32(((uint32_t *) p)[0]); 823 } 824 } else if (ifa->ifa_addr && 825 ifa->ifa_addr->sa_family == AF_INET6) { 826 /* interface with IPv6 address */ 827 address_item = g_malloc0(sizeof(*address_item)); 828 address_item->value = g_malloc0(sizeof(*address_item->value)); 829 p = &((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_addr; 830 if (!inet_ntop(AF_INET6, p, addr6, sizeof(addr6))) { 831 snprintf(err_msg, sizeof(err_msg), 832 "inet_ntop failed : %s", strerror(errno)); 833 error_set(errp, QERR_QGA_COMMAND_FAILED, err_msg); 834 goto error; 835 } 836 837 address_item->value->ip_address = g_strdup(addr6); 838 address_item->value->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV6; 839 840 if (ifa->ifa_netmask) { 841 /* Count the number of set bits in netmask. 842 * This is safe as '1' and '0' cannot be shuffled in netmask. */ 843 p = &((struct sockaddr_in6 *)ifa->ifa_netmask)->sin6_addr; 844 address_item->value->prefix = 845 ctpop32(((uint32_t *) p)[0]) + 846 ctpop32(((uint32_t *) p)[1]) + 847 ctpop32(((uint32_t *) p)[2]) + 848 ctpop32(((uint32_t *) p)[3]); 849 } 850 } 851 852 if (!address_item) { 853 continue; 854 } 855 856 address_list = &info->value->ip_addresses; 857 858 while (*address_list && (*address_list)->next) { 859 address_list = &(*address_list)->next; 860 } 861 862 if (!*address_list) { 863 *address_list = address_item; 864 } else { 865 (*address_list)->next = address_item; 866 } 867 868 info->value->has_ip_addresses = true; 869 870 871 } 872 873 freeifaddrs(ifap); 874 return head; 875 876 error: 877 freeifaddrs(ifap); 878 qapi_free_GuestNetworkInterfaceList(head); 879 return NULL; 880 } 881 882 #else /* defined(__linux__) */ 883 884 void qmp_guest_suspend_disk(Error **err) 885 { 886 error_set(err, QERR_UNSUPPORTED); 887 } 888 889 void qmp_guest_suspend_ram(Error **err) 890 { 891 error_set(err, QERR_UNSUPPORTED); 892 } 893 894 void qmp_guest_suspend_hybrid(Error **err) 895 { 896 error_set(err, QERR_UNSUPPORTED); 897 } 898 899 GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp) 900 { 901 error_set(errp, QERR_UNSUPPORTED); 902 return NULL; 903 } 904 905 #endif 906 907 #if !defined(CONFIG_FSFREEZE) 908 909 GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **err) 910 { 911 error_set(err, QERR_UNSUPPORTED); 912 913 return 0; 914 } 915 916 int64_t qmp_guest_fsfreeze_freeze(Error **err) 917 { 918 error_set(err, QERR_UNSUPPORTED); 919 920 return 0; 921 } 922 923 int64_t qmp_guest_fsfreeze_thaw(Error **err) 924 { 925 error_set(err, QERR_UNSUPPORTED); 926 927 return 0; 928 } 929 930 #endif 931 932 /* register init/cleanup routines for stateful command groups */ 933 void ga_command_state_init(GAState *s, GACommandState *cs) 934 { 935 #if defined(CONFIG_FSFREEZE) 936 ga_command_state_add(cs, guest_fsfreeze_init, guest_fsfreeze_cleanup); 937 #endif 938 ga_command_state_add(cs, guest_file_init, NULL); 939 } 940