VirtualBox

source: vbox/trunk/src/VBox/Frontends/VBoxManage/VBoxManageInfo.cpp@ 25275

Last change on this file since 25275 was 25149, checked in by vboxsync, 14 years ago

Main: cleanup: remove all CheckComRC* macros (no functional change)
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 80.2 KB
Line 
1/* $Id: VBoxManageInfo.cpp 25149 2009-12-02 14:34:47Z vboxsync $ */
2/** @file
3 * VBoxManage - The 'showvminfo' command and helper routines.
4 */
5
6/*
7 * Copyright (C) 2006-2009 Sun Microsystems, Inc.
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18 * Clara, CA 95054 USA or visit http://www.sun.com if you need
19 * additional information or have any questions.
20 */
21
22#ifndef VBOX_ONLY_DOCS
23
24/*******************************************************************************
25* Header Files *
26*******************************************************************************/
27#include <VBox/com/com.h>
28#include <VBox/com/string.h>
29#include <VBox/com/Guid.h>
30#include <VBox/com/array.h>
31#include <VBox/com/ErrorInfo.h>
32#include <VBox/com/errorprint.h>
33
34#include <VBox/com/VirtualBox.h>
35
36#include <VBox/log.h>
37#include <iprt/stream.h>
38#include <iprt/time.h>
39#include <iprt/string.h>
40#include <iprt/getopt.h>
41#include <iprt/ctype.h>
42
43#include "VBoxManage.h"
44using namespace com;
45
46
47// funcs
48///////////////////////////////////////////////////////////////////////////////
49
50void showSnapshots(ComPtr<ISnapshot> &rootSnapshot,
51 ComPtr<ISnapshot> &currentSnapshot,
52 VMINFO_DETAILS details,
53 const Bstr &prefix /* = ""*/,
54 int level /*= 0*/)
55{
56 /* start with the root */
57 Bstr name;
58 Bstr uuid;
59 rootSnapshot->COMGETTER(Name)(name.asOutParam());
60 rootSnapshot->COMGETTER(Id)(uuid.asOutParam());
61 if (details == VMINFO_MACHINEREADABLE)
62 {
63 /* print with hierarchical numbering */
64 RTPrintf("SnapshotName%lS=\"%lS\"\n", prefix.raw(), name.raw());
65 RTPrintf("SnapshotUUID%lS=\"%s\"\n", prefix.raw(), Utf8Str(uuid).raw());
66 }
67 else
68 {
69 /* print with indentation */
70 bool fCurrent = (rootSnapshot == currentSnapshot);
71 RTPrintf(" %lSName: %lS (UUID: %s)%s\n",
72 prefix.raw(),
73 name.raw(),
74 Utf8Str(uuid).raw(),
75 (fCurrent) ? " *" : "");
76 }
77
78 /* get the children */
79 SafeIfaceArray <ISnapshot> coll;
80 rootSnapshot->COMGETTER(Children)(ComSafeArrayAsOutParam(coll));
81 if (!coll.isNull())
82 {
83 for (size_t index = 0; index < coll.size(); ++index)
84 {
85 ComPtr<ISnapshot> snapshot = coll[index];
86 if (snapshot)
87 {
88 Bstr newPrefix;
89 if (details == VMINFO_MACHINEREADABLE)
90 newPrefix = Utf8StrFmt("%lS-%d", prefix.raw(), index + 1);
91 else
92 {
93 newPrefix = Utf8StrFmt("%lS ", prefix.raw());
94 }
95
96 /* recursive call */
97 showSnapshots(snapshot, currentSnapshot, details, newPrefix, level + 1);
98 }
99 }
100 }
101}
102
103static void makeTimeStr (char *s, int cb, int64_t millies)
104{
105 RTTIME t;
106 RTTIMESPEC ts;
107
108 RTTimeSpecSetMilli(&ts, millies);
109
110 RTTimeExplode (&t, &ts);
111
112 RTStrPrintf(s, cb, "%04d/%02d/%02d %02d:%02d:%02d UTC",
113 t.i32Year, t.u8Month, t.u8MonthDay,
114 t.u8Hour, t.u8Minute, t.u8Second);
115}
116
117/* Disable global optimizations for MSC 8.0/64 to make it compile in reasonable
118 time. MSC 7.1/32 doesn't have quite as much trouble with it, but still
119 sufficient to qualify for this hack as well since this code isn't performance
120 critical and probably won't gain much from the extra optimizing in real life. */
121#if defined(_MSC_VER)
122# pragma optimize("g", off)
123#endif
124
125HRESULT showVMInfo (ComPtr<IVirtualBox> virtualBox,
126 ComPtr<IMachine> machine,
127 VMINFO_DETAILS details /*= VMINFO_NONE*/,
128 ComPtr<IConsole> console /*= ComPtr <IConsole> ()*/)
129{
130 HRESULT rc;
131
132 /*
133 * The rules for output in -argdump format:
134 * 1) the key part (the [0-9a-zA-Z_]+ string before the '=' delimiter)
135 * is all lowercase for "VBoxManage modifyvm" parameters. Any
136 * other values printed are in CamelCase.
137 * 2) strings (anything non-decimal) are printed surrounded by
138 * double quotes '"'. If the strings themselves contain double
139 * quotes, these characters are escaped by '\'. Any '\' character
140 * in the original string is also escaped by '\'.
141 * 3) numbers (containing just [0-9\-]) are written out unchanged.
142 */
143
144 /** @todo the quoting is not yet implemented! */
145 /** @todo error checking! */
146
147 BOOL accessible = FALSE;
148 CHECK_ERROR(machine, COMGETTER(Accessible)(&accessible));
149 if (FAILED(rc)) return rc;
150
151 Bstr uuid;
152 rc = machine->COMGETTER(Id)(uuid.asOutParam());
153
154 if (!accessible)
155 {
156 if (details == VMINFO_COMPACT)
157 RTPrintf("\"<inaccessible>\" {%s}\n", Utf8Str(uuid).raw());
158 else
159 {
160 if (details == VMINFO_MACHINEREADABLE)
161 RTPrintf("name=\"<inaccessible>\"\n");
162 else
163 RTPrintf("Name: <inaccessible!>\n");
164 if (details == VMINFO_MACHINEREADABLE)
165 RTPrintf("UUID=\"%s\"\n", Utf8Str(uuid).raw());
166 else
167 RTPrintf("UUID: %s\n", Utf8Str(uuid).raw());
168 if (details != VMINFO_MACHINEREADABLE)
169 {
170 Bstr settingsFilePath;
171 rc = machine->COMGETTER(SettingsFilePath)(settingsFilePath.asOutParam());
172 RTPrintf("Config file: %lS\n", settingsFilePath.raw());
173 ComPtr<IVirtualBoxErrorInfo> accessError;
174 rc = machine->COMGETTER(AccessError)(accessError.asOutParam());
175 RTPrintf("Access error details:\n");
176 ErrorInfo ei(accessError);
177 GluePrintErrorInfo(ei);
178 RTPrintf("\n");
179 }
180 }
181 return S_OK;
182 }
183
184 Bstr machineName;
185 rc = machine->COMGETTER(Name)(machineName.asOutParam());
186
187 if (details == VMINFO_COMPACT)
188 {
189 RTPrintf("\"%lS\" {%s}\n", machineName.raw(), Utf8Str(uuid).raw());
190 return S_OK;
191 }
192
193 if (details == VMINFO_MACHINEREADABLE)
194 RTPrintf("name=\"%lS\"\n", machineName.raw());
195 else
196 RTPrintf("Name: %lS\n", machineName.raw());
197
198 Bstr osTypeId;
199 rc = machine->COMGETTER(OSTypeId)(osTypeId.asOutParam());
200 ComPtr<IGuestOSType> osType;
201 rc = virtualBox->GetGuestOSType (osTypeId, osType.asOutParam());
202 Bstr osName;
203 rc = osType->COMGETTER(Description)(osName.asOutParam());
204 if (details == VMINFO_MACHINEREADABLE)
205 RTPrintf("ostype=\"%lS\"\n", osTypeId.raw());
206 else
207 RTPrintf("Guest OS: %lS\n", osName.raw());
208
209 if (details == VMINFO_MACHINEREADABLE)
210 RTPrintf("UUID=\"%s\"\n", Utf8Str(uuid).raw());
211 else
212 RTPrintf("UUID: %s\n", Utf8Str(uuid).raw());
213
214 Bstr settingsFilePath;
215 rc = machine->COMGETTER(SettingsFilePath)(settingsFilePath.asOutParam());
216 if (details == VMINFO_MACHINEREADABLE)
217 RTPrintf("CfgFile=\"%lS\"\n", settingsFilePath.raw());
218 else
219 RTPrintf("Config file: %lS\n", settingsFilePath.raw());
220
221 Bstr strHardwareUuid;
222 rc = machine->COMGETTER(HardwareUUID)(strHardwareUuid.asOutParam());
223 if (details == VMINFO_MACHINEREADABLE)
224 RTPrintf("hardwareuuid=\"%lS\"\n", strHardwareUuid.raw());
225 else
226 RTPrintf("Hardware UUID: %lS\n", strHardwareUuid.raw());
227
228 ULONG memorySize;
229 rc = machine->COMGETTER(MemorySize)(&memorySize);
230 if (details == VMINFO_MACHINEREADABLE)
231 RTPrintf("memory=%u\n", memorySize);
232 else
233 RTPrintf("Memory size: %uMB\n", memorySize);
234
235 ULONG vramSize;
236 rc = machine->COMGETTER(VRAMSize)(&vramSize);
237 if (details == VMINFO_MACHINEREADABLE)
238 RTPrintf("vram=%u\n", vramSize);
239 else
240 RTPrintf("VRAM size: %uMB\n", vramSize);
241
242 ULONG numCpus;
243 rc = machine->COMGETTER(CPUCount)(&numCpus);
244 if (details == VMINFO_MACHINEREADABLE)
245 RTPrintf("cpus=%u\n", numCpus);
246 else
247 RTPrintf("Number of CPUs: %u\n", numCpus);
248
249 BOOL fSyntheticCpu;
250 machine->GetCpuProperty(CpuPropertyType_Synthetic, &fSyntheticCpu);
251 if (details == VMINFO_MACHINEREADABLE)
252 RTPrintf("synthcpu=\"%s\"\n", fSyntheticCpu ? "on" : "off");
253 else
254 RTPrintf("Synthetic Cpu: %s\n", fSyntheticCpu ? "on" : "off");
255
256 if (details != VMINFO_MACHINEREADABLE)
257 RTPrintf("CPUID overrides: ");
258 ULONG cFound = 0;
259 static uint32_t const s_auCpuIdRanges[] =
260 {
261 UINT32_C(0x00000000), UINT32_C(0x0000000a),
262 UINT32_C(0x80000000), UINT32_C(0x8000000a)
263 };
264 for (unsigned i = 0; i < RT_ELEMENTS(s_auCpuIdRanges); i += 2)
265 for (uint32_t uLeaf = s_auCpuIdRanges[i]; uLeaf < s_auCpuIdRanges[i + 1]; uLeaf++)
266 {
267 ULONG uEAX, uEBX, uECX, uEDX;
268 rc = machine->GetCpuIdLeaf(uLeaf, &uEAX, &uEBX, &uECX, &uEDX);
269 if (SUCCEEDED(rc))
270 {
271 if (details == VMINFO_MACHINEREADABLE)
272 RTPrintf("cpuid=%08x,%08x,%08x,%08x,%08x", uLeaf, uEAX, uEBX, uECX, uEDX);
273 else
274 {
275 if (!cFound)
276 RTPrintf("Leaf no. EAX EBX ECX EDX\n");
277 RTPrintf(" %08x %08x %08x %08x %08x\n", uLeaf, uEAX, uEBX, uECX, uEDX);
278 }
279 cFound++;
280 }
281 }
282 if (!cFound && details != VMINFO_MACHINEREADABLE)
283 RTPrintf("None\n");
284
285 ComPtr <IBIOSSettings> biosSettings;
286 machine->COMGETTER(BIOSSettings)(biosSettings.asOutParam());
287
288 BIOSBootMenuMode_T bootMenuMode;
289 biosSettings->COMGETTER(BootMenuMode)(&bootMenuMode);
290 const char *pszBootMenu = NULL;
291 switch (bootMenuMode)
292 {
293 case BIOSBootMenuMode_Disabled:
294 pszBootMenu = "disabled";
295 break;
296 case BIOSBootMenuMode_MenuOnly:
297 if (details == VMINFO_MACHINEREADABLE)
298 pszBootMenu = "menuonly";
299 else
300 pszBootMenu = "menu only";
301 break;
302 default:
303 if (details == VMINFO_MACHINEREADABLE)
304 pszBootMenu = "messageandmenu";
305 else
306 pszBootMenu = "message and menu";
307 }
308 if (details == VMINFO_MACHINEREADABLE)
309 RTPrintf("bootmenu=\"%s\"\n", pszBootMenu);
310 else
311 RTPrintf("Boot menu mode: %s\n", pszBootMenu);
312
313 ULONG maxBootPosition = 0;
314 ComPtr<ISystemProperties> systemProperties;
315 virtualBox->COMGETTER(SystemProperties)(systemProperties.asOutParam());
316 systemProperties->COMGETTER(MaxBootPosition)(&maxBootPosition);
317 for (ULONG i = 1; i <= maxBootPosition; i++)
318 {
319 DeviceType_T bootOrder;
320 machine->GetBootOrder(i, &bootOrder);
321 if (bootOrder == DeviceType_Floppy)
322 {
323 if (details == VMINFO_MACHINEREADABLE)
324 RTPrintf("boot%d=\"floppy\"\n", i);
325 else
326 RTPrintf("Boot Device (%d): Floppy\n", i);
327 }
328 else if (bootOrder == DeviceType_DVD)
329 {
330 if (details == VMINFO_MACHINEREADABLE)
331 RTPrintf("boot%d=\"dvd\"\n", i);
332 else
333 RTPrintf("Boot Device (%d): DVD\n", i);
334 }
335 else if (bootOrder == DeviceType_HardDisk)
336 {
337 if (details == VMINFO_MACHINEREADABLE)
338 RTPrintf("boot%d=\"disk\"\n", i);
339 else
340 RTPrintf("Boot Device (%d): HardDisk\n", i);
341 }
342 else if (bootOrder == DeviceType_Network)
343 {
344 if (details == VMINFO_MACHINEREADABLE)
345 RTPrintf("boot%d=\"net\"\n", i);
346 else
347 RTPrintf("Boot Device (%d): Network\n", i);
348 }
349 else if (bootOrder == DeviceType_USB)
350 {
351 if (details == VMINFO_MACHINEREADABLE)
352 RTPrintf("boot%d=\"usb\"\n", i);
353 else
354 RTPrintf("Boot Device (%d): USB\n", i);
355 }
356 else if (bootOrder == DeviceType_SharedFolder)
357 {
358 if (details == VMINFO_MACHINEREADABLE)
359 RTPrintf("boot%d=\"sharedfolder\"\n", i);
360 else
361 RTPrintf("Boot Device (%d): Shared Folder\n", i);
362 }
363 else
364 {
365 if (details == VMINFO_MACHINEREADABLE)
366 RTPrintf("boot%d=\"none\"\n", i);
367 else
368 RTPrintf("Boot Device (%d): Not Assigned\n", i);
369 }
370 }
371
372 BOOL acpiEnabled;
373 biosSettings->COMGETTER(ACPIEnabled)(&acpiEnabled);
374 if (details == VMINFO_MACHINEREADABLE)
375 RTPrintf("acpi=\"%s\"\n", acpiEnabled ? "on" : "off");
376 else
377 RTPrintf("ACPI: %s\n", acpiEnabled ? "on" : "off");
378
379 BOOL ioapicEnabled;
380 biosSettings->COMGETTER(IOAPICEnabled)(&ioapicEnabled);
381 if (details == VMINFO_MACHINEREADABLE)
382 RTPrintf("ioapic=\"%s\"\n", ioapicEnabled ? "on" : "off");
383 else
384 RTPrintf("IOAPIC: %s\n", ioapicEnabled ? "on" : "off");
385
386 BOOL PAEEnabled;
387 machine->GetCpuProperty(CpuPropertyType_PAE, &PAEEnabled);
388 if (details == VMINFO_MACHINEREADABLE)
389 RTPrintf("pae=\"%s\"\n", PAEEnabled ? "on" : "off");
390 else
391 RTPrintf("PAE: %s\n", PAEEnabled ? "on" : "off");
392
393 LONG64 timeOffset;
394 biosSettings->COMGETTER(TimeOffset)(&timeOffset);
395 if (details == VMINFO_MACHINEREADABLE)
396 RTPrintf("biossystemtimeoffset=%lld\n", timeOffset);
397 else
398 RTPrintf("Time offset: %lld ms\n", timeOffset);
399
400 BOOL hwVirtExEnabled;
401 machine->GetHWVirtExProperty(HWVirtExPropertyType_Enabled, &hwVirtExEnabled);
402 if (details == VMINFO_MACHINEREADABLE)
403 RTPrintf("hwvirtex=\"%s\"\n", hwVirtExEnabled ? "on" : "off");
404 else
405 RTPrintf("Hardw. virt.ext: %s\n", hwVirtExEnabled ? "on" : "off");
406
407 BOOL hwVirtExExclusive;
408 machine->GetHWVirtExProperty(HWVirtExPropertyType_Exclusive, &hwVirtExExclusive);
409 if (details == VMINFO_MACHINEREADABLE)
410 RTPrintf("hwvirtexexcl=\"%s\"\n", hwVirtExExclusive ? "on" : "off");
411 else
412 RTPrintf("Hardw. virt.ext exclusive: %s\n", hwVirtExExclusive ? "on" : "off");
413
414 BOOL HWVirtExNestedPagingEnabled;
415 machine->GetHWVirtExProperty(HWVirtExPropertyType_NestedPaging, &HWVirtExNestedPagingEnabled);
416 if (details == VMINFO_MACHINEREADABLE)
417 RTPrintf("nestedpaging=\"%s\"\n", HWVirtExNestedPagingEnabled ? "on" : "off");
418 else
419 RTPrintf("Nested Paging: %s\n", HWVirtExNestedPagingEnabled ? "on" : "off");
420
421 BOOL HWVirtExVPIDEnabled;
422 machine->GetHWVirtExProperty(HWVirtExPropertyType_VPID, &HWVirtExVPIDEnabled);
423 if (details == VMINFO_MACHINEREADABLE)
424 RTPrintf("vtxvpid=\"%s\"\n", HWVirtExVPIDEnabled ? "on" : "off");
425 else
426 RTPrintf("VT-x VPID: %s\n", HWVirtExVPIDEnabled ? "on" : "off");
427
428 MachineState_T machineState;
429 const char *pszState = NULL;
430 rc = machine->COMGETTER(State)(&machineState);
431 switch (machineState)
432 {
433 case MachineState_PoweredOff:
434 pszState = details == VMINFO_MACHINEREADABLE ? "poweroff" : "powered off";
435 break;
436 case MachineState_Saved:
437 pszState = "saved";
438 break;
439 case MachineState_Aborted:
440 pszState = "aborted";
441 break;
442 case MachineState_Teleported:
443 pszState = "teleported";
444 break;
445 case MachineState_Running:
446 pszState = "running";
447 break;
448 case MachineState_Paused:
449 pszState = "paused";
450 break;
451 case MachineState_Stuck:
452 pszState = details == VMINFO_MACHINEREADABLE ? "gurumeditation" : "guru meditation";
453 break;
454 case MachineState_LiveSnapshotting:
455 pszState = details == VMINFO_MACHINEREADABLE ? "livesnapshotting" : "live snapshotting";
456 break;
457 case MachineState_Teleporting:
458 pszState = "teleporting";
459 break;
460 case MachineState_Starting:
461 pszState = "starting";
462 break;
463 case MachineState_Stopping:
464 pszState = "stopping";
465 break;
466 case MachineState_Saving:
467 pszState = "saving";
468 break;
469 case MachineState_Restoring:
470 pszState = "restoring";
471 break;
472 case MachineState_TeleportingPausedVM:
473 pszState = details == VMINFO_MACHINEREADABLE ? "teleportingpausedvm" : "teleporting paused vm";
474 break;
475 case MachineState_TeleportingIn:
476 pszState = details == VMINFO_MACHINEREADABLE ? "teleportingin" : "teleporting (incoming)";
477 break;
478 case MachineState_RestoringSnapshot:
479 pszState = details == VMINFO_MACHINEREADABLE ? "restoringsnapshot" : "restoring snapshot";
480 case MachineState_DeletingSnapshot:
481 pszState = details == VMINFO_MACHINEREADABLE ? "deletingsnapshot" : "deleting snapshot";
482 case MachineState_SettingUp:
483 pszState = details == VMINFO_MACHINEREADABLE ? "settingup" : "setting up";
484 break;
485 default:
486 pszState = "unknown";
487 break;
488 }
489 LONG64 stateSince;
490 machine->COMGETTER(LastStateChange)(&stateSince);
491 RTTIMESPEC timeSpec;
492 RTTimeSpecSetMilli(&timeSpec, stateSince);
493 char pszTime[30] = {0};
494 RTTimeSpecToString(&timeSpec, pszTime, sizeof(pszTime));
495 Bstr stateFile;
496 machine->COMGETTER(StateFilePath)(stateFile.asOutParam());
497 if (details == VMINFO_MACHINEREADABLE)
498 {
499 RTPrintf("VMState=\"%s\"\n", pszState);
500 RTPrintf("VMStateChangeTime=\"%s\"\n", pszTime);
501 if (!stateFile.isEmpty())
502 RTPrintf("VMStateFile=\"%lS\"\n", stateFile.raw());
503 }
504 else
505 RTPrintf("State: %s (since %s)\n", pszState, pszTime);
506
507 ULONG numMonitors;
508 machine->COMGETTER(MonitorCount)(&numMonitors);
509 if (details == VMINFO_MACHINEREADABLE)
510 RTPrintf("monitorcount=%d\n", numMonitors);
511 else
512 RTPrintf("Monitor count: %d\n", numMonitors);
513
514 BOOL accelerate3d;
515 machine->COMGETTER(Accelerate3DEnabled)(&accelerate3d);
516 if (details == VMINFO_MACHINEREADABLE)
517 RTPrintf("accelerate3d=\"%s\"\n", accelerate3d ? "on" : "off");
518 else
519 RTPrintf("3D Acceleration: %s\n", accelerate3d ? "on" : "off");
520
521#ifdef VBOX_WITH_VIDEOHWACCEL
522 BOOL accelerate2dVideo;
523 machine->COMGETTER(Accelerate2DVideoEnabled)(&accelerate2dVideo);
524 if (details == VMINFO_MACHINEREADABLE)
525 RTPrintf("accelerate2dvideo=\"%s\"\n", accelerate2dVideo ? "on" : "off");
526 else
527 RTPrintf("2D Video Acceleration: %s\n", accelerate2dVideo ? "on" : "off");
528#endif
529
530 BOOL teleporterEnabled;
531 machine->COMGETTER(TeleporterEnabled)(&teleporterEnabled);
532 if (details == VMINFO_MACHINEREADABLE)
533 RTPrintf("teleporterenabled=\"%s\"\n", teleporterEnabled ? "on" : "off");
534 else
535 RTPrintf("Teleporter Enabled: %s\n", teleporterEnabled ? "on" : "off");
536
537 ULONG teleporterPort;
538 machine->COMGETTER(TeleporterPort)(&teleporterPort);
539 if (details == VMINFO_MACHINEREADABLE)
540 RTPrintf("teleporterport=%u\n", teleporterPort);
541 else
542 RTPrintf("Teleporter Port: %u\n", teleporterPort);
543
544 Bstr teleporterAddress;
545 machine->COMGETTER(TeleporterAddress)(teleporterAddress.asOutParam());
546 if (details == VMINFO_MACHINEREADABLE)
547 RTPrintf("teleporteraddress=\"%lS\"\n", teleporterAddress.raw());
548 else
549 RTPrintf("Teleporter Address: %lS\n", teleporterAddress.raw());
550
551 Bstr teleporterPassword;
552 machine->COMGETTER(TeleporterPassword)(teleporterPassword.asOutParam());
553 if (details == VMINFO_MACHINEREADABLE)
554 RTPrintf("teleporterpassword=\"%lS\"\n", teleporterPassword.raw());
555 else
556 RTPrintf("Teleporter Password: %lS\n", teleporterPassword.raw());
557
558 /*
559 * Storage Controllers and their attached Mediums.
560 */
561 com::SafeIfaceArray<IStorageController> storageCtls;
562 CHECK_ERROR(machine, COMGETTER(StorageControllers)(ComSafeArrayAsOutParam (storageCtls)));
563 for (size_t i = 0; i < storageCtls.size(); ++ i)
564 {
565 ComPtr<IStorageController> storageCtl = storageCtls[i];
566 StorageControllerType_T enmCtlType = StorageControllerType_Null;
567 const char *pszCtl = NULL;
568 ULONG ulValue = 0;
569 Bstr storageCtlName;
570
571 storageCtl->COMGETTER(Name)(storageCtlName.asOutParam());
572 if (details == VMINFO_MACHINEREADABLE)
573 RTPrintf("storagecontrollername%u=\"%lS\"\n", i, storageCtlName.raw());
574 else
575 RTPrintf("Storage Controller Name (%u): %lS\n", i, storageCtlName.raw());
576
577 storageCtl->COMGETTER(ControllerType)(&enmCtlType);
578 switch (enmCtlType)
579 {
580 case StorageControllerType_LsiLogic:
581 pszCtl = "LsiLogic";
582 break;
583 case StorageControllerType_BusLogic:
584 pszCtl = "BusLogic";
585 break;
586 case StorageControllerType_IntelAhci:
587 pszCtl = "IntelAhci";
588 break;
589 case StorageControllerType_PIIX3:
590 pszCtl = "PIIX3";
591 break;
592 case StorageControllerType_PIIX4:
593 pszCtl = "PIIX4";
594 break;
595 case StorageControllerType_ICH6:
596 pszCtl = "ICH6";
597 break;
598 case StorageControllerType_I82078:
599 pszCtl = "I82078";
600 break;
601
602 default:
603 pszCtl = "unknown";
604 }
605 if (details == VMINFO_MACHINEREADABLE)
606 RTPrintf("storagecontrollertype%u=\"%s\"\n", i, pszCtl);
607 else
608 RTPrintf("Storage Controller Type (%u): %s\n", i, pszCtl);
609
610 storageCtl->COMGETTER(Instance)(&ulValue);
611 if (details == VMINFO_MACHINEREADABLE)
612 RTPrintf("storagecontrollerinstance%u=\"%lu\"\n", i, ulValue);
613 else
614 RTPrintf("Storage Controller Instance Number (%u): %lu\n", i, ulValue);
615
616 storageCtl->COMGETTER(MaxPortCount)(&ulValue);
617 if (details == VMINFO_MACHINEREADABLE)
618 RTPrintf("storagecontrollermaxportcount%u=\"%lu\"\n", i, ulValue);
619 else
620 RTPrintf("Storage Controller Max Port Count (%u): %lu\n", i, ulValue);
621
622 storageCtl->COMGETTER(PortCount)(&ulValue);
623 if (details == VMINFO_MACHINEREADABLE)
624 RTPrintf("storagecontrollerportcount%u=\"%lu\"\n", i, ulValue);
625 else
626 RTPrintf("Storage Controller Port Count (%u): %lu\n", i, ulValue);
627 }
628
629 for (size_t j = 0; j < storageCtls.size(); ++ j)
630 {
631 ComPtr<IStorageController> storageCtl = storageCtls[j];
632 ComPtr<IMedium> medium;
633 Bstr storageCtlName;
634 Bstr filePath;
635 ULONG cDevices;
636 ULONG cPorts;
637
638 storageCtl->COMGETTER(Name)(storageCtlName.asOutParam());
639 storageCtl->COMGETTER(MaxDevicesPerPortCount)(&cDevices);
640 storageCtl->COMGETTER(PortCount)(&cPorts);
641
642 for (ULONG i = 0; i < cPorts; ++ i)
643 {
644 for (ULONG k = 0; k < cDevices; ++ k)
645 {
646 rc = machine->GetMedium(storageCtlName, i, k, medium.asOutParam());
647 if (SUCCEEDED(rc) && medium)
648 {
649 BOOL fPassthrough;
650 ComPtr<IMediumAttachment> mediumAttach;
651
652 rc = machine->GetMediumAttachment(storageCtlName, i, k, mediumAttach.asOutParam());
653 if (SUCCEEDED(rc) && mediumAttach)
654 mediumAttach->COMGETTER(Passthrough)(&fPassthrough);
655
656 medium->COMGETTER(Location)(filePath.asOutParam());
657 medium->COMGETTER(Id)(uuid.asOutParam());
658
659 if (details == VMINFO_MACHINEREADABLE)
660 {
661 RTPrintf("\"%lS-%d-%d\"=\"%lS\"\n", storageCtlName.raw(),
662 i, k, filePath.raw());
663 RTPrintf("\"%lS-ImageUUID-%d-%d\"=\"%s\"\n",
664 storageCtlName.raw(), i, k, Utf8Str(uuid).raw());
665 if (fPassthrough)
666 RTPrintf("\"%lS-dvdpassthrough\"=\"%s\"\n", storageCtlName.raw(),
667 fPassthrough ? "on" : "off");
668 }
669 else
670 {
671 RTPrintf("%lS (%d, %d): %lS (UUID: %s)",
672 storageCtlName.raw(), i, k, filePath.raw(),
673 Utf8Str(uuid).raw());
674 if (fPassthrough)
675 RTPrintf(" (passthrough enabled)");
676 RTPrintf("\n");
677 }
678 }
679 else if (SUCCEEDED(rc))
680 {
681 if (details == VMINFO_MACHINEREADABLE)
682 RTPrintf("\"%lS-%d-%d\"=\"emptydrive\"\n", storageCtlName.raw(), i, k);
683 else
684 RTPrintf("%lS (%d, %d): Empty\n", storageCtlName.raw(), i, k);
685 }
686 else
687 {
688 if (details == VMINFO_MACHINEREADABLE)
689 RTPrintf("\"%lS-%d-%d\"=\"none\"\n", storageCtlName.raw(), i, k);
690 }
691 }
692 }
693 }
694
695 /* get the maximum amount of NICS */
696 ComPtr<ISystemProperties> sysProps;
697 virtualBox->COMGETTER(SystemProperties)(sysProps.asOutParam());
698 ULONG maxNICs = 0;
699 sysProps->COMGETTER(NetworkAdapterCount)(&maxNICs);
700 for (ULONG currentNIC = 0; currentNIC < maxNICs; currentNIC++)
701 {
702 ComPtr<INetworkAdapter> nic;
703 rc = machine->GetNetworkAdapter(currentNIC, nic.asOutParam());
704 if (SUCCEEDED(rc) && nic)
705 {
706 BOOL fEnabled;
707 nic->COMGETTER(Enabled)(&fEnabled);
708 if (!fEnabled)
709 {
710 if (details == VMINFO_MACHINEREADABLE)
711 RTPrintf("nic%d=\"none\"\n", currentNIC + 1);
712 else
713 RTPrintf("NIC %d: disabled\n", currentNIC + 1);
714 }
715 else
716 {
717 Bstr strMACAddress;
718 nic->COMGETTER(MACAddress)(strMACAddress.asOutParam());
719 Utf8Str strAttachment;
720 NetworkAttachmentType_T attachment;
721 nic->COMGETTER(AttachmentType)(&attachment);
722 switch (attachment)
723 {
724 case NetworkAttachmentType_Null:
725 if (details == VMINFO_MACHINEREADABLE)
726 strAttachment = "null";
727 else
728 strAttachment = "none";
729 break;
730 case NetworkAttachmentType_NAT:
731 {
732 Bstr strNetwork;
733 nic->COMGETTER(NATNetwork)(strNetwork.asOutParam());
734 if (details == VMINFO_MACHINEREADABLE)
735 {
736 RTPrintf("natnet%d=\"%lS\"\n", currentNIC + 1, strNetwork.raw());
737 strAttachment = "nat";
738 }
739 else if (!strNetwork.isEmpty())
740 strAttachment = Utf8StrFmt("NAT (%lS)", strNetwork.raw());
741 else
742 strAttachment = "NAT";
743 break;
744 }
745 case NetworkAttachmentType_Bridged:
746 {
747 Bstr strBridgeAdp;
748 nic->COMGETTER(HostInterface)(strBridgeAdp.asOutParam());
749 if (details == VMINFO_MACHINEREADABLE)
750 {
751 RTPrintf("bridgeadapter%d=\"%lS\"\n", currentNIC + 1, strBridgeAdp.raw());
752 strAttachment = "bridged";
753 }
754 else
755 strAttachment = Utf8StrFmt("Bridged Interface '%lS'", strBridgeAdp.raw());
756 break;
757 }
758 case NetworkAttachmentType_Internal:
759 {
760 Bstr strNetwork;
761 nic->COMGETTER(InternalNetwork)(strNetwork.asOutParam());
762 if (details == VMINFO_MACHINEREADABLE)
763 {
764 RTPrintf("intnet%d=\"%lS\"\n", currentNIC + 1, strNetwork.raw());
765 strAttachment = "intnet";
766 }
767 else
768 strAttachment = Utf8StrFmt("Internal Network '%s'", Utf8Str(strNetwork).raw());
769 break;
770 }
771#if defined(VBOX_WITH_NETFLT)
772 case NetworkAttachmentType_HostOnly:
773 {
774 Bstr strHostonlyAdp;
775 nic->COMGETTER(HostInterface)(strHostonlyAdp.asOutParam());
776 if (details == VMINFO_MACHINEREADABLE)
777 {
778 RTPrintf("hostonlyadapter%d=\"%lS\"\n", currentNIC + 1, strHostonlyAdp.raw());
779 strAttachment = "hostonly";
780 }
781 else
782 strAttachment = Utf8StrFmt("Host-only Interface '%lS'", strHostonlyAdp.raw());
783 break;
784 }
785#endif
786 default:
787 strAttachment = "unknown";
788 break;
789 }
790
791 /* cable connected */
792 BOOL fConnected;
793 nic->COMGETTER(CableConnected)(&fConnected);
794
795 /* trace stuff */
796 BOOL fTraceEnabled;
797 nic->COMGETTER(TraceEnabled)(&fTraceEnabled);
798 Bstr traceFile;
799 nic->COMGETTER(TraceFile)(traceFile.asOutParam());
800
801 /* NIC type */
802 Utf8Str strNICType;
803 NetworkAdapterType_T NICType;
804 nic->COMGETTER(AdapterType)(&NICType);
805 switch (NICType) {
806 case NetworkAdapterType_Am79C970A:
807 strNICType = "Am79C970A";
808 break;
809 case NetworkAdapterType_Am79C973:
810 strNICType = "Am79C973";
811 break;
812#ifdef VBOX_WITH_E1000
813 case NetworkAdapterType_I82540EM:
814 strNICType = "82540EM";
815 break;
816 case NetworkAdapterType_I82543GC:
817 strNICType = "82543GC";
818 break;
819 case NetworkAdapterType_I82545EM:
820 strNICType = "82545EM";
821 break;
822#endif
823#ifdef VBOX_WITH_VIRTIO
824 case NetworkAdapterType_Virtio:
825 strNICType = "virtio";
826 break;
827#endif /* VBOX_WITH_VIRTIO */
828 default:
829 strNICType = "unknown";
830 break;
831 }
832
833 /* reported line speed */
834 ULONG ulLineSpeed;
835 nic->COMGETTER(LineSpeed)(&ulLineSpeed);
836
837 if (details == VMINFO_MACHINEREADABLE)
838 {
839 RTPrintf("macaddress%d=\"%lS\"\n", currentNIC + 1, strMACAddress.raw());
840 RTPrintf("cableconnected%d=\"%s\"\n", currentNIC + 1, fConnected ? "on" : "off");
841 RTPrintf("nic%d=\"%s\"\n", currentNIC + 1, strAttachment.raw());
842 }
843 else
844 RTPrintf("NIC %d: MAC: %lS, Attachment: %s, Cable connected: %s, Trace: %s (file: %lS), Type: %s, Reported speed: %d Mbps\n",
845 currentNIC + 1, strMACAddress.raw(), strAttachment.raw(),
846 fConnected ? "on" : "off",
847 fTraceEnabled ? "on" : "off",
848 traceFile.isEmpty() ? Bstr("none").raw() : traceFile.raw(),
849 strNICType.raw(),
850 ulLineSpeed / 1000);
851 }
852 }
853 }
854
855 /* get the maximum amount of UARTs */
856 ULONG maxUARTs = 0;
857 sysProps->COMGETTER(SerialPortCount)(&maxUARTs);
858 for (ULONG currentUART = 0; currentUART < maxUARTs; currentUART++)
859 {
860 ComPtr<ISerialPort> uart;
861 rc = machine->GetSerialPort(currentUART, uart.asOutParam());
862 if (SUCCEEDED(rc) && uart)
863 {
864 BOOL fEnabled;
865 uart->COMGETTER(Enabled)(&fEnabled);
866 if (!fEnabled)
867 {
868 if (details == VMINFO_MACHINEREADABLE)
869 RTPrintf("uart%d=\"off\"\n", currentUART + 1);
870 else
871 RTPrintf("UART %d: disabled\n", currentUART + 1);
872 }
873 else
874 {
875 ULONG ulIRQ, ulIOBase;
876 PortMode_T HostMode;
877 Bstr path;
878 BOOL fServer;
879 uart->COMGETTER(IRQ)(&ulIRQ);
880 uart->COMGETTER(IOBase)(&ulIOBase);
881 uart->COMGETTER(Path)(path.asOutParam());
882 uart->COMGETTER(Server)(&fServer);
883 uart->COMGETTER(HostMode)(&HostMode);
884
885 if (details == VMINFO_MACHINEREADABLE)
886 RTPrintf("uart%d=\"%#06x,%d\"\n", currentUART + 1,
887 ulIOBase, ulIRQ);
888 else
889 RTPrintf("UART %d: I/O base: 0x%04x, IRQ: %d",
890 currentUART + 1, ulIOBase, ulIRQ);
891 switch (HostMode)
892 {
893 default:
894 case PortMode_Disconnected:
895 if (details == VMINFO_MACHINEREADABLE)
896 RTPrintf("uartmode%d=\"disconnected\"\n", currentUART + 1);
897 else
898 RTPrintf(", disconnected\n");
899 break;
900 case PortMode_RawFile:
901 if (details == VMINFO_MACHINEREADABLE)
902 RTPrintf("uartmode%d=\"%lS\"\n", currentUART + 1,
903 path.raw());
904 else
905 RTPrintf(", attached to raw file '%lS'\n",
906 path.raw());
907 break;
908 case PortMode_HostPipe:
909 if (details == VMINFO_MACHINEREADABLE)
910 RTPrintf("uartmode%d=\"%s,%lS\"\n", currentUART + 1,
911 fServer ? "server" : "client", path.raw());
912 else
913 RTPrintf(", attached to pipe (%s) '%lS'\n",
914 fServer ? "server" : "client", path.raw());
915 break;
916 case PortMode_HostDevice:
917 if (details == VMINFO_MACHINEREADABLE)
918 RTPrintf("uartmode%d=\"%lS\"\n", currentUART + 1,
919 path.raw());
920 else
921 RTPrintf(", attached to device '%lS'\n", path.raw());
922 break;
923 }
924 }
925 }
926 }
927
928 ComPtr<IAudioAdapter> AudioAdapter;
929 rc = machine->COMGETTER(AudioAdapter)(AudioAdapter.asOutParam());
930 if (SUCCEEDED(rc))
931 {
932 const char *pszDrv = "Unknown";
933 const char *pszCtrl = "Unknown";
934 BOOL fEnabled;
935 rc = AudioAdapter->COMGETTER(Enabled)(&fEnabled);
936 if (SUCCEEDED(rc) && fEnabled)
937 {
938 AudioDriverType_T enmDrvType;
939 rc = AudioAdapter->COMGETTER(AudioDriver)(&enmDrvType);
940 switch (enmDrvType)
941 {
942 case AudioDriverType_Null:
943 if (details == VMINFO_MACHINEREADABLE)
944 pszDrv = "null";
945 else
946 pszDrv = "Null";
947 break;
948 case AudioDriverType_WinMM:
949 if (details == VMINFO_MACHINEREADABLE)
950 pszDrv = "winmm";
951 else
952 pszDrv = "WINMM";
953 break;
954 case AudioDriverType_DirectSound:
955 if (details == VMINFO_MACHINEREADABLE)
956 pszDrv = "dsound";
957 else
958 pszDrv = "DSOUND";
959 break;
960 case AudioDriverType_OSS:
961 if (details == VMINFO_MACHINEREADABLE)
962 pszDrv = "oss";
963 else
964 pszDrv = "OSS";
965 break;
966 case AudioDriverType_ALSA:
967 if (details == VMINFO_MACHINEREADABLE)
968 pszDrv = "alsa";
969 else
970 pszDrv = "ALSA";
971 break;
972 case AudioDriverType_Pulse:
973 if (details == VMINFO_MACHINEREADABLE)
974 pszDrv = "pulse";
975 else
976 pszDrv = "PulseAudio";
977 break;
978 case AudioDriverType_CoreAudio:
979 if (details == VMINFO_MACHINEREADABLE)
980 pszDrv = "coreaudio";
981 else
982 pszDrv = "CoreAudio";
983 break;
984 case AudioDriverType_SolAudio:
985 if (details == VMINFO_MACHINEREADABLE)
986 pszDrv = "solaudio";
987 else
988 pszDrv = "SolAudio";
989 break;
990 default:
991 if (details == VMINFO_MACHINEREADABLE)
992 pszDrv = "unknown";
993 break;
994 }
995 AudioControllerType_T enmCtrlType;
996 rc = AudioAdapter->COMGETTER(AudioController)(&enmCtrlType);
997 switch (enmCtrlType)
998 {
999 case AudioControllerType_AC97:
1000 if (details == VMINFO_MACHINEREADABLE)
1001 pszCtrl = "ac97";
1002 else
1003 pszCtrl = "AC97";
1004 break;
1005 case AudioControllerType_SB16:
1006 if (details == VMINFO_MACHINEREADABLE)
1007 pszCtrl = "sb16";
1008 else
1009 pszCtrl = "SB16";
1010 break;
1011 }
1012 }
1013 else
1014 fEnabled = FALSE;
1015 if (details == VMINFO_MACHINEREADABLE)
1016 {
1017 if (fEnabled)
1018 RTPrintf("audio=\"%s\"\n", pszDrv);
1019 else
1020 RTPrintf("audio=\"none\"\n");
1021 }
1022 else
1023 {
1024 RTPrintf("Audio: %s",
1025 fEnabled ? "enabled" : "disabled");
1026 if (fEnabled)
1027 RTPrintf(" (Driver: %s, Controller: %s)",
1028 pszDrv, pszCtrl);
1029 RTPrintf("\n");
1030 }
1031 }
1032
1033 /* Shared clipboard */
1034 {
1035 const char *psz = "Unknown";
1036 ClipboardMode_T enmMode;
1037 rc = machine->COMGETTER(ClipboardMode)(&enmMode);
1038 switch (enmMode)
1039 {
1040 case ClipboardMode_Disabled:
1041 if (details == VMINFO_MACHINEREADABLE)
1042 psz = "disabled";
1043 else
1044 psz = "disabled";
1045 break;
1046 case ClipboardMode_HostToGuest:
1047 if (details == VMINFO_MACHINEREADABLE)
1048 psz = "hosttoguest";
1049 else
1050 psz = "HostToGuest";
1051 break;
1052 case ClipboardMode_GuestToHost:
1053 if (details == VMINFO_MACHINEREADABLE)
1054 psz = "guesttohost";
1055 else
1056 psz = "GuestToHost";
1057 break;
1058 case ClipboardMode_Bidirectional:
1059 if (details == VMINFO_MACHINEREADABLE)
1060 psz = "bidirectional";
1061 else
1062 psz = "Bidirectional";
1063 break;
1064 default:
1065 if (details == VMINFO_MACHINEREADABLE)
1066 psz = "unknown";
1067 break;
1068 }
1069 if (details == VMINFO_MACHINEREADABLE)
1070 RTPrintf("clipboard=\"%s\"\n", psz);
1071 else
1072 RTPrintf("Clipboard Mode: %s\n", psz);
1073 }
1074
1075 if (console)
1076 {
1077 ComPtr<IDisplay> display;
1078 CHECK_ERROR_RET(console, COMGETTER(Display)(display.asOutParam()), rc);
1079 do
1080 {
1081 ULONG xRes, yRes, bpp;
1082 rc = display->COMGETTER(Width)(&xRes);
1083 if (rc == E_ACCESSDENIED)
1084 break; /* VM not powered up */
1085 if (FAILED(rc))
1086 {
1087 com::ErrorInfo info (display);
1088 GluePrintErrorInfo(info);
1089 return rc;
1090 }
1091 rc = display->COMGETTER(Height)(&yRes);
1092 if (rc == E_ACCESSDENIED)
1093 break; /* VM not powered up */
1094 if (FAILED(rc))
1095 {
1096 com::ErrorInfo info (display);
1097 GluePrintErrorInfo(info);
1098 return rc;
1099 }
1100 rc = display->COMGETTER(BitsPerPixel)(&bpp);
1101 if (rc == E_ACCESSDENIED)
1102 break; /* VM not powered up */
1103 if (FAILED(rc))
1104 {
1105 com::ErrorInfo info (display);
1106 GluePrintErrorInfo(info);
1107 return rc;
1108 }
1109 if (details == VMINFO_MACHINEREADABLE)
1110 RTPrintf("VideoMode=\"%d,%d,%d\"\n", xRes, yRes, bpp);
1111 else
1112 RTPrintf("Video mode: %dx%dx%d\n", xRes, yRes, bpp);
1113 }
1114 while (0);
1115 }
1116
1117 /*
1118 * VRDP
1119 */
1120 ComPtr<IVRDPServer> vrdpServer;
1121 rc = machine->COMGETTER(VRDPServer)(vrdpServer.asOutParam());
1122 if (SUCCEEDED(rc) && vrdpServer)
1123 {
1124 BOOL fEnabled = false;
1125 vrdpServer->COMGETTER(Enabled)(&fEnabled);
1126 if (fEnabled)
1127 {
1128 LONG vrdpPort = -1;
1129 Bstr ports;
1130 vrdpServer->COMGETTER(Ports)(ports.asOutParam());
1131 Bstr address;
1132 vrdpServer->COMGETTER(NetAddress)(address.asOutParam());
1133 BOOL fMultiCon;
1134 vrdpServer->COMGETTER(AllowMultiConnection)(&fMultiCon);
1135 BOOL fReuseCon;
1136 vrdpServer->COMGETTER(ReuseSingleConnection)(&fReuseCon);
1137 VRDPAuthType_T vrdpAuthType;
1138 const char *strAuthType;
1139 vrdpServer->COMGETTER(AuthType)(&vrdpAuthType);
1140 switch (vrdpAuthType)
1141 {
1142 case VRDPAuthType_Null:
1143 strAuthType = "null";
1144 break;
1145 case VRDPAuthType_External:
1146 strAuthType = "external";
1147 break;
1148 case VRDPAuthType_Guest:
1149 strAuthType = "guest";
1150 break;
1151 default:
1152 strAuthType = "unknown";
1153 break;
1154 }
1155 if (console)
1156 {
1157 ComPtr<IRemoteDisplayInfo> remoteDisplayInfo;
1158 CHECK_ERROR_RET(console, COMGETTER(RemoteDisplayInfo)(remoteDisplayInfo.asOutParam()), rc);
1159 rc = remoteDisplayInfo->COMGETTER(Port)(&vrdpPort);
1160 if (rc == E_ACCESSDENIED)
1161 {
1162 vrdpPort = -1; /* VM not powered up */
1163 }
1164 if (FAILED(rc))
1165 {
1166 com::ErrorInfo info (remoteDisplayInfo);
1167 GluePrintErrorInfo(info);
1168 return rc;
1169 }
1170 }
1171 if (details == VMINFO_MACHINEREADABLE)
1172 {
1173 RTPrintf("vrdp=\"on\"\n");
1174 RTPrintf("vrdpport=%d\n", vrdpPort);
1175 RTPrintf("vrdpports=\"%lS\"\n", ports.raw());
1176 RTPrintf("vrdpaddress=\"%lS\"\n", address.raw());
1177 RTPrintf("vrdpauthtype=\"%s\"\n", strAuthType);
1178 RTPrintf("vrdpmulticon=\"%s\"\n", fMultiCon ? "on" : "off");
1179 RTPrintf("vrdpreusecon=\"%s\"\n", fReuseCon ? "on" : "off");
1180 }
1181 else
1182 {
1183 if (address.isEmpty())
1184 address = "0.0.0.0";
1185 RTPrintf("VRDP: enabled (Address %lS, Ports %lS, MultiConn: %s, ReuseSingleConn: %s, Authentication type: %s)\n", address.raw(), ports.raw(), fMultiCon ? "on" : "off", fReuseCon ? "on" : "off", strAuthType);
1186 if (console && vrdpPort != -1 && vrdpPort != 0)
1187 RTPrintf("VRDP port: %d\n", vrdpPort);
1188 }
1189 }
1190 else
1191 {
1192 if (details == VMINFO_MACHINEREADABLE)
1193 RTPrintf("vrdp=\"off\"\n");
1194 else
1195 RTPrintf("VRDP: disabled\n");
1196 }
1197 }
1198
1199 /*
1200 * USB.
1201 */
1202 ComPtr<IUSBController> USBCtl;
1203 rc = machine->COMGETTER(USBController)(USBCtl.asOutParam());
1204 if (SUCCEEDED(rc))
1205 {
1206 BOOL fEnabled;
1207 rc = USBCtl->COMGETTER(Enabled)(&fEnabled);
1208 if (FAILED(rc))
1209 fEnabled = false;
1210 if (details == VMINFO_MACHINEREADABLE)
1211 RTPrintf("usb=\"%s\"\n", fEnabled ? "on" : "off");
1212 else
1213 RTPrintf("USB: %s\n", fEnabled ? "enabled" : "disabled");
1214
1215 if (details != VMINFO_MACHINEREADABLE)
1216 RTPrintf("\nUSB Device Filters:\n\n");
1217
1218 SafeIfaceArray <IUSBDeviceFilter> Coll;
1219 CHECK_ERROR_RET (USBCtl, COMGETTER(DeviceFilters)(ComSafeArrayAsOutParam(Coll)), rc);
1220
1221 if (Coll.size() == 0)
1222 {
1223 if (details != VMINFO_MACHINEREADABLE)
1224 RTPrintf("<none>\n\n");
1225 }
1226 else
1227 {
1228 for (size_t index = 0; index < Coll.size(); ++index)
1229 {
1230 ComPtr<IUSBDeviceFilter> DevPtr = Coll[index];
1231
1232 /* Query info. */
1233
1234 if (details != VMINFO_MACHINEREADABLE)
1235 RTPrintf("Index: %zu\n", index);
1236
1237 BOOL bActive = FALSE;
1238 CHECK_ERROR_RET (DevPtr, COMGETTER (Active) (&bActive), rc);
1239 if (details == VMINFO_MACHINEREADABLE)
1240 RTPrintf("USBFilterActive%zu=\"%s\"\n", index + 1, bActive ? "on" : "off");
1241 else
1242 RTPrintf("Active: %s\n", bActive ? "yes" : "no");
1243
1244 Bstr bstr;
1245 CHECK_ERROR_RET (DevPtr, COMGETTER (Name) (bstr.asOutParam()), rc);
1246 if (details == VMINFO_MACHINEREADABLE)
1247 RTPrintf("USBFilterName%zu=\"%lS\"\n", index + 1, bstr.raw());
1248 else
1249 RTPrintf("Name: %lS\n", bstr.raw());
1250 CHECK_ERROR_RET (DevPtr, COMGETTER (VendorId) (bstr.asOutParam()), rc);
1251 if (details == VMINFO_MACHINEREADABLE)
1252 RTPrintf("USBFilterVendorId%zu=\"%lS\"\n", index + 1, bstr.raw());
1253 else
1254 RTPrintf("VendorId: %lS\n", bstr.raw());
1255 CHECK_ERROR_RET (DevPtr, COMGETTER (ProductId) (bstr.asOutParam()), rc);
1256 if (details == VMINFO_MACHINEREADABLE)
1257 RTPrintf("USBFilterProductId%zu=\"%lS\"\n", index + 1, bstr.raw());
1258 else
1259 RTPrintf("ProductId: %lS\n", bstr.raw());
1260 CHECK_ERROR_RET (DevPtr, COMGETTER (Revision) (bstr.asOutParam()), rc);
1261 if (details == VMINFO_MACHINEREADABLE)
1262 RTPrintf("USBFilterRevision%zu=\"%lS\"\n", index + 1, bstr.raw());
1263 else
1264 RTPrintf("Revision: %lS\n", bstr.raw());
1265 CHECK_ERROR_RET (DevPtr, COMGETTER (Manufacturer) (bstr.asOutParam()), rc);
1266 if (details == VMINFO_MACHINEREADABLE)
1267 RTPrintf("USBFilterManufacturer%zu=\"%lS\"\n", index + 1, bstr.raw());
1268 else
1269 RTPrintf("Manufacturer: %lS\n", bstr.raw());
1270 CHECK_ERROR_RET (DevPtr, COMGETTER (Product) (bstr.asOutParam()), rc);
1271 if (details == VMINFO_MACHINEREADABLE)
1272 RTPrintf("USBFilterProduct%zu=\"%lS\"\n", index + 1, bstr.raw());
1273 else
1274 RTPrintf("Product: %lS\n", bstr.raw());
1275 CHECK_ERROR_RET (DevPtr, COMGETTER (Remote) (bstr.asOutParam()), rc);
1276 if (details == VMINFO_MACHINEREADABLE)
1277 RTPrintf("USBFilterRemote%zu=\"%lS\"\n", index + 1, bstr.raw());
1278 else
1279 RTPrintf("Remote: %lS\n", bstr.raw());
1280 CHECK_ERROR_RET (DevPtr, COMGETTER (SerialNumber) (bstr.asOutParam()), rc);
1281 if (details == VMINFO_MACHINEREADABLE)
1282 RTPrintf("USBFilterSerialNumber%zu=\"%lS\"\n", index + 1, bstr.raw());
1283 else
1284 RTPrintf("Serial Number: %lS\n", bstr.raw());
1285 if (details != VMINFO_MACHINEREADABLE)
1286 {
1287 ULONG fMaskedIfs;
1288 CHECK_ERROR_RET (DevPtr, COMGETTER (MaskedInterfaces) (&fMaskedIfs), rc);
1289 if (fMaskedIfs)
1290 RTPrintf("Masked Interfaces: 0x%08x\n", fMaskedIfs);
1291 RTPrintf("\n");
1292 }
1293 }
1294 }
1295
1296 if (console)
1297 {
1298 /* scope */
1299 {
1300 if (details != VMINFO_MACHINEREADABLE)
1301 RTPrintf("Available remote USB devices:\n\n");
1302
1303 SafeIfaceArray <IHostUSBDevice> coll;
1304 CHECK_ERROR_RET (console, COMGETTER(RemoteUSBDevices) (ComSafeArrayAsOutParam(coll)), rc);
1305
1306 if (coll.size() == 0)
1307 {
1308 if (details != VMINFO_MACHINEREADABLE)
1309 RTPrintf("<none>\n\n");
1310 }
1311 else
1312 {
1313 for (size_t index = 0; index < coll.size(); ++index)
1314 {
1315 ComPtr <IHostUSBDevice> dev = coll[index];
1316
1317 /* Query info. */
1318 Bstr id;
1319 CHECK_ERROR_RET (dev, COMGETTER(Id)(id.asOutParam()), rc);
1320 USHORT usVendorId;
1321 CHECK_ERROR_RET (dev, COMGETTER(VendorId)(&usVendorId), rc);
1322 USHORT usProductId;
1323 CHECK_ERROR_RET (dev, COMGETTER(ProductId)(&usProductId), rc);
1324 USHORT bcdRevision;
1325 CHECK_ERROR_RET (dev, COMGETTER(Revision)(&bcdRevision), rc);
1326
1327 if (details == VMINFO_MACHINEREADABLE)
1328 RTPrintf("USBRemoteUUID%zu=\"%S\"\n"
1329 "USBRemoteVendorId%zu=\"%#06x\"\n"
1330 "USBRemoteProductId%zu=\"%#06x\"\n"
1331 "USBRemoteRevision%zu=\"%#04x%02x\"\n",
1332 index + 1, Utf8Str(id).raw(),
1333 index + 1, usVendorId,
1334 index + 1, usProductId,
1335 index + 1, bcdRevision >> 8, bcdRevision & 0xff);
1336 else
1337 RTPrintf("UUID: %S\n"
1338 "VendorId: 0x%04x (%04X)\n"
1339 "ProductId: 0x%04x (%04X)\n"
1340 "Revision: %u.%u (%02u%02u)\n",
1341 Utf8Str(id).raw(),
1342 usVendorId, usVendorId, usProductId, usProductId,
1343 bcdRevision >> 8, bcdRevision & 0xff,
1344 bcdRevision >> 8, bcdRevision & 0xff);
1345
1346 /* optional stuff. */
1347 Bstr bstr;
1348 CHECK_ERROR_RET (dev, COMGETTER(Manufacturer)(bstr.asOutParam()), rc);
1349 if (!bstr.isEmpty())
1350 {
1351 if (details == VMINFO_MACHINEREADABLE)
1352 RTPrintf("USBRemoteManufacturer%zu=\"%lS\"\n", index + 1, bstr.raw());
1353 else
1354 RTPrintf("Manufacturer: %lS\n", bstr.raw());
1355 }
1356 CHECK_ERROR_RET (dev, COMGETTER(Product)(bstr.asOutParam()), rc);
1357 if (!bstr.isEmpty())
1358 {
1359 if (details == VMINFO_MACHINEREADABLE)
1360 RTPrintf("USBRemoteProduct%zu=\"%lS\"\n", index + 1, bstr.raw());
1361 else
1362 RTPrintf("Product: %lS\n", bstr.raw());
1363 }
1364 CHECK_ERROR_RET (dev, COMGETTER(SerialNumber)(bstr.asOutParam()), rc);
1365 if (!bstr.isEmpty())
1366 {
1367 if (details == VMINFO_MACHINEREADABLE)
1368 RTPrintf("USBRemoteSerialNumber%zu=\"%lS\"\n", index + 1, bstr.raw());
1369 else
1370 RTPrintf("SerialNumber: %lS\n", bstr.raw());
1371 }
1372 CHECK_ERROR_RET (dev, COMGETTER(Address)(bstr.asOutParam()), rc);
1373 if (!bstr.isEmpty())
1374 {
1375 if (details == VMINFO_MACHINEREADABLE)
1376 RTPrintf("USBRemoteAddress%zu=\"%lS\"\n", index + 1, bstr.raw());
1377 else
1378 RTPrintf("Address: %lS\n", bstr.raw());
1379 }
1380
1381 if (details != VMINFO_MACHINEREADABLE)
1382 RTPrintf("\n");
1383 }
1384 }
1385 }
1386
1387 /* scope */
1388 {
1389 if (details != VMINFO_MACHINEREADABLE)
1390 RTPrintf ("Currently Attached USB Devices:\n\n");
1391
1392 SafeIfaceArray <IUSBDevice> coll;
1393 CHECK_ERROR_RET (console, COMGETTER(USBDevices) (ComSafeArrayAsOutParam(coll)), rc);
1394
1395 if (coll.size() == 0)
1396 {
1397 if (details != VMINFO_MACHINEREADABLE)
1398 RTPrintf("<none>\n\n");
1399 }
1400 else
1401 {
1402 for (size_t index = 0; index < coll.size(); ++index)
1403 {
1404 ComPtr <IUSBDevice> dev = coll[index];
1405
1406 /* Query info. */
1407 Bstr id;
1408 CHECK_ERROR_RET (dev, COMGETTER(Id)(id.asOutParam()), rc);
1409 USHORT usVendorId;
1410 CHECK_ERROR_RET (dev, COMGETTER(VendorId)(&usVendorId), rc);
1411 USHORT usProductId;
1412 CHECK_ERROR_RET (dev, COMGETTER(ProductId)(&usProductId), rc);
1413 USHORT bcdRevision;
1414 CHECK_ERROR_RET (dev, COMGETTER(Revision)(&bcdRevision), rc);
1415
1416 if (details == VMINFO_MACHINEREADABLE)
1417 RTPrintf("USBAttachedUUID%zu=\"%S\"\n"
1418 "USBAttachedVendorId%zu=\"%#06x\"\n"
1419 "USBAttachedProductId%zu=\"%#06x\"\n"
1420 "USBAttachedRevision%zu=\"%#04x%02x\"\n",
1421 index + 1, Utf8Str(id).raw(),
1422 index + 1, usVendorId,
1423 index + 1, usProductId,
1424 index + 1, bcdRevision >> 8, bcdRevision & 0xff);
1425 else
1426 RTPrintf("UUID: %S\n"
1427 "VendorId: 0x%04x (%04X)\n"
1428 "ProductId: 0x%04x (%04X)\n"
1429 "Revision: %u.%u (%02u%02u)\n",
1430 Utf8Str(id).raw(),
1431 usVendorId, usVendorId, usProductId, usProductId,
1432 bcdRevision >> 8, bcdRevision & 0xff,
1433 bcdRevision >> 8, bcdRevision & 0xff);
1434
1435 /* optional stuff. */
1436 Bstr bstr;
1437 CHECK_ERROR_RET (dev, COMGETTER(Manufacturer)(bstr.asOutParam()), rc);
1438 if (!bstr.isEmpty())
1439 {
1440 if (details == VMINFO_MACHINEREADABLE)
1441 RTPrintf("USBAttachedManufacturer%zu=\"%lS\"\n", index + 1, bstr.raw());
1442 else
1443 RTPrintf("Manufacturer: %lS\n", bstr.raw());
1444 }
1445 CHECK_ERROR_RET (dev, COMGETTER(Product)(bstr.asOutParam()), rc);
1446 if (!bstr.isEmpty())
1447 {
1448 if (details == VMINFO_MACHINEREADABLE)
1449 RTPrintf("USBAttachedProduct%zu=\"%lS\"\n", index + 1, bstr.raw());
1450 else
1451 RTPrintf("Product: %lS\n", bstr.raw());
1452 }
1453 CHECK_ERROR_RET (dev, COMGETTER(SerialNumber)(bstr.asOutParam()), rc);
1454 if (!bstr.isEmpty())
1455 {
1456 if (details == VMINFO_MACHINEREADABLE)
1457 RTPrintf("USBAttachedSerialNumber%zu=\"%lS\"\n", index + 1, bstr.raw());
1458 else
1459 RTPrintf("SerialNumber: %lS\n", bstr.raw());
1460 }
1461 CHECK_ERROR_RET (dev, COMGETTER(Address)(bstr.asOutParam()), rc);
1462 if (!bstr.isEmpty())
1463 {
1464 if (details == VMINFO_MACHINEREADABLE)
1465 RTPrintf("USBAttachedAddress%zu=\"%lS\"\n", index + 1, bstr.raw());
1466 else
1467 RTPrintf("Address: %lS\n", bstr.raw());
1468 }
1469
1470 if (details != VMINFO_MACHINEREADABLE)
1471 RTPrintf("\n");
1472 }
1473 }
1474 }
1475 }
1476 } /* USB */
1477
1478 /*
1479 * Shared folders
1480 */
1481 if (details != VMINFO_MACHINEREADABLE)
1482 RTPrintf("Shared folders: ");
1483 uint32_t numSharedFolders = 0;
1484#if 0 // not yet implemented
1485 /* globally shared folders first */
1486 {
1487 SafeIfaceArray <ISharedFolder> sfColl;
1488 CHECK_ERROR_RET(virtualBox, COMGETTER(SharedFolders)(ComSafeArrayAsOutParam(sfColl)), rc);
1489 for (size_t i = 0; i < sfColl.size(); ++i)
1490 {
1491 ComPtr<ISharedFolder> sf = sfColl[i];
1492 Bstr name, hostPath;
1493 sf->COMGETTER(Name)(name.asOutParam());
1494 sf->COMGETTER(HostPath)(hostPath.asOutParam());
1495 RTPrintf("Name: '%lS', Host path: '%lS' (global mapping)\n", name.raw(), hostPath.raw());
1496 ++numSharedFolders;
1497 }
1498 }
1499#endif
1500 /* now VM mappings */
1501 {
1502 com::SafeIfaceArray <ISharedFolder> folders;
1503
1504 CHECK_ERROR_RET(machine, COMGETTER(SharedFolders)(ComSafeArrayAsOutParam(folders)), rc);
1505
1506 for (size_t i = 0; i < folders.size(); ++i)
1507 {
1508 ComPtr <ISharedFolder> sf = folders[i];
1509
1510 Bstr name, hostPath;
1511 BOOL writable;
1512 sf->COMGETTER(Name)(name.asOutParam());
1513 sf->COMGETTER(HostPath)(hostPath.asOutParam());
1514 sf->COMGETTER(Writable)(&writable);
1515 if (!numSharedFolders && details != VMINFO_MACHINEREADABLE)
1516 RTPrintf("\n\n");
1517 if (details == VMINFO_MACHINEREADABLE)
1518 {
1519 RTPrintf("SharedFolderNameMachineMapping%zu=\"%lS\"\n", i + 1,
1520 name.raw());
1521 RTPrintf("SharedFolderPathMachineMapping%zu=\"%lS\"\n", i + 1,
1522 hostPath.raw());
1523 }
1524 else
1525 RTPrintf("Name: '%lS', Host path: '%lS' (machine mapping), %s\n",
1526 name.raw(), hostPath.raw(), writable ? "writable" : "readonly");
1527 ++numSharedFolders;
1528 }
1529 }
1530 /* transient mappings */
1531 if (console)
1532 {
1533 com::SafeIfaceArray <ISharedFolder> folders;
1534
1535 CHECK_ERROR_RET(console, COMGETTER(SharedFolders)(ComSafeArrayAsOutParam(folders)), rc);
1536
1537 for (size_t i = 0; i < folders.size(); ++i)
1538 {
1539 ComPtr <ISharedFolder> sf = folders[i];
1540
1541 Bstr name, hostPath;
1542 sf->COMGETTER(Name)(name.asOutParam());
1543 sf->COMGETTER(HostPath)(hostPath.asOutParam());
1544 if (!numSharedFolders && details != VMINFO_MACHINEREADABLE)
1545 RTPrintf("\n\n");
1546 if (details == VMINFO_MACHINEREADABLE)
1547 {
1548 RTPrintf("SharedFolderNameTransientMapping%zu=\"%lS\"\n", i + 1,
1549 name.raw());
1550 RTPrintf("SharedFolderPathTransientMapping%zu=\"%lS\"\n", i + 1,
1551 hostPath.raw());
1552 }
1553 else
1554 RTPrintf("Name: '%lS', Host path: '%lS' (transient mapping)\n", name.raw(), hostPath.raw());
1555 ++numSharedFolders;
1556 }
1557 }
1558 if (!numSharedFolders && details != VMINFO_MACHINEREADABLE)
1559 RTPrintf("<none>\n");
1560 if (details != VMINFO_MACHINEREADABLE)
1561 RTPrintf("\n");
1562
1563 if (console)
1564 {
1565 /*
1566 * Live VRDP info.
1567 */
1568 ComPtr<IRemoteDisplayInfo> remoteDisplayInfo;
1569 CHECK_ERROR_RET(console, COMGETTER(RemoteDisplayInfo)(remoteDisplayInfo.asOutParam()), rc);
1570 BOOL Active;
1571 ULONG NumberOfClients;
1572 LONG64 BeginTime;
1573 LONG64 EndTime;
1574 ULONG64 BytesSent;
1575 ULONG64 BytesSentTotal;
1576 ULONG64 BytesReceived;
1577 ULONG64 BytesReceivedTotal;
1578 Bstr User;
1579 Bstr Domain;
1580 Bstr ClientName;
1581 Bstr ClientIP;
1582 ULONG ClientVersion;
1583 ULONG EncryptionStyle;
1584
1585 CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(Active) (&Active), rc);
1586 CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(NumberOfClients) (&NumberOfClients), rc);
1587 CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BeginTime) (&BeginTime), rc);
1588 CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(EndTime) (&EndTime), rc);
1589 CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BytesSent) (&BytesSent), rc);
1590 CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BytesSentTotal) (&BytesSentTotal), rc);
1591 CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BytesReceived) (&BytesReceived), rc);
1592 CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BytesReceivedTotal) (&BytesReceivedTotal), rc);
1593 CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(User) (User.asOutParam ()), rc);
1594 CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(Domain) (Domain.asOutParam ()), rc);
1595 CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(ClientName) (ClientName.asOutParam ()), rc);
1596 CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(ClientIP) (ClientIP.asOutParam ()), rc);
1597 CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(ClientVersion) (&ClientVersion), rc);
1598 CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(EncryptionStyle) (&EncryptionStyle), rc);
1599
1600 if (details == VMINFO_MACHINEREADABLE)
1601 RTPrintf("VRDPActiveConnection=\"%s\"\n", Active ? "on": "off");
1602 else
1603 RTPrintf("VRDP Connection: %s\n", Active? "active": "not active");
1604
1605 if (details == VMINFO_MACHINEREADABLE)
1606 RTPrintf("VRDPClients=%d\n", NumberOfClients);
1607 else
1608 RTPrintf("Clients so far: %d\n", NumberOfClients);
1609
1610 if (NumberOfClients > 0)
1611 {
1612 char timestr[128];
1613
1614 if (Active)
1615 {
1616 makeTimeStr (timestr, sizeof (timestr), BeginTime);
1617 if (details == VMINFO_MACHINEREADABLE)
1618 RTPrintf("VRDPStartTime=\"%s\"\n", timestr);
1619 else
1620 RTPrintf("Start time: %s\n", timestr);
1621 }
1622 else
1623 {
1624 makeTimeStr (timestr, sizeof (timestr), BeginTime);
1625 if (details == VMINFO_MACHINEREADABLE)
1626 RTPrintf("VRDPLastStartTime=\"%s\"\n", timestr);
1627 else
1628 RTPrintf("Last started: %s\n", timestr);
1629 makeTimeStr (timestr, sizeof (timestr), EndTime);
1630 if (details == VMINFO_MACHINEREADABLE)
1631 RTPrintf("VRDPLastEndTime=\"%s\"\n", timestr);
1632 else
1633 RTPrintf("Last ended: %s\n", timestr);
1634 }
1635
1636 uint64_t ThroughputSend = 0;
1637 uint64_t ThroughputReceive = 0;
1638 if (EndTime != BeginTime)
1639 {
1640 ThroughputSend = (BytesSent * 1000) / (EndTime - BeginTime);
1641 ThroughputReceive = (BytesReceived * 1000) / (EndTime - BeginTime);
1642 }
1643
1644 if (details == VMINFO_MACHINEREADABLE)
1645 {
1646 RTPrintf("VRDPBytesSent=%llu\n", BytesSent);
1647 RTPrintf("VRDPThroughputSend=%llu\n", ThroughputSend);
1648 RTPrintf("VRDPBytesSentTotal=%llu\n", BytesSentTotal);
1649
1650 RTPrintf("VRDPBytesReceived=%llu\n", BytesReceived);
1651 RTPrintf("VRDPThroughputReceive=%llu\n", ThroughputReceive);
1652 RTPrintf("VRDPBytesReceivedTotal=%llu\n", BytesReceivedTotal);
1653 }
1654 else
1655 {
1656 RTPrintf("Sent: %llu Bytes\n", BytesSent);
1657 RTPrintf("Average speed: %llu B/s\n", ThroughputSend);
1658 RTPrintf("Sent total: %llu Bytes\n", BytesSentTotal);
1659
1660 RTPrintf("Received: %llu Bytes\n", BytesReceived);
1661 RTPrintf("Speed: %llu B/s\n", ThroughputReceive);
1662 RTPrintf("Received total: %llu Bytes\n", BytesReceivedTotal);
1663 }
1664
1665 if (Active)
1666 {
1667 if (details == VMINFO_MACHINEREADABLE)
1668 {
1669 RTPrintf("VRDPUserName=\"%lS\"\n", User.raw());
1670 RTPrintf("VRDPDomain=\"%lS\"\n", Domain.raw());
1671 RTPrintf("VRDPClientName=\"%lS\"\n", ClientName.raw());
1672 RTPrintf("VRDPClientIP=\"%lS\"\n", ClientIP.raw());
1673 RTPrintf("VRDPClientVersion=%d\n", ClientVersion);
1674 RTPrintf("VRDPEncryption=\"%s\"\n", EncryptionStyle == 0? "RDP4": "RDP5 (X.509)");
1675 }
1676 else
1677 {
1678 RTPrintf("User name: %lS\n", User.raw());
1679 RTPrintf("Domain: %lS\n", Domain.raw());
1680 RTPrintf("Client name: %lS\n", ClientName.raw());
1681 RTPrintf("Client IP: %lS\n", ClientIP.raw());
1682 RTPrintf("Client version: %d\n", ClientVersion);
1683 RTPrintf("Encryption: %s\n", EncryptionStyle == 0? "RDP4": "RDP5 (X.509)");
1684 }
1685 }
1686 }
1687
1688 if (details != VMINFO_MACHINEREADABLE)
1689 RTPrintf("\n");
1690 }
1691
1692 if ( details == VMINFO_STANDARD
1693 || details == VMINFO_FULL
1694 || details == VMINFO_MACHINEREADABLE)
1695 {
1696 Bstr description;
1697 machine->COMGETTER(Description)(description.asOutParam());
1698 if (!description.isEmpty())
1699 {
1700 if (details == VMINFO_MACHINEREADABLE)
1701 RTPrintf("description=\"%lS\"\n", description.raw());
1702 else
1703 RTPrintf("Description:\n%lS\n", description.raw());
1704 }
1705 }
1706
1707 ULONG guestVal;
1708 if (details != VMINFO_MACHINEREADABLE)
1709 RTPrintf("Guest:\n\n");
1710
1711#ifdef VBOX_WITH_MEM_BALLOONING
1712 rc = machine->COMGETTER(MemoryBalloonSize)(&guestVal);
1713 if (SUCCEEDED(rc))
1714 {
1715 if (details == VMINFO_MACHINEREADABLE)
1716 RTPrintf("GuestMemoryBalloon=%d\n", guestVal);
1717 else
1718 RTPrintf("Configured memory balloon size: %d MB\n", guestVal);
1719 }
1720#endif
1721 rc = machine->COMGETTER(StatisticsUpdateInterval)(&guestVal);
1722 if (SUCCEEDED(rc))
1723 {
1724 if (details == VMINFO_MACHINEREADABLE)
1725 RTPrintf("GuestStatisticsUpdateInterval=%d\n", guestVal);
1726 else
1727 {
1728 if (guestVal == 0)
1729 RTPrintf("Statistics update: disabled\n");
1730 else
1731 RTPrintf("Statistics update interval: %d seconds\n", guestVal);
1732 }
1733 }
1734 if (details != VMINFO_MACHINEREADABLE)
1735 RTPrintf("\n");
1736
1737 if ( console
1738 && ( details == VMINFO_STATISTICS
1739 || details == VMINFO_FULL
1740 || details == VMINFO_MACHINEREADABLE))
1741 {
1742 ComPtr <IGuest> guest;
1743
1744 rc = console->COMGETTER(Guest)(guest.asOutParam());
1745 if (SUCCEEDED(rc))
1746 {
1747 ULONG statVal;
1748
1749 rc = guest->GetStatistic(0, GuestStatisticType_SampleNumber, &statVal);
1750 if (SUCCEEDED(rc))
1751 {
1752 if (details == VMINFO_MACHINEREADABLE)
1753 RTPrintf("StatGuestSample=%d\n", statVal);
1754 else
1755 RTPrintf("Guest statistics for sample %d:\n\n", statVal);
1756 }
1757
1758 rc = guest->GetStatistic(0, GuestStatisticType_CPULoad_Idle, &statVal);
1759 if (SUCCEEDED(rc))
1760 {
1761 if (details == VMINFO_MACHINEREADABLE)
1762 RTPrintf("StatGuestLoadIdleCPU%d=%d\n", 0, statVal);
1763 else
1764 RTPrintf("CPU%d: CPU Load Idle %-3d%%\n", 0, statVal);
1765 }
1766
1767 rc = guest->GetStatistic(0, GuestStatisticType_CPULoad_Kernel, &statVal);
1768 if (SUCCEEDED(rc))
1769 {
1770 if (details == VMINFO_MACHINEREADABLE)
1771 RTPrintf("StatGuestLoadKernelCPU%d=%d\n", 0, statVal);
1772 else
1773 RTPrintf("CPU%d: CPU Load Kernel %-3d%%\n", 0, statVal);
1774 }
1775
1776 rc = guest->GetStatistic(0, GuestStatisticType_CPULoad_User, &statVal);
1777 if (SUCCEEDED(rc))
1778 {
1779 if (details == VMINFO_MACHINEREADABLE)
1780 RTPrintf("StatGuestLoadUserCPU%d=%d\n", 0, statVal);
1781 else
1782 RTPrintf("CPU%d: CPU Load User %-3d%%\n", 0, statVal);
1783 }
1784
1785 rc = guest->GetStatistic(0, GuestStatisticType_Threads, &statVal);
1786 if (SUCCEEDED(rc))
1787 {
1788 if (details == VMINFO_MACHINEREADABLE)
1789 RTPrintf("StatGuestThreadsCPU%d=%d\n", 0, statVal);
1790 else
1791 RTPrintf("CPU%d: Threads %d\n", 0, statVal);
1792 }
1793
1794 rc = guest->GetStatistic(0, GuestStatisticType_Processes, &statVal);
1795 if (SUCCEEDED(rc))
1796 {
1797 if (details == VMINFO_MACHINEREADABLE)
1798 RTPrintf("StatGuestProcessesCPU%d=%d\n", 0, statVal);
1799 else
1800 RTPrintf("CPU%d: Processes %d\n", 0, statVal);
1801 }
1802
1803 rc = guest->GetStatistic(0, GuestStatisticType_Handles, &statVal);
1804 if (SUCCEEDED(rc))
1805 {
1806 if (details == VMINFO_MACHINEREADABLE)
1807 RTPrintf("StatGuestHandlesCPU%d=%d\n", 0, statVal);
1808 else
1809 RTPrintf("CPU%d: Handles %d\n", 0, statVal);
1810 }
1811
1812 rc = guest->GetStatistic(0, GuestStatisticType_MemoryLoad, &statVal);
1813 if (SUCCEEDED(rc))
1814 {
1815 if (details == VMINFO_MACHINEREADABLE)
1816 RTPrintf("StatGuestMemoryLoadCPU%d=%d\n", 0, statVal);
1817 else
1818 RTPrintf("CPU%d: Memory Load %d%%\n", 0, statVal);
1819 }
1820
1821 rc = guest->GetStatistic(0, GuestStatisticType_PhysMemTotal, &statVal);
1822 if (SUCCEEDED(rc))
1823 {
1824 if (details == VMINFO_MACHINEREADABLE)
1825 RTPrintf("StatGuestMemoryTotalPhysCPU%d=%d\n", 0, statVal);
1826 else
1827 RTPrintf("CPU%d: Total physical memory %-4d MB\n", 0, statVal);
1828 }
1829
1830 rc = guest->GetStatistic(0, GuestStatisticType_PhysMemAvailable, &statVal);
1831 if (SUCCEEDED(rc))
1832 {
1833 if (details == VMINFO_MACHINEREADABLE)
1834 RTPrintf("StatGuestMemoryFreePhysCPU%d=%d\n", 0, statVal);
1835 else
1836 RTPrintf("CPU%d: Free physical memory %-4d MB\n", 0, statVal);
1837 }
1838
1839#ifdef VBOX_WITH_MEM_BALLOONING
1840 rc = guest->GetStatistic(0, GuestStatisticType_PhysMemBalloon, &statVal);
1841 if (SUCCEEDED(rc))
1842 {
1843 if (details == VMINFO_MACHINEREADABLE)
1844 RTPrintf("StatGuestMemoryBalloonCPU%d=%d\n", 0, statVal);
1845 else
1846 RTPrintf("CPU%d: Memory balloon size %-4d MB\n", 0, statVal);
1847 }
1848#endif
1849 rc = guest->GetStatistic(0, GuestStatisticType_MemCommitTotal, &statVal);
1850 if (SUCCEEDED(rc))
1851 {
1852 if (details == VMINFO_MACHINEREADABLE)
1853 RTPrintf("StatGuestMemoryCommittedCPU%d=%d\n", 0, statVal);
1854 else
1855 RTPrintf("CPU%d: Committed memory %-4d MB\n", 0, statVal);
1856 }
1857
1858 rc = guest->GetStatistic(0, GuestStatisticType_MemKernelTotal, &statVal);
1859 if (SUCCEEDED(rc))
1860 {
1861 if (details == VMINFO_MACHINEREADABLE)
1862 RTPrintf("StatGuestMemoryTotalKernelCPU%d=%d\n", 0, statVal);
1863 else
1864 RTPrintf("CPU%d: Total kernel memory %-4d MB\n", 0, statVal);
1865 }
1866
1867 rc = guest->GetStatistic(0, GuestStatisticType_MemKernelPaged, &statVal);
1868 if (SUCCEEDED(rc))
1869 {
1870 if (details == VMINFO_MACHINEREADABLE)
1871 RTPrintf("StatGuestMemoryPagedKernelCPU%d=%d\n", 0, statVal);
1872 else
1873 RTPrintf("CPU%d: Paged kernel memory %-4d MB\n", 0, statVal);
1874 }
1875
1876 rc = guest->GetStatistic(0, GuestStatisticType_MemKernelNonpaged, &statVal);
1877 if (SUCCEEDED(rc))
1878 {
1879 if (details == VMINFO_MACHINEREADABLE)
1880 RTPrintf("StatGuestMemoryNonpagedKernelCPU%d=%d\n", 0, statVal);
1881 else
1882 RTPrintf("CPU%d: Nonpaged kernel memory %-4d MB\n", 0, statVal);
1883 }
1884
1885 rc = guest->GetStatistic(0, GuestStatisticType_MemSystemCache, &statVal);
1886 if (SUCCEEDED(rc))
1887 {
1888 if (details == VMINFO_MACHINEREADABLE)
1889 RTPrintf("StatGuestSystemCacheSizeCPU%d=%d\n", 0, statVal);
1890 else
1891 RTPrintf("CPU%d: System cache size %-4d MB\n", 0, statVal);
1892 }
1893
1894 rc = guest->GetStatistic(0, GuestStatisticType_PageFileSize, &statVal);
1895 if (SUCCEEDED(rc))
1896 {
1897 if (details == VMINFO_MACHINEREADABLE)
1898 RTPrintf("StatGuestPageFileSizeCPU%d=%d\n", 0, statVal);
1899 else
1900 RTPrintf("CPU%d: Page file size %-4d MB\n", 0, statVal);
1901 }
1902
1903 RTPrintf("\n");
1904 }
1905 else
1906 {
1907 if (details != VMINFO_MACHINEREADABLE)
1908 {
1909 RTPrintf("[!] FAILED calling console->getGuest at line %d!\n", __LINE__);
1910 GluePrintRCMessage(rc);
1911 }
1912 }
1913 }
1914
1915 /*
1916 * snapshots
1917 */
1918 ComPtr<ISnapshot> snapshot;
1919 rc = machine->GetSnapshot(Bstr(), snapshot.asOutParam());
1920 if (SUCCEEDED(rc) && snapshot)
1921 {
1922 ComPtr<ISnapshot> currentSnapshot;
1923 rc = machine->COMGETTER(CurrentSnapshot)(currentSnapshot.asOutParam());
1924 if (SUCCEEDED(rc))
1925 {
1926 if (details != VMINFO_MACHINEREADABLE)
1927 RTPrintf("Snapshots:\n\n");
1928 showSnapshots(snapshot, currentSnapshot, details);
1929 }
1930 }
1931
1932 if (details != VMINFO_MACHINEREADABLE)
1933 RTPrintf("\n");
1934 return S_OK;
1935}
1936
1937#if defined(_MSC_VER)
1938# pragma optimize("", on)
1939#endif
1940
1941static const RTGETOPTDEF g_aShowVMInfoOptions[] =
1942{
1943 { "--details", 'D', RTGETOPT_REQ_NOTHING },
1944 { "-details", 'D', RTGETOPT_REQ_NOTHING }, // deprecated
1945 { "--statistics", 'S', RTGETOPT_REQ_NOTHING },
1946 { "-statistics", 'S', RTGETOPT_REQ_NOTHING }, // deprecated
1947 { "--machinereadable", 'M', RTGETOPT_REQ_NOTHING },
1948 { "-machinereadable", 'M', RTGETOPT_REQ_NOTHING }, // deprecated
1949};
1950
1951int handleShowVMInfo(HandlerArg *a)
1952{
1953 HRESULT rc;
1954 const char *VMNameOrUuid = NULL;
1955 bool fDetails = false;
1956 bool fStatistics = false;
1957 bool fMachinereadable = false;
1958
1959 int c;
1960 RTGETOPTUNION ValueUnion;
1961 RTGETOPTSTATE GetState;
1962 // start at 0 because main() has hacked both the argc and argv given to us
1963 RTGetOptInit(&GetState, a->argc, a->argv, g_aShowVMInfoOptions, RT_ELEMENTS(g_aShowVMInfoOptions), 0, 0 /* fFlags */);
1964 while ((c = RTGetOpt(&GetState, &ValueUnion)))
1965 {
1966 switch (c)
1967 {
1968 case 'D': // --details
1969 fDetails = true;
1970 break;
1971
1972 case 'S': // --statistics
1973 fStatistics = true;
1974 break;
1975
1976 case 'M': // --machinereadable
1977 fMachinereadable = true;
1978 break;
1979
1980 case VINF_GETOPT_NOT_OPTION:
1981 if (!VMNameOrUuid)
1982 VMNameOrUuid = ValueUnion.psz;
1983 else
1984 return errorSyntax(USAGE_SHOWVMINFO, "Invalid parameter '%s'", ValueUnion.psz);
1985 break;
1986
1987 default:
1988 if (c > 0)
1989 {
1990 if (RT_C_IS_PRINT(c))
1991 return errorSyntax(USAGE_SHOWVMINFO, "Invalid option -%c", c);
1992 else
1993 return errorSyntax(USAGE_SHOWVMINFO, "Invalid option case %i", c);
1994 }
1995 else if (c == VERR_GETOPT_UNKNOWN_OPTION)
1996 return errorSyntax(USAGE_SHOWVMINFO, "unknown option: %s\n", ValueUnion.psz);
1997 else if (ValueUnion.pDef)
1998 return errorSyntax(USAGE_SHOWVMINFO, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
1999 else
2000 return errorSyntax(USAGE_SHOWVMINFO, "error: %Rrs", c);
2001 }
2002 }
2003
2004 /* check for required options */
2005 if (!VMNameOrUuid)
2006 return errorSyntax(USAGE_SHOWVMINFO, "VM name or UUID required");
2007
2008 /* try to find the given machine */
2009 ComPtr <IMachine> machine;
2010 Bstr uuid (VMNameOrUuid);
2011 if (!Guid (VMNameOrUuid).isEmpty())
2012 {
2013 CHECK_ERROR (a->virtualBox, GetMachine (uuid, machine.asOutParam()));
2014 }
2015 else
2016 {
2017 CHECK_ERROR (a->virtualBox, FindMachine (Bstr(VMNameOrUuid), machine.asOutParam()));
2018 if (SUCCEEDED (rc))
2019 machine->COMGETTER(Id) (uuid.asOutParam());
2020 }
2021 if (FAILED (rc))
2022 return 1;
2023
2024 /* 2nd option can be -details, -statistics or -argdump */
2025 VMINFO_DETAILS details = VMINFO_NONE;
2026 if (fMachinereadable)
2027 details = VMINFO_MACHINEREADABLE;
2028 else
2029 if (fDetails && fStatistics)
2030 details = VMINFO_FULL;
2031 else
2032 if (fDetails)
2033 details = VMINFO_STANDARD;
2034 else
2035 if (fStatistics)
2036 details = VMINFO_STATISTICS;
2037
2038 ComPtr <IConsole> console;
2039
2040 /* open an existing session for the VM */
2041 rc = a->virtualBox->OpenExistingSession (a->session, uuid);
2042 if (SUCCEEDED(rc))
2043 /* get the session machine */
2044 rc = a->session->COMGETTER(Machine)(machine.asOutParam());
2045 if (SUCCEEDED(rc))
2046 /* get the session console */
2047 rc = a->session->COMGETTER(Console)(console.asOutParam());
2048
2049 rc = showVMInfo(a->virtualBox, machine, details, console);
2050
2051 if (console)
2052 a->session->Close();
2053
2054 return SUCCEEDED (rc) ? 0 : 1;
2055}
2056
2057#endif /* !VBOX_ONLY_DOCS */
2058/* vi: set tabstop=4 shiftwidth=4 expandtab: */
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use