qga/commands-win32.c

   1 /*
   2  * QEMU Guest Agent win32-specific command implementations
   3  *
   4  * Copyright IBM Corp. 2012
   5  *
   6  * Authors:
   7  *  Michael Roth      <[email protected]>
   8  *  Gal Hammer        <[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 #include "qemu/osdep.h"
  14
  15 #include <wtypes.h>
  16 #include <powrprof.h>
  17 #include <winsock2.h>
  18 #include <ws2tcpip.h>
  19 #include <iptypes.h>
  20 #include <iphlpapi.h>
  21 #ifdef CONFIG_QGA_NTDDSCSI
  22 #include <winioctl.h>
  23 #include <ntddscsi.h>
  24 #endif
  25 #include <setupapi.h>
  26 #include <cfgmgr32.h>
  27 #include <initguid.h>
  28 #include <devpropdef.h>
  29 #include <lm.h>
  30 #include <wtsapi32.h>
  31 #include <wininet.h>
  32
  33 #include "guest-agent-core.h"
  34 #include "vss-win32.h"
  35 #include "qga-qapi-commands.h"
  36 #include "qapi/error.h"
  37 #include "qapi/qmp/qerror.h"
  38 #include "qemu/queue.h"
  39 #include "qemu/host-utils.h"
  40 #include "qemu/base64.h"
  41 #include "commands-common.h"
  42
  43 /*
  44  * The following should be in devpkey.h, but it isn't. The key names were
  45  * prefixed to avoid (future) name clashes. Once the definitions get into
  46  * mingw the following lines can be removed.
  47  */
  48 DEFINE_DEVPROPKEY(qga_DEVPKEY_NAME, 0xb725f130, 0x47ef, 0x101a, 0xa5,
  49     0xf1, 0x02, 0x60, 0x8c, 0x9e, 0xeb, 0xac, 10);
  50     /* DEVPROP_TYPE_STRING */
  51 DEFINE_DEVPROPKEY(qga_DEVPKEY_Device_HardwareIds, 0xa45c254e, 0xdf1c,
  52     0x4efd, 0x80, 0x20, 0x67, 0xd1, 0x46, 0xa8, 0x50, 0xe0, 3);
  53     /* DEVPROP_TYPE_STRING_LIST */
  54 DEFINE_DEVPROPKEY(qga_DEVPKEY_Device_DriverDate, 0xa8b865dd, 0x2e3d,
  55     0x4094, 0xad, 0x97, 0xe5, 0x93, 0xa7, 0xc, 0x75, 0xd6, 2);
  56     /* DEVPROP_TYPE_FILETIME */
  57 DEFINE_DEVPROPKEY(qga_DEVPKEY_Device_DriverVersion, 0xa8b865dd, 0x2e3d,
  58     0x4094, 0xad, 0x97, 0xe5, 0x93, 0xa7, 0xc, 0x75, 0xd6, 3);
  59     /* DEVPROP_TYPE_STRING */
  60 /* The CM_Get_DevNode_PropertyW prototype is only sometimes in cfgmgr32.h */
  61 #ifndef CM_Get_DevNode_Property
  62 #pragma GCC diagnostic push
  63 #pragma GCC diagnostic ignored "-Wredundant-decls"
  64 CMAPI CONFIGRET WINAPI CM_Get_DevNode_PropertyW(
  65     DEVINST          dnDevInst,
  66     CONST DEVPROPKEY * PropertyKey,
  67     DEVPROPTYPE      * PropertyType,
  68     PBYTE            PropertyBuffer,
  69     PULONG           PropertyBufferSize,
  70     ULONG            ulFlags
  71 );
  72 #define CM_Get_DevNode_Property CM_Get_DevNode_PropertyW
  73 #pragma GCC diagnostic pop
  74 #endif
  75
  76 #ifndef SHTDN_REASON_FLAG_PLANNED
  77 #define SHTDN_REASON_FLAG_PLANNED 0x80000000
  78 #endif
  79
  80 /* multiple of 100 nanoseconds elapsed between windows baseline
  81  *    (1/1/1601) and Unix Epoch (1/1/1970), accounting for leap years */
  82 #define W32_FT_OFFSET (10000000ULL * 60 * 60 * 24 * \
  83                        (365 * (1970 - 1601) +       \
  84                         (1970 - 1601) / 4 - 3))
  85
  86 #define INVALID_SET_FILE_POINTER ((DWORD)-1)
  87
  88 struct GuestFileHandle {
  89     int64_t id;
  90     HANDLE fh;
  91     QTAILQ_ENTRY(GuestFileHandle) next;
  92 };
  93
  94 static struct {
  95     QTAILQ_HEAD(, GuestFileHandle) filehandles;
  96 } guest_file_state = {
  97     .filehandles = QTAILQ_HEAD_INITIALIZER(guest_file_state.filehandles),
  98 };
  99
 100 #define FILE_GENERIC_APPEND (FILE_GENERIC_WRITE & ~FILE_WRITE_DATA)
 101
 102 typedef struct OpenFlags {
 103     const char *forms;
 104     DWORD desired_access;
 105     DWORD creation_disposition;
 106 } OpenFlags;
 107 static OpenFlags guest_file_open_modes[] = {
 108     {"r",   GENERIC_READ,                     OPEN_EXISTING},
 109     {"rb",  GENERIC_READ,                     OPEN_EXISTING},
 110     {"w",   GENERIC_WRITE,                    CREATE_ALWAYS},
 111     {"wb",  GENERIC_WRITE,                    CREATE_ALWAYS},
 112     {"a",   FILE_GENERIC_APPEND,              OPEN_ALWAYS  },
 113     {"r+",  GENERIC_WRITE | GENERIC_READ,       OPEN_EXISTING},
 114     {"rb+", GENERIC_WRITE | GENERIC_READ,       OPEN_EXISTING},
 115     {"r+b", GENERIC_WRITE | GENERIC_READ,       OPEN_EXISTING},
 116     {"w+",  GENERIC_WRITE | GENERIC_READ,       CREATE_ALWAYS},
 117     {"wb+", GENERIC_WRITE | GENERIC_READ,       CREATE_ALWAYS},
 118     {"w+b", GENERIC_WRITE | GENERIC_READ,       CREATE_ALWAYS},
 119     {"a+",  FILE_GENERIC_APPEND | GENERIC_READ, OPEN_ALWAYS  },
 120     {"ab+", FILE_GENERIC_APPEND | GENERIC_READ, OPEN_ALWAYS  },
 121     {"a+b", FILE_GENERIC_APPEND | GENERIC_READ, OPEN_ALWAYS  }
 122 };
 123
 124 #define debug_error(msg) do { \
 125     char *suffix = g_win32_error_message(GetLastError()); \
 126     g_debug("%s: %s", (msg), suffix); \
 127     g_free(suffix); \
 128 } while (0)
 129
 130 static OpenFlags *find_open_flag(const char *mode_str)
 131 {
 132     int mode;
 133     Error **errp = NULL;
 134
 135     for (mode = 0; mode < ARRAY_SIZE(guest_file_open_modes); ++mode) {
 136         OpenFlags *flags = guest_file_open_modes + mode;
 137
 138         if (strcmp(flags->forms, mode_str) == 0) {
 139             return flags;
 140         }
 141     }
 142
 143     error_setg(errp, "invalid file open mode '%s'", mode_str);
 144     return NULL;
 145 }
 146
 147 static int64_t guest_file_handle_add(HANDLE fh, Error **errp)
 148 {
 149     GuestFileHandle *gfh;
 150     int64_t handle;
 151
 152     handle = ga_get_fd_handle(ga_state, errp);
 153     if (handle < 0) {
 154         return -1;
 155     }
 156     gfh = g_new0(GuestFileHandle, 1);
 157     gfh->id = handle;
 158     gfh->fh = fh;
 159     QTAILQ_INSERT_TAIL(&guest_file_state.filehandles, gfh, next);
 160
 161     return handle;
 162 }
 163
 164 GuestFileHandle *guest_file_handle_find(int64_t id, Error **errp)
 165 {
 166     GuestFileHandle *gfh;
 167     QTAILQ_FOREACH(gfh, &guest_file_state.filehandles, next) {
 168         if (gfh->id == id) {
 169             return gfh;
 170         }
 171     }
 172     error_setg(errp, "handle '%" PRId64 "' has not been found", id);
 173     return NULL;
 174 }
 175
 176 static void handle_set_nonblocking(HANDLE fh)
 177 {
 178     DWORD file_type, pipe_state;
 179     file_type = GetFileType(fh);
 180     if (file_type != FILE_TYPE_PIPE) {
 181         return;
 182     }
 183     /* If file_type == FILE_TYPE_PIPE, according to MSDN
 184      * the specified file is socket or named pipe */
 185     if (!GetNamedPipeHandleState(fh, &pipe_state, NULL,
 186                                  NULL, NULL, NULL, 0)) {
 187         return;
 188     }
 189     /* The fd is named pipe fd */
 190     if (pipe_state & PIPE_NOWAIT) {
 191         return;
 192     }
 193
 194     pipe_state |= PIPE_NOWAIT;
 195     SetNamedPipeHandleState(fh, &pipe_state, NULL, NULL);
 196 }
 197
 198 int64_t qmp_guest_file_open(const char *path, bool has_mode,
 199                             const char *mode, Error **errp)
 200 {
 201     int64_t fd = -1;
 202     HANDLE fh;
 203     HANDLE templ_file = NULL;
 204     DWORD share_mode = FILE_SHARE_READ;
 205     DWORD flags_and_attr = FILE_ATTRIBUTE_NORMAL;
 206     LPSECURITY_ATTRIBUTES sa_attr = NULL;
 207     OpenFlags *guest_flags;
 208     GError *gerr = NULL;
 209     wchar_t *w_path = NULL;
 210
 211     if (!has_mode) {
 212         mode = "r";
 213     }
 214     slog("guest-file-open called, filepath: %s, mode: %s", path, mode);
 215     guest_flags = find_open_flag(mode);
 216     if (guest_flags == NULL) {
 217         error_setg(errp, "invalid file open mode");
 218         goto done;
 219     }
 220
 221     w_path = g_utf8_to_utf16(path, -1, NULL, NULL, &gerr);
 222     if (!w_path) {
 223         goto done;
 224     }
 225
 226     fh = CreateFileW(w_path, guest_flags->desired_access, share_mode, sa_attr,
 227                     guest_flags->creation_disposition, flags_and_attr,
 228                     templ_file);
 229     if (fh == INVALID_HANDLE_VALUE) {
 230         error_setg_win32(errp, GetLastError(), "failed to open file '%s'",
 231                          path);
 232         goto done;
 233     }
 234
 235     /* set fd non-blocking to avoid common use cases (like reading from a
 236      * named pipe) from hanging the agent
 237      */
 238     handle_set_nonblocking(fh);
 239
 240     fd = guest_file_handle_add(fh, errp);
 241     if (fd < 0) {
 242         CloseHandle(fh);
 243         error_setg(errp, "failed to add handle to qmp handle table");
 244         goto done;
 245     }
 246
 247     slog("guest-file-open, handle: % " PRId64, fd);
 248
 249 done:
 250     if (gerr) {
 251         error_setg(errp, QERR_QGA_COMMAND_FAILED, gerr->message);
 252         g_error_free(gerr);
 253     }
 254     g_free(w_path);
 255     return fd;
 256 }
 257
 258 void qmp_guest_file_close(int64_t handle, Error **errp)
 259 {
 260     bool ret;
 261     GuestFileHandle *gfh = guest_file_handle_find(handle, errp);
 262     slog("guest-file-close called, handle: %" PRId64, handle);
 263     if (gfh == NULL) {
 264         return;
 265     }
 266     ret = CloseHandle(gfh->fh);
 267     if (!ret) {
 268         error_setg_win32(errp, GetLastError(), "failed close handle");
 269         return;
 270     }
 271
 272     QTAILQ_REMOVE(&guest_file_state.filehandles, gfh, next);
 273     g_free(gfh);
 274 }
 275
 276 static void acquire_privilege(const char *name, Error **errp)
 277 {
 278     HANDLE token = NULL;
 279     TOKEN_PRIVILEGES priv;
 280     Error *local_err = NULL;
 281
 282     if (OpenProcessToken(GetCurrentProcess(),
 283         TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &token))
 284     {
 285         if (!LookupPrivilegeValue(NULL, name, &priv.Privileges[0].Luid)) {
 286             error_setg(&local_err, QERR_QGA_COMMAND_FAILED,
 287                        "no luid for requested privilege");
 288             goto out;
 289         }
 290
 291         priv.PrivilegeCount = 1;
 292         priv.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
 293
 294         if (!AdjustTokenPrivileges(token, FALSE, &priv, 0, NULL, 0)) {
 295             error_setg(&local_err, QERR_QGA_COMMAND_FAILED,
 296                        "unable to acquire requested privilege");
 297             goto out;
 298         }
 299
 300     } else {
 301         error_setg(&local_err, QERR_QGA_COMMAND_FAILED,
 302                    "failed to open privilege token");
 303     }
 304
 305 out:
 306     if (token) {
 307         CloseHandle(token);
 308     }
 309     error_propagate(errp, local_err);
 310 }
 311
 312 static void execute_async(DWORD WINAPI (*func)(LPVOID), LPVOID opaque,
 313                           Error **errp)
 314 {
 315     HANDLE thread = CreateThread(NULL, 0, func, opaque, 0, NULL);
 316     if (!thread) {
 317         error_setg(errp, QERR_QGA_COMMAND_FAILED,
 318                    "failed to dispatch asynchronous command");
 319     }
 320 }
 321
 322 void qmp_guest_shutdown(bool has_mode, const char *mode, Error **errp)
 323 {
 324     Error *local_err = NULL;
 325     UINT shutdown_flag = EWX_FORCE;
 326
 327     slog("guest-shutdown called, mode: %s", mode);
 328
 329     if (!has_mode || strcmp(mode, "powerdown") == 0) {
 330         shutdown_flag |= EWX_POWEROFF;
 331     } else if (strcmp(mode, "halt") == 0) {
 332         shutdown_flag |= EWX_SHUTDOWN;
 333     } else if (strcmp(mode, "reboot") == 0) {
 334         shutdown_flag |= EWX_REBOOT;
 335     } else {
 336         error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "mode",
 337                    "'halt', 'powerdown', or 'reboot'");
 338         return;
 339     }
 340
 341     /* Request a shutdown privilege, but try to shut down the system
 342        anyway. */
 343     acquire_privilege(SE_SHUTDOWN_NAME, &local_err);
 344     if (local_err) {
 345         error_propagate(errp, local_err);
 346         return;
 347     }
 348
 349     if (!ExitWindowsEx(shutdown_flag, SHTDN_REASON_FLAG_PLANNED)) {
 350         g_autofree gchar *emsg = g_win32_error_message(GetLastError());
 351         slog("guest-shutdown failed: %s", emsg);
 352         error_setg_win32(errp, GetLastError(), "guest-shutdown failed");
 353     }
 354 }
 355
 356 GuestFileRead *guest_file_read_unsafe(GuestFileHandle *gfh,
 357                                       int64_t count, Error **errp)
 358 {
 359     GuestFileRead *read_data = NULL;
 360     guchar *buf;
 361     HANDLE fh = gfh->fh;
 362     bool is_ok;
 363     DWORD read_count;
 364
 365     buf = g_malloc0(count + 1);
 366     is_ok = ReadFile(fh, buf, count, &read_count, NULL);
 367     if (!is_ok) {
 368         error_setg_win32(errp, GetLastError(), "failed to read file");
 369     } else {
 370         buf[read_count] = 0;
 371         read_data = g_new0(GuestFileRead, 1);
 372         read_data->count = (size_t)read_count;
 373         read_data->eof = read_count == 0;
 374
 375         if (read_count != 0) {
 376             read_data->buf_b64 = g_base64_encode(buf, read_count);
 377         }
 378     }
 379     g_free(buf);
 380
 381     return read_data;
 382 }
 383
 384 GuestFileWrite *qmp_guest_file_write(int64_t handle, const char *buf_b64,
 385                                      bool has_count, int64_t count,
 386                                      Error **errp)
 387 {
 388     GuestFileWrite *write_data = NULL;
 389     guchar *buf;
 390     gsize buf_len;
 391     bool is_ok;
 392     DWORD write_count;
 393     GuestFileHandle *gfh = guest_file_handle_find(handle, errp);
 394     HANDLE fh;
 395
 396     if (!gfh) {
 397         return NULL;
 398     }
 399     fh = gfh->fh;
 400     buf = qbase64_decode(buf_b64, -1, &buf_len, errp);
 401     if (!buf) {
 402         return NULL;
 403     }
 404
 405     if (!has_count) {
 406         count = buf_len;
 407     } else if (count < 0 || count > buf_len) {
 408         error_setg(errp, "value '%" PRId64
 409                    "' is invalid for argument count", count);
 410         goto done;
 411     }
 412
 413     is_ok = WriteFile(fh, buf, count, &write_count, NULL);
 414     if (!is_ok) {
 415         error_setg_win32(errp, GetLastError(), "failed to write to file");
 416         slog("guest-file-write-failed, handle: %" PRId64, handle);
 417     } else {
 418         write_data = g_new0(GuestFileWrite, 1);
 419         write_data->count = (size_t) write_count;
 420     }
 421
 422 done:
 423     g_free(buf);
 424     return write_data;
 425 }
 426
 427 GuestFileSeek *qmp_guest_file_seek(int64_t handle, int64_t offset,
 428                                    GuestFileWhence *whence_code,
 429                                    Error **errp)
 430 {
 431     GuestFileHandle *gfh;
 432     GuestFileSeek *seek_data;
 433     HANDLE fh;
 434     LARGE_INTEGER new_pos, off_pos;
 435     off_pos.QuadPart = offset;
 436     BOOL res;
 437     int whence;
 438     Error *err = NULL;
 439
 440     gfh = guest_file_handle_find(handle, errp);
 441     if (!gfh) {
 442         return NULL;
 443     }
 444
 445     /* We stupidly exposed 'whence':'int' in our qapi */
 446     whence = ga_parse_whence(whence_code, &err);
 447     if (err) {
 448         error_propagate(errp, err);
 449         return NULL;
 450     }
 451
 452     fh = gfh->fh;
 453     res = SetFilePointerEx(fh, off_pos, &new_pos, whence);
 454     if (!res) {
 455         error_setg_win32(errp, GetLastError(), "failed to seek file");
 456         return NULL;
 457     }
 458     seek_data = g_new0(GuestFileSeek, 1);
 459     seek_data->position = new_pos.QuadPart;
 460     return seek_data;
 461 }
 462
 463 void qmp_guest_file_flush(int64_t handle, Error **errp)
 464 {
 465     HANDLE fh;
 466     GuestFileHandle *gfh = guest_file_handle_find(handle, errp);
 467     if (!gfh) {
 468         return;
 469     }
 470
 471     fh = gfh->fh;
 472     if (!FlushFileBuffers(fh)) {
 473         error_setg_win32(errp, GetLastError(), "failed to flush file");
 474     }
 475 }
 476
 477 #ifdef CONFIG_QGA_NTDDSCSI
 478
 479 static GuestDiskBusType win2qemu[] = {
 480     [BusTypeUnknown] = GUEST_DISK_BUS_TYPE_UNKNOWN,
 481     [BusTypeScsi] = GUEST_DISK_BUS_TYPE_SCSI,
 482     [BusTypeAtapi] = GUEST_DISK_BUS_TYPE_IDE,
 483     [BusTypeAta] = GUEST_DISK_BUS_TYPE_IDE,
 484     [BusType1394] = GUEST_DISK_BUS_TYPE_IEEE1394,
 485     [BusTypeSsa] = GUEST_DISK_BUS_TYPE_SSA,
 486     [BusTypeFibre] = GUEST_DISK_BUS_TYPE_SSA,
 487     [BusTypeUsb] = GUEST_DISK_BUS_TYPE_USB,
 488     [BusTypeRAID] = GUEST_DISK_BUS_TYPE_RAID,
 489     [BusTypeiScsi] = GUEST_DISK_BUS_TYPE_ISCSI,
 490     [BusTypeSas] = GUEST_DISK_BUS_TYPE_SAS,
 491     [BusTypeSata] = GUEST_DISK_BUS_TYPE_SATA,
 492     [BusTypeSd] =  GUEST_DISK_BUS_TYPE_SD,
 493     [BusTypeMmc] = GUEST_DISK_BUS_TYPE_MMC,
 494 #if (_WIN32_WINNT >= 0x0601)
 495     [BusTypeVirtual] = GUEST_DISK_BUS_TYPE_VIRTUAL,
 496     [BusTypeFileBackedVirtual] = GUEST_DISK_BUS_TYPE_FILE_BACKED_VIRTUAL,
 497 #endif
 498 };
 499
 500 static GuestDiskBusType find_bus_type(STORAGE_BUS_TYPE bus)
 501 {
 502     if (bus >= ARRAY_SIZE(win2qemu) || (int)bus < 0) {
 503         return GUEST_DISK_BUS_TYPE_UNKNOWN;
 504     }
 505     return win2qemu[(int)bus];
 506 }
 507
 508 DEFINE_GUID(GUID_DEVINTERFACE_DISK,
 509         0x53f56307L, 0xb6bf, 0x11d0, 0x94, 0xf2,
 510         0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b);
 511 DEFINE_GUID(GUID_DEVINTERFACE_STORAGEPORT,
 512         0x2accfe60L, 0xc130, 0x11d2, 0xb0, 0x82,
 513         0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b);
 514
 515 static GuestPCIAddress *get_pci_info(int number, Error **errp)
 516 {
 517     HDEVINFO dev_info;
 518     SP_DEVINFO_DATA dev_info_data;
 519     SP_DEVICE_INTERFACE_DATA dev_iface_data;
 520     HANDLE dev_file;
 521     int i;
 522     GuestPCIAddress *pci = NULL;
 523     bool partial_pci = false;
 524
 525     pci = g_malloc0(sizeof(*pci));
 526     pci->domain = -1;
 527     pci->slot = -1;
 528     pci->function = -1;
 529     pci->bus = -1;
 530
 531     dev_info = SetupDiGetClassDevs(&GUID_DEVINTERFACE_DISK, 0, 0,
 532                                    DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
 533     if (dev_info == INVALID_HANDLE_VALUE) {
 534         error_setg_win32(errp, GetLastError(), "failed to get devices tree");
 535         goto out;
 536     }
 537
 538     g_debug("enumerating devices");
 539     dev_info_data.cbSize = sizeof(SP_DEVINFO_DATA);
 540     dev_iface_data.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
 541     for (i = 0; SetupDiEnumDeviceInfo(dev_info, i, &dev_info_data); i++) {
 542         PSP_DEVICE_INTERFACE_DETAIL_DATA pdev_iface_detail_data = NULL;
 543         STORAGE_DEVICE_NUMBER sdn;
 544         char *parent_dev_id = NULL;
 545         HDEVINFO parent_dev_info;
 546         SP_DEVINFO_DATA parent_dev_info_data;
 547         DWORD j;
 548         DWORD size = 0;
 549
 550         g_debug("getting device path");
 551         if (SetupDiEnumDeviceInterfaces(dev_info, &dev_info_data,
 552                                         &GUID_DEVINTERFACE_DISK, 0,
 553                                         &dev_iface_data)) {
 554             while (!SetupDiGetDeviceInterfaceDetail(dev_info, &dev_iface_data,
 555                                                     pdev_iface_detail_data,
 556                                                     size, &size,
 557                                                     &dev_info_data)) {
 558                 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
 559                     pdev_iface_detail_data = g_malloc(size);
 560                     pdev_iface_detail_data->cbSize =
 561                         sizeof(*pdev_iface_detail_data);
 562                 } else {
 563                     error_setg_win32(errp, GetLastError(),
 564                                      "failed to get device interfaces");
 565                     goto free_dev_info;
 566                 }
 567             }
 568
 569             dev_file = CreateFile(pdev_iface_detail_data->DevicePath, 0,
 570                                   FILE_SHARE_READ, NULL, OPEN_EXISTING, 0,
 571                                   NULL);
 572             g_free(pdev_iface_detail_data);
 573
 574             if (!DeviceIoControl(dev_file, IOCTL_STORAGE_GET_DEVICE_NUMBER,
 575                                  NULL, 0, &sdn, sizeof(sdn), &size, NULL)) {
 576                 CloseHandle(dev_file);
 577                 error_setg_win32(errp, GetLastError(),
 578                                  "failed to get device slot number");
 579                 goto free_dev_info;
 580             }
 581
 582             CloseHandle(dev_file);
 583             if (sdn.DeviceNumber != number) {
 584                 continue;
 585             }
 586         } else {
 587             error_setg_win32(errp, GetLastError(),
 588                              "failed to get device interfaces");
 589             goto free_dev_info;
 590         }
 591
 592         g_debug("found device slot %d. Getting storage controller", number);
 593         {
 594             CONFIGRET cr;
 595             DEVINST dev_inst, parent_dev_inst;
 596             ULONG dev_id_size = 0;
 597
 598             size = 0;
 599             while (!SetupDiGetDeviceInstanceId(dev_info, &dev_info_data,
 600                                                parent_dev_id, size, &size)) {
 601                 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
 602                     parent_dev_id = g_malloc(size);
 603                 } else {
 604                     error_setg_win32(errp, GetLastError(),
 605                                      "failed to get device instance ID");
 606                     goto out;
 607                 }
 608             }
 609
 610             /*
 611              * CM API used here as opposed to
 612              * SetupDiGetDeviceProperty(..., DEVPKEY_Device_Parent, ...)
 613              * which exports are only available in mingw-w64 6+
 614              */
 615             cr = CM_Locate_DevInst(&dev_inst, parent_dev_id, 0);
 616             if (cr != CR_SUCCESS) {
 617                 g_error("CM_Locate_DevInst failed with code %lx", cr);
 618                 error_setg_win32(errp, GetLastError(),
 619                                  "failed to get device instance");
 620                 goto out;
 621             }
 622             cr = CM_Get_Parent(&parent_dev_inst, dev_inst, 0);
 623             if (cr != CR_SUCCESS) {
 624                 g_error("CM_Get_Parent failed with code %lx", cr);
 625                 error_setg_win32(errp, GetLastError(),
 626                                  "failed to get parent device instance");
 627                 goto out;
 628             }
 629
 630             cr = CM_Get_Device_ID_Size(&dev_id_size, parent_dev_inst, 0);
 631             if (cr != CR_SUCCESS) {
 632                 g_error("CM_Get_Device_ID_Size failed with code %lx", cr);
 633                 error_setg_win32(errp, GetLastError(),
 634                                  "failed to get parent device ID length");
 635                 goto out;
 636             }
 637
 638             ++dev_id_size;
 639             if (dev_id_size > size) {
 640                 g_free(parent_dev_id);
 641                 parent_dev_id = g_malloc(dev_id_size);
 642             }
 643
 644             cr = CM_Get_Device_ID(parent_dev_inst, parent_dev_id, dev_id_size,
 645                                   0);
 646             if (cr != CR_SUCCESS) {
 647                 g_error("CM_Get_Device_ID failed with code %lx", cr);
 648                 error_setg_win32(errp, GetLastError(),
 649                                  "failed to get parent device ID");
 650                 goto out;
 651             }
 652         }
 653
 654         g_debug("querying storage controller %s for PCI information",
 655                 parent_dev_id);
 656         parent_dev_info =
 657             SetupDiGetClassDevs(&GUID_DEVINTERFACE_STORAGEPORT, parent_dev_id,
 658                                 NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
 659         g_free(parent_dev_id);
 660
 661         if (parent_dev_info == INVALID_HANDLE_VALUE) {
 662             error_setg_win32(errp, GetLastError(),
 663                              "failed to get parent device");
 664             goto out;
 665         }
 666
 667         parent_dev_info_data.cbSize = sizeof(SP_DEVINFO_DATA);
 668         if (!SetupDiEnumDeviceInfo(parent_dev_info, 0, &parent_dev_info_data)) {
 669             error_setg_win32(errp, GetLastError(),
 670                            "failed to get parent device data");
 671             goto out;
 672         }
 673
 674         for (j = 0;
 675              SetupDiEnumDeviceInfo(parent_dev_info, j, &parent_dev_info_data);
 676              j++) {
 677             DWORD addr, bus, ui_slot, type;
 678             int func, slot;
 679
 680             /*
 681              * There is no need to allocate buffer in the next functions. The
 682              * size is known and ULONG according to
 683              * https://msdn.microsoft.com/en-us/library/windows/hardware/ff543095(v=vs.85).aspx
 684              */
 685             if (!SetupDiGetDeviceRegistryProperty(
 686                   parent_dev_info, &parent_dev_info_data, SPDRP_BUSNUMBER,
 687                   &type, (PBYTE)&bus, size, NULL)) {
 688                 debug_error("failed to get PCI bus");
 689                 bus = -1;
 690                 partial_pci = true;
 691             }
 692
 693             /*
 694              * The function retrieves the device's address. This value will be
 695              * transformed into device function and number
 696              */
 697             if (!SetupDiGetDeviceRegistryProperty(
 698                     parent_dev_info, &parent_dev_info_data, SPDRP_ADDRESS,
 699                     &type, (PBYTE)&addr, size, NULL)) {
 700                 debug_error("failed to get PCI address");
 701                 addr = -1;
 702                 partial_pci = true;
 703             }
 704
 705             /*
 706              * This call returns UINumber of DEVICE_CAPABILITIES structure.
 707              * This number is typically a user-perceived slot number.
 708              */
 709             if (!SetupDiGetDeviceRegistryProperty(
 710                     parent_dev_info, &parent_dev_info_data, SPDRP_UI_NUMBER,
 711                     &type, (PBYTE)&ui_slot, size, NULL)) {
 712                 debug_error("failed to get PCI slot");
 713                 ui_slot = -1;
 714                 partial_pci = true;
 715             }
 716
 717             /*
 718              * SetupApi gives us the same information as driver with
 719              * IoGetDeviceProperty. According to Microsoft:
 720              *
 721              *   FunctionNumber = (USHORT)((propertyAddress) & 0x0000FFFF)
 722              *   DeviceNumber = (USHORT)(((propertyAddress) >> 16) & 0x0000FFFF)
 723              *   SPDRP_ADDRESS is propertyAddress, so we do the same.
 724              *
 725              * https://docs.microsoft.com/en-us/windows/desktop/api/setupapi/nf-setupapi-setupdigetdeviceregistrypropertya
 726              */
 727             if (partial_pci) {
 728                 pci->domain = -1;
 729                 pci->slot = -1;
 730                 pci->function = -1;
 731                 pci->bus = -1;
 732                 continue;
 733             } else {
 734                 func = ((int)addr == -1) ? -1 : addr & 0x0000FFFF;
 735                 slot = ((int)addr == -1) ? -1 : (addr >> 16) & 0x0000FFFF;
 736                 if ((int)ui_slot != slot) {
 737                     g_debug("mismatch with reported slot values: %d vs %d",
 738                             (int)ui_slot, slot);
 739                 }
 740                 pci->domain = 0;
 741                 pci->slot = (int)ui_slot;
 742                 pci->function = func;
 743                 pci->bus = (int)bus;
 744                 break;
 745             }
 746         }
 747         SetupDiDestroyDeviceInfoList(parent_dev_info);
 748         break;
 749     }
 750
 751 free_dev_info:
 752     SetupDiDestroyDeviceInfoList(dev_info);
 753 out:
 754     return pci;
 755 }
 756
 757 static void get_disk_properties(HANDLE vol_h, GuestDiskAddress *disk,
 758     Error **errp)
 759 {
 760     STORAGE_PROPERTY_QUERY query;
 761     STORAGE_DEVICE_DESCRIPTOR *dev_desc, buf;
 762     DWORD received;
 763     ULONG size = sizeof(buf);
 764
 765     dev_desc = &buf;
 766     query.PropertyId = StorageDeviceProperty;
 767     query.QueryType = PropertyStandardQuery;
 768
 769     if (!DeviceIoControl(vol_h, IOCTL_STORAGE_QUERY_PROPERTY, &query,
 770                          sizeof(STORAGE_PROPERTY_QUERY), dev_desc,
 771                          size, &received, NULL)) {
 772         error_setg_win32(errp, GetLastError(), "failed to get bus type");
 773         return;
 774     }
 775     disk->bus_type = find_bus_type(dev_desc->BusType);
 776     g_debug("bus type %d", disk->bus_type);
 777
 778     /* Query once more. Now with long enough buffer. */
 779     size = dev_desc->Size;
 780     dev_desc = g_malloc0(size);
 781     if (!DeviceIoControl(vol_h, IOCTL_STORAGE_QUERY_PROPERTY, &query,
 782                          sizeof(STORAGE_PROPERTY_QUERY), dev_desc,
 783                          size, &received, NULL)) {
 784         error_setg_win32(errp, GetLastError(), "failed to get serial number");
 785         g_debug("failed to get serial number");
 786         goto out_free;
 787     }
 788     if (dev_desc->SerialNumberOffset > 0) {
 789         const char *serial;
 790         size_t len;
 791
 792         if (dev_desc->SerialNumberOffset >= received) {
 793             error_setg(errp, "failed to get serial number: offset outside the buffer");
 794             g_debug("serial number offset outside the buffer");
 795             goto out_free;
 796         }
 797         serial = (char *)dev_desc + dev_desc->SerialNumberOffset;
 798         len = received - dev_desc->SerialNumberOffset;
 799         g_debug("serial number \"%s\"", serial);
 800         if (*serial != 0) {
 801             disk->serial = g_strndup(serial, len);
 802             disk->has_serial = true;
 803         }
 804     }
 805 out_free:
 806     g_free(dev_desc);
 807
 808     return;
 809 }
 810
 811 static void get_single_disk_info(int disk_number,
 812                                  GuestDiskAddress *disk, Error **errp)
 813 {
 814     SCSI_ADDRESS addr, *scsi_ad;
 815     DWORD len;
 816     HANDLE disk_h;
 817     Error *local_err = NULL;
 818
 819     scsi_ad = &addr;
 820
 821     g_debug("getting disk info for: %s", disk->dev);
 822     disk_h = CreateFile(disk->dev, 0, FILE_SHARE_READ, NULL, OPEN_EXISTING,
 823                        0, NULL);
 824     if (disk_h == INVALID_HANDLE_VALUE) {
 825         error_setg_win32(errp, GetLastError(), "failed to open disk");
 826         return;
 827     }
 828
 829     get_disk_properties(disk_h, disk, &local_err);
 830     if (local_err) {
 831         error_propagate(errp, local_err);
 832         goto err_close;
 833     }
 834
 835     g_debug("bus type %d", disk->bus_type);
 836     /* always set pci_controller as required by schema. get_pci_info() should
 837      * report -1 values for non-PCI buses rather than fail. fail the command
 838      * if that doesn't hold since that suggests some other unexpected
 839      * breakage
 840      */
 841     disk->pci_controller = get_pci_info(disk_number, &local_err);
 842     if (local_err) {
 843         error_propagate(errp, local_err);
 844         goto err_close;
 845     }
 846     if (disk->bus_type == GUEST_DISK_BUS_TYPE_SCSI
 847             || disk->bus_type == GUEST_DISK_BUS_TYPE_IDE
 848             || disk->bus_type == GUEST_DISK_BUS_TYPE_RAID
 849             /* This bus type is not supported before Windows Server 2003 SP1 */
 850             || disk->bus_type == GUEST_DISK_BUS_TYPE_SAS
 851         ) {
 852         /* We are able to use the same ioctls for different bus types
 853          * according to Microsoft docs
 854          * https://technet.microsoft.com/en-us/library/ee851589(v=ws.10).aspx */
 855         g_debug("getting SCSI info");
 856         if (DeviceIoControl(disk_h, IOCTL_SCSI_GET_ADDRESS, NULL, 0, scsi_ad,
 857                             sizeof(SCSI_ADDRESS), &len, NULL)) {
 858             disk->unit = addr.Lun;
 859             disk->target = addr.TargetId;
 860             disk->bus = addr.PathId;
 861         }
 862         /* We do not set error in this case, because we still have enough
 863          * information about volume. */
 864     }
 865
 866 err_close:
 867     CloseHandle(disk_h);
 868     return;
 869 }
 870
 871 /* VSS provider works with volumes, thus there is no difference if
 872  * the volume consist of spanned disks. Info about the first disk in the
 873  * volume is returned for the spanned disk group (LVM) */
 874 static GuestDiskAddressList *build_guest_disk_info(char *guid, Error **errp)
 875 {
 876     Error *local_err = NULL;
 877     GuestDiskAddressList *list = NULL;
 878     GuestDiskAddress *disk = NULL;
 879     int i;
 880     HANDLE vol_h;
 881     DWORD size;
 882     PVOLUME_DISK_EXTENTS extents = NULL;
 883
 884     /* strip final backslash */
 885     char *name = g_strdup(guid);
 886     if (g_str_has_suffix(name, "\\")) {
 887         name[strlen(name) - 1] = 0;
 888     }
 889
 890     g_debug("opening %s", name);
 891     vol_h = CreateFile(name, 0, FILE_SHARE_READ, NULL, OPEN_EXISTING,
 892                        0, NULL);
 893     if (vol_h == INVALID_HANDLE_VALUE) {
 894         error_setg_win32(errp, GetLastError(), "failed to open volume");
 895         goto out;
 896     }
 897
 898     /* Get list of extents */
 899     g_debug("getting disk extents");
 900     size = sizeof(VOLUME_DISK_EXTENTS);
 901     extents = g_malloc0(size);
 902     if (!DeviceIoControl(vol_h, IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS, NULL,
 903                          0, extents, size, &size, NULL)) {
 904         DWORD last_err = GetLastError();
 905         if (last_err == ERROR_MORE_DATA) {
 906             /* Try once more with big enough buffer */
 907             g_free(extents);
 908             extents = g_malloc0(size);
 909             if (!DeviceIoControl(
 910                     vol_h, IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS, NULL,
 911                     0, extents, size, NULL, NULL)) {
 912                 error_setg_win32(errp, GetLastError(),
 913                     "failed to get disk extents");
 914                 goto out;
 915             }
 916         } else if (last_err == ERROR_INVALID_FUNCTION) {
 917             /* Possibly CD-ROM or a shared drive. Try to pass the volume */
 918             g_debug("volume not on disk");
 919             disk = g_malloc0(sizeof(GuestDiskAddress));
 920             disk->has_dev = true;
 921             disk->dev = g_strdup(name);
 922             get_single_disk_info(0xffffffff, disk, &local_err);
 923             if (local_err) {
 924                 g_debug("failed to get disk info, ignoring error: %s",
 925                     error_get_pretty(local_err));
 926                 error_free(local_err);
 927                 goto out;
 928             }
 929             QAPI_LIST_PREPEND(list, disk);
 930             disk = NULL;
 931             goto out;
 932         } else {
 933             error_setg_win32(errp, GetLastError(),
 934                 "failed to get disk extents");
 935             goto out;
 936         }
 937     }
 938     g_debug("Number of extents: %lu", extents->NumberOfDiskExtents);
 939
 940     /* Go through each extent */
 941     for (i = 0; i < extents->NumberOfDiskExtents; i++) {
 942         disk = g_malloc0(sizeof(GuestDiskAddress));
 943
 944         /* Disk numbers directly correspond to numbers used in UNCs
 945          *
 946          * See documentation for DISK_EXTENT:
 947          * https://docs.microsoft.com/en-us/windows/desktop/api/winioctl/ns-winioctl-_disk_extent
 948          *
 949          * See also Naming Files, Paths and Namespaces:
 950          * https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#win32-device-namespaces
 951          */
 952         disk->has_dev = true;
 953         disk->dev = g_strdup_printf("\\\\.\\PhysicalDrive%lu",
 954                                     extents->Extents[i].DiskNumber);
 955
 956         get_single_disk_info(extents->Extents[i].DiskNumber, disk, &local_err);
 957         if (local_err) {
 958             error_propagate(errp, local_err);
 959             goto out;
 960         }
 961         QAPI_LIST_PREPEND(list, disk);
 962         disk = NULL;
 963     }
 964
 965
 966 out:
 967     if (vol_h != INVALID_HANDLE_VALUE) {
 968         CloseHandle(vol_h);
 969     }
 970     qapi_free_GuestDiskAddress(disk);
 971     g_free(extents);
 972     g_free(name);
 973
 974     return list;
 975 }
 976
 977 GuestDiskInfoList *qmp_guest_get_disks(Error **errp)
 978 {
 979     ERRP_GUARD();
 980     GuestDiskInfoList *ret = NULL;
 981     HDEVINFO dev_info;
 982     SP_DEVICE_INTERFACE_DATA dev_iface_data;
 983     int i;
 984
 985     dev_info = SetupDiGetClassDevs(&GUID_DEVINTERFACE_DISK, 0, 0,
 986         DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
 987     if (dev_info == INVALID_HANDLE_VALUE) {
 988         error_setg_win32(errp, GetLastError(), "failed to get device tree");
 989         return NULL;
 990     }
 991
 992     g_debug("enumerating devices");
 993     dev_iface_data.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
 994     for (i = 0;
 995         SetupDiEnumDeviceInterfaces(dev_info, NULL, &GUID_DEVINTERFACE_DISK,
 996             i, &dev_iface_data);
 997         i++) {
 998         GuestDiskAddress *address = NULL;
 999         GuestDiskInfo *disk = NULL;
1000         Error *local_err = NULL;
1001         g_autofree PSP_DEVICE_INTERFACE_DETAIL_DATA
1002             pdev_iface_detail_data = NULL;
1003         STORAGE_DEVICE_NUMBER sdn;
1004         HANDLE dev_file;
1005         DWORD size = 0;
1006         BOOL result;
1007         int attempt;
1008
1009         g_debug("  getting device path");
1010         for (attempt = 0, result = FALSE; attempt < 2 && !result; attempt++) {
1011             result = SetupDiGetDeviceInterfaceDetail(dev_info,
1012                 &dev_iface_data, pdev_iface_detail_data, size, &size, NULL);
1013             if (result) {
1014                 break;
1015             }
1016             if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
1017                 pdev_iface_detail_data = g_realloc(pdev_iface_detail_data,
1018                     size);
1019                 pdev_iface_detail_data->cbSize =
1020                     sizeof(*pdev_iface_detail_data);
1021             } else {
1022                 g_debug("failed to get device interface details");
1023                 break;
1024             }
1025         }
1026         if (!result) {
1027             g_debug("skipping device");
1028             continue;
1029         }
1030
1031         g_debug("  device: %s", pdev_iface_detail_data->DevicePath);
1032         dev_file = CreateFile(pdev_iface_detail_data->DevicePath, 0,
1033             FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
1034         if (!DeviceIoControl(dev_file, IOCTL_STORAGE_GET_DEVICE_NUMBER,
1035                 NULL, 0, &sdn, sizeof(sdn), &size, NULL)) {
1036             CloseHandle(dev_file);
1037             debug_error("failed to get storage device number");
1038             continue;
1039         }
1040         CloseHandle(dev_file);
1041
1042         disk = g_new0(GuestDiskInfo, 1);
1043         disk->name = g_strdup_printf("\\\\.\\PhysicalDrive%lu",
1044             sdn.DeviceNumber);
1045
1046         g_debug("  number: %lu", sdn.DeviceNumber);
1047         address = g_malloc0(sizeof(GuestDiskAddress));
1048         address->has_dev = true;
1049         address->dev = g_strdup(disk->name);
1050         get_single_disk_info(sdn.DeviceNumber, address, &local_err);
1051         if (local_err) {
1052             g_debug("failed to get disk info: %s",
1053                 error_get_pretty(local_err));
1054             error_free(local_err);
1055             qapi_free_GuestDiskAddress(address);
1056             address = NULL;
1057         } else {
1058             disk->address = address;
1059             disk->has_address = true;
1060         }
1061
1062         QAPI_LIST_PREPEND(ret, disk);
1063     }
1064
1065     SetupDiDestroyDeviceInfoList(dev_info);
1066     return ret;
1067 }
1068
1069 #else
1070
1071 static GuestDiskAddressList *build_guest_disk_info(char *guid, Error **errp)
1072 {
1073     return NULL;
1074 }
1075
1076 GuestDiskInfoList *qmp_guest_get_disks(Error **errp)
1077 {
1078     error_setg(errp, QERR_UNSUPPORTED);
1079     return NULL;
1080 }
1081
1082 #endif /* CONFIG_QGA_NTDDSCSI */
1083
1084 static GuestFilesystemInfo *build_guest_fsinfo(char *guid, Error **errp)
1085 {
1086     DWORD info_size;
1087     char mnt, *mnt_point;
1088     wchar_t wfs_name[32];
1089     char fs_name[32];
1090     wchar_t vol_info[MAX_PATH + 1];
1091     size_t len;
1092     uint64_t i64FreeBytesToCaller, i64TotalBytes, i64FreeBytes;
1093     GuestFilesystemInfo *fs = NULL;
1094     HANDLE hLocalDiskHandle = INVALID_HANDLE_VALUE;
1095
1096     GetVolumePathNamesForVolumeName(guid, (LPCH)&mnt, 0, &info_size);
1097     if (GetLastError() != ERROR_MORE_DATA) {
1098         error_setg_win32(errp, GetLastError(), "failed to get volume name");
1099         return NULL;
1100     }
1101
1102     mnt_point = g_malloc(info_size + 1);
1103     if (!GetVolumePathNamesForVolumeName(guid, mnt_point, info_size,
1104                                          &info_size)) {
1105         error_setg_win32(errp, GetLastError(), "failed to get volume name");
1106         goto free;
1107     }
1108
1109     hLocalDiskHandle = CreateFile(guid, 0 , 0, NULL, OPEN_EXISTING,
1110                                   FILE_ATTRIBUTE_NORMAL |
1111                                   FILE_FLAG_BACKUP_SEMANTICS, NULL);
1112     if (INVALID_HANDLE_VALUE == hLocalDiskHandle) {
1113         error_setg_win32(errp, GetLastError(), "failed to get handle for volume");
1114         goto free;
1115     }
1116
1117     len = strlen(mnt_point);
1118     mnt_point[len] = '\\';
1119     mnt_point[len + 1] = 0;
1120
1121     if (!GetVolumeInformationByHandleW(hLocalDiskHandle, vol_info,
1122                                        sizeof(vol_info), NULL, NULL, NULL,
1123                                        (LPWSTR) & wfs_name, sizeof(wfs_name))) {
1124         if (GetLastError() != ERROR_NOT_READY) {
1125             error_setg_win32(errp, GetLastError(), "failed to get volume info");
1126         }
1127         goto free;
1128     }
1129
1130     fs = g_malloc(sizeof(*fs));
1131     fs->name = g_strdup(guid);
1132     fs->has_total_bytes = false;
1133     fs->has_used_bytes = false;
1134     if (len == 0) {
1135         fs->mountpoint = g_strdup("System Reserved");
1136     } else {
1137         fs->mountpoint = g_strndup(mnt_point, len);
1138         if (GetDiskFreeSpaceEx(fs->mountpoint,
1139                                (PULARGE_INTEGER) & i64FreeBytesToCaller,
1140                                (PULARGE_INTEGER) & i64TotalBytes,
1141                                (PULARGE_INTEGER) & i64FreeBytes)) {
1142             fs->used_bytes = i64TotalBytes - i64FreeBytes;
1143             fs->total_bytes = i64TotalBytes;
1144             fs->has_total_bytes = true;
1145             fs->has_used_bytes = true;
1146         }
1147     }
1148     wcstombs(fs_name, wfs_name, sizeof(wfs_name));
1149     fs->type = g_strdup(fs_name);
1150     fs->disk = build_guest_disk_info(guid, errp);
1151 free:
1152     if (hLocalDiskHandle != INVALID_HANDLE_VALUE) {
1153         CloseHandle(hLocalDiskHandle);
1154     }
1155     g_free(mnt_point);
1156     return fs;
1157 }
1158
1159 GuestFilesystemInfoList *qmp_guest_get_fsinfo(Error **errp)
1160 {
1161     HANDLE vol_h;
1162     GuestFilesystemInfoList *ret = NULL;
1163     char guid[256];
1164
1165     vol_h = FindFirstVolume(guid, sizeof(guid));
1166     if (vol_h == INVALID_HANDLE_VALUE) {
1167         error_setg_win32(errp, GetLastError(), "failed to find any volume");
1168         return NULL;
1169     }
1170
1171     do {
1172         Error *local_err = NULL;
1173         GuestFilesystemInfo *info = build_guest_fsinfo(guid, &local_err);
1174         if (local_err) {
1175             g_debug("failed to get filesystem info, ignoring error: %s",
1176                     error_get_pretty(local_err));
1177             error_free(local_err);
1178             continue;
1179         }
1180         QAPI_LIST_PREPEND(ret, info);
1181     } while (FindNextVolume(vol_h, guid, sizeof(guid)));
1182
1183     if (GetLastError() != ERROR_NO_MORE_FILES) {
1184         error_setg_win32(errp, GetLastError(), "failed to find next volume");
1185     }
1186
1187     FindVolumeClose(vol_h);
1188     return ret;
1189 }
1190
1191 /*
1192  * Return status of freeze/thaw
1193  */
1194 GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **errp)
1195 {
1196     if (!vss_initialized()) {
1197         error_setg(errp, QERR_UNSUPPORTED);
1198         return 0;
1199     }
1200
1201     if (ga_is_frozen(ga_state)) {
1202         return GUEST_FSFREEZE_STATUS_FROZEN;
1203     }
1204
1205     return GUEST_FSFREEZE_STATUS_THAWED;
1206 }
1207
1208 /*
1209  * Freeze local file systems using Volume Shadow-copy Service.
1210  * The frozen state is limited for up to 10 seconds by VSS.
1211  */
1212 int64_t qmp_guest_fsfreeze_freeze(Error **errp)
1213 {
1214     return qmp_guest_fsfreeze_freeze_list(false, NULL, errp);
1215 }
1216
1217 int64_t qmp_guest_fsfreeze_freeze_list(bool has_mountpoints,
1218                                        strList *mountpoints,
1219                                        Error **errp)
1220 {
1221     int i;
1222     Error *local_err = NULL;
1223
1224     if (!vss_initialized()) {
1225         error_setg(errp, QERR_UNSUPPORTED);
1226         return 0;
1227     }
1228
1229     slog("guest-fsfreeze called");
1230
1231     /* cannot risk guest agent blocking itself on a write in this state */
1232     ga_set_frozen(ga_state);
1233
1234     qga_vss_fsfreeze(&i, true, mountpoints, &local_err);
1235     if (local_err) {
1236         error_propagate(errp, local_err);
1237         goto error;
1238     }
1239
1240     return i;
1241
1242 error:
1243     local_err = NULL;
1244     qmp_guest_fsfreeze_thaw(&local_err);
1245     if (local_err) {
1246         g_debug("cleanup thaw: %s", error_get_pretty(local_err));
1247         error_free(local_err);
1248     }
1249     return 0;
1250 }
1251
1252 /*
1253  * Thaw local file systems using Volume Shadow-copy Service.
1254  */
1255 int64_t qmp_guest_fsfreeze_thaw(Error **errp)
1256 {
1257     int i;
1258
1259     if (!vss_initialized()) {
1260         error_setg(errp, QERR_UNSUPPORTED);
1261         return 0;
1262     }
1263
1264     qga_vss_fsfreeze(&i, false, NULL, errp);
1265
1266     ga_unset_frozen(ga_state);
1267     return i;
1268 }
1269
1270 static void guest_fsfreeze_cleanup(void)
1271 {
1272     Error *err = NULL;
1273
1274     if (!vss_initialized()) {
1275         return;
1276     }
1277
1278     if (ga_is_frozen(ga_state) == GUEST_FSFREEZE_STATUS_FROZEN) {
1279         qmp_guest_fsfreeze_thaw(&err);
1280         if (err) {
1281             slog("failed to clean up frozen filesystems: %s",
1282                  error_get_pretty(err));
1283             error_free(err);
1284         }
1285     }
1286
1287     vss_deinit(true);
1288 }
1289
1290 /*
1291  * Walk list of mounted file systems in the guest, and discard unused
1292  * areas.
1293  */
1294 GuestFilesystemTrimResponse *
1295 qmp_guest_fstrim(bool has_minimum, int64_t minimum, Error **errp)
1296 {
1297     GuestFilesystemTrimResponse *resp;
1298     HANDLE handle;
1299     WCHAR guid[MAX_PATH] = L"";
1300     OSVERSIONINFO osvi;
1301     BOOL win8_or_later;
1302
1303     ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
1304     osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
1305     GetVersionEx(&osvi);
1306     win8_or_later = (osvi.dwMajorVersion > 6 ||
1307                           ((osvi.dwMajorVersion == 6) &&
1308                            (osvi.dwMinorVersion >= 2)));
1309     if (!win8_or_later) {
1310         error_setg(errp, "fstrim is only supported for Win8+");
1311         return NULL;
1312     }
1313
1314     handle = FindFirstVolumeW(guid, ARRAYSIZE(guid));
1315     if (handle == INVALID_HANDLE_VALUE) {
1316         error_setg_win32(errp, GetLastError(), "failed to find any volume");
1317         return NULL;
1318     }
1319
1320     resp = g_new0(GuestFilesystemTrimResponse, 1);
1321
1322     do {
1323         GuestFilesystemTrimResult *res;
1324         PWCHAR uc_path;
1325         DWORD char_count = 0;
1326         char *path, *out;
1327         GError *gerr = NULL;
1328         gchar *argv[4];
1329
1330         GetVolumePathNamesForVolumeNameW(guid, NULL, 0, &char_count);
1331
1332         if (GetLastError() != ERROR_MORE_DATA) {
1333             continue;
1334         }
1335         if (GetDriveTypeW(guid) != DRIVE_FIXED) {
1336             continue;
1337         }
1338
1339         uc_path = g_malloc(sizeof(WCHAR) * char_count);
1340         if (!GetVolumePathNamesForVolumeNameW(guid, uc_path, char_count,
1341                                               &char_count) || !*uc_path) {
1342             /* strange, but this condition could be faced even with size == 2 */
1343             g_free(uc_path);
1344             continue;
1345         }
1346
1347         res = g_new0(GuestFilesystemTrimResult, 1);
1348
1349         path = g_utf16_to_utf8(uc_path, char_count, NULL, NULL, &gerr);
1350
1351         g_free(uc_path);
1352
1353         if (!path) {
1354             res->has_error = true;
1355             res->error = g_strdup(gerr->message);
1356             g_error_free(gerr);
1357             break;
1358         }
1359
1360         res->path = path;
1361
1362         QAPI_LIST_PREPEND(resp->paths, res);
1363
1364         memset(argv, 0, sizeof(argv));
1365         argv[0] = (gchar *)"defrag.exe";
1366         argv[1] = (gchar *)"/L";
1367         argv[2] = path;
1368
1369         if (!g_spawn_sync(NULL, argv, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL,
1370                           &out /* stdout */, NULL /* stdin */,
1371                           NULL, &gerr)) {
1372             res->has_error = true;
1373             res->error = g_strdup(gerr->message);
1374             g_error_free(gerr);
1375         } else {
1376             /* defrag.exe is UGLY. Exit code is ALWAYS zero.
1377                Error is reported in the output with something like
1378                (x89000020) etc code in the stdout */
1379
1380             int i;
1381             gchar **lines = g_strsplit(out, "\r\n", 0);
1382             g_free(out);
1383
1384             for (i = 0; lines[i] != NULL; i++) {
1385                 if (g_strstr_len(lines[i], -1, "(0x") == NULL) {
1386                     continue;
1387                 }
1388                 res->has_error = true;
1389                 res->error = g_strdup(lines[i]);
1390                 break;
1391             }
1392             g_strfreev(lines);
1393         }
1394     } while (FindNextVolumeW(handle, guid, ARRAYSIZE(guid)));
1395
1396     FindVolumeClose(handle);
1397     return resp;
1398 }
1399
1400 typedef enum {
1401     GUEST_SUSPEND_MODE_DISK,
1402     GUEST_SUSPEND_MODE_RAM
1403 } GuestSuspendMode;
1404
1405 static void check_suspend_mode(GuestSuspendMode mode, Error **errp)
1406 {
1407     SYSTEM_POWER_CAPABILITIES sys_pwr_caps;
1408
1409     ZeroMemory(&sys_pwr_caps, sizeof(sys_pwr_caps));
1410     if (!GetPwrCapabilities(&sys_pwr_caps)) {
1411         error_setg(errp, QERR_QGA_COMMAND_FAILED,
1412                    "failed to determine guest suspend capabilities");
1413         return;
1414     }
1415
1416     switch (mode) {
1417     case GUEST_SUSPEND_MODE_DISK:
1418         if (!sys_pwr_caps.SystemS4) {
1419             error_setg(errp, QERR_QGA_COMMAND_FAILED,
1420                        "suspend-to-disk not supported by OS");
1421         }
1422         break;
1423     case GUEST_SUSPEND_MODE_RAM:
1424         if (!sys_pwr_caps.SystemS3) {
1425             error_setg(errp, QERR_QGA_COMMAND_FAILED,
1426                        "suspend-to-ram not supported by OS");
1427         }
1428         break;
1429     default:
1430         abort();
1431     }
1432 }
1433
1434 static DWORD WINAPI do_suspend(LPVOID opaque)
1435 {
1436     GuestSuspendMode *mode = opaque;
1437     DWORD ret = 0;
1438
1439     if (!SetSuspendState(*mode == GUEST_SUSPEND_MODE_DISK, TRUE, TRUE)) {
1440         g_autofree gchar *emsg = g_win32_error_message(GetLastError());
1441         slog("failed to suspend guest: %s", emsg);
1442         ret = -1;
1443     }
1444     g_free(mode);
1445     return ret;
1446 }
1447
1448 void qmp_guest_suspend_disk(Error **errp)
1449 {
1450     Error *local_err = NULL;
1451     GuestSuspendMode *mode = g_new(GuestSuspendMode, 1);
1452
1453     *mode = GUEST_SUSPEND_MODE_DISK;
1454     check_suspend_mode(*mode, &local_err);
1455     if (local_err) {
1456         goto out;
1457     }
1458     acquire_privilege(SE_SHUTDOWN_NAME, &local_err);
1459     if (local_err) {
1460         goto out;
1461     }
1462     execute_async(do_suspend, mode, &local_err);
1463
1464 out:
1465     if (local_err) {
1466         error_propagate(errp, local_err);
1467         g_free(mode);
1468     }
1469 }
1470
1471 void qmp_guest_suspend_ram(Error **errp)
1472 {
1473     Error *local_err = NULL;
1474     GuestSuspendMode *mode = g_new(GuestSuspendMode, 1);
1475
1476     *mode = GUEST_SUSPEND_MODE_RAM;
1477     check_suspend_mode(*mode, &local_err);
1478     if (local_err) {
1479         goto out;
1480     }
1481     acquire_privilege(SE_SHUTDOWN_NAME, &local_err);
1482     if (local_err) {
1483         goto out;
1484     }
1485     execute_async(do_suspend, mode, &local_err);
1486
1487 out:
1488     if (local_err) {
1489         error_propagate(errp, local_err);
1490         g_free(mode);
1491     }
1492 }
1493
1494 void qmp_guest_suspend_hybrid(Error **errp)
1495 {
1496     error_setg(errp, QERR_UNSUPPORTED);
1497 }
1498
1499 static IP_ADAPTER_ADDRESSES *guest_get_adapters_addresses(Error **errp)
1500 {
1501     IP_ADAPTER_ADDRESSES *adptr_addrs = NULL;
1502     ULONG adptr_addrs_len = 0;
1503     DWORD ret;
1504
1505     /* Call the first time to get the adptr_addrs_len. */
1506     GetAdaptersAddresses(AF_UNSPEC, GAA_FLAG_INCLUDE_PREFIX,
1507                          NULL, adptr_addrs, &adptr_addrs_len);
1508
1509     adptr_addrs = g_malloc(adptr_addrs_len);
1510     ret = GetAdaptersAddresses(AF_UNSPEC, GAA_FLAG_INCLUDE_PREFIX,
1511                                NULL, adptr_addrs, &adptr_addrs_len);
1512     if (ret != ERROR_SUCCESS) {
1513         error_setg_win32(errp, ret, "failed to get adapters addresses");
1514         g_free(adptr_addrs);
1515         adptr_addrs = NULL;
1516     }
1517     return adptr_addrs;
1518 }
1519
1520 static char *guest_wctomb_dup(WCHAR *wstr)
1521 {
1522     char *str;
1523     size_t str_size;
1524
1525     str_size = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL);
1526     /* add 1 to str_size for NULL terminator */
1527     str = g_malloc(str_size + 1);
1528     WideCharToMultiByte(CP_UTF8, 0, wstr, -1, str, str_size, NULL, NULL);
1529     return str;
1530 }
1531
1532 static char *guest_addr_to_str(IP_ADAPTER_UNICAST_ADDRESS *ip_addr,
1533                                Error **errp)
1534 {
1535     char addr_str[INET6_ADDRSTRLEN + INET_ADDRSTRLEN];
1536     DWORD len;
1537     int ret;
1538
1539     if (ip_addr->Address.lpSockaddr->sa_family == AF_INET ||
1540             ip_addr->Address.lpSockaddr->sa_family == AF_INET6) {
1541         len = sizeof(addr_str);
1542         ret = WSAAddressToString(ip_addr->Address.lpSockaddr,
1543                                  ip_addr->Address.iSockaddrLength,
1544                                  NULL,
1545                                  addr_str,
1546                                  &len);
1547         if (ret != 0) {
1548             error_setg_win32(errp, WSAGetLastError(),
1549                 "failed address presentation form conversion");
1550             return NULL;
1551         }
1552         return g_strdup(addr_str);
1553     }
1554     return NULL;
1555 }
1556
1557 static int64_t guest_ip_prefix(IP_ADAPTER_UNICAST_ADDRESS *ip_addr)
1558 {
1559     /* For Windows Vista/2008 and newer, use the OnLinkPrefixLength
1560      * field to obtain the prefix.
1561      */
1562     return ip_addr->OnLinkPrefixLength;
1563 }
1564
1565 #define INTERFACE_PATH_BUF_SZ 512
1566
1567 static DWORD get_interface_index(const char *guid)
1568 {
1569     ULONG index;
1570     DWORD status;
1571     wchar_t wbuf[INTERFACE_PATH_BUF_SZ];
1572     snwprintf(wbuf, INTERFACE_PATH_BUF_SZ, L"\\device\\tcpip_%s", guid);
1573     wbuf[INTERFACE_PATH_BUF_SZ - 1] = 0;
1574     status = GetAdapterIndex (wbuf, &index);
1575     if (status != NO_ERROR) {
1576         return (DWORD)~0;
1577     } else {
1578         return index;
1579     }
1580 }
1581
1582 typedef NETIOAPI_API (WINAPI *GetIfEntry2Func)(PMIB_IF_ROW2 Row);
1583
1584 static int guest_get_network_stats(const char *name,
1585                                    GuestNetworkInterfaceStat *stats)
1586 {
1587     OSVERSIONINFO os_ver;
1588
1589     os_ver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
1590     GetVersionEx(&os_ver);
1591     if (os_ver.dwMajorVersion >= 6) {
1592         MIB_IF_ROW2 a_mid_ifrow;
1593         GetIfEntry2Func getifentry2_ex;
1594         DWORD if_index = 0;
1595         HMODULE module = GetModuleHandle("iphlpapi");
1596         PVOID func = GetProcAddress(module, "GetIfEntry2");
1597
1598         if (func == NULL) {
1599             return -1;
1600         }
1601
1602         getifentry2_ex = (GetIfEntry2Func)func;
1603         if_index = get_interface_index(name);
1604         if (if_index == (DWORD)~0) {
1605             return -1;
1606         }
1607
1608         memset(&a_mid_ifrow, 0, sizeof(a_mid_ifrow));
1609         a_mid_ifrow.InterfaceIndex = if_index;
1610         if (NO_ERROR == getifentry2_ex(&a_mid_ifrow)) {
1611             stats->rx_bytes = a_mid_ifrow.InOctets;
1612             stats->rx_packets = a_mid_ifrow.InUcastPkts;
1613             stats->rx_errs = a_mid_ifrow.InErrors;
1614             stats->rx_dropped = a_mid_ifrow.InDiscards;
1615             stats->tx_bytes = a_mid_ifrow.OutOctets;
1616             stats->tx_packets = a_mid_ifrow.OutUcastPkts;
1617             stats->tx_errs = a_mid_ifrow.OutErrors;
1618             stats->tx_dropped = a_mid_ifrow.OutDiscards;
1619             return 0;
1620         }
1621     }
1622     return -1;
1623 }
1624
1625 GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp)
1626 {
1627     IP_ADAPTER_ADDRESSES *adptr_addrs, *addr;
1628     IP_ADAPTER_UNICAST_ADDRESS *ip_addr = NULL;
1629     GuestNetworkInterfaceList *head = NULL, **tail = &head;
1630     GuestIpAddressList *head_addr, **tail_addr;
1631     GuestNetworkInterface *info;
1632     GuestNetworkInterfaceStat *interface_stat = NULL;
1633     GuestIpAddress *address_item = NULL;
1634     unsigned char *mac_addr;
1635     char *addr_str;
1636     WORD wsa_version;
1637     WSADATA wsa_data;
1638     int ret;
1639
1640     adptr_addrs = guest_get_adapters_addresses(errp);
1641     if (adptr_addrs == NULL) {
1642         return NULL;
1643     }
1644
1645     /* Make WSA APIs available. */
1646     wsa_version = MAKEWORD(2, 2);
1647     ret = WSAStartup(wsa_version, &wsa_data);
1648     if (ret != 0) {
1649         error_setg_win32(errp, ret, "failed socket startup");
1650         goto out;
1651     }
1652
1653     for (addr = adptr_addrs; addr; addr = addr->Next) {
1654         info = g_malloc0(sizeof(*info));
1655
1656         QAPI_LIST_APPEND(tail, info);
1657
1658         info->name = guest_wctomb_dup(addr->FriendlyName);
1659
1660         if (addr->PhysicalAddressLength != 0) {
1661             mac_addr = addr->PhysicalAddress;
1662
1663             info->hardware_address =
1664                 g_strdup_printf("%02x:%02x:%02x:%02x:%02x:%02x",
1665                                 (int) mac_addr[0], (int) mac_addr[1],
1666                                 (int) mac_addr[2], (int) mac_addr[3],
1667                                 (int) mac_addr[4], (int) mac_addr[5]);
1668
1669             info->has_hardware_address = true;
1670         }
1671
1672         head_addr = NULL;
1673         tail_addr = &head_addr;
1674         for (ip_addr = addr->FirstUnicastAddress;
1675                 ip_addr;
1676                 ip_addr = ip_addr->Next) {
1677             addr_str = guest_addr_to_str(ip_addr, errp);
1678             if (addr_str == NULL) {
1679                 continue;
1680             }
1681
1682             address_item = g_malloc0(sizeof(*address_item));
1683
1684             QAPI_LIST_APPEND(tail_addr, address_item);
1685
1686             address_item->ip_address = addr_str;
1687             address_item->prefix = guest_ip_prefix(ip_addr);
1688             if (ip_addr->Address.lpSockaddr->sa_family == AF_INET) {
1689                 address_item->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV4;
1690             } else if (ip_addr->Address.lpSockaddr->sa_family == AF_INET6) {
1691                 address_item->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV6;
1692             }
1693         }
1694         if (head_addr) {
1695             info->has_ip_addresses = true;
1696             info->ip_addresses = head_addr;
1697         }
1698         if (!info->has_statistics) {
1699             interface_stat = g_malloc0(sizeof(*interface_stat));
1700             if (guest_get_network_stats(addr->AdapterName,
1701                 interface_stat) == -1) {
1702                 info->has_statistics = false;
1703                 g_free(interface_stat);
1704             } else {
1705                 info->statistics = interface_stat;
1706                 info->has_statistics = true;
1707             }
1708         }
1709     }
1710     WSACleanup();
1711 out:
1712     g_free(adptr_addrs);
1713     return head;
1714 }
1715
1716 static int64_t filetime_to_ns(const FILETIME *tf)
1717 {
1718     return ((((int64_t)tf->dwHighDateTime << 32) | tf->dwLowDateTime)
1719             - W32_FT_OFFSET) * 100;
1720 }
1721
1722 int64_t qmp_guest_get_time(Error **errp)
1723 {
1724     SYSTEMTIME ts = {0};
1725     FILETIME tf;
1726
1727     GetSystemTime(&ts);
1728     if (ts.wYear < 1601 || ts.wYear > 30827) {
1729         error_setg(errp, "Failed to get time");
1730         return -1;
1731     }
1732
1733     if (!SystemTimeToFileTime(&ts, &tf)) {
1734         error_setg(errp, "Failed to convert system time: %d", (int)GetLastError());
1735         return -1;
1736     }
1737
1738     return filetime_to_ns(&tf);
1739 }
1740
1741 void qmp_guest_set_time(bool has_time, int64_t time_ns, Error **errp)
1742 {
1743     Error *local_err = NULL;
1744     SYSTEMTIME ts;
1745     FILETIME tf;
1746     LONGLONG time;
1747
1748     if (!has_time) {
1749         /* Unfortunately, Windows libraries don't provide an easy way to access
1750          * RTC yet:
1751          *
1752          * https://msdn.microsoft.com/en-us/library/aa908981.aspx
1753          *
1754          * Instead, a workaround is to use the Windows win32tm command to
1755          * resync the time using the Windows Time service.
1756          */
1757         LPVOID msg_buffer;
1758         DWORD ret_flags;
1759
1760         HRESULT hr = system("w32tm /resync /nowait");
1761
1762         if (GetLastError() != 0) {
1763             strerror_s((LPTSTR) & msg_buffer, 0, errno);
1764             error_setg(errp, "system(...) failed: %s", (LPCTSTR)msg_buffer);
1765         } else if (hr != 0) {
1766             if (hr == HRESULT_FROM_WIN32(ERROR_SERVICE_NOT_ACTIVE)) {
1767                 error_setg(errp, "Windows Time service not running on the "
1768                                  "guest");
1769             } else {
1770                 if (!FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
1771                                    FORMAT_MESSAGE_FROM_SYSTEM |
1772                                    FORMAT_MESSAGE_IGNORE_INSERTS, NULL,
1773                                    (DWORD)hr, MAKELANGID(LANG_NEUTRAL,
1774                                    SUBLANG_DEFAULT), (LPTSTR) & msg_buffer, 0,
1775                                    NULL)) {
1776                     error_setg(errp, "w32tm failed with error (0x%lx), couldn'"
1777                                      "t retrieve error message", hr);
1778                 } else {
1779                     error_setg(errp, "w32tm failed with error (0x%lx): %s", hr,
1780                                (LPCTSTR)msg_buffer);
1781                     LocalFree(msg_buffer);
1782                 }
1783             }
1784         } else if (!InternetGetConnectedState(&ret_flags, 0)) {
1785             error_setg(errp, "No internet connection on guest, sync not "
1786                              "accurate");
1787         }
1788         return;
1789     }
1790
1791     /* Validate time passed by user. */
1792     if (time_ns < 0 || time_ns / 100 > INT64_MAX - W32_FT_OFFSET) {
1793         error_setg(errp, "Time %" PRId64 "is invalid", time_ns);
1794         return;
1795     }
1796
1797     time = time_ns / 100 + W32_FT_OFFSET;
1798
1799     tf.dwLowDateTime = (DWORD) time;
1800     tf.dwHighDateTime = (DWORD) (time >> 32);
1801
1802     if (!FileTimeToSystemTime(&tf, &ts)) {
1803         error_setg(errp, "Failed to convert system time %d",
1804                    (int)GetLastError());
1805         return;
1806     }
1807
1808     acquire_privilege(SE_SYSTEMTIME_NAME, &local_err);
1809     if (local_err) {
1810         error_propagate(errp, local_err);
1811         return;
1812     }
1813
1814     if (!SetSystemTime(&ts)) {
1815         error_setg(errp, "Failed to set time to guest: %d", (int)GetLastError());
1816         return;
1817     }
1818 }
1819
1820 GuestLogicalProcessorList *qmp_guest_get_vcpus(Error **errp)
1821 {
1822     PSYSTEM_LOGICAL_PROCESSOR_INFORMATION pslpi, ptr;
1823     DWORD length;
1824     GuestLogicalProcessorList *head, **tail;
1825     Error *local_err = NULL;
1826     int64_t current;
1827
1828     ptr = pslpi = NULL;
1829     length = 0;
1830     current = 0;
1831     head = NULL;
1832     tail = &head;
1833
1834     if ((GetLogicalProcessorInformation(pslpi, &length) == FALSE) &&
1835         (GetLastError() == ERROR_INSUFFICIENT_BUFFER) &&
1836         (length > sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION))) {
1837         ptr = pslpi = g_malloc0(length);
1838         if (GetLogicalProcessorInformation(pslpi, &length) == FALSE) {
1839             error_setg(&local_err, "Failed to get processor information: %d",
1840                        (int)GetLastError());
1841         }
1842     } else {
1843         error_setg(&local_err,
1844                    "Failed to get processor information buffer length: %d",
1845                    (int)GetLastError());
1846     }
1847
1848     while ((local_err == NULL) && (length > 0)) {
1849         if (pslpi->Relationship == RelationProcessorCore) {
1850             ULONG_PTR cpu_bits = pslpi->ProcessorMask;
1851
1852             while (cpu_bits > 0) {
1853                 if (!!(cpu_bits & 1)) {
1854                     GuestLogicalProcessor *vcpu;
1855
1856                     vcpu = g_malloc0(sizeof *vcpu);
1857                     vcpu->logical_id = current++;
1858                     vcpu->online = true;
1859                     vcpu->has_can_offline = true;
1860
1861                     QAPI_LIST_APPEND(tail, vcpu);
1862                 }
1863                 cpu_bits >>= 1;
1864             }
1865         }
1866         length -= sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
1867         pslpi++; /* next entry */
1868     }
1869
1870     g_free(ptr);
1871
1872     if (local_err == NULL) {
1873         if (head != NULL) {
1874             return head;
1875         }
1876         /* there's no guest with zero VCPUs */
1877         error_setg(&local_err, "Guest reported zero VCPUs");
1878     }
1879
1880     qapi_free_GuestLogicalProcessorList(head);
1881     error_propagate(errp, local_err);
1882     return NULL;
1883 }
1884
1885 int64_t qmp_guest_set_vcpus(GuestLogicalProcessorList *vcpus, Error **errp)
1886 {
1887     error_setg(errp, QERR_UNSUPPORTED);
1888     return -1;
1889 }
1890
1891 static gchar *
1892 get_net_error_message(gint error)
1893 {
1894     HMODULE module = NULL;
1895     gchar *retval = NULL;
1896     wchar_t *msg = NULL;
1897     int flags;
1898     size_t nchars;
1899
1900     flags = FORMAT_MESSAGE_ALLOCATE_BUFFER |
1901         FORMAT_MESSAGE_IGNORE_INSERTS |
1902         FORMAT_MESSAGE_FROM_SYSTEM;
1903
1904     if (error >= NERR_BASE && error <= MAX_NERR) {
1905         module = LoadLibraryExW(L"netmsg.dll", NULL, LOAD_LIBRARY_AS_DATAFILE);
1906
1907         if (module != NULL) {
1908             flags |= FORMAT_MESSAGE_FROM_HMODULE;
1909         }
1910     }
1911
1912     FormatMessageW(flags, module, error, 0, (LPWSTR)&msg, 0, NULL);
1913
1914     if (msg != NULL) {
1915         nchars = wcslen(msg);
1916
1917         if (nchars >= 2 &&
1918             msg[nchars - 1] == L'\n' &&
1919             msg[nchars - 2] == L'\r') {
1920             msg[nchars - 2] = L'\0';
1921         }
1922
1923         retval = g_utf16_to_utf8(msg, -1, NULL, NULL, NULL);
1924
1925         LocalFree(msg);
1926     }
1927
1928     if (module != NULL) {
1929         FreeLibrary(module);
1930     }
1931
1932     return retval;
1933 }
1934
1935 void qmp_guest_set_user_password(const char *username,
1936                                  const char *password,
1937                                  bool crypted,
1938                                  Error **errp)
1939 {
1940     NET_API_STATUS nas;
1941     char *rawpasswddata = NULL;
1942     size_t rawpasswdlen;
1943     wchar_t *user = NULL, *wpass = NULL;
1944     USER_INFO_1003 pi1003 = { 0, };
1945     GError *gerr = NULL;
1946
1947     if (crypted) {
1948         error_setg(errp, QERR_UNSUPPORTED);
1949         return;
1950     }
1951
1952     rawpasswddata = (char *)qbase64_decode(password, -1, &rawpasswdlen, errp);
1953     if (!rawpasswddata) {
1954         return;
1955     }
1956     rawpasswddata = g_renew(char, rawpasswddata, rawpasswdlen + 1);
1957     rawpasswddata[rawpasswdlen] = '\0';
1958
1959     user = g_utf8_to_utf16(username, -1, NULL, NULL, &gerr);
1960     if (!user) {
1961         goto done;
1962     }
1963
1964     wpass = g_utf8_to_utf16(rawpasswddata, -1, NULL, NULL, &gerr);
1965     if (!wpass) {
1966         goto done;
1967     }
1968
1969     pi1003.usri1003_password = wpass;
1970     nas = NetUserSetInfo(NULL, user,
1971                          1003, (LPBYTE)&pi1003,
1972                          NULL);
1973
1974     if (nas != NERR_Success) {
1975         gchar *msg = get_net_error_message(nas);
1976         error_setg(errp, "failed to set password: %s", msg);
1977         g_free(msg);
1978     }
1979
1980 done:
1981     if (gerr) {
1982         error_setg(errp, QERR_QGA_COMMAND_FAILED, gerr->message);
1983         g_error_free(gerr);
1984     }
1985     g_free(user);
1986     g_free(wpass);
1987     g_free(rawpasswddata);
1988 }
1989
1990 GuestMemoryBlockList *qmp_guest_get_memory_blocks(Error **errp)
1991 {
1992     error_setg(errp, QERR_UNSUPPORTED);
1993     return NULL;
1994 }
1995
1996 GuestMemoryBlockResponseList *
1997 qmp_guest_set_memory_blocks(GuestMemoryBlockList *mem_blks, Error **errp)
1998 {
1999     error_setg(errp, QERR_UNSUPPORTED);
2000     return NULL;
2001 }
2002
2003 GuestMemoryBlockInfo *qmp_guest_get_memory_block_info(Error **errp)
2004 {
2005     error_setg(errp, QERR_UNSUPPORTED);
2006     return NULL;
2007 }
2008
2009 /* add unsupported commands to the blacklist */
2010 GList *ga_command_blacklist_init(GList *blacklist)
2011 {
2012     const char *list_unsupported[] = {
2013         "guest-suspend-hybrid",
2014         "guest-set-vcpus",
2015         "guest-get-memory-blocks", "guest-set-memory-blocks",
2016         "guest-get-memory-block-size", "guest-get-memory-block-info",
2017         NULL};
2018     char **p = (char **)list_unsupported;
2019
2020     while (*p) {
2021         blacklist = g_list_append(blacklist, g_strdup(*p++));
2022     }
2023
2024     if (!vss_init(true)) {
2025         g_debug("vss_init failed, vss commands are going to be disabled");
2026         const char *list[] = {
2027             "guest-get-fsinfo", "guest-fsfreeze-status",
2028             "guest-fsfreeze-freeze", "guest-fsfreeze-thaw", NULL};
2029         p = (char **)list;
2030
2031         while (*p) {
2032             blacklist = g_list_append(blacklist, g_strdup(*p++));
2033         }
2034     }
2035
2036     return blacklist;
2037 }
2038
2039 /* register init/cleanup routines for stateful command groups */
2040 void ga_command_state_init(GAState *s, GACommandState *cs)
2041 {
2042     if (!vss_initialized()) {
2043         ga_command_state_add(cs, NULL, guest_fsfreeze_cleanup);
2044     }
2045 }
2046
2047 /* MINGW is missing two fields: IncomingFrames & OutgoingFrames */
2048 typedef struct _GA_WTSINFOA {
2049     WTS_CONNECTSTATE_CLASS State;
2050     DWORD SessionId;
2051     DWORD IncomingBytes;
2052     DWORD OutgoingBytes;
2053     DWORD IncomingFrames;
2054     DWORD OutgoingFrames;
2055     DWORD IncomingCompressedBytes;
2056     DWORD OutgoingCompressedBy;
2057     CHAR WinStationName[WINSTATIONNAME_LENGTH];
2058     CHAR Domain[DOMAIN_LENGTH];
2059     CHAR UserName[USERNAME_LENGTH + 1];
2060     LARGE_INTEGER ConnectTime;
2061     LARGE_INTEGER DisconnectTime;
2062     LARGE_INTEGER LastInputTime;
2063     LARGE_INTEGER LogonTime;
2064     LARGE_INTEGER CurrentTime;
2065
2066 } GA_WTSINFOA;
2067
2068 GuestUserList *qmp_guest_get_users(Error **errp)
2069 {
2070 #define QGA_NANOSECONDS 10000000
2071
2072     GHashTable *cache = NULL;
2073     GuestUserList *head = NULL, **tail = &head;
2074
2075     DWORD buffer_size = 0, count = 0, i = 0;
2076     GA_WTSINFOA *info = NULL;
2077     WTS_SESSION_INFOA *entries = NULL;
2078     GuestUser *user = NULL;
2079     gpointer value = NULL;
2080     INT64 login = 0;
2081     double login_time = 0;
2082
2083     cache = g_hash_table_new(g_str_hash, g_str_equal);
2084
2085     if (WTSEnumerateSessionsA(NULL, 0, 1, &entries, &count)) {
2086         for (i = 0; i < count; ++i) {
2087             buffer_size = 0;
2088             info = NULL;
2089             if (WTSQuerySessionInformationA(
2090                 NULL,
2091                 entries[i].SessionId,
2092                 WTSSessionInfo,
2093                 (LPSTR *)&info,
2094                 &buffer_size
2095             )) {
2096
2097                 if (strlen(info->UserName) == 0) {
2098                     WTSFreeMemory(info);
2099                     continue;
2100                 }
2101
2102                 login = info->LogonTime.QuadPart;
2103                 login -= W32_FT_OFFSET;
2104                 login_time = ((double)login) / QGA_NANOSECONDS;
2105
2106                 if (g_hash_table_contains(cache, info->UserName)) {
2107                     value = g_hash_table_lookup(cache, info->UserName);
2108                     user = (GuestUser *)value;
2109                     if (user->login_time > login_time) {
2110                         user->login_time = login_time;
2111                     }
2112                 } else {
2113                     user = g_new0(GuestUser, 1);
2114
2115                     user->user = g_strdup(info->UserName);
2116                     user->domain = g_strdup(info->Domain);
2117                     user->has_domain = true;
2118
2119                     user->login_time = login_time;
2120
2121                     g_hash_table_add(cache, user->user);
2122
2123                     QAPI_LIST_APPEND(tail, user);
2124                 }
2125             }
2126             WTSFreeMemory(info);
2127         }
2128         WTSFreeMemory(entries);
2129     }
2130     g_hash_table_destroy(cache);
2131     return head;
2132 }
2133
2134 typedef struct _ga_matrix_lookup_t {
2135     int major;
2136     int minor;
2137     char const *version;
2138     char const *version_id;
2139 } ga_matrix_lookup_t;
2140
2141 static ga_matrix_lookup_t const WIN_VERSION_MATRIX[2][8] = {
2142     {
2143         /* Desktop editions */
2144         { 5, 0, "Microsoft Windows 2000",   "2000"},
2145         { 5, 1, "Microsoft Windows XP",     "xp"},
2146         { 6, 0, "Microsoft Windows Vista",  "vista"},
2147         { 6, 1, "Microsoft Windows 7"       "7"},
2148         { 6, 2, "Microsoft Windows 8",      "8"},
2149         { 6, 3, "Microsoft Windows 8.1",    "8.1"},
2150         {10, 0, "Microsoft Windows 10",     "10"},
2151         { 0, 0, 0}
2152     },{
2153         /* Server editions */
2154         { 5, 2, "Microsoft Windows Server 2003",        "2003"},
2155         { 6, 0, "Microsoft Windows Server 2008",        "2008"},
2156         { 6, 1, "Microsoft Windows Server 2008 R2",     "2008r2"},
2157         { 6, 2, "Microsoft Windows Server 2012",        "2012"},
2158         { 6, 3, "Microsoft Windows Server 2012 R2",     "2012r2"},
2159         { 0, 0, 0},
2160         { 0, 0, 0},
2161         { 0, 0, 0}
2162     }
2163 };
2164
2165 typedef struct _ga_win_10_0_server_t {
2166     int final_build;
2167     char const *version;
2168     char const *version_id;
2169 } ga_win_10_0_server_t;
2170
2171 static ga_win_10_0_server_t const WIN_10_0_SERVER_VERSION_MATRIX[4] = {
2172     {14393, "Microsoft Windows Server 2016",    "2016"},
2173     {17763, "Microsoft Windows Server 2019",    "2019"},
2174     {20344, "Microsoft Windows Server 2022",    "2022"},
2175     {0, 0}
2176 };
2177
2178 static void ga_get_win_version(RTL_OSVERSIONINFOEXW *info, Error **errp)
2179 {
2180     typedef NTSTATUS(WINAPI *rtl_get_version_t)(
2181         RTL_OSVERSIONINFOEXW *os_version_info_ex);
2182
2183     info->dwOSVersionInfoSize = sizeof(RTL_OSVERSIONINFOEXW);
2184
2185     HMODULE module = GetModuleHandle("ntdll");
2186     PVOID fun = GetProcAddress(module, "RtlGetVersion");
2187     if (fun == NULL) {
2188         error_setg(errp, QERR_QGA_COMMAND_FAILED,
2189             "Failed to get address of RtlGetVersion");
2190         return;
2191     }
2192
2193     rtl_get_version_t rtl_get_version = (rtl_get_version_t)fun;
2194     rtl_get_version(info);
2195     return;
2196 }
2197
2198 static char *ga_get_win_name(OSVERSIONINFOEXW const *os_version, bool id)
2199 {
2200     DWORD major = os_version->dwMajorVersion;
2201     DWORD minor = os_version->dwMinorVersion;
2202     DWORD build = os_version->dwBuildNumber;
2203     int tbl_idx = (os_version->wProductType != VER_NT_WORKSTATION);
2204     ga_matrix_lookup_t const *table = WIN_VERSION_MATRIX[tbl_idx];
2205     ga_win_10_0_server_t const *win_10_0_table = WIN_10_0_SERVER_VERSION_MATRIX;
2206     while (table->version != NULL) {
2207         if (major == 10 && minor == 0 && tbl_idx) {
2208             while (win_10_0_table->version != NULL) {
2209                 if (build <= win_10_0_table->final_build) {
2210                     if (id) {
2211                         return g_strdup(win_10_0_table->version_id);
2212                     } else {
2213                         return g_strdup(win_10_0_table->version);
2214                     }
2215                 }
2216                 win_10_0_table++;
2217             }
2218         } else if (major == table->major && minor == table->minor) {
2219             if (id) {
2220                 return g_strdup(table->version_id);
2221             } else {
2222                 return g_strdup(table->version);
2223             }
2224         }
2225         ++table;
2226     }
2227     slog("failed to lookup Windows version: major=%lu, minor=%lu",
2228         major, minor);
2229     return g_strdup("N/A");
2230 }
2231
2232 static char *ga_get_win_product_name(Error **errp)
2233 {
2234     HKEY key = INVALID_HANDLE_VALUE;
2235     DWORD size = 128;
2236     char *result = g_malloc0(size);
2237     LONG err = ERROR_SUCCESS;
2238
2239     err = RegOpenKeyA(HKEY_LOCAL_MACHINE,
2240                       "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion",
2241                       &key);
2242     if (err != ERROR_SUCCESS) {
2243         error_setg_win32(errp, err, "failed to open registry key");
2244         g_free(result);
2245         return NULL;
2246     }
2247
2248     err = RegQueryValueExA(key, "ProductName", NULL, NULL,
2249                             (LPBYTE)result, &size);
2250     if (err == ERROR_MORE_DATA) {
2251         slog("ProductName longer than expected (%lu bytes), retrying",
2252                 size);
2253         g_free(result);
2254         result = NULL;
2255         if (size > 0) {
2256             result = g_malloc0(size);
2257             err = RegQueryValueExA(key, "ProductName", NULL, NULL,
2258                                     (LPBYTE)result, &size);
2259         }
2260     }
2261     if (err != ERROR_SUCCESS) {
2262         error_setg_win32(errp, err, "failed to retrive ProductName");
2263         goto fail;
2264     }
2265
2266     RegCloseKey(key);
2267     return result;
2268
2269 fail:
2270     if (key != INVALID_HANDLE_VALUE) {
2271         RegCloseKey(key);
2272     }
2273     g_free(result);
2274     return NULL;
2275 }
2276
2277 static char *ga_get_current_arch(void)
2278 {
2279     SYSTEM_INFO info;
2280     GetNativeSystemInfo(&info);
2281     char *result = NULL;
2282     switch (info.wProcessorArchitecture) {
2283     case PROCESSOR_ARCHITECTURE_AMD64:
2284         result = g_strdup("x86_64");
2285         break;
2286     case PROCESSOR_ARCHITECTURE_ARM:
2287         result = g_strdup("arm");
2288         break;
2289     case PROCESSOR_ARCHITECTURE_IA64:
2290         result = g_strdup("ia64");
2291         break;
2292     case PROCESSOR_ARCHITECTURE_INTEL:
2293         result = g_strdup("x86");
2294         break;
2295     case PROCESSOR_ARCHITECTURE_UNKNOWN:
2296     default:
2297         slog("unknown processor architecture 0x%0x",
2298             info.wProcessorArchitecture);
2299         result = g_strdup("unknown");
2300         break;
2301     }
2302     return result;
2303 }
2304
2305 GuestOSInfo *qmp_guest_get_osinfo(Error **errp)
2306 {
2307     Error *local_err = NULL;
2308     OSVERSIONINFOEXW os_version = {0};
2309     bool server;
2310     char *product_name;
2311     GuestOSInfo *info;
2312
2313     ga_get_win_version(&os_version, &local_err);
2314     if (local_err) {
2315         error_propagate(errp, local_err);
2316         return NULL;
2317     }
2318
2319     server = os_version.wProductType != VER_NT_WORKSTATION;
2320     product_name = ga_get_win_product_name(errp);
2321     if (product_name == NULL) {
2322         return NULL;
2323     }
2324
2325     info = g_new0(GuestOSInfo, 1);
2326
2327     info->has_kernel_version = true;
2328     info->kernel_version = g_strdup_printf("%lu.%lu",
2329         os_version.dwMajorVersion,
2330         os_version.dwMinorVersion);
2331     info->has_kernel_release = true;
2332     info->kernel_release = g_strdup_printf("%lu",
2333         os_version.dwBuildNumber);
2334     info->has_machine = true;
2335     info->machine = ga_get_current_arch();
2336
2337     info->has_id = true;
2338     info->id = g_strdup("mswindows");
2339     info->has_name = true;
2340     info->name = g_strdup("Microsoft Windows");
2341     info->has_pretty_name = true;
2342     info->pretty_name = product_name;
2343     info->has_version = true;
2344     info->version = ga_get_win_name(&os_version, false);
2345     info->has_version_id = true;
2346     info->version_id = ga_get_win_name(&os_version, true);
2347     info->has_variant = true;
2348     info->variant = g_strdup(server ? "server" : "client");
2349     info->has_variant_id = true;
2350     info->variant_id = g_strdup(server ? "server" : "client");
2351
2352     return info;
2353 }
2354
2355 /*
2356  * Safely get device property. Returned strings are using wide characters.
2357  * Caller is responsible for freeing the buffer.
2358  */
2359 static LPBYTE cm_get_property(DEVINST devInst, const DEVPROPKEY *propName,
2360     PDEVPROPTYPE propType)
2361 {
2362     CONFIGRET cr;
2363     g_autofree LPBYTE buffer = NULL;
2364     ULONG buffer_len = 0;
2365
2366     /* First query for needed space */
2367     cr = CM_Get_DevNode_PropertyW(devInst, propName, propType,
2368         buffer, &buffer_len, 0);
2369     if (cr != CR_SUCCESS && cr != CR_BUFFER_SMALL) {
2370
2371         slog("failed to get property size, error=0x%lx", cr);
2372         return NULL;
2373     }
2374     buffer = g_new0(BYTE, buffer_len + 1);
2375     cr = CM_Get_DevNode_PropertyW(devInst, propName, propType,
2376         buffer, &buffer_len, 0);
2377     if (cr != CR_SUCCESS) {
2378         slog("failed to get device property, error=0x%lx", cr);
2379         return NULL;
2380     }
2381     return g_steal_pointer(&buffer);
2382 }
2383
2384 static GStrv ga_get_hardware_ids(DEVINST devInstance)
2385 {
2386     GArray *values = NULL;
2387     DEVPROPTYPE cm_type;
2388     LPWSTR id;
2389     g_autofree LPWSTR property = (LPWSTR)cm_get_property(devInstance,
2390         &qga_DEVPKEY_Device_HardwareIds, &cm_type);
2391     if (property == NULL) {
2392         slog("failed to get hardware IDs");
2393         return NULL;
2394     }
2395     if (*property == '\0') {
2396         /* empty list */
2397         return NULL;
2398     }
2399     values = g_array_new(TRUE, TRUE, sizeof(gchar *));
2400     for (id = property; '\0' != *id; id += lstrlenW(id) + 1) {
2401         gchar *id8 = g_utf16_to_utf8(id, -1, NULL, NULL, NULL);
2402         g_array_append_val(values, id8);
2403     }
2404     return (GStrv)g_array_free(values, FALSE);
2405 }
2406
2407 /*
2408  * https://docs.microsoft.com/en-us/windows-hardware/drivers/install/identifiers-for-pci-devices
2409  */
2410 #define DEVICE_PCI_RE "PCI\\\\VEN_(1AF4|1B36)&DEV_([0-9A-B]{4})(&|$)"
2411
2412 GuestDeviceInfoList *qmp_guest_get_devices(Error **errp)
2413 {
2414     GuestDeviceInfoList *head = NULL, **tail = &head;
2415     HDEVINFO dev_info = INVALID_HANDLE_VALUE;
2416     SP_DEVINFO_DATA dev_info_data;
2417     int i, j;
2418     GError *gerr = NULL;
2419     g_autoptr(GRegex) device_pci_re = NULL;
2420     DEVPROPTYPE cm_type;
2421
2422     device_pci_re = g_regex_new(DEVICE_PCI_RE,
2423         G_REGEX_ANCHORED | G_REGEX_OPTIMIZE, 0,
2424         &gerr);
2425     g_assert(device_pci_re != NULL);
2426
2427     dev_info_data.cbSize = sizeof(SP_DEVINFO_DATA);
2428     dev_info = SetupDiGetClassDevs(0, 0, 0, DIGCF_PRESENT | DIGCF_ALLCLASSES);
2429     if (dev_info == INVALID_HANDLE_VALUE) {
2430         error_setg(errp, "failed to get device tree");
2431         return NULL;
2432     }
2433
2434     slog("enumerating devices");
2435     for (i = 0; SetupDiEnumDeviceInfo(dev_info, i, &dev_info_data); i++) {
2436         bool skip = true;
2437         g_autofree LPWSTR name = NULL;
2438         g_autofree LPFILETIME date = NULL;
2439         g_autofree LPWSTR version = NULL;
2440         g_auto(GStrv) hw_ids = NULL;
2441         g_autoptr(GuestDeviceInfo) device = g_new0(GuestDeviceInfo, 1);
2442         g_autofree char *vendor_id = NULL;
2443         g_autofree char *device_id = NULL;
2444
2445         name = (LPWSTR)cm_get_property(dev_info_data.DevInst,
2446             &qga_DEVPKEY_NAME, &cm_type);
2447         if (name == NULL) {
2448             slog("failed to get device description");
2449             continue;
2450         }
2451         device->driver_name = g_utf16_to_utf8(name, -1, NULL, NULL, NULL);
2452         if (device->driver_name == NULL) {
2453             error_setg(errp, "conversion to utf8 failed (driver name)");
2454             return NULL;
2455         }
2456         slog("querying device: %s", device->driver_name);
2457         hw_ids = ga_get_hardware_ids(dev_info_data.DevInst);
2458         if (hw_ids == NULL) {
2459             continue;
2460         }
2461         for (j = 0; hw_ids[j] != NULL; j++) {
2462             g_autoptr(GMatchInfo) match_info;
2463             GuestDeviceIdPCI *id;
2464             if (!g_regex_match(device_pci_re, hw_ids[j], 0, &match_info)) {
2465                 continue;
2466             }
2467             skip = false;
2468
2469             vendor_id = g_match_info_fetch(match_info, 1);
2470             device_id = g_match_info_fetch(match_info, 2);
2471
2472             device->id = g_new0(GuestDeviceId, 1);
2473             device->has_id = true;
2474             device->id->type = GUEST_DEVICE_TYPE_PCI;
2475             id = &device->id->u.pci;
2476             id->vendor_id = g_ascii_strtoull(vendor_id, NULL, 16);
2477             id->device_id = g_ascii_strtoull(device_id, NULL, 16);
2478
2479             break;
2480         }
2481         if (skip) {
2482             continue;
2483         }
2484
2485         version = (LPWSTR)cm_get_property(dev_info_data.DevInst,
2486             &qga_DEVPKEY_Device_DriverVersion, &cm_type);
2487         if (version == NULL) {
2488             slog("failed to get driver version");
2489             continue;
2490         }
2491         device->driver_version = g_utf16_to_utf8(version, -1, NULL,
2492             NULL, NULL);
2493         if (device->driver_version == NULL) {
2494             error_setg(errp, "conversion to utf8 failed (driver version)");
2495             return NULL;
2496         }
2497         device->has_driver_version = true;
2498
2499         date = (LPFILETIME)cm_get_property(dev_info_data.DevInst,
2500             &qga_DEVPKEY_Device_DriverDate, &cm_type);
2501         if (date == NULL) {
2502             slog("failed to get driver date");
2503             continue;
2504         }
2505         device->driver_date = filetime_to_ns(date);
2506         device->has_driver_date = true;
2507
2508         slog("driver: %s\ndriver version: %" PRId64 ",%s\n",
2509              device->driver_name, device->driver_date,
2510              device->driver_version);
2511         QAPI_LIST_APPEND(tail, g_steal_pointer(&device));
2512     }
2513
2514     if (dev_info != INVALID_HANDLE_VALUE) {
2515         SetupDiDestroyDeviceInfoList(dev_info);
2516     }
2517     return head;
2518 }