qga/commands-posix.c

   1 /*
   2  * QEMU Guest Agent POSIX-specific command implementations
   3  *
   4  * Copyright IBM Corp. 2011
   5  *
   6  * Authors:
   7  *  Michael Roth      <[email protected]>
   8  *  Michal Privoznik  <[email protected]>
   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 }