1
2
3
4
5
6
7
8
9
10
11
12
13
14#ifndef _WIN32_WINNT
15# define _WIN32_WINNT 0x0600
16#endif
17#include "qemu/osdep.h"
18#include <wtypes.h>
19#include <powrprof.h>
20#include <winsock2.h>
21#include <ws2tcpip.h>
22#include <iptypes.h>
23#include <iphlpapi.h>
24#ifdef CONFIG_QGA_NTDDSCSI
25#include <winioctl.h>
26#include <ntddscsi.h>
27#include <setupapi.h>
28#include <initguid.h>
29#endif
30#include <lm.h>
31#include <wtsapi32.h>
32#include <wininet.h>
33
34#include "qga/guest-agent-core.h"
35#include "qga/vss-win32.h"
36#include "qga-qmp-commands.h"
37#include "qapi/qmp/qerror.h"
38#include "qemu/queue.h"
39#include "qemu/host-utils.h"
40#include "qemu/base64.h"
41
42#ifndef SHTDN_REASON_FLAG_PLANNED
43#define SHTDN_REASON_FLAG_PLANNED 0x80000000
44#endif
45
46
47
48#define W32_FT_OFFSET (10000000ULL * 60 * 60 * 24 * \
49 (365 * (1970 - 1601) + \
50 (1970 - 1601) / 4 - 3))
51
52#define INVALID_SET_FILE_POINTER ((DWORD)-1)
53
54typedef struct GuestFileHandle {
55 int64_t id;
56 HANDLE fh;
57 QTAILQ_ENTRY(GuestFileHandle) next;
58} GuestFileHandle;
59
60static struct {
61 QTAILQ_HEAD(, GuestFileHandle) filehandles;
62} guest_file_state = {
63 .filehandles = QTAILQ_HEAD_INITIALIZER(guest_file_state.filehandles),
64};
65
66#define FILE_GENERIC_APPEND (FILE_GENERIC_WRITE & ~FILE_WRITE_DATA)
67
68typedef struct OpenFlags {
69 const char *forms;
70 DWORD desired_access;
71 DWORD creation_disposition;
72} OpenFlags;
73static OpenFlags guest_file_open_modes[] = {
74 {"r", GENERIC_READ, OPEN_EXISTING},
75 {"rb", GENERIC_READ, OPEN_EXISTING},
76 {"w", GENERIC_WRITE, CREATE_ALWAYS},
77 {"wb", GENERIC_WRITE, CREATE_ALWAYS},
78 {"a", FILE_GENERIC_APPEND, OPEN_ALWAYS },
79 {"r+", GENERIC_WRITE|GENERIC_READ, OPEN_EXISTING},
80 {"rb+", GENERIC_WRITE|GENERIC_READ, OPEN_EXISTING},
81 {"r+b", GENERIC_WRITE|GENERIC_READ, OPEN_EXISTING},
82 {"w+", GENERIC_WRITE|GENERIC_READ, CREATE_ALWAYS},
83 {"wb+", GENERIC_WRITE|GENERIC_READ, CREATE_ALWAYS},
84 {"w+b", GENERIC_WRITE|GENERIC_READ, CREATE_ALWAYS},
85 {"a+", FILE_GENERIC_APPEND|GENERIC_READ, OPEN_ALWAYS },
86 {"ab+", FILE_GENERIC_APPEND|GENERIC_READ, OPEN_ALWAYS },
87 {"a+b", FILE_GENERIC_APPEND|GENERIC_READ, OPEN_ALWAYS }
88};
89
90static OpenFlags *find_open_flag(const char *mode_str)
91{
92 int mode;
93 Error **errp = NULL;
94
95 for (mode = 0; mode < ARRAY_SIZE(guest_file_open_modes); ++mode) {
96 OpenFlags *flags = guest_file_open_modes + mode;
97
98 if (strcmp(flags->forms, mode_str) == 0) {
99 return flags;
100 }
101 }
102
103 error_setg(errp, "invalid file open mode '%s'", mode_str);
104 return NULL;
105}
106
107static int64_t guest_file_handle_add(HANDLE fh, Error **errp)
108{
109 GuestFileHandle *gfh;
110 int64_t handle;
111
112 handle = ga_get_fd_handle(ga_state, errp);
113 if (handle < 0) {
114 return -1;
115 }
116 gfh = g_new0(GuestFileHandle, 1);
117 gfh->id = handle;
118 gfh->fh = fh;
119 QTAILQ_INSERT_TAIL(&guest_file_state.filehandles, gfh, next);
120
121 return handle;
122}
123
124static GuestFileHandle *guest_file_handle_find(int64_t id, Error **errp)
125{
126 GuestFileHandle *gfh;
127 QTAILQ_FOREACH(gfh, &guest_file_state.filehandles, next) {
128 if (gfh->id == id) {
129 return gfh;
130 }
131 }
132 error_setg(errp, "handle '%" PRId64 "' has not been found", id);
133 return NULL;
134}
135
136static void handle_set_nonblocking(HANDLE fh)
137{
138 DWORD file_type, pipe_state;
139 file_type = GetFileType(fh);
140 if (file_type != FILE_TYPE_PIPE) {
141 return;
142 }
143
144
145 if (!GetNamedPipeHandleState(fh, &pipe_state, NULL,
146 NULL, NULL, NULL, 0)) {
147 return;
148 }
149
150 if (pipe_state & PIPE_NOWAIT) {
151 return;
152 }
153
154 pipe_state |= PIPE_NOWAIT;
155 SetNamedPipeHandleState(fh, &pipe_state, NULL, NULL);
156}
157
158int64_t qmp_guest_file_open(const char *path, bool has_mode,
159 const char *mode, Error **errp)
160{
161 int64_t fd;
162 HANDLE fh;
163 HANDLE templ_file = NULL;
164 DWORD share_mode = FILE_SHARE_READ;
165 DWORD flags_and_attr = FILE_ATTRIBUTE_NORMAL;
166 LPSECURITY_ATTRIBUTES sa_attr = NULL;
167 OpenFlags *guest_flags;
168
169 if (!has_mode) {
170 mode = "r";
171 }
172 slog("guest-file-open called, filepath: %s, mode: %s", path, mode);
173 guest_flags = find_open_flag(mode);
174 if (guest_flags == NULL) {
175 error_setg(errp, "invalid file open mode");
176 return -1;
177 }
178
179 fh = CreateFile(path, guest_flags->desired_access, share_mode, sa_attr,
180 guest_flags->creation_disposition, flags_and_attr,
181 templ_file);
182 if (fh == INVALID_HANDLE_VALUE) {
183 error_setg_win32(errp, GetLastError(), "failed to open file '%s'",
184 path);
185 return -1;
186 }
187
188
189
190
191 handle_set_nonblocking(fh);
192
193 fd = guest_file_handle_add(fh, errp);
194 if (fd < 0) {
195 CloseHandle(fh);
196 error_setg(errp, "failed to add handle to qmp handle table");
197 return -1;
198 }
199
200 slog("guest-file-open, handle: % " PRId64, fd);
201 return fd;
202}
203
204void qmp_guest_file_close(int64_t handle, Error **errp)
205{
206 bool ret;
207 GuestFileHandle *gfh = guest_file_handle_find(handle, errp);
208 slog("guest-file-close called, handle: %" PRId64, handle);
209 if (gfh == NULL) {
210 return;
211 }
212 ret = CloseHandle(gfh->fh);
213 if (!ret) {
214 error_setg_win32(errp, GetLastError(), "failed close handle");
215 return;
216 }
217
218 QTAILQ_REMOVE(&guest_file_state.filehandles, gfh, next);
219 g_free(gfh);
220}
221
222static void acquire_privilege(const char *name, Error **errp)
223{
224 HANDLE token = NULL;
225 TOKEN_PRIVILEGES priv;
226 Error *local_err = NULL;
227
228 if (OpenProcessToken(GetCurrentProcess(),
229 TOKEN_ADJUST_PRIVILEGES|TOKEN_QUERY, &token))
230 {
231 if (!LookupPrivilegeValue(NULL, name, &priv.Privileges[0].Luid)) {
232 error_setg(&local_err, QERR_QGA_COMMAND_FAILED,
233 "no luid for requested privilege");
234 goto out;
235 }
236
237 priv.PrivilegeCount = 1;
238 priv.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
239
240 if (!AdjustTokenPrivileges(token, FALSE, &priv, 0, NULL, 0)) {
241 error_setg(&local_err, QERR_QGA_COMMAND_FAILED,
242 "unable to acquire requested privilege");
243 goto out;
244 }
245
246 } else {
247 error_setg(&local_err, QERR_QGA_COMMAND_FAILED,
248 "failed to open privilege token");
249 }
250
251out:
252 if (token) {
253 CloseHandle(token);
254 }
255 error_propagate(errp, local_err);
256}
257
258static void execute_async(DWORD WINAPI (*func)(LPVOID), LPVOID opaque,
259 Error **errp)
260{
261 Error *local_err = NULL;
262
263 HANDLE thread = CreateThread(NULL, 0, func, opaque, 0, NULL);
264 if (!thread) {
265 error_setg(&local_err, QERR_QGA_COMMAND_FAILED,
266 "failed to dispatch asynchronous command");
267 error_propagate(errp, local_err);
268 }
269}
270
271void qmp_guest_shutdown(bool has_mode, const char *mode, Error **errp)
272{
273 Error *local_err = NULL;
274 UINT shutdown_flag = EWX_FORCE;
275
276 slog("guest-shutdown called, mode: %s", mode);
277
278 if (!has_mode || strcmp(mode, "powerdown") == 0) {
279 shutdown_flag |= EWX_POWEROFF;
280 } else if (strcmp(mode, "halt") == 0) {
281 shutdown_flag |= EWX_SHUTDOWN;
282 } else if (strcmp(mode, "reboot") == 0) {
283 shutdown_flag |= EWX_REBOOT;
284 } else {
285 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "mode",
286 "halt|powerdown|reboot");
287 return;
288 }
289
290
291
292 acquire_privilege(SE_SHUTDOWN_NAME, &local_err);
293 if (local_err) {
294 error_propagate(errp, local_err);
295 return;
296 }
297
298 if (!ExitWindowsEx(shutdown_flag, SHTDN_REASON_FLAG_PLANNED)) {
299 slog("guest-shutdown failed: %lu", GetLastError());
300 error_setg(errp, QERR_UNDEFINED_ERROR);
301 }
302}
303
304GuestFileRead *qmp_guest_file_read(int64_t handle, bool has_count,
305 int64_t count, Error **errp)
306{
307 GuestFileRead *read_data = NULL;
308 guchar *buf;
309 HANDLE fh;
310 bool is_ok;
311 DWORD read_count;
312 GuestFileHandle *gfh = guest_file_handle_find(handle, errp);
313
314 if (!gfh) {
315 return NULL;
316 }
317 if (!has_count) {
318 count = QGA_READ_COUNT_DEFAULT;
319 } else if (count < 0) {
320 error_setg(errp, "value '%" PRId64
321 "' is invalid for argument count", count);
322 return NULL;
323 }
324
325 fh = gfh->fh;
326 buf = g_malloc0(count+1);
327 is_ok = ReadFile(fh, buf, count, &read_count, NULL);
328 if (!is_ok) {
329 error_setg_win32(errp, GetLastError(), "failed to read file");
330 slog("guest-file-read failed, handle %" PRId64, handle);
331 } else {
332 buf[read_count] = 0;
333 read_data = g_new0(GuestFileRead, 1);
334 read_data->count = (size_t)read_count;
335 read_data->eof = read_count == 0;
336
337 if (read_count != 0) {
338 read_data->buf_b64 = g_base64_encode(buf, read_count);
339 }
340 }
341 g_free(buf);
342
343 return read_data;
344}
345
346GuestFileWrite *qmp_guest_file_write(int64_t handle, const char *buf_b64,
347 bool has_count, int64_t count,
348 Error **errp)
349{
350 GuestFileWrite *write_data = NULL;
351 guchar *buf;
352 gsize buf_len;
353 bool is_ok;
354 DWORD write_count;
355 GuestFileHandle *gfh = guest_file_handle_find(handle, errp);
356 HANDLE fh;
357
358 if (!gfh) {
359 return NULL;
360 }
361 fh = gfh->fh;
362 buf = qbase64_decode(buf_b64, -1, &buf_len, errp);
363 if (!buf) {
364 return NULL;
365 }
366
367 if (!has_count) {
368 count = buf_len;
369 } else if (count < 0 || count > buf_len) {
370 error_setg(errp, "value '%" PRId64
371 "' is invalid for argument count", count);
372 goto done;
373 }
374
375 is_ok = WriteFile(fh, buf, count, &write_count, NULL);
376 if (!is_ok) {
377 error_setg_win32(errp, GetLastError(), "failed to write to file");
378 slog("guest-file-write-failed, handle: %" PRId64, handle);
379 } else {
380 write_data = g_new0(GuestFileWrite, 1);
381 write_data->count = (size_t) write_count;
382 }
383
384done:
385 g_free(buf);
386 return write_data;
387}
388
389GuestFileSeek *qmp_guest_file_seek(int64_t handle, int64_t offset,
390 GuestFileWhence *whence_code,
391 Error **errp)
392{
393 GuestFileHandle *gfh;
394 GuestFileSeek *seek_data;
395 HANDLE fh;
396 LARGE_INTEGER new_pos, off_pos;
397 off_pos.QuadPart = offset;
398 BOOL res;
399 int whence;
400 Error *err = NULL;
401
402 gfh = guest_file_handle_find(handle, errp);
403 if (!gfh) {
404 return NULL;
405 }
406
407
408 whence = ga_parse_whence(whence_code, &err);
409 if (err) {
410 error_propagate(errp, err);
411 return NULL;
412 }
413
414 fh = gfh->fh;
415 res = SetFilePointerEx(fh, off_pos, &new_pos, whence);
416 if (!res) {
417 error_setg_win32(errp, GetLastError(), "failed to seek file");
418 return NULL;
419 }
420 seek_data = g_new0(GuestFileSeek, 1);
421 seek_data->position = new_pos.QuadPart;
422 return seek_data;
423}
424
425void qmp_guest_file_flush(int64_t handle, Error **errp)
426{
427 HANDLE fh;
428 GuestFileHandle *gfh = guest_file_handle_find(handle, errp);
429 if (!gfh) {
430 return;
431 }
432
433 fh = gfh->fh;
434 if (!FlushFileBuffers(fh)) {
435 error_setg_win32(errp, GetLastError(), "failed to flush file");
436 }
437}
438
439#ifdef CONFIG_QGA_NTDDSCSI
440
441static STORAGE_BUS_TYPE win2qemu[] = {
442 [BusTypeUnknown] = GUEST_DISK_BUS_TYPE_UNKNOWN,
443 [BusTypeScsi] = GUEST_DISK_BUS_TYPE_SCSI,
444 [BusTypeAtapi] = GUEST_DISK_BUS_TYPE_IDE,
445 [BusTypeAta] = GUEST_DISK_BUS_TYPE_IDE,
446 [BusType1394] = GUEST_DISK_BUS_TYPE_IEEE1394,
447 [BusTypeSsa] = GUEST_DISK_BUS_TYPE_SSA,
448 [BusTypeFibre] = GUEST_DISK_BUS_TYPE_SSA,
449 [BusTypeUsb] = GUEST_DISK_BUS_TYPE_USB,
450 [BusTypeRAID] = GUEST_DISK_BUS_TYPE_RAID,
451#if (_WIN32_WINNT >= 0x0600)
452 [BusTypeiScsi] = GUEST_DISK_BUS_TYPE_ISCSI,
453 [BusTypeSas] = GUEST_DISK_BUS_TYPE_SAS,
454 [BusTypeSata] = GUEST_DISK_BUS_TYPE_SATA,
455 [BusTypeSd] = GUEST_DISK_BUS_TYPE_SD,
456 [BusTypeMmc] = GUEST_DISK_BUS_TYPE_MMC,
457#endif
458#if (_WIN32_WINNT >= 0x0601)
459 [BusTypeVirtual] = GUEST_DISK_BUS_TYPE_VIRTUAL,
460 [BusTypeFileBackedVirtual] = GUEST_DISK_BUS_TYPE_FILE_BACKED_VIRTUAL,
461#endif
462};
463
464static GuestDiskBusType find_bus_type(STORAGE_BUS_TYPE bus)
465{
466 if (bus > ARRAY_SIZE(win2qemu) || (int)bus < 0) {
467 return GUEST_DISK_BUS_TYPE_UNKNOWN;
468 }
469 return win2qemu[(int)bus];
470}
471
472DEFINE_GUID(GUID_DEVINTERFACE_VOLUME,
473 0x53f5630dL, 0xb6bf, 0x11d0, 0x94, 0xf2,
474 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b);
475
476static GuestPCIAddress *get_pci_info(char *guid, Error **errp)
477{
478 HDEVINFO dev_info;
479 SP_DEVINFO_DATA dev_info_data;
480 DWORD size = 0;
481 int i;
482 char dev_name[MAX_PATH];
483 char *buffer = NULL;
484 GuestPCIAddress *pci = NULL;
485 char *name = g_strdup(&guid[4]);
486
487 if (!QueryDosDevice(name, dev_name, ARRAY_SIZE(dev_name))) {
488 error_setg_win32(errp, GetLastError(), "failed to get dos device name");
489 goto out;
490 }
491
492 dev_info = SetupDiGetClassDevs(&GUID_DEVINTERFACE_VOLUME, 0, 0,
493 DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
494 if (dev_info == INVALID_HANDLE_VALUE) {
495 error_setg_win32(errp, GetLastError(), "failed to get devices tree");
496 goto out;
497 }
498
499 dev_info_data.cbSize = sizeof(SP_DEVINFO_DATA);
500 for (i = 0; SetupDiEnumDeviceInfo(dev_info, i, &dev_info_data); i++) {
501 DWORD addr, bus, slot, func, dev, data, size2;
502 while (!SetupDiGetDeviceRegistryProperty(dev_info, &dev_info_data,
503 SPDRP_PHYSICAL_DEVICE_OBJECT_NAME,
504 &data, (PBYTE)buffer, size,
505 &size2)) {
506 size = MAX(size, size2);
507 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
508 g_free(buffer);
509
510
511
512 buffer = g_malloc(size * 2);
513 } else {
514 error_setg_win32(errp, GetLastError(),
515 "failed to get device name");
516 goto free_dev_info;
517 }
518 }
519
520 if (g_strcmp0(buffer, dev_name)) {
521 continue;
522 }
523
524
525
526
527
528
529 if (!SetupDiGetDeviceRegistryProperty(dev_info, &dev_info_data,
530 SPDRP_BUSNUMBER, &data, (PBYTE)&bus, size, NULL)) {
531 break;
532 }
533
534
535
536 if (!SetupDiGetDeviceRegistryProperty(dev_info, &dev_info_data,
537 SPDRP_ADDRESS, &data, (PBYTE)&addr, size, NULL)) {
538 break;
539 }
540
541
542
543 if (!SetupDiGetDeviceRegistryProperty(dev_info, &dev_info_data,
544 SPDRP_UI_NUMBER, &data, (PBYTE)&slot, size, NULL)) {
545 break;
546 }
547
548
549
550
551
552
553
554
555 func = addr & 0x0000FFFF;
556 dev = (addr >> 16) & 0x0000FFFF;
557 pci = g_malloc0(sizeof(*pci));
558 pci->domain = dev;
559 pci->slot = slot;
560 pci->function = func;
561 pci->bus = bus;
562 break;
563 }
564
565free_dev_info:
566 SetupDiDestroyDeviceInfoList(dev_info);
567out:
568 g_free(buffer);
569 g_free(name);
570 return pci;
571}
572
573static int get_disk_bus_type(HANDLE vol_h, Error **errp)
574{
575 STORAGE_PROPERTY_QUERY query;
576 STORAGE_DEVICE_DESCRIPTOR *dev_desc, buf;
577 DWORD received;
578
579 dev_desc = &buf;
580 dev_desc->Size = sizeof(buf);
581 query.PropertyId = StorageDeviceProperty;
582 query.QueryType = PropertyStandardQuery;
583
584 if (!DeviceIoControl(vol_h, IOCTL_STORAGE_QUERY_PROPERTY, &query,
585 sizeof(STORAGE_PROPERTY_QUERY), dev_desc,
586 dev_desc->Size, &received, NULL)) {
587 error_setg_win32(errp, GetLastError(), "failed to get bus type");
588 return -1;
589 }
590
591 return dev_desc->BusType;
592}
593
594
595
596
597static GuestDiskAddressList *build_guest_disk_info(char *guid, Error **errp)
598{
599 GuestDiskAddressList *list = NULL;
600 GuestDiskAddress *disk;
601 SCSI_ADDRESS addr, *scsi_ad;
602 DWORD len;
603 int bus;
604 HANDLE vol_h;
605
606 scsi_ad = &addr;
607 char *name = g_strndup(guid, strlen(guid)-1);
608
609 vol_h = CreateFile(name, 0, FILE_SHARE_READ, NULL, OPEN_EXISTING,
610 0, NULL);
611 if (vol_h == INVALID_HANDLE_VALUE) {
612 error_setg_win32(errp, GetLastError(), "failed to open volume");
613 goto out_free;
614 }
615
616 bus = get_disk_bus_type(vol_h, errp);
617 if (bus < 0) {
618 goto out_close;
619 }
620
621 disk = g_malloc0(sizeof(*disk));
622 disk->bus_type = find_bus_type(bus);
623 if (bus == BusTypeScsi || bus == BusTypeAta || bus == BusTypeRAID
624#if (_WIN32_WINNT >= 0x0600)
625
626 || bus == BusTypeSas
627#endif
628 ) {
629
630
631
632 if (DeviceIoControl(vol_h, IOCTL_SCSI_GET_ADDRESS, NULL, 0, scsi_ad,
633 sizeof(SCSI_ADDRESS), &len, NULL)) {
634 disk->unit = addr.Lun;
635 disk->target = addr.TargetId;
636 disk->bus = addr.PathId;
637 disk->pci_controller = get_pci_info(name, errp);
638 }
639
640
641 } else {
642 disk->pci_controller = NULL;
643 }
644
645 list = g_malloc0(sizeof(*list));
646 list->value = disk;
647 list->next = NULL;
648out_close:
649 CloseHandle(vol_h);
650out_free:
651 g_free(name);
652 return list;
653}
654
655#else
656
657static GuestDiskAddressList *build_guest_disk_info(char *guid, Error **errp)
658{
659 return NULL;
660}
661
662#endif
663
664static GuestFilesystemInfo *build_guest_fsinfo(char *guid, Error **errp)
665{
666 DWORD info_size;
667 char mnt, *mnt_point;
668 char fs_name[32];
669 char vol_info[MAX_PATH+1];
670 size_t len;
671 GuestFilesystemInfo *fs = NULL;
672
673 GetVolumePathNamesForVolumeName(guid, (LPCH)&mnt, 0, &info_size);
674 if (GetLastError() != ERROR_MORE_DATA) {
675 error_setg_win32(errp, GetLastError(), "failed to get volume name");
676 return NULL;
677 }
678
679 mnt_point = g_malloc(info_size + 1);
680 if (!GetVolumePathNamesForVolumeName(guid, mnt_point, info_size,
681 &info_size)) {
682 error_setg_win32(errp, GetLastError(), "failed to get volume name");
683 goto free;
684 }
685
686 len = strlen(mnt_point);
687 mnt_point[len] = '\\';
688 mnt_point[len+1] = 0;
689 if (!GetVolumeInformation(mnt_point, vol_info, sizeof(vol_info), NULL, NULL,
690 NULL, (LPSTR)&fs_name, sizeof(fs_name))) {
691 if (GetLastError() != ERROR_NOT_READY) {
692 error_setg_win32(errp, GetLastError(), "failed to get volume info");
693 }
694 goto free;
695 }
696
697 fs_name[sizeof(fs_name) - 1] = 0;
698 fs = g_malloc(sizeof(*fs));
699 fs->name = g_strdup(guid);
700 if (len == 0) {
701 fs->mountpoint = g_strdup("System Reserved");
702 } else {
703 fs->mountpoint = g_strndup(mnt_point, len);
704 }
705 fs->type = g_strdup(fs_name);
706 fs->disk = build_guest_disk_info(guid, errp);
707free:
708 g_free(mnt_point);
709 return fs;
710}
711
712GuestFilesystemInfoList *qmp_guest_get_fsinfo(Error **errp)
713{
714 HANDLE vol_h;
715 GuestFilesystemInfoList *new, *ret = NULL;
716 char guid[256];
717
718 vol_h = FindFirstVolume(guid, sizeof(guid));
719 if (vol_h == INVALID_HANDLE_VALUE) {
720 error_setg_win32(errp, GetLastError(), "failed to find any volume");
721 return NULL;
722 }
723
724 do {
725 GuestFilesystemInfo *info = build_guest_fsinfo(guid, errp);
726 if (info == NULL) {
727 continue;
728 }
729 new = g_malloc(sizeof(*ret));
730 new->value = info;
731 new->next = ret;
732 ret = new;
733 } while (FindNextVolume(vol_h, guid, sizeof(guid)));
734
735 if (GetLastError() != ERROR_NO_MORE_FILES) {
736 error_setg_win32(errp, GetLastError(), "failed to find next volume");
737 }
738
739 FindVolumeClose(vol_h);
740 return ret;
741}
742
743
744
745
746GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **errp)
747{
748 if (!vss_initialized()) {
749 error_setg(errp, QERR_UNSUPPORTED);
750 return 0;
751 }
752
753 if (ga_is_frozen(ga_state)) {
754 return GUEST_FSFREEZE_STATUS_FROZEN;
755 }
756
757 return GUEST_FSFREEZE_STATUS_THAWED;
758}
759
760
761
762
763
764int64_t qmp_guest_fsfreeze_freeze(Error **errp)
765{
766 int i;
767 Error *local_err = NULL;
768
769 if (!vss_initialized()) {
770 error_setg(errp, QERR_UNSUPPORTED);
771 return 0;
772 }
773
774 slog("guest-fsfreeze called");
775
776
777 ga_set_frozen(ga_state);
778
779 qga_vss_fsfreeze(&i, true, &local_err);
780 if (local_err) {
781 error_propagate(errp, local_err);
782 goto error;
783 }
784
785 return i;
786
787error:
788 local_err = NULL;
789 qmp_guest_fsfreeze_thaw(&local_err);
790 if (local_err) {
791 g_debug("cleanup thaw: %s", error_get_pretty(local_err));
792 error_free(local_err);
793 }
794 return 0;
795}
796
797int64_t qmp_guest_fsfreeze_freeze_list(bool has_mountpoints,
798 strList *mountpoints,
799 Error **errp)
800{
801 error_setg(errp, QERR_UNSUPPORTED);
802
803 return 0;
804}
805
806
807
808
809int64_t qmp_guest_fsfreeze_thaw(Error **errp)
810{
811 int i;
812
813 if (!vss_initialized()) {
814 error_setg(errp, QERR_UNSUPPORTED);
815 return 0;
816 }
817
818 qga_vss_fsfreeze(&i, false, errp);
819
820 ga_unset_frozen(ga_state);
821 return i;
822}
823
824static void guest_fsfreeze_cleanup(void)
825{
826 Error *err = NULL;
827
828 if (!vss_initialized()) {
829 return;
830 }
831
832 if (ga_is_frozen(ga_state) == GUEST_FSFREEZE_STATUS_FROZEN) {
833 qmp_guest_fsfreeze_thaw(&err);
834 if (err) {
835 slog("failed to clean up frozen filesystems: %s",
836 error_get_pretty(err));
837 error_free(err);
838 }
839 }
840
841 vss_deinit(true);
842}
843
844
845
846
847
848GuestFilesystemTrimResponse *
849qmp_guest_fstrim(bool has_minimum, int64_t minimum, Error **errp)
850{
851 GuestFilesystemTrimResponse *resp;
852 HANDLE handle;
853 WCHAR guid[MAX_PATH] = L"";
854
855 handle = FindFirstVolumeW(guid, ARRAYSIZE(guid));
856 if (handle == INVALID_HANDLE_VALUE) {
857 error_setg_win32(errp, GetLastError(), "failed to find any volume");
858 return NULL;
859 }
860
861 resp = g_new0(GuestFilesystemTrimResponse, 1);
862
863 do {
864 GuestFilesystemTrimResult *res;
865 GuestFilesystemTrimResultList *list;
866 PWCHAR uc_path;
867 DWORD char_count = 0;
868 char *path, *out;
869 GError *gerr = NULL;
870 gchar * argv[4];
871
872 GetVolumePathNamesForVolumeNameW(guid, NULL, 0, &char_count);
873
874 if (GetLastError() != ERROR_MORE_DATA) {
875 continue;
876 }
877 if (GetDriveTypeW(guid) != DRIVE_FIXED) {
878 continue;
879 }
880
881 uc_path = g_malloc(sizeof(WCHAR) * char_count);
882 if (!GetVolumePathNamesForVolumeNameW(guid, uc_path, char_count,
883 &char_count) || !*uc_path) {
884
885 g_free(uc_path);
886 continue;
887 }
888
889 res = g_new0(GuestFilesystemTrimResult, 1);
890
891 path = g_utf16_to_utf8(uc_path, char_count, NULL, NULL, &gerr);
892
893 g_free(uc_path);
894
895 if (!path) {
896 res->has_error = true;
897 res->error = g_strdup(gerr->message);
898 g_error_free(gerr);
899 break;
900 }
901
902 res->path = path;
903
904 list = g_new0(GuestFilesystemTrimResultList, 1);
905 list->value = res;
906 list->next = resp->paths;
907
908 resp->paths = list;
909
910 memset(argv, 0, sizeof(argv));
911 argv[0] = (gchar *)"defrag.exe";
912 argv[1] = (gchar *)"/L";
913 argv[2] = path;
914
915 if (!g_spawn_sync(NULL, argv, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL,
916 &out , NULL ,
917 NULL, &gerr)) {
918 res->has_error = true;
919 res->error = g_strdup(gerr->message);
920 g_error_free(gerr);
921 } else {
922
923
924
925
926 int i;
927 gchar **lines = g_strsplit(out, "\r\n", 0);
928 g_free(out);
929
930 for (i = 0; lines[i] != NULL; i++) {
931 if (g_strstr_len(lines[i], -1, "(0x") == NULL) {
932 continue;
933 }
934 res->has_error = true;
935 res->error = g_strdup(lines[i]);
936 break;
937 }
938 g_strfreev(lines);
939 }
940 } while (FindNextVolumeW(handle, guid, ARRAYSIZE(guid)));
941
942 FindVolumeClose(handle);
943 return resp;
944}
945
946typedef enum {
947 GUEST_SUSPEND_MODE_DISK,
948 GUEST_SUSPEND_MODE_RAM
949} GuestSuspendMode;
950
951static void check_suspend_mode(GuestSuspendMode mode, Error **errp)
952{
953 SYSTEM_POWER_CAPABILITIES sys_pwr_caps;
954 Error *local_err = NULL;
955
956 ZeroMemory(&sys_pwr_caps, sizeof(sys_pwr_caps));
957 if (!GetPwrCapabilities(&sys_pwr_caps)) {
958 error_setg(&local_err, QERR_QGA_COMMAND_FAILED,
959 "failed to determine guest suspend capabilities");
960 goto out;
961 }
962
963 switch (mode) {
964 case GUEST_SUSPEND_MODE_DISK:
965 if (!sys_pwr_caps.SystemS4) {
966 error_setg(&local_err, QERR_QGA_COMMAND_FAILED,
967 "suspend-to-disk not supported by OS");
968 }
969 break;
970 case GUEST_SUSPEND_MODE_RAM:
971 if (!sys_pwr_caps.SystemS3) {
972 error_setg(&local_err, QERR_QGA_COMMAND_FAILED,
973 "suspend-to-ram not supported by OS");
974 }
975 break;
976 default:
977 error_setg(&local_err, QERR_INVALID_PARAMETER_VALUE, "mode",
978 "GuestSuspendMode");
979 }
980
981out:
982 error_propagate(errp, local_err);
983}
984
985static DWORD WINAPI do_suspend(LPVOID opaque)
986{
987 GuestSuspendMode *mode = opaque;
988 DWORD ret = 0;
989
990 if (!SetSuspendState(*mode == GUEST_SUSPEND_MODE_DISK, TRUE, TRUE)) {
991 slog("failed to suspend guest, %lu", GetLastError());
992 ret = -1;
993 }
994 g_free(mode);
995 return ret;
996}
997
998void qmp_guest_suspend_disk(Error **errp)
999{
1000 Error *local_err = NULL;
1001 GuestSuspendMode *mode = g_new(GuestSuspendMode, 1);
1002
1003 *mode = GUEST_SUSPEND_MODE_DISK;
1004 check_suspend_mode(*mode, &local_err);
1005 acquire_privilege(SE_SHUTDOWN_NAME, &local_err);
1006 execute_async(do_suspend, mode, &local_err);
1007
1008 if (local_err) {
1009 error_propagate(errp, local_err);
1010 g_free(mode);
1011 }
1012}
1013
1014void qmp_guest_suspend_ram(Error **errp)
1015{
1016 Error *local_err = NULL;
1017 GuestSuspendMode *mode = g_new(GuestSuspendMode, 1);
1018
1019 *mode = GUEST_SUSPEND_MODE_RAM;
1020 check_suspend_mode(*mode, &local_err);
1021 acquire_privilege(SE_SHUTDOWN_NAME, &local_err);
1022 execute_async(do_suspend, mode, &local_err);
1023
1024 if (local_err) {
1025 error_propagate(errp, local_err);
1026 g_free(mode);
1027 }
1028}
1029
1030void qmp_guest_suspend_hybrid(Error **errp)
1031{
1032 error_setg(errp, QERR_UNSUPPORTED);
1033}
1034
1035static IP_ADAPTER_ADDRESSES *guest_get_adapters_addresses(Error **errp)
1036{
1037 IP_ADAPTER_ADDRESSES *adptr_addrs = NULL;
1038 ULONG adptr_addrs_len = 0;
1039 DWORD ret;
1040
1041
1042 GetAdaptersAddresses(AF_UNSPEC, GAA_FLAG_INCLUDE_PREFIX,
1043 NULL, adptr_addrs, &adptr_addrs_len);
1044
1045 adptr_addrs = g_malloc(adptr_addrs_len);
1046 ret = GetAdaptersAddresses(AF_UNSPEC, GAA_FLAG_INCLUDE_PREFIX,
1047 NULL, adptr_addrs, &adptr_addrs_len);
1048 if (ret != ERROR_SUCCESS) {
1049 error_setg_win32(errp, ret, "failed to get adapters addresses");
1050 g_free(adptr_addrs);
1051 adptr_addrs = NULL;
1052 }
1053 return adptr_addrs;
1054}
1055
1056static char *guest_wctomb_dup(WCHAR *wstr)
1057{
1058 char *str;
1059 size_t i;
1060
1061 i = wcslen(wstr) + 1;
1062 str = g_malloc(i);
1063 WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK,
1064 wstr, -1, str, i, NULL, NULL);
1065 return str;
1066}
1067
1068static char *guest_addr_to_str(IP_ADAPTER_UNICAST_ADDRESS *ip_addr,
1069 Error **errp)
1070{
1071 char addr_str[INET6_ADDRSTRLEN + INET_ADDRSTRLEN];
1072 DWORD len;
1073 int ret;
1074
1075 if (ip_addr->Address.lpSockaddr->sa_family == AF_INET ||
1076 ip_addr->Address.lpSockaddr->sa_family == AF_INET6) {
1077 len = sizeof(addr_str);
1078 ret = WSAAddressToString(ip_addr->Address.lpSockaddr,
1079 ip_addr->Address.iSockaddrLength,
1080 NULL,
1081 addr_str,
1082 &len);
1083 if (ret != 0) {
1084 error_setg_win32(errp, WSAGetLastError(),
1085 "failed address presentation form conversion");
1086 return NULL;
1087 }
1088 return g_strdup(addr_str);
1089 }
1090 return NULL;
1091}
1092
1093#if (_WIN32_WINNT >= 0x0600)
1094static int64_t guest_ip_prefix(IP_ADAPTER_UNICAST_ADDRESS *ip_addr)
1095{
1096
1097
1098
1099 return ip_addr->OnLinkPrefixLength;
1100}
1101#else
1102
1103
1104
1105static IP_ADAPTER_INFO *guest_get_adapters_info(void)
1106{
1107 IP_ADAPTER_INFO *adptr_info = NULL;
1108 ULONG adptr_info_len = 0;
1109 DWORD ret;
1110
1111
1112 GetAdaptersInfo(adptr_info, &adptr_info_len);
1113
1114 adptr_info = g_malloc(adptr_info_len);
1115 ret = GetAdaptersInfo(adptr_info, &adptr_info_len);
1116 if (ret != ERROR_SUCCESS) {
1117 g_free(adptr_info);
1118 adptr_info = NULL;
1119 }
1120 return adptr_info;
1121}
1122
1123static int64_t guest_ip_prefix(IP_ADAPTER_UNICAST_ADDRESS *ip_addr)
1124{
1125 int64_t prefix = -1;
1126 IP_ADAPTER_INFO *adptr_info, *info;
1127 IP_ADDR_STRING *ip;
1128 struct in_addr *p;
1129
1130 if (ip_addr->Address.lpSockaddr->sa_family != AF_INET) {
1131 return prefix;
1132 }
1133 adptr_info = guest_get_adapters_info();
1134 if (adptr_info == NULL) {
1135 return prefix;
1136 }
1137
1138
1139
1140
1141 p = &((struct sockaddr_in *)ip_addr->Address.lpSockaddr)->sin_addr;
1142 for (info = adptr_info; info; info = info->Next) {
1143 for (ip = &info->IpAddressList; ip; ip = ip->Next) {
1144 if (p->S_un.S_addr == inet_addr(ip->IpAddress.String)) {
1145 prefix = ctpop32(inet_addr(ip->IpMask.String));
1146 goto out;
1147 }
1148 }
1149 }
1150out:
1151 g_free(adptr_info);
1152 return prefix;
1153}
1154#endif
1155
1156#define INTERFACE_PATH_BUF_SZ 512
1157
1158static DWORD get_interface_index(const char *guid)
1159{
1160 ULONG index;
1161 DWORD status;
1162 wchar_t wbuf[INTERFACE_PATH_BUF_SZ];
1163 snwprintf(wbuf, INTERFACE_PATH_BUF_SZ, L"\\device\\tcpip_%s", guid);
1164 wbuf[INTERFACE_PATH_BUF_SZ - 1] = 0;
1165 status = GetAdapterIndex (wbuf, &index);
1166 if (status != NO_ERROR) {
1167 return (DWORD)~0;
1168 } else {
1169 return index;
1170 }
1171}
1172
1173typedef NETIOAPI_API (WINAPI *GetIfEntry2Func)(PMIB_IF_ROW2 Row);
1174
1175static int guest_get_network_stats(const char *name,
1176 GuestNetworkInterfaceStat *stats)
1177{
1178 OSVERSIONINFO os_ver;
1179
1180 os_ver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
1181 GetVersionEx(&os_ver);
1182 if (os_ver.dwMajorVersion >= 6) {
1183 MIB_IF_ROW2 a_mid_ifrow;
1184 GetIfEntry2Func getifentry2_ex;
1185 DWORD if_index = 0;
1186 HMODULE module = GetModuleHandle("iphlpapi");
1187 PVOID func = GetProcAddress(module, "GetIfEntry2");
1188
1189 if (func == NULL) {
1190 return -1;
1191 }
1192
1193 getifentry2_ex = (GetIfEntry2Func)func;
1194 if_index = get_interface_index(name);
1195 if (if_index == (DWORD)~0) {
1196 return -1;
1197 }
1198
1199 memset(&a_mid_ifrow, 0, sizeof(a_mid_ifrow));
1200 a_mid_ifrow.InterfaceIndex = if_index;
1201 if (NO_ERROR == getifentry2_ex(&a_mid_ifrow)) {
1202 stats->rx_bytes = a_mid_ifrow.InOctets;
1203 stats->rx_packets = a_mid_ifrow.InUcastPkts;
1204 stats->rx_errs = a_mid_ifrow.InErrors;
1205 stats->rx_dropped = a_mid_ifrow.InDiscards;
1206 stats->tx_bytes = a_mid_ifrow.OutOctets;
1207 stats->tx_packets = a_mid_ifrow.OutUcastPkts;
1208 stats->tx_errs = a_mid_ifrow.OutErrors;
1209 stats->tx_dropped = a_mid_ifrow.OutDiscards;
1210 return 0;
1211 }
1212 }
1213 return -1;
1214}
1215
1216GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp)
1217{
1218 IP_ADAPTER_ADDRESSES *adptr_addrs, *addr;
1219 IP_ADAPTER_UNICAST_ADDRESS *ip_addr = NULL;
1220 GuestNetworkInterfaceList *head = NULL, *cur_item = NULL;
1221 GuestIpAddressList *head_addr, *cur_addr;
1222 GuestNetworkInterfaceList *info;
1223 GuestNetworkInterfaceStat *interface_stat = NULL;
1224 GuestIpAddressList *address_item = NULL;
1225 unsigned char *mac_addr;
1226 char *addr_str;
1227 WORD wsa_version;
1228 WSADATA wsa_data;
1229 int ret;
1230
1231 adptr_addrs = guest_get_adapters_addresses(errp);
1232 if (adptr_addrs == NULL) {
1233 return NULL;
1234 }
1235
1236
1237 wsa_version = MAKEWORD(2, 2);
1238 ret = WSAStartup(wsa_version, &wsa_data);
1239 if (ret != 0) {
1240 error_setg_win32(errp, ret, "failed socket startup");
1241 goto out;
1242 }
1243
1244 for (addr = adptr_addrs; addr; addr = addr->Next) {
1245 info = g_malloc0(sizeof(*info));
1246
1247 if (cur_item == NULL) {
1248 head = cur_item = info;
1249 } else {
1250 cur_item->next = info;
1251 cur_item = info;
1252 }
1253
1254 info->value = g_malloc0(sizeof(*info->value));
1255 info->value->name = guest_wctomb_dup(addr->FriendlyName);
1256
1257 if (addr->PhysicalAddressLength != 0) {
1258 mac_addr = addr->PhysicalAddress;
1259
1260 info->value->hardware_address =
1261 g_strdup_printf("%02x:%02x:%02x:%02x:%02x:%02x",
1262 (int) mac_addr[0], (int) mac_addr[1],
1263 (int) mac_addr[2], (int) mac_addr[3],
1264 (int) mac_addr[4], (int) mac_addr[5]);
1265
1266 info->value->has_hardware_address = true;
1267 }
1268
1269 head_addr = NULL;
1270 cur_addr = NULL;
1271 for (ip_addr = addr->FirstUnicastAddress;
1272 ip_addr;
1273 ip_addr = ip_addr->Next) {
1274 addr_str = guest_addr_to_str(ip_addr, errp);
1275 if (addr_str == NULL) {
1276 continue;
1277 }
1278
1279 address_item = g_malloc0(sizeof(*address_item));
1280
1281 if (!cur_addr) {
1282 head_addr = cur_addr = address_item;
1283 } else {
1284 cur_addr->next = address_item;
1285 cur_addr = address_item;
1286 }
1287
1288 address_item->value = g_malloc0(sizeof(*address_item->value));
1289 address_item->value->ip_address = addr_str;
1290 address_item->value->prefix = guest_ip_prefix(ip_addr);
1291 if (ip_addr->Address.lpSockaddr->sa_family == AF_INET) {
1292 address_item->value->ip_address_type =
1293 GUEST_IP_ADDRESS_TYPE_IPV4;
1294 } else if (ip_addr->Address.lpSockaddr->sa_family == AF_INET6) {
1295 address_item->value->ip_address_type =
1296 GUEST_IP_ADDRESS_TYPE_IPV6;
1297 }
1298 }
1299 if (head_addr) {
1300 info->value->has_ip_addresses = true;
1301 info->value->ip_addresses = head_addr;
1302 }
1303 if (!info->value->has_statistics) {
1304 interface_stat = g_malloc0(sizeof(*interface_stat));
1305 if (guest_get_network_stats(addr->AdapterName,
1306 interface_stat) == -1) {
1307 info->value->has_statistics = false;
1308 g_free(interface_stat);
1309 } else {
1310 info->value->statistics = interface_stat;
1311 info->value->has_statistics = true;
1312 }
1313 }
1314 }
1315 WSACleanup();
1316out:
1317 g_free(adptr_addrs);
1318 return head;
1319}
1320
1321int64_t qmp_guest_get_time(Error **errp)
1322{
1323 SYSTEMTIME ts = {0};
1324 FILETIME tf;
1325
1326 GetSystemTime(&ts);
1327 if (ts.wYear < 1601 || ts.wYear > 30827) {
1328 error_setg(errp, "Failed to get time");
1329 return -1;
1330 }
1331
1332 if (!SystemTimeToFileTime(&ts, &tf)) {
1333 error_setg(errp, "Failed to convert system time: %d", (int)GetLastError());
1334 return -1;
1335 }
1336
1337 return ((((int64_t)tf.dwHighDateTime << 32) | tf.dwLowDateTime)
1338 - W32_FT_OFFSET) * 100;
1339}
1340
1341void qmp_guest_set_time(bool has_time, int64_t time_ns, Error **errp)
1342{
1343 Error *local_err = NULL;
1344 SYSTEMTIME ts;
1345 FILETIME tf;
1346 LONGLONG time;
1347
1348 if (!has_time) {
1349
1350
1351
1352
1353
1354
1355
1356
1357 LPVOID msg_buffer;
1358 DWORD ret_flags;
1359
1360 HRESULT hr = system("w32tm /resync /nowait");
1361
1362 if (GetLastError() != 0) {
1363 strerror_s((LPTSTR) & msg_buffer, 0, errno);
1364 error_setg(errp, "system(...) failed: %s", (LPCTSTR)msg_buffer);
1365 } else if (hr != 0) {
1366 if (hr == HRESULT_FROM_WIN32(ERROR_SERVICE_NOT_ACTIVE)) {
1367 error_setg(errp, "Windows Time service not running on the "
1368 "guest");
1369 } else {
1370 if (!FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
1371 FORMAT_MESSAGE_FROM_SYSTEM |
1372 FORMAT_MESSAGE_IGNORE_INSERTS, NULL,
1373 (DWORD)hr, MAKELANGID(LANG_NEUTRAL,
1374 SUBLANG_DEFAULT), (LPTSTR) & msg_buffer, 0,
1375 NULL)) {
1376 error_setg(errp, "w32tm failed with error (0x%lx), couldn'"
1377 "t retrieve error message", hr);
1378 } else {
1379 error_setg(errp, "w32tm failed with error (0x%lx): %s", hr,
1380 (LPCTSTR)msg_buffer);
1381 LocalFree(msg_buffer);
1382 }
1383 }
1384 } else if (!InternetGetConnectedState(&ret_flags, 0)) {
1385 error_setg(errp, "No internet connection on guest, sync not "
1386 "accurate");
1387 }
1388 return;
1389 }
1390
1391
1392 if (time_ns < 0 || time_ns / 100 > INT64_MAX - W32_FT_OFFSET) {
1393 error_setg(errp, "Time %" PRId64 "is invalid", time_ns);
1394 return;
1395 }
1396
1397 time = time_ns / 100 + W32_FT_OFFSET;
1398
1399 tf.dwLowDateTime = (DWORD) time;
1400 tf.dwHighDateTime = (DWORD) (time >> 32);
1401
1402 if (!FileTimeToSystemTime(&tf, &ts)) {
1403 error_setg(errp, "Failed to convert system time %d",
1404 (int)GetLastError());
1405 return;
1406 }
1407
1408 acquire_privilege(SE_SYSTEMTIME_NAME, &local_err);
1409 if (local_err) {
1410 error_propagate(errp, local_err);
1411 return;
1412 }
1413
1414 if (!SetSystemTime(&ts)) {
1415 error_setg(errp, "Failed to set time to guest: %d", (int)GetLastError());
1416 return;
1417 }
1418}
1419
1420GuestLogicalProcessorList *qmp_guest_get_vcpus(Error **errp)
1421{
1422 PSYSTEM_LOGICAL_PROCESSOR_INFORMATION pslpi, ptr;
1423 DWORD length;
1424 GuestLogicalProcessorList *head, **link;
1425 Error *local_err = NULL;
1426 int64_t current;
1427
1428 ptr = pslpi = NULL;
1429 length = 0;
1430 current = 0;
1431 head = NULL;
1432 link = &head;
1433
1434 if ((GetLogicalProcessorInformation(pslpi, &length) == FALSE) &&
1435 (GetLastError() == ERROR_INSUFFICIENT_BUFFER) &&
1436 (length > sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION))) {
1437 ptr = pslpi = g_malloc0(length);
1438 if (GetLogicalProcessorInformation(pslpi, &length) == FALSE) {
1439 error_setg(&local_err, "Failed to get processor information: %d",
1440 (int)GetLastError());
1441 }
1442 } else {
1443 error_setg(&local_err,
1444 "Failed to get processor information buffer length: %d",
1445 (int)GetLastError());
1446 }
1447
1448 while ((local_err == NULL) && (length > 0)) {
1449 if (pslpi->Relationship == RelationProcessorCore) {
1450 ULONG_PTR cpu_bits = pslpi->ProcessorMask;
1451
1452 while (cpu_bits > 0) {
1453 if (!!(cpu_bits & 1)) {
1454 GuestLogicalProcessor *vcpu;
1455 GuestLogicalProcessorList *entry;
1456
1457 vcpu = g_malloc0(sizeof *vcpu);
1458 vcpu->logical_id = current++;
1459 vcpu->online = true;
1460 vcpu->has_can_offline = true;
1461
1462 entry = g_malloc0(sizeof *entry);
1463 entry->value = vcpu;
1464
1465 *link = entry;
1466 link = &entry->next;
1467 }
1468 cpu_bits >>= 1;
1469 }
1470 }
1471 length -= sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
1472 pslpi++;
1473 }
1474
1475 g_free(ptr);
1476
1477 if (local_err == NULL) {
1478 if (head != NULL) {
1479 return head;
1480 }
1481
1482 error_setg(&local_err, "Guest reported zero VCPUs");
1483 }
1484
1485 qapi_free_GuestLogicalProcessorList(head);
1486 error_propagate(errp, local_err);
1487 return NULL;
1488}
1489
1490int64_t qmp_guest_set_vcpus(GuestLogicalProcessorList *vcpus, Error **errp)
1491{
1492 error_setg(errp, QERR_UNSUPPORTED);
1493 return -1;
1494}
1495
1496static gchar *
1497get_net_error_message(gint error)
1498{
1499 HMODULE module = NULL;
1500 gchar *retval = NULL;
1501 wchar_t *msg = NULL;
1502 int flags;
1503 size_t nchars;
1504
1505 flags = FORMAT_MESSAGE_ALLOCATE_BUFFER |
1506 FORMAT_MESSAGE_IGNORE_INSERTS |
1507 FORMAT_MESSAGE_FROM_SYSTEM;
1508
1509 if (error >= NERR_BASE && error <= MAX_NERR) {
1510 module = LoadLibraryExW(L"netmsg.dll", NULL, LOAD_LIBRARY_AS_DATAFILE);
1511
1512 if (module != NULL) {
1513 flags |= FORMAT_MESSAGE_FROM_HMODULE;
1514 }
1515 }
1516
1517 FormatMessageW(flags, module, error, 0, (LPWSTR)&msg, 0, NULL);
1518
1519 if (msg != NULL) {
1520 nchars = wcslen(msg);
1521
1522 if (nchars >= 2 &&
1523 msg[nchars - 1] == L'\n' &&
1524 msg[nchars - 2] == L'\r') {
1525 msg[nchars - 2] = L'\0';
1526 }
1527
1528 retval = g_utf16_to_utf8(msg, -1, NULL, NULL, NULL);
1529
1530 LocalFree(msg);
1531 }
1532
1533 if (module != NULL) {
1534 FreeLibrary(module);
1535 }
1536
1537 return retval;
1538}
1539
1540void qmp_guest_set_user_password(const char *username,
1541 const char *password,
1542 bool crypted,
1543 Error **errp)
1544{
1545 NET_API_STATUS nas;
1546 char *rawpasswddata = NULL;
1547 size_t rawpasswdlen;
1548 wchar_t *user = NULL, *wpass = NULL;
1549 USER_INFO_1003 pi1003 = { 0, };
1550 GError *gerr = NULL;
1551
1552 if (crypted) {
1553 error_setg(errp, QERR_UNSUPPORTED);
1554 return;
1555 }
1556
1557 rawpasswddata = (char *)qbase64_decode(password, -1, &rawpasswdlen, errp);
1558 if (!rawpasswddata) {
1559 return;
1560 }
1561 rawpasswddata = g_renew(char, rawpasswddata, rawpasswdlen + 1);
1562 rawpasswddata[rawpasswdlen] = '\0';
1563
1564 user = g_utf8_to_utf16(username, -1, NULL, NULL, &gerr);
1565 if (!user) {
1566 goto done;
1567 }
1568
1569 wpass = g_utf8_to_utf16(rawpasswddata, -1, NULL, NULL, &gerr);
1570 if (!wpass) {
1571 goto done;
1572 }
1573
1574 pi1003.usri1003_password = wpass;
1575 nas = NetUserSetInfo(NULL, user,
1576 1003, (LPBYTE)&pi1003,
1577 NULL);
1578
1579 if (nas != NERR_Success) {
1580 gchar *msg = get_net_error_message(nas);
1581 error_setg(errp, "failed to set password: %s", msg);
1582 g_free(msg);
1583 }
1584
1585done:
1586 if (gerr) {
1587 error_setg(errp, QERR_QGA_COMMAND_FAILED, gerr->message);
1588 g_error_free(gerr);
1589 }
1590 g_free(user);
1591 g_free(wpass);
1592 g_free(rawpasswddata);
1593}
1594
1595GuestMemoryBlockList *qmp_guest_get_memory_blocks(Error **errp)
1596{
1597 error_setg(errp, QERR_UNSUPPORTED);
1598 return NULL;
1599}
1600
1601GuestMemoryBlockResponseList *
1602qmp_guest_set_memory_blocks(GuestMemoryBlockList *mem_blks, Error **errp)
1603{
1604 error_setg(errp, QERR_UNSUPPORTED);
1605 return NULL;
1606}
1607
1608GuestMemoryBlockInfo *qmp_guest_get_memory_block_info(Error **errp)
1609{
1610 error_setg(errp, QERR_UNSUPPORTED);
1611 return NULL;
1612}
1613
1614
1615GList *ga_command_blacklist_init(GList *blacklist)
1616{
1617 const char *list_unsupported[] = {
1618 "guest-suspend-hybrid",
1619 "guest-set-vcpus",
1620 "guest-get-memory-blocks", "guest-set-memory-blocks",
1621 "guest-get-memory-block-size",
1622 "guest-fsfreeze-freeze-list",
1623 NULL};
1624 char **p = (char **)list_unsupported;
1625
1626 while (*p) {
1627 blacklist = g_list_append(blacklist, g_strdup(*p++));
1628 }
1629
1630 if (!vss_init(true)) {
1631 g_debug("vss_init failed, vss commands are going to be disabled");
1632 const char *list[] = {
1633 "guest-get-fsinfo", "guest-fsfreeze-status",
1634 "guest-fsfreeze-freeze", "guest-fsfreeze-thaw", NULL};
1635 p = (char **)list;
1636
1637 while (*p) {
1638 blacklist = g_list_append(blacklist, g_strdup(*p++));
1639 }
1640 }
1641
1642 return blacklist;
1643}
1644
1645
1646void ga_command_state_init(GAState *s, GACommandState *cs)
1647{
1648 if (!vss_initialized()) {
1649 ga_command_state_add(cs, NULL, guest_fsfreeze_cleanup);
1650 }
1651}
1652
1653
1654typedef struct _GA_WTSINFOA {
1655 WTS_CONNECTSTATE_CLASS State;
1656 DWORD SessionId;
1657 DWORD IncomingBytes;
1658 DWORD OutgoingBytes;
1659 DWORD IncomingFrames;
1660 DWORD OutgoingFrames;
1661 DWORD IncomingCompressedBytes;
1662 DWORD OutgoingCompressedBy;
1663 CHAR WinStationName[WINSTATIONNAME_LENGTH];
1664 CHAR Domain[DOMAIN_LENGTH];
1665 CHAR UserName[USERNAME_LENGTH + 1];
1666 LARGE_INTEGER ConnectTime;
1667 LARGE_INTEGER DisconnectTime;
1668 LARGE_INTEGER LastInputTime;
1669 LARGE_INTEGER LogonTime;
1670 LARGE_INTEGER CurrentTime;
1671
1672} GA_WTSINFOA;
1673
1674GuestUserList *qmp_guest_get_users(Error **err)
1675{
1676#if (_WIN32_WINNT >= 0x0600)
1677#define QGA_NANOSECONDS 10000000
1678
1679 GHashTable *cache = NULL;
1680 GuestUserList *head = NULL, *cur_item = NULL;
1681
1682 DWORD buffer_size = 0, count = 0, i = 0;
1683 GA_WTSINFOA *info = NULL;
1684 WTS_SESSION_INFOA *entries = NULL;
1685 GuestUserList *item = NULL;
1686 GuestUser *user = NULL;
1687 gpointer value = NULL;
1688 INT64 login = 0;
1689 double login_time = 0;
1690
1691 cache = g_hash_table_new(g_str_hash, g_str_equal);
1692
1693 if (WTSEnumerateSessionsA(NULL, 0, 1, &entries, &count)) {
1694 for (i = 0; i < count; ++i) {
1695 buffer_size = 0;
1696 info = NULL;
1697 if (WTSQuerySessionInformationA(
1698 NULL,
1699 entries[i].SessionId,
1700 WTSSessionInfo,
1701 (LPSTR *)&info,
1702 &buffer_size
1703 )) {
1704
1705 if (strlen(info->UserName) == 0) {
1706 WTSFreeMemory(info);
1707 continue;
1708 }
1709
1710 login = info->LogonTime.QuadPart;
1711 login -= W32_FT_OFFSET;
1712 login_time = ((double)login) / QGA_NANOSECONDS;
1713
1714 if (g_hash_table_contains(cache, info->UserName)) {
1715 value = g_hash_table_lookup(cache, info->UserName);
1716 user = (GuestUser *)value;
1717 if (user->login_time > login_time) {
1718 user->login_time = login_time;
1719 }
1720 } else {
1721 item = g_new0(GuestUserList, 1);
1722 item->value = g_new0(GuestUser, 1);
1723
1724 item->value->user = g_strdup(info->UserName);
1725 item->value->domain = g_strdup(info->Domain);
1726 item->value->has_domain = true;
1727
1728 item->value->login_time = login_time;
1729
1730 g_hash_table_add(cache, item->value->user);
1731
1732 if (!cur_item) {
1733 head = cur_item = item;
1734 } else {
1735 cur_item->next = item;
1736 cur_item = item;
1737 }
1738 }
1739 }
1740 WTSFreeMemory(info);
1741 }
1742 WTSFreeMemory(entries);
1743 }
1744 g_hash_table_destroy(cache);
1745 return head;
1746#else
1747 error_setg(err, QERR_UNSUPPORTED);
1748 return NULL;
1749#endif
1750}
1751
1752typedef struct _ga_matrix_lookup_t {
1753 int major;
1754 int minor;
1755 char const *version;
1756 char const *version_id;
1757} ga_matrix_lookup_t;
1758
1759static ga_matrix_lookup_t const WIN_VERSION_MATRIX[2][8] = {
1760 {
1761
1762 { 5, 0, "Microsoft Windows 2000", "2000"},
1763 { 5, 1, "Microsoft Windows XP", "xp"},
1764 { 6, 0, "Microsoft Windows Vista", "vista"},
1765 { 6, 1, "Microsoft Windows 7" "7"},
1766 { 6, 2, "Microsoft Windows 8", "8"},
1767 { 6, 3, "Microsoft Windows 8.1", "8.1"},
1768 {10, 0, "Microsoft Windows 10", "10"},
1769 { 0, 0, 0}
1770 },{
1771
1772 { 5, 2, "Microsoft Windows Server 2003", "2003"},
1773 { 6, 0, "Microsoft Windows Server 2008", "2008"},
1774 { 6, 1, "Microsoft Windows Server 2008 R2", "2008r2"},
1775 { 6, 2, "Microsoft Windows Server 2012", "2012"},
1776 { 6, 3, "Microsoft Windows Server 2012 R2", "2012r2"},
1777 {10, 0, "Microsoft Windows Server 2016", "2016"},
1778 { 0, 0, 0},
1779 { 0, 0, 0}
1780 }
1781};
1782
1783static void ga_get_win_version(RTL_OSVERSIONINFOEXW *info, Error **errp)
1784{
1785 typedef NTSTATUS(WINAPI * rtl_get_version_t)(
1786 RTL_OSVERSIONINFOEXW *os_version_info_ex);
1787
1788 info->dwOSVersionInfoSize = sizeof(RTL_OSVERSIONINFOEXW);
1789
1790 HMODULE module = GetModuleHandle("ntdll");
1791 PVOID fun = GetProcAddress(module, "RtlGetVersion");
1792 if (fun == NULL) {
1793 error_setg(errp, QERR_QGA_COMMAND_FAILED,
1794 "Failed to get address of RtlGetVersion");
1795 return;
1796 }
1797
1798 rtl_get_version_t rtl_get_version = (rtl_get_version_t)fun;
1799 rtl_get_version(info);
1800 return;
1801}
1802
1803static char *ga_get_win_name(OSVERSIONINFOEXW const *os_version, bool id)
1804{
1805 DWORD major = os_version->dwMajorVersion;
1806 DWORD minor = os_version->dwMinorVersion;
1807 int tbl_idx = (os_version->wProductType != VER_NT_WORKSTATION);
1808 ga_matrix_lookup_t const *table = WIN_VERSION_MATRIX[tbl_idx];
1809 while (table->version != NULL) {
1810 if (major == table->major && minor == table->minor) {
1811 if (id) {
1812 return g_strdup(table->version_id);
1813 } else {
1814 return g_strdup(table->version);
1815 }
1816 }
1817 ++table;
1818 }
1819 slog("failed to lookup Windows version: major=%lu, minor=%lu",
1820 major, minor);
1821 return g_strdup("N/A");
1822}
1823
1824static char *ga_get_win_product_name(Error **errp)
1825{
1826 HKEY key = NULL;
1827 DWORD size = 128;
1828 char *result = g_malloc0(size);
1829 LONG err = ERROR_SUCCESS;
1830
1831 err = RegOpenKeyA(HKEY_LOCAL_MACHINE,
1832 "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion",
1833 &key);
1834 if (err != ERROR_SUCCESS) {
1835 error_setg_win32(errp, err, "failed to open registry key");
1836 goto fail;
1837 }
1838
1839 err = RegQueryValueExA(key, "ProductName", NULL, NULL,
1840 (LPBYTE)result, &size);
1841 if (err == ERROR_MORE_DATA) {
1842 slog("ProductName longer than expected (%lu bytes), retrying",
1843 size);
1844 g_free(result);
1845 result = NULL;
1846 if (size > 0) {
1847 result = g_malloc0(size);
1848 err = RegQueryValueExA(key, "ProductName", NULL, NULL,
1849 (LPBYTE)result, &size);
1850 }
1851 }
1852 if (err != ERROR_SUCCESS) {
1853 error_setg_win32(errp, err, "failed to retrive ProductName");
1854 goto fail;
1855 }
1856
1857 return result;
1858
1859fail:
1860 g_free(result);
1861 return NULL;
1862}
1863
1864static char *ga_get_current_arch(void)
1865{
1866 SYSTEM_INFO info;
1867 GetNativeSystemInfo(&info);
1868 char *result = NULL;
1869 switch (info.wProcessorArchitecture) {
1870 case PROCESSOR_ARCHITECTURE_AMD64:
1871 result = g_strdup("x86_64");
1872 break;
1873 case PROCESSOR_ARCHITECTURE_ARM:
1874 result = g_strdup("arm");
1875 break;
1876 case PROCESSOR_ARCHITECTURE_IA64:
1877 result = g_strdup("ia64");
1878 break;
1879 case PROCESSOR_ARCHITECTURE_INTEL:
1880 result = g_strdup("x86");
1881 break;
1882 case PROCESSOR_ARCHITECTURE_UNKNOWN:
1883 default:
1884 slog("unknown processor architecture 0x%0x",
1885 info.wProcessorArchitecture);
1886 result = g_strdup("unknown");
1887 break;
1888 }
1889 return result;
1890}
1891
1892GuestOSInfo *qmp_guest_get_osinfo(Error **errp)
1893{
1894 Error *local_err = NULL;
1895 OSVERSIONINFOEXW os_version = {0};
1896 bool server;
1897 char *product_name;
1898 GuestOSInfo *info;
1899
1900 ga_get_win_version(&os_version, &local_err);
1901 if (local_err) {
1902 error_propagate(errp, local_err);
1903 return NULL;
1904 }
1905
1906 server = os_version.wProductType != VER_NT_WORKSTATION;
1907 product_name = ga_get_win_product_name(&local_err);
1908 if (product_name == NULL) {
1909 error_propagate(errp, local_err);
1910 return NULL;
1911 }
1912
1913 info = g_new0(GuestOSInfo, 1);
1914
1915 info->has_kernel_version = true;
1916 info->kernel_version = g_strdup_printf("%lu.%lu",
1917 os_version.dwMajorVersion,
1918 os_version.dwMinorVersion);
1919 info->has_kernel_release = true;
1920 info->kernel_release = g_strdup_printf("%lu",
1921 os_version.dwBuildNumber);
1922 info->has_machine = true;
1923 info->machine = ga_get_current_arch();
1924
1925 info->has_id = true;
1926 info->id = g_strdup("mswindows");
1927 info->has_name = true;
1928 info->name = g_strdup("Microsoft Windows");
1929 info->has_pretty_name = true;
1930 info->pretty_name = product_name;
1931 info->has_version = true;
1932 info->version = ga_get_win_name(&os_version, false);
1933 info->has_version_id = true;
1934 info->version_id = ga_get_win_name(&os_version, true);
1935 info->has_variant = true;
1936 info->variant = g_strdup(server ? "server" : "client");
1937 info->has_variant_id = true;
1938 info->variant_id = g_strdup(server ? "server" : "client");
1939
1940 return info;
1941}
1942
