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 "qemu/osdep.h" 15 #include <sys/ioctl.h> 16 #include <sys/utsname.h> 17 #include <sys/wait.h> 18 #include <dirent.h> 19 #include "qga-qapi-commands.h" 20 #include "qapi/error.h" 21 #include "qapi/qmp/qerror.h" 22 #include "qemu/host-utils.h" 23 #include "qemu/sockets.h" 24 #include "qemu/base64.h" 25 #include "qemu/cutils.h" 26 #include "commands-common.h" 27 #include "cutils.h" 28 29 #ifdef HAVE_UTMPX 30 #include <utmpx.h> 31 #endif 32 33 #ifdef HAVE_GETIFADDRS 34 #include <arpa/inet.h> 35 #include <sys/socket.h> 36 #include <net/if.h> 37 #if defined(__NetBSD__) || defined(__OpenBSD__) || defined(CONFIG_SOLARIS) 38 #include <net/if_arp.h> 39 #include <netinet/if_ether.h> 40 #if !defined(ETHER_ADDR_LEN) && defined(ETHERADDRL) 41 #define ETHER_ADDR_LEN ETHERADDRL 42 #endif 43 #else 44 #include <net/ethernet.h> 45 #endif 46 #ifdef CONFIG_SOLARIS 47 #include <sys/sockio.h> 48 #endif 49 #endif 50 51 static bool ga_wait_child(pid_t pid, int *status, Error **errp) 52 { 53 pid_t rpid; 54 55 *status = 0; 56 57 rpid = RETRY_ON_EINTR(waitpid(pid, status, 0)); 58 59 if (rpid == -1) { 60 error_setg_errno(errp, errno, "failed to wait for child (pid: %d)", 61 pid); 62 return false; 63 } 64 65 g_assert(rpid == pid); 66 return true; 67 } 68 69 static ssize_t ga_pipe_read_str(int fd[2], char **str) 70 { 71 ssize_t n, len = 0; 72 char buf[1024]; 73 74 close(fd[1]); 75 fd[1] = -1; 76 while ((n = read(fd[0], buf, sizeof(buf))) != 0) { 77 if (n < 0) { 78 if (errno == EINTR) { 79 continue; 80 } else { 81 len = -errno; 82 break; 83 } 84 } 85 *str = g_realloc(*str, len + n + 1); 86 memcpy(*str + len, buf, n); 87 len += n; 88 *str[len] = '\0'; 89 } 90 close(fd[0]); 91 fd[0] = -1; 92 93 return len; 94 } 95 96 /* 97 * Helper to run command with input/output redirection, 98 * sending string to stdin and taking error message from 99 * stdout/err. 100 */ 101 static int ga_run_command(const char *argv[], const char *in_str, 102 const char *action, Error **errp) 103 { 104 pid_t pid; 105 int status; 106 int retcode = -1; 107 int infd[2] = { -1, -1 }; 108 int outfd[2] = { -1, -1 }; 109 char *str = NULL; 110 ssize_t len = 0; 111 112 if ((in_str && !g_unix_open_pipe(infd, FD_CLOEXEC, NULL)) || 113 !g_unix_open_pipe(outfd, FD_CLOEXEC, NULL)) { 114 error_setg(errp, "cannot create pipe FDs"); 115 goto out; 116 } 117 118 pid = fork(); 119 if (pid == 0) { 120 char *cherr = NULL; 121 122 setsid(); 123 124 if (in_str) { 125 /* Redirect stdin to infd. */ 126 close(infd[1]); 127 dup2(infd[0], 0); 128 close(infd[0]); 129 } else { 130 reopen_fd_to_null(0); 131 } 132 133 /* Redirect stdout/stderr to outfd. */ 134 close(outfd[0]); 135 dup2(outfd[1], 1); 136 dup2(outfd[1], 2); 137 close(outfd[1]); 138 139 execvp(argv[0], (char *const *)argv); 140 141 /* Write the cause of failed exec to pipe for the parent to read it. */ 142 cherr = g_strdup_printf("failed to exec '%s'", argv[0]); 143 perror(cherr); 144 g_free(cherr); 145 _exit(EXIT_FAILURE); 146 } else if (pid < 0) { 147 error_setg_errno(errp, errno, "failed to create child process"); 148 goto out; 149 } 150 151 if (in_str) { 152 close(infd[0]); 153 infd[0] = -1; 154 if (qemu_write_full(infd[1], in_str, strlen(in_str)) != 155 strlen(in_str)) { 156 error_setg_errno(errp, errno, "%s: cannot write to stdin pipe", 157 action); 158 goto out; 159 } 160 close(infd[1]); 161 infd[1] = -1; 162 } 163 164 len = ga_pipe_read_str(outfd, &str); 165 if (len < 0) { 166 error_setg_errno(errp, -len, "%s: cannot read from stdout/stderr pipe", 167 action); 168 goto out; 169 } 170 171 if (!ga_wait_child(pid, &status, errp)) { 172 goto out; 173 } 174 175 if (!WIFEXITED(status)) { 176 if (len) { 177 error_setg(errp, "child process has terminated abnormally: %s", 178 str); 179 } else { 180 error_setg(errp, "child process has terminated abnormally"); 181 } 182 goto out; 183 } 184 185 retcode = WEXITSTATUS(status); 186 187 if (WEXITSTATUS(status)) { 188 if (len) { 189 error_setg(errp, "child process has failed to %s: %s", 190 action, str); 191 } else { 192 error_setg(errp, "child process has failed to %s: exit status %d", 193 action, WEXITSTATUS(status)); 194 } 195 goto out; 196 } 197 198 out: 199 g_free(str); 200 201 if (infd[0] != -1) { 202 close(infd[0]); 203 } 204 if (infd[1] != -1) { 205 close(infd[1]); 206 } 207 if (outfd[0] != -1) { 208 close(outfd[0]); 209 } 210 if (outfd[1] != -1) { 211 close(outfd[1]); 212 } 213 214 return retcode; 215 } 216 217 void qmp_guest_shutdown(const char *mode, Error **errp) 218 { 219 const char *shutdown_flag; 220 Error *local_err = NULL; 221 222 #ifdef CONFIG_SOLARIS 223 const char *powerdown_flag = "-i5"; 224 const char *halt_flag = "-i0"; 225 const char *reboot_flag = "-i6"; 226 #elif defined(CONFIG_BSD) 227 const char *powerdown_flag = "-p"; 228 const char *halt_flag = "-h"; 229 const char *reboot_flag = "-r"; 230 #else 231 const char *powerdown_flag = "-P"; 232 const char *halt_flag = "-H"; 233 const char *reboot_flag = "-r"; 234 #endif 235 236 slog("guest-shutdown called, mode: %s", mode); 237 if (!mode || strcmp(mode, "powerdown") == 0) { 238 shutdown_flag = powerdown_flag; 239 } else if (strcmp(mode, "halt") == 0) { 240 shutdown_flag = halt_flag; 241 } else if (strcmp(mode, "reboot") == 0) { 242 shutdown_flag = reboot_flag; 243 } else { 244 error_setg(errp, 245 "mode is invalid (valid values are: halt|powerdown|reboot"); 246 return; 247 } 248 249 const char *argv[] = {"/sbin/shutdown", 250 #ifdef CONFIG_SOLARIS 251 shutdown_flag, "-g0", "-y", 252 #elif defined(CONFIG_BSD) 253 shutdown_flag, "+0", 254 #else 255 "-h", shutdown_flag, "+0", 256 #endif 257 "hypervisor initiated shutdown", (char *) NULL}; 258 259 ga_run_command(argv, NULL, "shutdown", &local_err); 260 if (local_err) { 261 error_propagate(errp, local_err); 262 return; 263 } 264 265 /* succeeded */ 266 } 267 268 void qmp_guest_set_time(bool has_time, int64_t time_ns, Error **errp) 269 { 270 int ret; 271 Error *local_err = NULL; 272 struct timeval tv; 273 const char *argv[] = {"/sbin/hwclock", has_time ? "-w" : "-s", NULL}; 274 275 /* If user has passed a time, validate and set it. */ 276 if (has_time) { 277 GDate date = { 0, }; 278 279 /* year-2038 will overflow in case time_t is 32bit */ 280 if (time_ns / 1000000000 != (time_t)(time_ns / 1000000000)) { 281 error_setg(errp, "Time %" PRId64 " is too large", time_ns); 282 return; 283 } 284 285 tv.tv_sec = time_ns / 1000000000; 286 tv.tv_usec = (time_ns % 1000000000) / 1000; 287 g_date_set_time_t(&date, tv.tv_sec); 288 if (date.year < 1970 || date.year >= 2070) { 289 error_setg_errno(errp, errno, "Invalid time"); 290 return; 291 } 292 293 ret = settimeofday(&tv, NULL); 294 if (ret < 0) { 295 error_setg_errno(errp, errno, "Failed to set time to guest"); 296 return; 297 } 298 } 299 300 /* Now, if user has passed a time to set and the system time is set, we 301 * just need to synchronize the hardware clock. However, if no time was 302 * passed, user is requesting the opposite: set the system time from the 303 * hardware clock (RTC). */ 304 ga_run_command(argv, NULL, "set hardware clock to system time", 305 &local_err); 306 if (local_err) { 307 error_propagate(errp, local_err); 308 return; 309 } 310 } 311 312 typedef enum { 313 RW_STATE_NEW, 314 RW_STATE_READING, 315 RW_STATE_WRITING, 316 } RwState; 317 318 struct GuestFileHandle { 319 uint64_t id; 320 FILE *fh; 321 RwState state; 322 QTAILQ_ENTRY(GuestFileHandle) next; 323 }; 324 325 static struct { 326 QTAILQ_HEAD(, GuestFileHandle) filehandles; 327 } guest_file_state = { 328 .filehandles = QTAILQ_HEAD_INITIALIZER(guest_file_state.filehandles), 329 }; 330 331 static int64_t guest_file_handle_add(FILE *fh, Error **errp) 332 { 333 GuestFileHandle *gfh; 334 int64_t handle; 335 336 handle = ga_get_fd_handle(ga_state, errp); 337 if (handle < 0) { 338 return -1; 339 } 340 341 gfh = g_new0(GuestFileHandle, 1); 342 gfh->id = handle; 343 gfh->fh = fh; 344 QTAILQ_INSERT_TAIL(&guest_file_state.filehandles, gfh, next); 345 346 return handle; 347 } 348 349 GuestFileHandle *guest_file_handle_find(int64_t id, Error **errp) 350 { 351 GuestFileHandle *gfh; 352 353 QTAILQ_FOREACH(gfh, &guest_file_state.filehandles, next) 354 { 355 if (gfh->id == id) { 356 return gfh; 357 } 358 } 359 360 error_setg(errp, "handle '%" PRId64 "' has not been found", id); 361 return NULL; 362 } 363 364 typedef const char * const ccpc; 365 366 #ifndef O_BINARY 367 #define O_BINARY 0 368 #endif 369 370 /* http://pubs.opengroup.org/onlinepubs/9699919799/functions/fopen.html */ 371 static const struct { 372 ccpc *forms; 373 int oflag_base; 374 } guest_file_open_modes[] = { 375 { (ccpc[]){ "r", NULL }, O_RDONLY }, 376 { (ccpc[]){ "rb", NULL }, O_RDONLY | O_BINARY }, 377 { (ccpc[]){ "w", NULL }, O_WRONLY | O_CREAT | O_TRUNC }, 378 { (ccpc[]){ "wb", NULL }, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY }, 379 { (ccpc[]){ "a", NULL }, O_WRONLY | O_CREAT | O_APPEND }, 380 { (ccpc[]){ "ab", NULL }, O_WRONLY | O_CREAT | O_APPEND | O_BINARY }, 381 { (ccpc[]){ "r+", NULL }, O_RDWR }, 382 { (ccpc[]){ "rb+", "r+b", NULL }, O_RDWR | O_BINARY }, 383 { (ccpc[]){ "w+", NULL }, O_RDWR | O_CREAT | O_TRUNC }, 384 { (ccpc[]){ "wb+", "w+b", NULL }, O_RDWR | O_CREAT | O_TRUNC | O_BINARY }, 385 { (ccpc[]){ "a+", NULL }, O_RDWR | O_CREAT | O_APPEND }, 386 { (ccpc[]){ "ab+", "a+b", NULL }, O_RDWR | O_CREAT | O_APPEND | O_BINARY } 387 }; 388 389 static int 390 find_open_flag(const char *mode_str, Error **errp) 391 { 392 unsigned mode; 393 394 for (mode = 0; mode < ARRAY_SIZE(guest_file_open_modes); ++mode) { 395 ccpc *form; 396 397 form = guest_file_open_modes[mode].forms; 398 while (*form != NULL && strcmp(*form, mode_str) != 0) { 399 ++form; 400 } 401 if (*form != NULL) { 402 break; 403 } 404 } 405 406 if (mode == ARRAY_SIZE(guest_file_open_modes)) { 407 error_setg(errp, "invalid file open mode '%s'", mode_str); 408 return -1; 409 } 410 return guest_file_open_modes[mode].oflag_base | O_NOCTTY | O_NONBLOCK; 411 } 412 413 #define DEFAULT_NEW_FILE_MODE (S_IRUSR | S_IWUSR | \ 414 S_IRGRP | S_IWGRP | \ 415 S_IROTH | S_IWOTH) 416 417 static FILE * 418 safe_open_or_create(const char *path, const char *mode, Error **errp) 419 { 420 int oflag; 421 int fd = -1; 422 FILE *f = NULL; 423 424 oflag = find_open_flag(mode, errp); 425 if (oflag < 0) { 426 goto end; 427 } 428 429 /* If the caller wants / allows creation of a new file, we implement it 430 * with a two step process: open() + (open() / fchmod()). 431 * 432 * First we insist on creating the file exclusively as a new file. If 433 * that succeeds, we're free to set any file-mode bits on it. (The 434 * motivation is that we want to set those file-mode bits independently 435 * of the current umask.) 436 * 437 * If the exclusive creation fails because the file already exists 438 * (EEXIST is not possible for any other reason), we just attempt to 439 * open the file, but in this case we won't be allowed to change the 440 * file-mode bits on the preexistent file. 441 * 442 * The pathname should never disappear between the two open()s in 443 * practice. If it happens, then someone very likely tried to race us. 444 * In this case just go ahead and report the ENOENT from the second 445 * open() to the caller. 446 * 447 * If the caller wants to open a preexistent file, then the first 448 * open() is decisive and its third argument is ignored, and the second 449 * open() and the fchmod() are never called. 450 */ 451 fd = qga_open_cloexec(path, oflag | ((oflag & O_CREAT) ? O_EXCL : 0), 0); 452 if (fd == -1 && errno == EEXIST) { 453 oflag &= ~(unsigned)O_CREAT; 454 fd = qga_open_cloexec(path, oflag, 0); 455 } 456 if (fd == -1) { 457 error_setg_errno(errp, errno, 458 "failed to open file '%s' (mode: '%s')", 459 path, mode); 460 goto end; 461 } 462 463 if ((oflag & O_CREAT) && fchmod(fd, DEFAULT_NEW_FILE_MODE) == -1) { 464 error_setg_errno(errp, errno, "failed to set permission " 465 "0%03o on new file '%s' (mode: '%s')", 466 (unsigned)DEFAULT_NEW_FILE_MODE, path, mode); 467 goto end; 468 } 469 470 f = fdopen(fd, mode); 471 if (f == NULL) { 472 error_setg_errno(errp, errno, "failed to associate stdio stream with " 473 "file descriptor %d, file '%s' (mode: '%s')", 474 fd, path, mode); 475 } 476 477 end: 478 if (f == NULL && fd != -1) { 479 close(fd); 480 if (oflag & O_CREAT) { 481 unlink(path); 482 } 483 } 484 return f; 485 } 486 487 int64_t qmp_guest_file_open(const char *path, const char *mode, 488 Error **errp) 489 { 490 FILE *fh; 491 Error *local_err = NULL; 492 int64_t handle; 493 494 if (!mode) { 495 mode = "r"; 496 } 497 slog("guest-file-open called, filepath: %s, mode: %s", path, mode); 498 fh = safe_open_or_create(path, mode, &local_err); 499 if (local_err != NULL) { 500 error_propagate(errp, local_err); 501 return -1; 502 } 503 504 /* set fd non-blocking to avoid common use cases (like reading from a 505 * named pipe) from hanging the agent 506 */ 507 if (!g_unix_set_fd_nonblocking(fileno(fh), true, NULL)) { 508 fclose(fh); 509 error_setg_errno(errp, errno, "Failed to set FD nonblocking"); 510 return -1; 511 } 512 513 handle = guest_file_handle_add(fh, errp); 514 if (handle < 0) { 515 fclose(fh); 516 return -1; 517 } 518 519 slog("guest-file-open, handle: %" PRId64, handle); 520 return handle; 521 } 522 523 void qmp_guest_file_close(int64_t handle, Error **errp) 524 { 525 GuestFileHandle *gfh = guest_file_handle_find(handle, errp); 526 int ret; 527 528 slog("guest-file-close called, handle: %" PRId64, handle); 529 if (!gfh) { 530 return; 531 } 532 533 ret = fclose(gfh->fh); 534 if (ret == EOF) { 535 error_setg_errno(errp, errno, "failed to close handle"); 536 return; 537 } 538 539 QTAILQ_REMOVE(&guest_file_state.filehandles, gfh, next); 540 g_free(gfh); 541 } 542 543 GuestFileRead *guest_file_read_unsafe(GuestFileHandle *gfh, 544 int64_t count, Error **errp) 545 { 546 GuestFileRead *read_data = NULL; 547 guchar *buf; 548 FILE *fh = gfh->fh; 549 size_t read_count; 550 551 /* explicitly flush when switching from writing to reading */ 552 if (gfh->state == RW_STATE_WRITING) { 553 int ret = fflush(fh); 554 if (ret == EOF) { 555 error_setg_errno(errp, errno, "failed to flush file"); 556 return NULL; 557 } 558 gfh->state = RW_STATE_NEW; 559 } 560 561 buf = g_malloc0(count + 1); 562 read_count = fread(buf, 1, count, fh); 563 if (ferror(fh)) { 564 error_setg_errno(errp, errno, "failed to read file"); 565 } else { 566 buf[read_count] = 0; 567 read_data = g_new0(GuestFileRead, 1); 568 read_data->count = read_count; 569 read_data->eof = feof(fh); 570 if (read_count) { 571 read_data->buf_b64 = g_base64_encode(buf, read_count); 572 } 573 gfh->state = RW_STATE_READING; 574 } 575 g_free(buf); 576 clearerr(fh); 577 578 return read_data; 579 } 580 581 GuestFileWrite *qmp_guest_file_write(int64_t handle, const char *buf_b64, 582 bool has_count, int64_t count, 583 Error **errp) 584 { 585 GuestFileWrite *write_data = NULL; 586 guchar *buf; 587 gsize buf_len; 588 int write_count; 589 GuestFileHandle *gfh = guest_file_handle_find(handle, errp); 590 FILE *fh; 591 592 if (!gfh) { 593 return NULL; 594 } 595 596 fh = gfh->fh; 597 598 if (gfh->state == RW_STATE_READING) { 599 int ret = fseek(fh, 0, SEEK_CUR); 600 if (ret == -1) { 601 error_setg_errno(errp, errno, "failed to seek file"); 602 return NULL; 603 } 604 gfh->state = RW_STATE_NEW; 605 } 606 607 buf = qbase64_decode(buf_b64, -1, &buf_len, errp); 608 if (!buf) { 609 return NULL; 610 } 611 612 if (!has_count) { 613 count = buf_len; 614 } else if (count < 0 || count > buf_len) { 615 error_setg(errp, "value '%" PRId64 "' is invalid for argument count", 616 count); 617 g_free(buf); 618 return NULL; 619 } 620 621 write_count = fwrite(buf, 1, count, fh); 622 if (ferror(fh)) { 623 error_setg_errno(errp, errno, "failed to write to file"); 624 slog("guest-file-write failed, handle: %" PRId64, handle); 625 } else { 626 write_data = g_new0(GuestFileWrite, 1); 627 write_data->count = write_count; 628 write_data->eof = feof(fh); 629 gfh->state = RW_STATE_WRITING; 630 } 631 g_free(buf); 632 clearerr(fh); 633 634 return write_data; 635 } 636 637 struct GuestFileSeek *qmp_guest_file_seek(int64_t handle, int64_t offset, 638 GuestFileWhence *whence_code, 639 Error **errp) 640 { 641 GuestFileHandle *gfh = guest_file_handle_find(handle, errp); 642 GuestFileSeek *seek_data = NULL; 643 FILE *fh; 644 int ret; 645 int whence; 646 Error *err = NULL; 647 648 if (!gfh) { 649 return NULL; 650 } 651 652 /* We stupidly exposed 'whence':'int' in our qapi */ 653 whence = ga_parse_whence(whence_code, &err); 654 if (err) { 655 error_propagate(errp, err); 656 return NULL; 657 } 658 659 fh = gfh->fh; 660 ret = fseek(fh, offset, whence); 661 if (ret == -1) { 662 error_setg_errno(errp, errno, "failed to seek file"); 663 if (errno == ESPIPE) { 664 /* file is non-seekable, stdio shouldn't be buffering anyways */ 665 gfh->state = RW_STATE_NEW; 666 } 667 } else { 668 seek_data = g_new0(GuestFileSeek, 1); 669 seek_data->position = ftell(fh); 670 seek_data->eof = feof(fh); 671 gfh->state = RW_STATE_NEW; 672 } 673 clearerr(fh); 674 675 return seek_data; 676 } 677 678 void qmp_guest_file_flush(int64_t handle, Error **errp) 679 { 680 GuestFileHandle *gfh = guest_file_handle_find(handle, errp); 681 FILE *fh; 682 int ret; 683 684 if (!gfh) { 685 return; 686 } 687 688 fh = gfh->fh; 689 ret = fflush(fh); 690 if (ret == EOF) { 691 error_setg_errno(errp, errno, "failed to flush file"); 692 } else { 693 gfh->state = RW_STATE_NEW; 694 } 695 } 696 697 #if defined(CONFIG_FSFREEZE) || defined(CONFIG_FSTRIM) 698 void free_fs_mount_list(FsMountList *mounts) 699 { 700 FsMount *mount, *temp; 701 702 if (!mounts) { 703 return; 704 } 705 706 QTAILQ_FOREACH_SAFE(mount, mounts, next, temp) { 707 QTAILQ_REMOVE(mounts, mount, next); 708 g_free(mount->dirname); 709 g_free(mount->devtype); 710 g_free(mount); 711 } 712 } 713 #endif 714 715 #if defined(CONFIG_FSFREEZE) 716 typedef enum { 717 FSFREEZE_HOOK_THAW = 0, 718 FSFREEZE_HOOK_FREEZE, 719 } FsfreezeHookArg; 720 721 static const char *fsfreeze_hook_arg_string[] = { 722 "thaw", 723 "freeze", 724 }; 725 726 static void execute_fsfreeze_hook(FsfreezeHookArg arg, Error **errp) 727 { 728 const char *hook; 729 const char *arg_str = fsfreeze_hook_arg_string[arg]; 730 Error *local_err = NULL; 731 732 hook = ga_fsfreeze_hook(ga_state); 733 if (!hook) { 734 return; 735 } 736 737 const char *argv[] = {hook, arg_str, NULL}; 738 739 slog("executing fsfreeze hook with arg '%s'", arg_str); 740 ga_run_command(argv, NULL, "execute fsfreeze hook", &local_err); 741 if (local_err) { 742 error_propagate(errp, local_err); 743 return; 744 } 745 } 746 747 /* 748 * Return status of freeze/thaw 749 */ 750 GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **errp) 751 { 752 if (ga_is_frozen(ga_state)) { 753 return GUEST_FSFREEZE_STATUS_FROZEN; 754 } 755 756 return GUEST_FSFREEZE_STATUS_THAWED; 757 } 758 759 int64_t qmp_guest_fsfreeze_freeze(Error **errp) 760 { 761 return qmp_guest_fsfreeze_freeze_list(false, NULL, errp); 762 } 763 764 int64_t qmp_guest_fsfreeze_freeze_list(bool has_mountpoints, 765 strList *mountpoints, 766 Error **errp) 767 { 768 int ret; 769 FsMountList mounts; 770 Error *local_err = NULL; 771 772 slog("guest-fsfreeze called"); 773 774 execute_fsfreeze_hook(FSFREEZE_HOOK_FREEZE, &local_err); 775 if (local_err) { 776 error_propagate(errp, local_err); 777 return -1; 778 } 779 780 QTAILQ_INIT(&mounts); 781 if (!build_fs_mount_list(&mounts, &local_err)) { 782 error_propagate(errp, local_err); 783 return -1; 784 } 785 786 /* cannot risk guest agent blocking itself on a write in this state */ 787 ga_set_frozen(ga_state); 788 789 ret = qmp_guest_fsfreeze_do_freeze_list(has_mountpoints, mountpoints, 790 mounts, errp); 791 792 free_fs_mount_list(&mounts); 793 /* We may not issue any FIFREEZE here. 794 * Just unset ga_state here and ready for the next call. 795 */ 796 if (ret == 0) { 797 ga_unset_frozen(ga_state); 798 } else if (ret < 0) { 799 qmp_guest_fsfreeze_thaw(NULL); 800 } 801 return ret; 802 } 803 804 int64_t qmp_guest_fsfreeze_thaw(Error **errp) 805 { 806 int ret; 807 808 ret = qmp_guest_fsfreeze_do_thaw(errp); 809 if (ret >= 0) { 810 ga_unset_frozen(ga_state); 811 execute_fsfreeze_hook(FSFREEZE_HOOK_THAW, errp); 812 } else { 813 ret = 0; 814 } 815 816 return ret; 817 } 818 819 static void guest_fsfreeze_cleanup(void) 820 { 821 Error *err = NULL; 822 823 if (ga_is_frozen(ga_state) == GUEST_FSFREEZE_STATUS_FROZEN) { 824 qmp_guest_fsfreeze_thaw(&err); 825 if (err) { 826 slog("failed to clean up frozen filesystems: %s", 827 error_get_pretty(err)); 828 error_free(err); 829 } 830 } 831 } 832 #endif 833 834 #if defined(__linux__) || defined(__FreeBSD__) 835 void qmp_guest_set_user_password(const char *username, 836 const char *password, 837 bool crypted, 838 Error **errp) 839 { 840 Error *local_err = NULL; 841 g_autofree char *rawpasswddata = NULL; 842 size_t rawpasswdlen; 843 844 rawpasswddata = (char *)qbase64_decode(password, -1, &rawpasswdlen, errp); 845 if (!rawpasswddata) { 846 return; 847 } 848 rawpasswddata = g_renew(char, rawpasswddata, rawpasswdlen + 1); 849 rawpasswddata[rawpasswdlen] = '\0'; 850 851 if (strchr(rawpasswddata, '\n')) { 852 error_setg(errp, "forbidden characters in raw password"); 853 return; 854 } 855 856 if (strchr(username, '\n') || 857 strchr(username, ':')) { 858 error_setg(errp, "forbidden characters in username"); 859 return; 860 } 861 862 #ifdef __FreeBSD__ 863 g_autofree char *chpasswddata = g_strdup(rawpasswddata); 864 const char *crypt_flag = crypted ? "-H" : "-h"; 865 const char *argv[] = {"pw", "usermod", "-n", username, 866 crypt_flag, "0", NULL}; 867 #else 868 g_autofree char *chpasswddata = g_strdup_printf("%s:%s\n", username, 869 rawpasswddata); 870 const char *crypt_flag = crypted ? "-e" : NULL; 871 const char *argv[] = {"chpasswd", crypt_flag, NULL}; 872 #endif 873 874 ga_run_command(argv, chpasswddata, "set user password", &local_err); 875 if (local_err) { 876 error_propagate(errp, local_err); 877 return; 878 } 879 } 880 #endif /* __linux__ || __FreeBSD__ */ 881 882 #ifdef HAVE_GETIFADDRS 883 static GuestNetworkInterface * 884 guest_find_interface(GuestNetworkInterfaceList *head, 885 const char *name) 886 { 887 for (; head; head = head->next) { 888 if (strcmp(head->value->name, name) == 0) { 889 return head->value; 890 } 891 } 892 893 return NULL; 894 } 895 896 static int guest_get_network_stats(const char *name, 897 GuestNetworkInterfaceStat *stats) 898 { 899 #ifdef CONFIG_LINUX 900 int name_len; 901 char const *devinfo = "/proc/net/dev"; 902 FILE *fp; 903 char *line = NULL, *colon; 904 size_t n = 0; 905 fp = fopen(devinfo, "r"); 906 if (!fp) { 907 g_debug("failed to open network stats %s: %s", devinfo, 908 g_strerror(errno)); 909 return -1; 910 } 911 name_len = strlen(name); 912 while (getline(&line, &n, fp) != -1) { 913 long long dummy; 914 long long rx_bytes; 915 long long rx_packets; 916 long long rx_errs; 917 long long rx_dropped; 918 long long tx_bytes; 919 long long tx_packets; 920 long long tx_errs; 921 long long tx_dropped; 922 char *trim_line; 923 trim_line = g_strchug(line); 924 if (trim_line[0] == '\0') { 925 continue; 926 } 927 colon = strchr(trim_line, ':'); 928 if (!colon) { 929 continue; 930 } 931 if (colon - name_len == trim_line && 932 strncmp(trim_line, name, name_len) == 0) { 933 if (sscanf(colon + 1, 934 "%lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld", 935 &rx_bytes, &rx_packets, &rx_errs, &rx_dropped, 936 &dummy, &dummy, &dummy, &dummy, 937 &tx_bytes, &tx_packets, &tx_errs, &tx_dropped, 938 &dummy, &dummy, &dummy, &dummy) != 16) { 939 continue; 940 } 941 stats->rx_bytes = rx_bytes; 942 stats->rx_packets = rx_packets; 943 stats->rx_errs = rx_errs; 944 stats->rx_dropped = rx_dropped; 945 stats->tx_bytes = tx_bytes; 946 stats->tx_packets = tx_packets; 947 stats->tx_errs = tx_errs; 948 stats->tx_dropped = tx_dropped; 949 fclose(fp); 950 g_free(line); 951 return 0; 952 } 953 } 954 fclose(fp); 955 g_free(line); 956 g_debug("/proc/net/dev: Interface '%s' not found", name); 957 #else /* !CONFIG_LINUX */ 958 g_debug("Network stats reporting available only for Linux"); 959 #endif /* !CONFIG_LINUX */ 960 return -1; 961 } 962 963 #ifndef CONFIG_BSD 964 /* 965 * Fill "buf" with MAC address by ifaddrs. Pointer buf must point to a 966 * buffer with ETHER_ADDR_LEN length at least. 967 * 968 * Returns false in case of an error, otherwise true. "obtained" argument 969 * is true if a MAC address was obtained successful, otherwise false. 970 */ 971 bool guest_get_hw_addr(struct ifaddrs *ifa, unsigned char *buf, 972 bool *obtained, Error **errp) 973 { 974 struct ifreq ifr; 975 int sock; 976 977 *obtained = false; 978 979 /* we haven't obtained HW address yet */ 980 sock = socket(PF_INET, SOCK_STREAM, 0); 981 if (sock == -1) { 982 error_setg_errno(errp, errno, "failed to create socket"); 983 return false; 984 } 985 986 memset(&ifr, 0, sizeof(ifr)); 987 pstrcpy(ifr.ifr_name, IF_NAMESIZE, ifa->ifa_name); 988 if (ioctl(sock, SIOCGIFHWADDR, &ifr) == -1) { 989 /* 990 * We can't get the hw addr of this interface, but that's not a 991 * fatal error. 992 */ 993 if (errno == EADDRNOTAVAIL) { 994 /* The interface doesn't have a hw addr (e.g. loopback). */ 995 g_debug("failed to get MAC address of %s: %s", 996 ifa->ifa_name, strerror(errno)); 997 } else{ 998 g_warning("failed to get MAC address of %s: %s", 999 ifa->ifa_name, strerror(errno)); 1000 } 1001 } else { 1002 #ifdef CONFIG_SOLARIS 1003 memcpy(buf, &ifr.ifr_addr.sa_data, ETHER_ADDR_LEN); 1004 #else 1005 memcpy(buf, &ifr.ifr_hwaddr.sa_data, ETHER_ADDR_LEN); 1006 #endif 1007 *obtained = true; 1008 } 1009 close(sock); 1010 return true; 1011 } 1012 #endif /* CONFIG_BSD */ 1013 1014 /* 1015 * Build information about guest interfaces 1016 */ 1017 GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp) 1018 { 1019 GuestNetworkInterfaceList *head = NULL, **tail = &head; 1020 struct ifaddrs *ifap, *ifa; 1021 1022 if (getifaddrs(&ifap) < 0) { 1023 error_setg_errno(errp, errno, "getifaddrs failed"); 1024 goto error; 1025 } 1026 1027 for (ifa = ifap; ifa; ifa = ifa->ifa_next) { 1028 GuestNetworkInterface *info; 1029 GuestIpAddressList **address_tail; 1030 GuestIpAddress *address_item = NULL; 1031 GuestNetworkInterfaceStat *interface_stat = NULL; 1032 char addr4[INET_ADDRSTRLEN]; 1033 char addr6[INET6_ADDRSTRLEN]; 1034 unsigned char mac_addr[ETHER_ADDR_LEN]; 1035 bool obtained; 1036 void *p; 1037 1038 g_debug("Processing %s interface", ifa->ifa_name); 1039 1040 info = guest_find_interface(head, ifa->ifa_name); 1041 1042 if (!info) { 1043 info = g_malloc0(sizeof(*info)); 1044 info->name = g_strdup(ifa->ifa_name); 1045 1046 QAPI_LIST_APPEND(tail, info); 1047 } 1048 1049 if (!info->hardware_address) { 1050 if (!guest_get_hw_addr(ifa, mac_addr, &obtained, errp)) { 1051 goto error; 1052 } 1053 if (obtained) { 1054 info->hardware_address = 1055 g_strdup_printf("%02x:%02x:%02x:%02x:%02x:%02x", 1056 (int) mac_addr[0], (int) mac_addr[1], 1057 (int) mac_addr[2], (int) mac_addr[3], 1058 (int) mac_addr[4], (int) mac_addr[5]); 1059 } 1060 } 1061 1062 if (ifa->ifa_addr && 1063 ifa->ifa_addr->sa_family == AF_INET) { 1064 /* interface with IPv4 address */ 1065 p = &((struct sockaddr_in *)ifa->ifa_addr)->sin_addr; 1066 if (!inet_ntop(AF_INET, p, addr4, sizeof(addr4))) { 1067 error_setg_errno(errp, errno, "inet_ntop failed"); 1068 goto error; 1069 } 1070 1071 address_item = g_malloc0(sizeof(*address_item)); 1072 address_item->ip_address = g_strdup(addr4); 1073 address_item->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV4; 1074 1075 if (ifa->ifa_netmask) { 1076 /* Count the number of set bits in netmask. 1077 * This is safe as '1' and '0' cannot be shuffled in netmask. */ 1078 p = &((struct sockaddr_in *)ifa->ifa_netmask)->sin_addr; 1079 address_item->prefix = ctpop32(((uint32_t *) p)[0]); 1080 } 1081 } else if (ifa->ifa_addr && 1082 ifa->ifa_addr->sa_family == AF_INET6) { 1083 /* interface with IPv6 address */ 1084 p = &((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_addr; 1085 if (!inet_ntop(AF_INET6, p, addr6, sizeof(addr6))) { 1086 error_setg_errno(errp, errno, "inet_ntop failed"); 1087 goto error; 1088 } 1089 1090 address_item = g_malloc0(sizeof(*address_item)); 1091 address_item->ip_address = g_strdup(addr6); 1092 address_item->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV6; 1093 1094 if (ifa->ifa_netmask) { 1095 /* Count the number of set bits in netmask. 1096 * This is safe as '1' and '0' cannot be shuffled in netmask. */ 1097 p = &((struct sockaddr_in6 *)ifa->ifa_netmask)->sin6_addr; 1098 address_item->prefix = 1099 ctpop32(((uint32_t *) p)[0]) + 1100 ctpop32(((uint32_t *) p)[1]) + 1101 ctpop32(((uint32_t *) p)[2]) + 1102 ctpop32(((uint32_t *) p)[3]); 1103 } 1104 } 1105 1106 if (!address_item) { 1107 continue; 1108 } 1109 1110 address_tail = &info->ip_addresses; 1111 while (*address_tail) { 1112 address_tail = &(*address_tail)->next; 1113 } 1114 QAPI_LIST_APPEND(address_tail, address_item); 1115 1116 info->has_ip_addresses = true; 1117 1118 if (!info->statistics) { 1119 interface_stat = g_malloc0(sizeof(*interface_stat)); 1120 if (guest_get_network_stats(info->name, interface_stat) == -1) { 1121 g_free(interface_stat); 1122 } else { 1123 info->statistics = interface_stat; 1124 } 1125 } 1126 } 1127 1128 freeifaddrs(ifap); 1129 return head; 1130 1131 error: 1132 freeifaddrs(ifap); 1133 qapi_free_GuestNetworkInterfaceList(head); 1134 return NULL; 1135 } 1136 1137 #endif /* HAVE_GETIFADDRS */ 1138 1139 /* register init/cleanup routines for stateful command groups */ 1140 void ga_command_state_init(GAState *s, GACommandState *cs) 1141 { 1142 #if defined(CONFIG_FSFREEZE) 1143 ga_command_state_add(cs, NULL, guest_fsfreeze_cleanup); 1144 #endif 1145 } 1146 1147 #ifdef HAVE_UTMPX 1148 1149 #define QGA_MICRO_SECOND_TO_SECOND 1000000 1150 1151 static double ga_get_login_time(struct utmpx *user_info) 1152 { 1153 double seconds = (double)user_info->ut_tv.tv_sec; 1154 double useconds = (double)user_info->ut_tv.tv_usec; 1155 useconds /= QGA_MICRO_SECOND_TO_SECOND; 1156 return seconds + useconds; 1157 } 1158 1159 GuestUserList *qmp_guest_get_users(Error **errp) 1160 { 1161 GHashTable *cache = NULL; 1162 GuestUserList *head = NULL, **tail = &head; 1163 struct utmpx *user_info = NULL; 1164 gpointer value = NULL; 1165 GuestUser *user = NULL; 1166 double login_time = 0; 1167 1168 cache = g_hash_table_new(g_str_hash, g_str_equal); 1169 setutxent(); 1170 1171 for (;;) { 1172 user_info = getutxent(); 1173 if (user_info == NULL) { 1174 break; 1175 } else if (user_info->ut_type != USER_PROCESS) { 1176 continue; 1177 } else if (g_hash_table_contains(cache, user_info->ut_user)) { 1178 value = g_hash_table_lookup(cache, user_info->ut_user); 1179 user = (GuestUser *)value; 1180 login_time = ga_get_login_time(user_info); 1181 /* We're ensuring the earliest login time to be sent */ 1182 if (login_time < user->login_time) { 1183 user->login_time = login_time; 1184 } 1185 continue; 1186 } 1187 1188 user = g_new0(GuestUser, 1); 1189 user->user = g_strdup(user_info->ut_user); 1190 user->login_time = ga_get_login_time(user_info); 1191 1192 g_hash_table_insert(cache, user->user, user); 1193 1194 QAPI_LIST_APPEND(tail, user); 1195 } 1196 endutxent(); 1197 g_hash_table_destroy(cache); 1198 return head; 1199 } 1200 1201 #endif /* HAVE_UTMPX */ 1202 1203 /* Replace escaped special characters with their real values. The replacement 1204 * is done in place -- returned value is in the original string. 1205 */ 1206 static void ga_osrelease_replace_special(gchar *value) 1207 { 1208 gchar *p, *p2, quote; 1209 1210 /* Trim the string at first space or semicolon if it is not enclosed in 1211 * single or double quotes. */ 1212 if ((value[0] != '"') || (value[0] == '\'')) { 1213 p = strchr(value, ' '); 1214 if (p != NULL) { 1215 *p = 0; 1216 } 1217 p = strchr(value, ';'); 1218 if (p != NULL) { 1219 *p = 0; 1220 } 1221 return; 1222 } 1223 1224 quote = value[0]; 1225 p2 = value; 1226 p = value + 1; 1227 while (*p != 0) { 1228 if (*p == '\\') { 1229 p++; 1230 switch (*p) { 1231 case '$': 1232 case '\'': 1233 case '"': 1234 case '\\': 1235 case '`': 1236 break; 1237 default: 1238 /* Keep literal backslash followed by whatever is there */ 1239 p--; 1240 break; 1241 } 1242 } else if (*p == quote) { 1243 *p2 = 0; 1244 break; 1245 } 1246 *(p2++) = *(p++); 1247 } 1248 } 1249 1250 static GKeyFile *ga_parse_osrelease(const char *fname) 1251 { 1252 gchar *content = NULL; 1253 gchar *content2 = NULL; 1254 GError *err = NULL; 1255 GKeyFile *keys = g_key_file_new(); 1256 const char *group = "[os-release]\n"; 1257 1258 if (!g_file_get_contents(fname, &content, NULL, &err)) { 1259 slog("failed to read '%s', error: %s", fname, err->message); 1260 goto fail; 1261 } 1262 1263 if (!g_utf8_validate(content, -1, NULL)) { 1264 slog("file is not utf-8 encoded: %s", fname); 1265 goto fail; 1266 } 1267 content2 = g_strdup_printf("%s%s", group, content); 1268 1269 if (!g_key_file_load_from_data(keys, content2, -1, G_KEY_FILE_NONE, 1270 &err)) { 1271 slog("failed to parse file '%s', error: %s", fname, err->message); 1272 goto fail; 1273 } 1274 1275 g_free(content); 1276 g_free(content2); 1277 return keys; 1278 1279 fail: 1280 g_error_free(err); 1281 g_free(content); 1282 g_free(content2); 1283 g_key_file_free(keys); 1284 return NULL; 1285 } 1286 1287 GuestOSInfo *qmp_guest_get_osinfo(Error **errp) 1288 { 1289 GuestOSInfo *info = NULL; 1290 struct utsname kinfo; 1291 GKeyFile *osrelease = NULL; 1292 const char *qga_os_release = g_getenv("QGA_OS_RELEASE"); 1293 1294 info = g_new0(GuestOSInfo, 1); 1295 1296 if (uname(&kinfo) != 0) { 1297 error_setg_errno(errp, errno, "uname failed"); 1298 } else { 1299 info->kernel_version = g_strdup(kinfo.version); 1300 info->kernel_release = g_strdup(kinfo.release); 1301 info->machine = g_strdup(kinfo.machine); 1302 } 1303 1304 if (qga_os_release != NULL) { 1305 osrelease = ga_parse_osrelease(qga_os_release); 1306 } else { 1307 osrelease = ga_parse_osrelease("/etc/os-release"); 1308 if (osrelease == NULL) { 1309 osrelease = ga_parse_osrelease("/usr/lib/os-release"); 1310 } 1311 } 1312 1313 if (osrelease != NULL) { 1314 char *value; 1315 1316 #define GET_FIELD(field, osfield) do { \ 1317 value = g_key_file_get_value(osrelease, "os-release", osfield, NULL); \ 1318 if (value != NULL) { \ 1319 ga_osrelease_replace_special(value); \ 1320 info->field = value; \ 1321 } \ 1322 } while (0) 1323 GET_FIELD(id, "ID"); 1324 GET_FIELD(name, "NAME"); 1325 GET_FIELD(pretty_name, "PRETTY_NAME"); 1326 GET_FIELD(version, "VERSION"); 1327 GET_FIELD(version_id, "VERSION_ID"); 1328 GET_FIELD(variant, "VARIANT"); 1329 GET_FIELD(variant_id, "VARIANT_ID"); 1330 #undef GET_FIELD 1331 1332 g_key_file_free(osrelease); 1333 } 1334 1335 return info; 1336 } 1337 1338 #ifndef HOST_NAME_MAX 1339 # ifdef _POSIX_HOST_NAME_MAX 1340 # define HOST_NAME_MAX _POSIX_HOST_NAME_MAX 1341 # else 1342 # define HOST_NAME_MAX 255 1343 # endif 1344 #endif 1345 1346 char *qga_get_host_name(Error **errp) 1347 { 1348 long len = -1; 1349 g_autofree char *hostname = NULL; 1350 1351 #ifdef _SC_HOST_NAME_MAX 1352 len = sysconf(_SC_HOST_NAME_MAX); 1353 #endif /* _SC_HOST_NAME_MAX */ 1354 1355 if (len < 0) { 1356 len = HOST_NAME_MAX; 1357 } 1358 1359 /* Unfortunately, gethostname() below does not guarantee a 1360 * NULL terminated string. Therefore, allocate one byte more 1361 * to be sure. */ 1362 hostname = g_new0(char, len + 1); 1363 1364 if (gethostname(hostname, len) < 0) { 1365 error_setg_errno(errp, errno, 1366 "cannot get hostname"); 1367 return NULL; 1368 } 1369 1370 return g_steal_pointer(&hostname); 1371 } 1372