tstAPI.cpp@ 53517

Last change on this file since 53517 was 50117, checked in by vboxsync, 11 years ago
Main+Frontends: clear out some cruft code, outdated EventQueue stuff and whitespace cleanup
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 63.3 KB

Line
1	/** @file
2	*
3	* tstAPI - test program for our COM/XPCOM interface
4	*/
5
6	/*
7	* Copyright (C) 2006-2014 Oracle Corporation
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
18	#include <stdio.h>
19	#include <stdlib.h>
20
21	#include <VBox/com/com.h>
22	#include <VBox/com/string.h>
23	#include <VBox/com/array.h>
24	#include <VBox/com/Guid.h>
25	#include <VBox/com/ErrorInfo.h>
26	#include <VBox/com/errorprint.h>
27
28	#include <VBox/com/VirtualBox.h>
29
30	using namespace com;
31
32	#define LOG_ENABLED
33	#define LOG_GROUP LOG_GROUP_MAIN
34	#define LOG_INSTANCE NULL
35	#include <VBox/log.h>
36
37	#include <iprt/initterm.h>
38	#include <iprt/path.h>
39	#include <iprt/param.h>
40	#include <iprt/stream.h>
41	#include <iprt/thread.h>
42
43
44	// forward declarations
45	///////////////////////////////////////////////////////////////////////////////
46
47	static Bstr getObjectName(ComPtr<IVirtualBox> aVirtualBox,
48	ComPtr<IUnknown> aObject);
49	static void queryMetrics(ComPtr<IVirtualBox> aVirtualBox,
50	ComPtr<IPerformanceCollector> collector,
51	ComSafeArrayIn(IUnknown *, objects));
52	static void listAffectedMetrics(ComPtr<IVirtualBox> aVirtualBox,
53	ComSafeArrayIn(IPerformanceMetric*, aMetrics));
54
55	// funcs
56	///////////////////////////////////////////////////////////////////////////////
57
58	HRESULT readAndChangeMachineSettings(IMachine machine, IMachine readonlyMachine = 0)
59	{
60	HRESULT rc = S_OK;
61
62	Bstr name;
63	RTPrintf("Getting machine name...\n");
64	CHECK_ERROR_RET(machine, COMGETTER(Name)(name.asOutParam()), rc);
65	RTPrintf("Name: {%ls}\n", name.raw());
66
67	RTPrintf("Getting machine GUID...\n");
68	Bstr guid;
69	CHECK_ERROR(machine, COMGETTER(Id)(guid.asOutParam()));
70	if (SUCCEEDED(rc) && !guid.isEmpty()) {
71	RTPrintf("Guid::toString(): {%s}\n", Utf8Str(guid).c_str());
72	} else {
73	RTPrintf("WARNING: there's no GUID!");
74	}
75
76	ULONG memorySize;
77	RTPrintf("Getting memory size...\n");
78	CHECK_ERROR_RET(machine, COMGETTER(MemorySize)(&memorySize), rc);
79	RTPrintf("Memory size: %d\n", memorySize);
80
81	MachineState_T machineState;
82	RTPrintf("Getting machine state...\n");
83	CHECK_ERROR_RET(machine, COMGETTER(State)(&machineState), rc);
84	RTPrintf("Machine state: %d\n", machineState);
85
86	BOOL modified;
87	RTPrintf("Are any settings modified?...\n");
88	CHECK_ERROR(machine, COMGETTER(SettingsModified)(&modified));
89	if (SUCCEEDED(rc))
90	RTPrintf("%s\n", modified ? "yes" : "no");
91
92	ULONG memorySizeBig = memorySize * 10;
93	RTPrintf("Changing memory size to %d...\n", memorySizeBig);
94	CHECK_ERROR(machine, COMSETTER(MemorySize)(memorySizeBig));
95
96	if (SUCCEEDED(rc))
97	{
98	RTPrintf("Are any settings modified now?...\n");
99	CHECK_ERROR_RET(machine, COMGETTER(SettingsModified)(&modified), rc);
100	RTPrintf("%s\n", modified ? "yes" : "no");
101	ASSERT_RET(modified, 0);
102
103	ULONG memorySizeGot;
104	RTPrintf("Getting memory size again...\n");
105	CHECK_ERROR_RET(machine, COMGETTER(MemorySize)(&memorySizeGot), rc);
106	RTPrintf("Memory size: %d\n", memorySizeGot);
107	ASSERT_RET(memorySizeGot == memorySizeBig, 0);
108
109	if (readonlyMachine)
110	{
111	RTPrintf("Getting memory size of the counterpart readonly machine...\n");
112	ULONG memorySizeRO;
113	readonlyMachine->COMGETTER(MemorySize)(&memorySizeRO);
114	RTPrintf("Memory size: %d\n", memorySizeRO);
115	ASSERT_RET(memorySizeRO != memorySizeGot, 0);
116	}
117
118	RTPrintf("Discarding recent changes...\n");
119	CHECK_ERROR_RET(machine, DiscardSettings(), rc);
120	RTPrintf("Are any settings modified after discarding?...\n");
121	CHECK_ERROR_RET(machine, COMGETTER(SettingsModified)(&modified), rc);
122	RTPrintf("%s\n", modified ? "yes" : "no");
123	ASSERT_RET(!modified, 0);
124
125	RTPrintf("Getting memory size once more...\n");
126	CHECK_ERROR_RET(machine, COMGETTER(MemorySize)(&memorySizeGot), rc);
127	RTPrintf("Memory size: %d\n", memorySizeGot);
128	ASSERT_RET(memorySizeGot == memorySize, 0);
129
130	memorySize = memorySize > 128 ? memorySize / 2 : memorySize * 2;
131	RTPrintf("Changing memory size to %d...\n", memorySize);
132	CHECK_ERROR_RET(machine, COMSETTER(MemorySize)(memorySize), rc);
133	}
134
135	Bstr desc;
136	RTPrintf("Getting description...\n");
137	CHECK_ERROR_RET(machine, COMGETTER(Description)(desc.asOutParam()), rc);
138	RTPrintf("Description is: \"%ls\"\n", desc.raw());
139
140	desc = L"This is an exemplary description (changed).";
141	RTPrintf("Setting description to \"%ls\"...\n", desc.raw());
142	CHECK_ERROR_RET(machine, COMSETTER(Description)(desc.raw()), rc);
143
144	RTPrintf("Saving machine settings...\n");
145	CHECK_ERROR(machine, SaveSettings());
146	if (SUCCEEDED(rc))
147	{
148	RTPrintf("Are any settings modified after saving?...\n");
149	CHECK_ERROR_RET(machine, COMGETTER(SettingsModified)(&modified), rc);
150	RTPrintf("%s\n", modified ? "yes" : "no");
151	ASSERT_RET(!modified, 0);
152
153	if (readonlyMachine) {
154	RTPrintf("Getting memory size of the counterpart readonly machine...\n");
155	ULONG memorySizeRO;
156	readonlyMachine->COMGETTER(MemorySize)(&memorySizeRO);
157	RTPrintf("Memory size: %d\n", memorySizeRO);
158	ASSERT_RET(memorySizeRO == memorySize, 0);
159	}
160	}
161
162	Bstr extraDataKey = L"Blafasel";
163	Bstr extraData;
164	RTPrintf("Getting extra data key {%ls}...\n", extraDataKey.raw());
165	CHECK_ERROR_RET(machine, GetExtraData(extraDataKey.raw(), extraData.asOutParam()), rc);
166	if (!extraData.isEmpty()) {
167	RTPrintf("Extra data value: {%ls}\n", extraData.raw());
168	} else {
169	RTPrintf("No extra data exists\n");
170	}
171
172	if (extraData.isEmpty())
173	extraData = L"Das ist die Berliner Luft, Luft, Luft...";
174	else
175	extraData.setNull();
176	RTPrintf("Setting extra data key {%ls} to {%ls}...\n",
177	extraDataKey.raw(), extraData.raw());
178	CHECK_ERROR(machine, SetExtraData(extraDataKey.raw(), extraData.raw()));
179
180	if (SUCCEEDED(rc)) {
181	RTPrintf("Getting extra data key {%ls} again...\n", extraDataKey.raw());
182	CHECK_ERROR_RET(machine, GetExtraData(extraDataKey.raw(), extraData.asOutParam()), rc);
183	if (!extraData.isEmpty()) {
184	RTPrintf("Extra data value: {%ls}\n", extraData.raw());
185	} else {
186	RTPrintf("No extra data exists\n");
187	}
188	}
189
190	return rc;
191	}
192
193	// main
194	///////////////////////////////////////////////////////////////////////////////
195
196	int main(int argc, char *argv[])
197	{
198	/*
199	* Initialize the VBox runtime without loading
200	* the support driver.
201	*/
202	RTR3InitExe(argc, &argv, 0);
203
204	HRESULT rc;
205
206	{
207	char homeDir[RTPATH_MAX];
208	GetVBoxUserHomeDirectory(homeDir, sizeof(homeDir));
209	RTPrintf("VirtualBox Home Directory = '%s'\n", homeDir);
210	}
211
212	RTPrintf("Initializing COM...\n");
213
214	rc = com::Initialize();
215	if (FAILED(rc))
216	{
217	RTPrintf("ERROR: failed to initialize COM!\n");
218	return rc;
219	}
220
221	do
222	{
223	// scopes all the stuff till shutdown
224	////////////////////////////////////////////////////////////////////////////
225
226	ComPtr<IVirtualBox> virtualBox;
227	ComPtr<ISession> session;
228
229	#if 0
230	// Utf8Str test
231	////////////////////////////////////////////////////////////////////////////
232
233	Utf8Str nullUtf8Str;
234	RTPrintf("nullUtf8Str='%s'\n", nullUtf8Str.raw());
235
236	Utf8Str simpleUtf8Str = "simpleUtf8Str";
237	RTPrintf("simpleUtf8Str='%s'\n", simpleUtf8Str.raw());
238
239	Utf8Str utf8StrFmt = Utf8StrFmt("[0=%d]%s[1=%d]", 0, "utf8StrFmt", 1);
240	RTPrintf("utf8StrFmt='%s'\n", utf8StrFmt.raw());
241
242	#endif
243
244	RTPrintf("Creating VirtualBox object...\n");
245	rc = virtualBox.createLocalObject(CLSID_VirtualBox);
246	if (FAILED(rc))
247	RTPrintf("ERROR: failed to create the VirtualBox object!\n");
248	else
249	{
250	rc = session.createInprocObject(CLSID_Session);
251	if (FAILED(rc))
252	RTPrintf("ERROR: failed to create a session object!\n");
253	}
254
255	if (FAILED(rc))
256	{
257	com::ErrorInfo info;
258	if (!info.isFullAvailable() && !info.isBasicAvailable())
259	{
260	com::GluePrintRCMessage(rc);
261	RTPrintf("Most likely, the VirtualBox COM server is not running or failed to start.\n");
262	}
263	else
264	com::GluePrintErrorInfo(info);
265	break;
266	}
267
268	#if 0
269	// Testing VirtualBox::COMGETTER(ProgressOperations).
270	// This is designed to be tested while running
271	// "./VBoxManage clonehd src.vdi clone.vdi" in parallel.
272	// It will then display the progress every 2 seconds.
273	////////////////////////////////////////////////////////////////////////////
274	{
275	RTPrintf("Testing VirtualBox::COMGETTER(ProgressOperations)...\n");
276
277	for (;;) {
278	com::SafeIfaceArray<IProgress> operations;
279
280	CHECK_ERROR_BREAK(virtualBox,
281	COMGETTER(ProgressOperations)(ComSafeArrayAsOutParam(operations)));
282
283	RTPrintf("operations: %d\n", operations.size());
284	if (operations.size() == 0)
285	break; // No more operations left.
286
287	for (size_t i = 0; i < operations.size(); ++i) {
288	PRInt32 percent;
289
290	operations[i]->COMGETTER(Percent)(&percent);
291	RTPrintf("operations[%u]: %ld\n", (unsigned)i, (long)percent);
292	}
293	RTThreadSleep(2000); // msec
294	}
295	}
296	#endif
297
298	#if 0
299	// IUnknown identity test
300	////////////////////////////////////////////////////////////////////////////
301	{
302	{
303	ComPtr<IVirtualBox> virtualBox2;
304
305	RTPrintf("Creating one more VirtualBox object...\n");
306	CHECK_RC(virtualBox2.createLocalObject(CLSID_VirtualBox));
307	if (FAILED(rc))
308	{
309	CHECK_ERROR_NOCALL();
310	break;
311	}
312
313	RTPrintf("IVirtualBox(virtualBox)=%p IVirtualBox(virtualBox2)=%p\n",
314	(IVirtualBox )virtualBox, (IVirtualBox )virtualBox2);
315	Assert((IVirtualBox )virtualBox == (IVirtualBox )virtualBox2);
316
317	ComPtr<IUnknown> unk(virtualBox);
318	ComPtr<IUnknown> unk2;
319	unk2 = virtualBox2;
320
321	RTPrintf("IUnknown(virtualBox)=%p IUnknown(virtualBox2)=%p\n",
322	(IUnknown )unk, (IUnknown )unk2);
323	Assert((IUnknown )unk == (IUnknown )unk2);
324
325	ComPtr<IVirtualBox> vb = unk;
326	ComPtr<IVirtualBox> vb2 = unk;
327
328	RTPrintf("IVirtualBox(IUnknown(virtualBox))=%p IVirtualBox(IUnknown(virtualBox2))=%p\n",
329	(IVirtualBox )vb, (IVirtualBox )vb2);
330	Assert((IVirtualBox )vb == (IVirtualBox )vb2);
331	}
332
333	{
334	ComPtr<IHost> host;
335	CHECK_ERROR_BREAK(virtualBox, COMGETTER(Host)(host.asOutParam()));
336	RTPrintf(" IHost(host)=%p\n", (IHost *)host);
337	ComPtr<IUnknown> unk = host;
338	RTPrintf(" IUnknown(host)=%p\n", (IUnknown *)unk);
339	ComPtr<IHost> host_copy = unk;
340	RTPrintf(" IHost(host_copy)=%p\n", (IHost *)host_copy);
341	ComPtr<IUnknown> unk_copy = host_copy;
342	RTPrintf(" IUnknown(host_copy)=%p\n", (IUnknown *)unk_copy);
343	Assert((IUnknown )unk == (IUnknown )unk_copy);
344
345	/* query IUnknown on IUnknown */
346	ComPtr<IUnknown> unk_copy_copy;
347	unk_copy.queryInterfaceTo(unk_copy_copy.asOutParam());
348	RTPrintf(" IUnknown(unk_copy)=%p\n", (IUnknown *)unk_copy_copy);
349	Assert((IUnknown )unk_copy == (IUnknown )unk_copy_copy);
350	/* query IUnknown on IUnknown in the opposite direction */
351	unk_copy_copy.queryInterfaceTo(unk_copy.asOutParam());
352	RTPrintf(" IUnknown(unk_copy_copy)=%p\n", (IUnknown *)unk_copy);
353	Assert((IUnknown )unk_copy == (IUnknown )unk_copy_copy);
354
355	/* query IUnknown again after releasing all previous IUnknown instances
356	* but keeping IHost -- it should remain the same (Identity Rule) */
357	IUnknown *oldUnk = unk;
358	unk.setNull();
359	unk_copy.setNull();
360	unk_copy_copy.setNull();
361	unk = host;
362	RTPrintf(" IUnknown(host)=%p\n", (IUnknown *)unk);
363	Assert(oldUnk == (IUnknown *)unk);
364	}
365
366	// RTPrintf("Will be now released (press Enter)...");
367	// getchar();
368	}
369	#endif
370
371	#if 0
372	// the simplest COM API test
373	////////////////////////////////////////////////////////////////////////////
374	{
375	Bstr version;
376	CHECK_ERROR_BREAK(virtualBox, COMGETTER(Version)(version.asOutParam()));
377	RTPrintf("VirtualBox version = %ls\n", version.raw());
378	}
379	#endif
380
381	#if 0
382	// Array test
383	////////////////////////////////////////////////////////////////////////////
384	{
385	RTPrintf("Calling IVirtualBox::Machines...\n");
386
387	com::SafeIfaceArray<IMachine> machines;
388	CHECK_ERROR_BREAK(virtualBox,
389	COMGETTER(Machines)(ComSafeArrayAsOutParam(machines)));
390
391	RTPrintf("%u machines registered (machines.isNull()=%d).\n",
392	machines.size(), machines.isNull());
393
394	for (size_t i = 0; i < machines.size(); ++ i)
395	{
396	Bstr name;
397	CHECK_ERROR_BREAK(machines[i], COMGETTER(Name)(name.asOutParam()));
398	RTPrintf("machines[%u]='%s'\n", i, Utf8Str(name).raw());
399	}
400
401	#if 0
402	{
403	RTPrintf("Testing [out] arrays...\n");
404	com::SafeGUIDArray uuids;
405	CHECK_ERROR_BREAK(virtualBox,
406	COMGETTER(Uuids)(ComSafeArrayAsOutParam(uuids)));
407
408	for (size_t i = 0; i < uuids.size(); ++ i)
409	RTPrintf("uuids[%u]=%RTuuid\n", i, &uuids[i]);
410	}
411
412	{
413	RTPrintf("Testing [in] arrays...\n");
414	com::SafeGUIDArray uuids(5);
415	for (size_t i = 0; i < uuids.size(); ++ i)
416	{
417	Guid id;
418	id.create();
419	uuids[i] = id;
420	RTPrintf("uuids[%u]=%RTuuid\n", i, &uuids[i]);
421	}
422
423	CHECK_ERROR_BREAK(virtualBox,
424	SetUuids(ComSafeArrayAsInParam(uuids)));
425	}
426	#endif
427
428	}
429	#endif
430
431	#if 0
432	// some outdated stuff
433	////////////////////////////////////////////////////////////////////////////
434
435	RTPrintf("Getting IHost interface...\n");
436	IHost *host;
437	rc = virtualBox->GetHost(&host);
438	if (SUCCEEDED(rc))
439	{
440	IHostDVDDriveCollection *dvdColl;
441	rc = host->GetHostDVDDrives(&dvdColl);
442	if (SUCCEEDED(rc))
443	{
444	IHostDVDDrive *dvdDrive = NULL;
445	dvdColl->GetNextHostDVDDrive(dvdDrive, &dvdDrive);
446	while (dvdDrive)
447	{
448	BSTR driveName;
449	char *driveNameUtf8;
450	dvdDrive->GetDriveName(&driveName);
451	RTUtf16ToUtf8((PCRTUTF16)driveName, &driveNameUtf8);
452	RTPrintf("Host DVD drive name: %s\n", driveNameUtf8);
453	RTStrFree(driveNameUtf8);
454	SysFreeString(driveName);
455	IHostDVDDrive *dvdDriveTemp = dvdDrive;
456	dvdColl->GetNextHostDVDDrive(dvdDriveTemp, &dvdDrive);
457	dvdDriveTemp->Release();
458	}
459	dvdColl->Release();
460	} else
461	{
462	RTPrintf("Could not get host DVD drive collection\n");
463	}
464
465	IHostFloppyDriveCollection *floppyColl;
466	rc = host->GetHostFloppyDrives(&floppyColl);
467	if (SUCCEEDED(rc))
468	{
469	IHostFloppyDrive *floppyDrive = NULL;
470	floppyColl->GetNextHostFloppyDrive(floppyDrive, &floppyDrive);
471	while (floppyDrive)
472	{
473	BSTR driveName;
474	char *driveNameUtf8;
475	floppyDrive->GetDriveName(&driveName);
476	RTUtf16ToUtf8((PCRTUTF16)driveName, &driveNameUtf8);
477	RTPrintf("Host floppy drive name: %s\n", driveNameUtf8);
478	RTStrFree(driveNameUtf8);
479	SysFreeString(driveName);
480	IHostFloppyDrive *floppyDriveTemp = floppyDrive;
481	floppyColl->GetNextHostFloppyDrive(floppyDriveTemp, &floppyDrive);
482	floppyDriveTemp->Release();
483	}
484	floppyColl->Release();
485	} else
486	{
487	RTPrintf("Could not get host floppy drive collection\n");
488	}
489	host->Release();
490	} else
491	{
492	RTPrintf("Call failed\n");
493	}
494	RTPrintf("\n");
495	#endif
496
497	#if 0
498	// IVirtualBoxErrorInfo test
499	////////////////////////////////////////////////////////////////////////////
500	{
501	// RPC calls
502
503	// call a method that will definitely fail
504	Guid uuid;
505	ComPtr<IHardDisk> hardDisk;
506	rc = virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());
507	RTPrintf("virtualBox->GetHardDisk(null-uuid)=%08X\n", rc);
508
509	// {
510	// com::ErrorInfo info(virtualBox);
511	// PRINT_ERROR_INFO(info);
512	// }
513
514	// call a method that will definitely succeed
515	Bstr version;
516	rc = virtualBox->COMGETTER(Version)(version.asOutParam());
517	RTPrintf("virtualBox->COMGETTER(Version)=%08X\n", rc);
518
519	{
520	com::ErrorInfo info(virtualBox);
521	PRINT_ERROR_INFO(info);
522	}
523
524	// Local calls
525
526	// call a method that will definitely fail
527	ComPtr<IMachine> machine;
528	rc = session->COMGETTER(Machine)(machine.asOutParam());
529	RTPrintf("session->COMGETTER(Machine)=%08X\n", rc);
530
531	// {
532	// com::ErrorInfo info(virtualBox);
533	// PRINT_ERROR_INFO(info);
534	// }
535
536	// call a method that will definitely succeed
537	SessionState_T state;
538	rc = session->COMGETTER(State)(&state);
539	RTPrintf("session->COMGETTER(State)=%08X\n", rc);
540
541	{
542	com::ErrorInfo info(virtualBox);
543	PRINT_ERROR_INFO(info);
544	}
545	}
546	#endif
547
548	#if 0
549	// register the existing hard disk image
550	///////////////////////////////////////////////////////////////////////////
551	do
552	{
553	ComPtr<IHardDisk> hd;
554	Bstr src = L"E:\\develop\\innotek\\images\\NewHardDisk.vdi";
555	RTPrintf("Opening the existing hard disk '%ls'...\n", src.raw());
556	CHECK_ERROR_BREAK(virtualBox, OpenHardDisk(src, AccessMode_ReadWrite, hd.asOutParam()));
557	RTPrintf("Enter to continue...\n");
558	getchar();
559	RTPrintf("Registering the existing hard disk '%ls'...\n", src.raw());
560	CHECK_ERROR_BREAK(virtualBox, RegisterHardDisk(hd));
561	RTPrintf("Enter to continue...\n");
562	getchar();
563	}
564	while (FALSE);
565	RTPrintf("\n");
566	#endif
567
568	#if 0
569	// find and unregister the existing hard disk image
570	///////////////////////////////////////////////////////////////////////////
571	do
572	{
573	ComPtr<IVirtualDiskImage> vdi;
574	Bstr src = L"CreatorTest.vdi";
575	RTPrintf("Unregistering the hard disk '%ls'...\n", src.raw());
576	CHECK_ERROR_BREAK(virtualBox, FindVirtualDiskImage(src, vdi.asOutParam()));
577	ComPtr<IHardDisk> hd = vdi;
578	Guid id;
579	CHECK_ERROR_BREAK(hd, COMGETTER(Id)(id.asOutParam()));
580	CHECK_ERROR_BREAK(virtualBox, UnregisterHardDisk(id, hd.asOutParam()));
581	}
582	while (FALSE);
583	RTPrintf("\n");
584	#endif
585
586	#if 0
587	// clone the registered hard disk
588	///////////////////////////////////////////////////////////////////////////
589	do
590	{
591	#if defined RT_OS_LINUX
592	Bstr src = L"/mnt/hugaida/common/develop/innotek/images/freedos-linux.vdi";
593	#else
594	Bstr src = L"E:/develop/innotek/images/freedos.vdi";
595	#endif
596	Bstr dst = L"./clone.vdi";
597	RTPrintf("Cloning '%ls' to '%ls'...\n", src.raw(), dst.raw());
598	ComPtr<IVirtualDiskImage> vdi;
599	CHECK_ERROR_BREAK(virtualBox, FindVirtualDiskImage(src, vdi.asOutParam()));
600	ComPtr<IHardDisk> hd = vdi;
601	ComPtr<IProgress> progress;
602	CHECK_ERROR_BREAK(hd, CloneToImage(dst, vdi.asOutParam(), progress.asOutParam()));
603	RTPrintf("Waiting for completion...\n");
604	CHECK_ERROR_BREAK(progress, WaitForCompletion(-1));
605	ProgressErrorInfo ei(progress);
606	if (FAILED(ei.getResultCode()))
607	{
608	PRINT_ERROR_INFO(ei);
609	}
610	else
611	{
612	vdi->COMGETTER(FilePath)(dst.asOutParam());
613	RTPrintf("Actual clone path is '%ls'\n", dst.raw());
614	}
615	}
616	while (FALSE);
617	RTPrintf("\n");
618	#endif
619
620	#if 0
621	// find a registered hard disk by location and get properties
622	///////////////////////////////////////////////////////////////////////////
623	do
624	{
625	ComPtr<IHardDisk> hd;
626	static const wchar_t *Names[] =
627	{
628	#ifndef RT_OS_LINUX
629	L"freedos.vdi",
630	L"MS-DOS.vmdk",
631	L"iscsi",
632	L"some/path/and/disk.vdi",
633	#else
634	L"xp.vdi",
635	L"Xp.vDI",
636	#endif
637	};
638
639	RTPrintf("\n");
640
641	for (size_t i = 0; i < RT_ELEMENTS(Names); ++ i)
642	{
643	Bstr src = Names[i];
644	RTPrintf("Searching for hard disk '%ls'...\n", src.raw());
645	rc = virtualBox->FindHardDisk(src, hd.asOutParam());
646	if (SUCCEEDED(rc))
647	{
648	Guid id;
649	Bstr location;
650	CHECK_ERROR_BREAK(hd, COMGETTER(Id)(id.asOutParam()));
651	CHECK_ERROR_BREAK(hd, COMGETTER(Location)(location.asOutParam()));
652	RTPrintf("Found, UUID={%RTuuid}, location='%ls'.\n",
653	id.raw(), location.raw());
654
655	com::SafeArray<BSTR> names;
656	com::SafeArray<BSTR> values;
657
658	CHECK_ERROR_BREAK(hd, GetProperties(NULL,
659	ComSafeArrayAsOutParam(names),
660	ComSafeArrayAsOutParam(values)));
661
662	RTPrintf("Properties:\n");
663	for (size_t i = 0; i < names.size(); ++ i)
664	RTPrintf(" %ls = %ls\n", names[i], values[i]);
665
666	if (names.size() == 0)
667	RTPrintf(" <none>\n");
668
669	#if 0
670	Bstr name("TargetAddress");
671	Bstr value = Utf8StrFmt("lalala (%llu)", RTTimeMilliTS());
672
673	RTPrintf("Settings property %ls to %ls...\n", name.raw(), value.raw());
674	CHECK_ERROR(hd, SetProperty(name, value));
675	#endif
676	}
677	else
678	{
679	com::ErrorInfo info(virtualBox);
680	PRINT_ERROR_INFO(info);
681	}
682	RTPrintf("\n");
683	}
684	}
685	while (FALSE);
686	RTPrintf("\n");
687	#endif
688
689	#if 0
690	// access the machine in read-only mode
691	///////////////////////////////////////////////////////////////////////////
692	do
693	{
694	ComPtr<IMachine> machine;
695	Bstr name = argc > 1 ? argv[1] : "dos";
696	RTPrintf("Getting a machine object named '%ls'...\n", name.raw());
697	CHECK_ERROR_BREAK(virtualBox, FindMachine(name, machine.asOutParam()));
698	RTPrintf("Accessing the machine in read-only mode:\n");
699	readAndChangeMachineSettings(machine);
700	#if 0
701	if (argc != 2)
702	{
703	RTPrintf("Error: a string has to be supplied!\n");
704	}
705	else
706	{
707	Bstr secureLabel = argv[1];
708	machine->COMSETTER(ExtraData)(L"VBoxSDL/SecureLabel", secureLabel);
709	}
710	#endif
711	}
712	while (0);
713	RTPrintf("\n");
714	#endif
715
716	#if 0
717	// create a new machine (w/o registering it)
718	///////////////////////////////////////////////////////////////////////////
719	do
720	{
721	ComPtr<IMachine> machine;
722	#if defined(RT_OS_LINUX)
723	Bstr baseDir = L"/tmp/vbox";
724	#else
725	Bstr baseDir = L"C:\\vbox";
726	#endif
727	Bstr name = L"machina";
728
729	RTPrintf("Creating a new machine object(base dir '%ls', name '%ls')...\n",
730	baseDir.raw(), name.raw());
731	CHECK_ERROR_BREAK(virtualBox, CreateMachine(name, L"", baseDir, L"",
732	false,
733	machine.asOutParam()));
734
735	RTPrintf("Getting name...\n");
736	CHECK_ERROR_BREAK(machine, COMGETTER(Name)(name.asOutParam()));
737	RTPrintf("Name: {%ls}\n", name.raw());
738
739	BOOL modified = FALSE;
740	RTPrintf("Are any settings modified?...\n");
741	CHECK_ERROR_BREAK(machine, COMGETTER(SettingsModified)(&modified));
742	RTPrintf("%s\n", modified ? "yes" : "no");
743
744	ASSERT_BREAK(modified == TRUE);
745
746	name = L"Kakaya prekrasnaya virtual'naya mashina!";
747	RTPrintf("Setting new name ({%ls})...\n", name.raw());
748	CHECK_ERROR_BREAK(machine, COMSETTER(Name)(name));
749
750	RTPrintf("Setting memory size to 111...\n");
751	CHECK_ERROR_BREAK(machine, COMSETTER(MemorySize)(111));
752
753	Bstr desc = L"This is an exemplary description.";
754	RTPrintf("Setting description to \"%ls\"...\n", desc.raw());
755	CHECK_ERROR_BREAK(machine, COMSETTER(Description)(desc));
756
757	ComPtr<IGuestOSType> guestOSType;
758	Bstr type = L"os2warp45";
759	CHECK_ERROR_BREAK(virtualBox, GetGuestOSType(type, guestOSType.asOutParam()));
760
761	RTPrintf("Saving new machine settings...\n");
762	CHECK_ERROR_BREAK(machine, SaveSettings());
763
764	RTPrintf("Accessing the newly created machine:\n");
765	readAndChangeMachineSettings(machine);
766	}
767	while (FALSE);
768	RTPrintf("\n");
769	#endif
770
771	#if 0
772	// enumerate host DVD drives
773	///////////////////////////////////////////////////////////////////////////
774	do
775	{
776	ComPtr<IHost> host;
777	CHECK_RC_BREAK(virtualBox->COMGETTER(Host)(host.asOutParam()));
778
779	{
780	ComPtr<IHostDVDDriveCollection> coll;
781	CHECK_RC_BREAK(host->COMGETTER(DVDDrives)(coll.asOutParam()));
782	ComPtr<IHostDVDDriveEnumerator> enumerator;
783	CHECK_RC_BREAK(coll->Enumerate(enumerator.asOutParam()));
784	BOOL hasmore;
785	while (SUCCEEDED(enumerator->HasMore(&hasmore)) && hasmore)
786	{
787	ComPtr<IHostDVDDrive> drive;
788	CHECK_RC_BREAK(enumerator->GetNext(drive.asOutParam()));
789	Bstr name;
790	CHECK_RC_BREAK(drive->COMGETTER(Name)(name.asOutParam()));
791	RTPrintf("Host DVD drive: name={%ls}\n", name.raw());
792	}
793	CHECK_RC_BREAK(rc);
794
795	ComPtr<IHostDVDDrive> drive;
796	CHECK_ERROR(enumerator, GetNext(drive.asOutParam()));
797	CHECK_ERROR(coll, GetItemAt(1000, drive.asOutParam()));
798	CHECK_ERROR(coll, FindByName(Bstr("R:"), drive.asOutParam()));
799	if (SUCCEEDED(rc))
800	{
801	Bstr name;
802	CHECK_RC_BREAK(drive->COMGETTER(Name)(name.asOutParam()));
803	RTPrintf("Found by name: name={%ls}\n", name.raw());
804	}
805	}
806	}
807	while (FALSE);
808	RTPrintf("\n");
809	#endif
810
811	#if 0
812	// check for available hd backends
813	///////////////////////////////////////////////////////////////////////////
814	{
815	RTPrintf("Supported hard disk backends: --------------------------\n");
816	ComPtr<ISystemProperties> systemProperties;
817	CHECK_ERROR_BREAK(virtualBox,
818	COMGETTER(SystemProperties)(systemProperties.asOutParam()));
819	com::SafeIfaceArray<IHardDiskFormat> hardDiskFormats;
820	CHECK_ERROR_BREAK(systemProperties,
821	COMGETTER(HardDiskFormats)(ComSafeArrayAsOutParam(hardDiskFormats)));
822
823	for (size_t i = 0; i < hardDiskFormats.size(); ++ i)
824	{
825	/* General information */
826	Bstr id;
827	CHECK_ERROR_BREAK(hardDiskFormats[i],
828	COMGETTER(Id)(id.asOutParam()));
829
830	Bstr description;
831	CHECK_ERROR_BREAK(hardDiskFormats[i],
832	COMGETTER(Id)(description.asOutParam()));
833
834	ULONG caps;
835	CHECK_ERROR_BREAK(hardDiskFormats[i],
836	COMGETTER(Capabilities)(&caps));
837
838	RTPrintf("Backend %u: id='%ls' description='%ls' capabilities=%#06x extensions='",
839	i, id.raw(), description.raw(), caps);
840
841	/* File extensions */
842	com::SafeArray<BSTR> fileExtensions;
843	CHECK_ERROR_BREAK(hardDiskFormats[i],
844	COMGETTER(FileExtensions)(ComSafeArrayAsOutParam(fileExtensions)));
845	for (size_t a = 0; a < fileExtensions.size(); ++ a)
846	{
847	RTPrintf("%ls", Bstr(fileExtensions[a]).raw());
848	if (a != fileExtensions.size()-1)
849	RTPrintf(",");
850	}
851	RTPrintf("'");
852
853	/* Configuration keys */
854	com::SafeArray<BSTR> propertyNames;
855	com::SafeArray<BSTR> propertyDescriptions;
856	com::SafeArray<ULONG> propertyTypes;
857	com::SafeArray<ULONG> propertyFlags;
858	com::SafeArray<BSTR> propertyDefaults;
859	CHECK_ERROR_BREAK(hardDiskFormats[i],
860	DescribeProperties(ComSafeArrayAsOutParam(propertyNames),
861	ComSafeArrayAsOutParam(propertyDescriptions),
862	ComSafeArrayAsOutParam(propertyTypes),
863	ComSafeArrayAsOutParam(propertyFlags),
864	ComSafeArrayAsOutParam(propertyDefaults)));
865
866	RTPrintf(" config=(");
867	if (propertyNames.size() > 0)
868	{
869	for (size_t a = 0; a < propertyNames.size(); ++ a)
870	{
871	RTPrintf("key='%ls' desc='%ls' type=", Bstr(propertyNames[a]).raw(), Bstr(propertyDescriptions[a]).raw());
872	switch (propertyTypes[a])
873	{
874	case DataType_Int32Type: RTPrintf("int"); break;
875	case DataType_Int8Type: RTPrintf("byte"); break;
876	case DataType_StringType: RTPrintf("string"); break;
877	}
878	RTPrintf(" flags=%#04x", propertyFlags[a]);
879	RTPrintf(" default='%ls'", Bstr(propertyDefaults[a]).raw());
880	if (a != propertyNames.size()-1)
881	RTPrintf(",");
882	}
883	}
884	RTPrintf(")\n");
885	}
886	RTPrintf("-------------------------------------------------------\n");
887	}
888	#endif
889
890	#if 0
891	// enumerate hard disks & dvd images
892	///////////////////////////////////////////////////////////////////////////
893	do
894	{
895	{
896	com::SafeIfaceArray<IHardDisk> disks;
897	CHECK_ERROR_BREAK(virtualBox,
898	COMGETTER(HardDisks)(ComSafeArrayAsOutParam(disks)));
899
900	RTPrintf("%u base hard disks registered (disks.isNull()=%d).\n",
901	disks.size(), disks.isNull());
902
903	for (size_t i = 0; i < disks.size(); ++ i)
904	{
905	Bstr loc;
906	CHECK_ERROR_BREAK(disks[i], COMGETTER(Location)(loc.asOutParam()));
907	Guid id;
908	CHECK_ERROR_BREAK(disks[i], COMGETTER(Id)(id.asOutParam()));
909	MediaState_T state;
910	CHECK_ERROR_BREAK(disks[i], COMGETTER(State)(&state));
911	Bstr format;
912	CHECK_ERROR_BREAK(disks[i], COMGETTER(Format)(format.asOutParam()));
913
914	RTPrintf(" disks[%u]: '%ls'\n"
915	" UUID: {%RTuuid}\n"
916	" State: %s\n"
917	" Format: %ls\n",
918	i, loc.raw(), id.raw(),
919	state == MediaState_NotCreated ? "Not Created" :
920	state == MediaState_Created ? "Created" :
921	state == MediaState_Inaccessible ? "Inaccessible" :
922	state == MediaState_LockedRead ? "Locked Read" :
923	state == MediaState_LockedWrite ? "Locked Write" :
924	"???",
925	format.raw());
926
927	if (state == MediaState_Inaccessible)
928	{
929	Bstr error;
930	CHECK_ERROR_BREAK(disks[i],
931	COMGETTER(LastAccessError)(error.asOutParam()));
932	RTPrintf(" Access Error: %ls\n", error.raw());
933	}
934
935	/* get usage */
936
937	RTPrintf(" Used by VMs:\n");
938
939	com::SafeGUIDArray ids;
940	CHECK_ERROR_BREAK(disks[i],
941	COMGETTER(MachineIds)(ComSafeArrayAsOutParam(ids)));
942	if (ids.size() == 0)
943	{
944	RTPrintf(" <not used>\n");
945	}
946	else
947	{
948	for (size_t j = 0; j < ids.size(); ++ j)
949	{
950	RTPrintf(" {%RTuuid}\n", &ids[j]);
951	}
952	}
953	}
954	}
955	{
956	com::SafeIfaceArray<IDVDImage> images;
957	CHECK_ERROR_BREAK(virtualBox,
958	COMGETTER(DVDImages)(ComSafeArrayAsOutParam(images)));
959
960	RTPrintf("%u DVD images registered (images.isNull()=%d).\n",
961	images.size(), images.isNull());
962
963	for (size_t i = 0; i < images.size(); ++ i)
964	{
965	Bstr loc;
966	CHECK_ERROR_BREAK(images[i], COMGETTER(Location)(loc.asOutParam()));
967	Guid id;
968	CHECK_ERROR_BREAK(images[i], COMGETTER(Id)(id.asOutParam()));
969	MediaState_T state;
970	CHECK_ERROR_BREAK(images[i], COMGETTER(State)(&state));
971
972	RTPrintf(" images[%u]: '%ls'\n"
973	" UUID: {%RTuuid}\n"
974	" State: %s\n",
975	i, loc.raw(), id.raw(),
976	state == MediaState_NotCreated ? "Not Created" :
977	state == MediaState_Created ? "Created" :
978	state == MediaState_Inaccessible ? "Inaccessible" :
979	state == MediaState_LockedRead ? "Locked Read" :
980	state == MediaState_LockedWrite ? "Locked Write" :
981	"???");
982
983	if (state == MediaState_Inaccessible)
984	{
985	Bstr error;
986	CHECK_ERROR_BREAK(images[i],
987	COMGETTER(LastAccessError)(error.asOutParam()));
988	RTPrintf(" Access Error: %ls\n", error.raw());
989	}
990
991	/* get usage */
992
993	RTPrintf(" Used by VMs:\n");
994
995	com::SafeGUIDArray ids;
996	CHECK_ERROR_BREAK(images[i],
997	COMGETTER(MachineIds)(ComSafeArrayAsOutParam(ids)));
998	if (ids.size() == 0)
999	{
1000	RTPrintf(" <not used>\n");
1001	}
1002	else
1003	{
1004	for (size_t j = 0; j < ids.size(); ++ j)
1005	{
1006	RTPrintf(" {%RTuuid}\n", &ids[j]);
1007	}
1008	}
1009	}
1010	}
1011	}
1012	while (FALSE);
1013	RTPrintf("\n");
1014	#endif
1015
1016	#if 0
1017	// open a (direct) session
1018	///////////////////////////////////////////////////////////////////////////
1019	do
1020	{
1021	ComPtr<IMachine> machine;
1022	Bstr name = argc > 1 ? argv[1] : "dos";
1023	RTPrintf("Getting a machine object named '%ls'...\n", name.raw());
1024	CHECK_ERROR_BREAK(virtualBox, FindMachine(name, machine.asOutParam()));
1025	Guid guid;
1026	CHECK_RC_BREAK(machine->COMGETTER(Id)(guid.asOutParam()));
1027	RTPrintf("Opening a session for this machine...\n");
1028	CHECK_RC_BREAK(virtualBox->OpenSession(session, guid));
1029	#if 1
1030	ComPtr<IMachine> sessionMachine;
1031	RTPrintf("Getting machine session object...\n");
1032	CHECK_RC_BREAK(session->COMGETTER(Machine)(sessionMachine.asOutParam()));
1033	RTPrintf("Accessing the machine within the session:\n");
1034	readAndChangeMachineSettings(sessionMachine, machine);
1035	#if 0
1036	RTPrintf("\n");
1037	RTPrintf("Enabling the VRDE server (must succeed even if the VM is saved):\n");
1038	ComPtr<IVRDEServer> vrdeServer;
1039	CHECK_ERROR_BREAK(sessionMachine, COMGETTER(VRDEServer)(vrdeServer.asOutParam()));
1040	if (FAILED(vrdeServer->COMSETTER(Enabled)(TRUE)))
1041	{
1042	PRINT_ERROR_INFO(com::ErrorInfo(vrdeServer));
1043	}
1044	else
1045	{
1046	BOOL enabled = FALSE;
1047	CHECK_ERROR_BREAK(vrdeServer, COMGETTER(Enabled)(&enabled));
1048	RTPrintf("VRDE server is %s\n", enabled ? "enabled" : "disabled");
1049	}
1050	#endif
1051	#endif
1052	#if 0
1053	ComPtr<IConsole> console;
1054	RTPrintf("Getting the console object...\n");
1055	CHECK_RC_BREAK(session->COMGETTER(Console)(console.asOutParam()));
1056	RTPrintf("Discarding the current machine state...\n");
1057	ComPtr<IProgress> progress;
1058	CHECK_ERROR_BREAK(console, DiscardCurrentState(progress.asOutParam()));
1059	RTPrintf("Waiting for completion...\n");
1060	CHECK_ERROR_BREAK(progress, WaitForCompletion(-1));
1061	ProgressErrorInfo ei(progress);
1062	if (FAILED(ei.getResultCode()))
1063	{
1064	PRINT_ERROR_INFO(ei);
1065
1066	ComPtr<IUnknown> initiator;
1067	CHECK_ERROR_BREAK(progress, COMGETTER(Initiator)(initiator.asOutParam()));
1068
1069	RTPrintf("initiator(unk) = %p\n", (IUnknown *)initiator);
1070	RTPrintf("console(unk) = %p\n", (IUnknown )ComPtr<IUnknown>((IConsole )console));
1071	RTPrintf("console = %p\n", (IConsole *)console);
1072	}
1073	#endif
1074	RTPrintf("Press enter to close session...");
1075	getchar();
1076	session->Close();
1077	}
1078	while (FALSE);
1079	RTPrintf("\n");
1080	#endif
1081
1082	#if 0
1083	// open a remote session
1084	///////////////////////////////////////////////////////////////////////////
1085	do
1086	{
1087	ComPtr<IMachine> machine;
1088	Bstr name = L"dos";
1089	RTPrintf("Getting a machine object named '%ls'...\n", name.raw());
1090	CHECK_RC_BREAK(virtualBox->FindMachine(name, machine.asOutParam()));
1091	Guid guid;
1092	CHECK_RC_BREAK(machine->COMGETTER(Id)(guid.asOutParam()));
1093	RTPrintf("Opening a remote session for this machine...\n");
1094	ComPtr<IProgress> progress;
1095	CHECK_RC_BREAK(virtualBox->OpenRemoteSession(session, guid, Bstr("gui"),
1096	NULL, progress.asOutParam()));
1097	RTPrintf("Waiting for the session to open...\n");
1098	CHECK_RC_BREAK(progress->WaitForCompletion(-1));
1099	ComPtr<IMachine> sessionMachine;
1100	RTPrintf("Getting machine session object...\n");
1101	CHECK_RC_BREAK(session->COMGETTER(Machine)(sessionMachine.asOutParam()));
1102	ComPtr<IConsole> console;
1103	RTPrintf("Getting console object...\n");
1104	CHECK_RC_BREAK(session->COMGETTER(Console)(console.asOutParam()));
1105	RTPrintf("Press enter to pause the VM execution in the remote session...");
1106	getchar();
1107	CHECK_RC(console->Pause());
1108	RTPrintf("Press enter to close this session...");
1109	getchar();
1110	session->Close();
1111	}
1112	while (FALSE);
1113	RTPrintf("\n");
1114	#endif
1115
1116	#if 0
1117	// open an existing remote session
1118	///////////////////////////////////////////////////////////////////////////
1119	do
1120	{
1121	ComPtr<IMachine> machine;
1122	Bstr name = "dos";
1123	RTPrintf("Getting a machine object named '%ls'...\n", name.raw());
1124	CHECK_RC_BREAK(virtualBox->FindMachine(name, machine.asOutParam()));
1125	Guid guid;
1126	CHECK_RC_BREAK(machine->COMGETTER(Id)(guid.asOutParam()));
1127	RTPrintf("Opening an existing remote session for this machine...\n");
1128	CHECK_RC_BREAK(virtualBox->OpenExistingSession(session, guid));
1129	ComPtr<IMachine> sessionMachine;
1130	RTPrintf("Getting machine session object...\n");
1131	CHECK_RC_BREAK(session->COMGETTER(Machine)(sessionMachine.asOutParam()));
1132
1133	#if 0
1134	Bstr extraDataKey = "VBoxSDL/SecureLabel";
1135	Bstr extraData = "Das kommt jetzt noch viel krasser vom total konkreten API!";
1136	CHECK_RC(sessionMachine->SetExtraData(extraDataKey, extraData));
1137	#endif
1138	#if 0
1139	ComPtr<IConsole> console;
1140	RTPrintf("Getting console object...\n");
1141	CHECK_RC_BREAK(session->COMGETTER(Console)(console.asOutParam()));
1142	RTPrintf("Press enter to pause the VM execution in the remote session...");
1143	getchar();
1144	CHECK_RC(console->Pause());
1145	RTPrintf("Press enter to close this session...");
1146	getchar();
1147	#endif
1148	session->Close();
1149	}
1150	while (FALSE);
1151	RTPrintf("\n");
1152	#endif
1153
1154	#if 1
1155	do {
1156	// Get host
1157	ComPtr<IHost> host;
1158	CHECK_ERROR_BREAK(virtualBox, COMGETTER(Host)(host.asOutParam()));
1159
1160	ULONG uMemSize, uMemAvail;
1161	CHECK_ERROR_BREAK(host, COMGETTER(MemorySize)(&uMemSize));
1162	RTPrintf("Total memory (MB): %u\n", uMemSize);
1163	CHECK_ERROR_BREAK(host, COMGETTER(MemoryAvailable)(&uMemAvail));
1164	RTPrintf("Free memory (MB): %u\n", uMemAvail);
1165	} while (0);
1166	#endif
1167
1168	#if 0
1169	do {
1170	// Get host
1171	ComPtr<IHost> host;
1172	CHECK_ERROR_BREAK(virtualBox, COMGETTER(Host)(host.asOutParam()));
1173
1174	com::SafeIfaceArray<IHostNetworkInterface> hostNetworkInterfaces;
1175	CHECK_ERROR_BREAK(host,
1176	COMGETTER(NetworkInterfaces)(ComSafeArrayAsOutParam(hostNetworkInterfaces)));
1177	if (hostNetworkInterfaces.size() > 0)
1178	{
1179	ComPtr<IHostNetworkInterface> networkInterface = hostNetworkInterfaces[0];
1180	Bstr interfaceName;
1181	networkInterface->COMGETTER(Name)(interfaceName.asOutParam());
1182	RTPrintf("Found %d network interfaces, testing with %ls...\n", hostNetworkInterfaces.size(), interfaceName.raw());
1183	Bstr interfaceGuid;
1184	networkInterface->COMGETTER(Id)(interfaceGuid.asOutParam());
1185	// Find the interface by its name
1186	networkInterface.setNull();
1187	CHECK_ERROR_BREAK(host,
1188	FindHostNetworkInterfaceByName(interfaceName.raw(), networkInterface.asOutParam()));
1189	Bstr interfaceGuid2;
1190	networkInterface->COMGETTER(Id)(interfaceGuid2.asOutParam());
1191	if (interfaceGuid2 != interfaceGuid)
1192	RTPrintf("Failed to retrieve an interface by name %ls.\n", interfaceName.raw());
1193	// Find the interface by its guid
1194	networkInterface.setNull();
1195	CHECK_ERROR_BREAK(host,
1196	FindHostNetworkInterfaceById(interfaceGuid.raw(), networkInterface.asOutParam()));
1197	Bstr interfaceName2;
1198	networkInterface->COMGETTER(Name)(interfaceName2.asOutParam());
1199	if (interfaceName != interfaceName2)
1200	RTPrintf("Failed to retrieve an interface by GUID %ls.\n", interfaceGuid.raw());
1201	}
1202	else
1203	{
1204	RTPrintf("No network interfaces found!\n");
1205	}
1206	} while (0);
1207	#endif
1208
1209	#if 0
1210	// DNS & Co.
1211	///////////////////////////////////////////////////////////////////////////
1212	/* XXX: Note it's endless loop */
1213	do
1214	{
1215	ComPtr<IHost> host;
1216	CHECK_ERROR_BREAK(virtualBox, COMGETTER(Host)(host.asOutParam()));
1217
1218	{
1219	Bstr domainName;
1220	CHECK_ERROR_BREAK(host,COMGETTER(DomainName)(domainName.asOutParam()));
1221	RTPrintf("Domain name: %ls\n", domainName.raw());
1222	}
1223
1224	com::SafeArray<BSTR> strs;
1225	CHECK_ERROR_BREAK(host, COMGETTER(NameServers)(ComSafeArrayAsOutParam(strs)));
1226
1227	unsigned int i;
1228	for (i = 0; i < strs.size(); ++i)
1229	RTPrintf("Name server[%d]:%s\n", i, com::Utf8Str(strs[i]).c_str());
1230
1231	RTThreadSleep(1000);
1232	}
1233	while (1);
1234	RTPrintf("\n");
1235	#endif
1236
1237
1238	#if 0 && defined(VBOX_WITH_RESOURCE_USAGE_API)
1239	do {
1240	// Get collector
1241	ComPtr<IPerformanceCollector> collector;
1242	CHECK_ERROR_BREAK(virtualBox,
1243	COMGETTER(PerformanceCollector)(collector.asOutParam()));
1244
1245
1246	// Fill base metrics array
1247	Bstr baseMetricNames[] = { L"Net/eth0/Load" };
1248	com::SafeArray<BSTR> baseMetrics(1);
1249	baseMetricNames[0].cloneTo(&baseMetrics[0]);
1250
1251	// Get host
1252	ComPtr<IHost> host;
1253	CHECK_ERROR_BREAK(virtualBox, COMGETTER(Host)(host.asOutParam()));
1254
1255	// Get host network interfaces
1256	// com::SafeIfaceArray<IHostNetworkInterface> hostNetworkInterfaces;
1257	// CHECK_ERROR_BREAK(host,
1258	// COMGETTER(NetworkInterfaces)(ComSafeArrayAsOutParam(hostNetworkInterfaces)));
1259
1260	// Setup base metrics
1261	// Note that one needs to set up metrics after a session is open for a machine.
1262	com::SafeIfaceArray<IPerformanceMetric> affectedMetrics;
1263	com::SafeIfaceArray<IUnknown> objects(1);
1264	host.queryInterfaceTo(&objects[0]);
1265	CHECK_ERROR_BREAK(collector, SetupMetrics(ComSafeArrayAsInParam(baseMetrics),
1266	ComSafeArrayAsInParam(objects), 1u, 10u,
1267	ComSafeArrayAsOutParam(affectedMetrics)));
1268	listAffectedMetrics(virtualBox,
1269	ComSafeArrayAsInParam(affectedMetrics));
1270	affectedMetrics.setNull();
1271
1272	RTPrintf("Sleeping for 5 seconds...\n");
1273	RTThreadSleep(5000); // Sleep for 5 seconds
1274
1275	RTPrintf("\nMetrics collected: --------------------\n");
1276	queryMetrics(virtualBox, collector, ComSafeArrayAsInParam(objects));
1277	} while (false);
1278	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
1279	#if 0 && defined(VBOX_WITH_RESOURCE_USAGE_API)
1280	do {
1281	// Get collector
1282	ComPtr<IPerformanceCollector> collector;
1283	CHECK_ERROR_BREAK(virtualBox,
1284	COMGETTER(PerformanceCollector)(collector.asOutParam()));
1285
1286
1287	// Fill base metrics array
1288	//Bstr baseMetricNames[] = { L"CPU/Load,RAM/Usage" };
1289	Bstr baseMetricNames[] = { L"RAM/VMM" };
1290	com::SafeArray<BSTR> baseMetrics(1);
1291	baseMetricNames[0].cloneTo(&baseMetrics[0]);
1292
1293	// Get host
1294	ComPtr<IHost> host;
1295	CHECK_ERROR_BREAK(virtualBox, COMGETTER(Host)(host.asOutParam()));
1296
1297	// Get machine
1298	ComPtr<IMachine> machine;
1299	Bstr name = argc > 1 ? argv[1] : "dsl";
1300	Bstr sessionType = argc > 2 ? argv[2] : "headless";
1301	RTPrintf("Getting a machine object named '%ls'...\n", name.raw());
1302	CHECK_ERROR_BREAK(virtualBox, FindMachine(name.raw(), machine.asOutParam()));
1303
1304	// Open session
1305	ComPtr<IProgress> progress;
1306	RTPrintf("Launching VM process...\n");
1307	CHECK_ERROR_BREAK(machine, LaunchVMProcess(session, sessionType.raw(),
1308	NULL, progress.asOutParam()));
1309	RTPrintf("Waiting for the VM to power on...\n");
1310	CHECK_ERROR_BREAK(progress, WaitForCompletion(-1));
1311
1312	// ComPtr<IMachine> sessionMachine;
1313	// RTPrintf("Getting machine session object...\n");
1314	// CHECK_ERROR_BREAK(session, COMGETTER(Machine)(sessionMachine.asOutParam()));
1315
1316	// Setup base metrics
1317	// Note that one needs to set up metrics after a session is open for a machine.
1318	com::SafeIfaceArray<IPerformanceMetric> affectedMetrics;
1319	com::SafeIfaceArray<IUnknown> objects(1);
1320	host.queryInterfaceTo(&objects[0]);
1321	//machine.queryInterfaceTo(&objects[1]);
1322	CHECK_ERROR_BREAK(collector, SetupMetrics(ComSafeArrayAsInParam(baseMetrics),
1323	ComSafeArrayAsInParam(objects), 1u, 10u,
1324	ComSafeArrayAsOutParam(affectedMetrics)));
1325	listAffectedMetrics(virtualBox,
1326	ComSafeArrayAsInParam(affectedMetrics));
1327	affectedMetrics.setNull();
1328
1329	// Get console
1330	ComPtr<IConsole> console;
1331	RTPrintf("Getting console object...\n");
1332	CHECK_ERROR_BREAK(session, COMGETTER(Console)(console.asOutParam()));
1333
1334	RTThreadSleep(5000); // Sleep for 5 seconds
1335
1336	RTPrintf("\nMetrics collected with VM running: --------------------\n");
1337	queryMetrics(virtualBox, collector, ComSafeArrayAsInParam(objects));
1338
1339	// Pause
1340	//RTPrintf("Press enter to pause the VM execution in the remote session...");
1341	//getchar();
1342	CHECK_ERROR_BREAK(console, Pause());
1343
1344	RTThreadSleep(5000); // Sleep for 5 seconds
1345
1346	RTPrintf("\nMetrics collected with VM paused: ---------------------\n");
1347	queryMetrics(virtualBox, collector, ComSafeArrayAsInParam(objects));
1348
1349	RTPrintf("\nDrop collected metrics: ----------------------------------------\n");
1350	CHECK_ERROR_BREAK(collector,
1351	SetupMetrics(ComSafeArrayAsInParam(baseMetrics),
1352	ComSafeArrayAsInParam(objects),
1353	1u, 5u, ComSafeArrayAsOutParam(affectedMetrics)));
1354	listAffectedMetrics(virtualBox,
1355	ComSafeArrayAsInParam(affectedMetrics));
1356	affectedMetrics.setNull();
1357	queryMetrics(virtualBox, collector, ComSafeArrayAsInParam(objects));
1358
1359	com::SafeIfaceArray<IUnknown> vmObject(1);
1360	machine.queryInterfaceTo(&vmObject[0]);
1361
1362	RTPrintf("\nDisable collection of VM metrics: ------------------------------\n");
1363	CHECK_ERROR_BREAK(collector,
1364	DisableMetrics(ComSafeArrayAsInParam(baseMetrics),
1365	ComSafeArrayAsInParam(vmObject),
1366	ComSafeArrayAsOutParam(affectedMetrics)));
1367	listAffectedMetrics(virtualBox,
1368	ComSafeArrayAsInParam(affectedMetrics));
1369	affectedMetrics.setNull();
1370	RTThreadSleep(5000); // Sleep for 5 seconds
1371	queryMetrics(virtualBox, collector, ComSafeArrayAsInParam(objects));
1372
1373	RTPrintf("\nRe-enable collection of all metrics: ---------------------------\n");
1374	CHECK_ERROR_BREAK(collector,
1375	EnableMetrics(ComSafeArrayAsInParam(baseMetrics),
1376	ComSafeArrayAsInParam(objects),
1377	ComSafeArrayAsOutParam(affectedMetrics)));
1378	listAffectedMetrics(virtualBox,
1379	ComSafeArrayAsInParam(affectedMetrics));
1380	affectedMetrics.setNull();
1381	RTThreadSleep(5000); // Sleep for 5 seconds
1382	queryMetrics(virtualBox, collector, ComSafeArrayAsInParam(objects));
1383
1384	// Power off
1385	RTPrintf("Press enter to power off VM...");
1386	getchar();
1387	CHECK_ERROR_BREAK(console, PowerDown(progress.asOutParam()));
1388	RTPrintf("Waiting for the VM to power down...\n");
1389	CHECK_ERROR_BREAK(progress, WaitForCompletion(-1));
1390	RTPrintf("Press enter to close this session...");
1391	getchar();
1392	session->UnlockMachine();
1393	} while (false);
1394	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
1395	#if 0
1396	// check of OVF appliance handling
1397	///////////////////////////////////////////////////////////////////////////
1398	do
1399	{
1400	Bstr ovf = argc > 1 ? argv[1] : "someOVF.ovf";
1401	RTPrintf("Try to open %ls ...\n", ovf.raw());
1402
1403	ComPtr<IAppliance> appliance;
1404	CHECK_ERROR_BREAK(virtualBox,
1405	CreateAppliance(appliance.asOutParam()));
1406	CHECK_ERROR_BREAK(appliance, Read(ovf));
1407	Bstr path;
1408	CHECK_ERROR_BREAK(appliance, COMGETTER(Path)(path.asOutParam()));
1409	RTPrintf("Successfully opened %ls.\n", path.raw());
1410	CHECK_ERROR_BREAK(appliance, Interpret());
1411	RTPrintf("Successfully interpreted %ls.\n", path.raw());
1412	RTPrintf("Appliance:\n");
1413	// Fetch all disks
1414	com::SafeArray<BSTR> retDisks;
1415	CHECK_ERROR_BREAK(appliance,
1416	COMGETTER(Disks)(ComSafeArrayAsOutParam(retDisks)));
1417	if (retDisks.size() > 0)
1418	{
1419	RTPrintf("Disks:");
1420	for (unsigned i = 0; i < retDisks.size(); i++)
1421	RTPrintf(" %ls", Bstr(retDisks[i]).raw());
1422	RTPrintf("\n");
1423	}
1424	/* Fetch all virtual system descriptions */
1425	com::SafeIfaceArray<IVirtualSystemDescription> retVSD;
1426	CHECK_ERROR_BREAK(appliance,
1427	COMGETTER(VirtualSystemDescriptions)(ComSafeArrayAsOutParam(retVSD)));
1428	if (retVSD.size() > 0)
1429	{
1430	for (unsigned i = 0; i < retVSD.size(); ++i)
1431	{
1432	com::SafeArray<VirtualSystemDescriptionType_T> retTypes;
1433	com::SafeArray<BSTR> retRefValues;
1434	com::SafeArray<BSTR> retOrigValues;
1435	com::SafeArray<BSTR> retAutoValues;
1436	com::SafeArray<BSTR> retConfiguration;
1437	CHECK_ERROR_BREAK(retVSD[i],
1438	GetDescription(ComSafeArrayAsOutParam(retTypes),
1439	ComSafeArrayAsOutParam(retRefValues),
1440	ComSafeArrayAsOutParam(retOrigValues),
1441	ComSafeArrayAsOutParam(retAutoValues),
1442	ComSafeArrayAsOutParam(retConfiguration)));
1443
1444	RTPrintf("VirtualSystemDescription:\n");
1445	for (unsigned a = 0; a < retTypes.size(); ++a)
1446	{
1447	RTPrintf(" %d %ls %ls %ls\n",
1448	retTypes[a],
1449	Bstr(retOrigValues[a]).raw(),
1450	Bstr(retAutoValues[a]).raw(),
1451	Bstr(retConfiguration[a]).raw());
1452	}
1453	/* Show warnings from interpret */
1454	com::SafeArray<BSTR> retWarnings;
1455	CHECK_ERROR_BREAK(retVSD[i],
1456	GetWarnings(ComSafeArrayAsOutParam(retWarnings)));
1457	if (retWarnings.size() > 0)
1458	{
1459	RTPrintf("The following warnings occurs on interpret:\n");
1460	for (unsigned r = 0; r < retWarnings.size(); ++r)
1461	RTPrintf("%ls\n", Bstr(retWarnings[r]).raw());
1462	RTPrintf("\n");
1463	}
1464	}
1465	RTPrintf("\n");
1466	}
1467	RTPrintf("Try to import the appliance ...\n");
1468	ComPtr<IProgress> progress;
1469	CHECK_ERROR_BREAK(appliance,
1470	ImportMachines(progress.asOutParam()));
1471	CHECK_ERROR(progress, WaitForCompletion(-1));
1472	if (SUCCEEDED(rc))
1473	{
1474	/* Check if the import was successfully */
1475	progress->COMGETTER(ResultCode)(&rc);
1476	if (FAILED(rc))
1477	{
1478	com::ProgressErrorInfo info(progress);
1479	if (info.isBasicAvailable())
1480	RTPrintf("Error: failed to import appliance. Error message: %ls\n", info.getText().raw());
1481	else
1482	RTPrintf("Error: failed to import appliance. No error message available!\n");
1483	}
1484	else
1485	RTPrintf("Successfully imported the appliance.\n");
1486	}
1487
1488	}
1489	while (FALSE);
1490	RTPrintf("\n");
1491	#endif
1492	#if 0
1493	// check of network bandwidth control
1494	///////////////////////////////////////////////////////////////////////////
1495	do
1496	{
1497	Bstr name = argc > 1 ? argv[1] : "ubuntu";
1498	Bstr sessionType = argc > 2 ? argv[2] : "headless";
1499	Bstr grpName = "tstAPI";
1500	{
1501	// Get machine
1502	ComPtr<IMachine> machine;
1503	ComPtr<IBandwidthControl> bwCtrl;
1504	ComPtr<IBandwidthGroup> bwGroup;
1505	ComPtr<INetworkAdapter> nic;
1506	RTPrintf("Getting a machine object named '%ls'...\n", name.raw());
1507	CHECK_ERROR_BREAK(virtualBox, FindMachine(name.raw(), machine.asOutParam()));
1508	/* open a session for the VM (new or shared) */
1509	CHECK_ERROR_BREAK(machine, LockMachine(session, LockType_Shared));
1510	SessionType_T st;
1511	CHECK_ERROR_BREAK(session, COMGETTER(Type)(&st));
1512	bool fRunTime = (st == SessionType_Shared);
1513	if (fRunTime)
1514	{
1515	RTPrintf("Machine %ls must not be running!\n");
1516	break;
1517	}
1518	/* get the mutable session machine */
1519	session->COMGETTER(Machine)(machine.asOutParam());
1520	CHECK_ERROR_BREAK(machine, COMGETTER(BandwidthControl)(bwCtrl.asOutParam()));
1521
1522	RTPrintf("Creating bandwidth group named '%ls'...\n", grpName.raw());
1523	CHECK_ERROR_BREAK(bwCtrl, CreateBandwidthGroup(grpName.raw(), BandwidthGroupType_Network, 123));
1524
1525
1526	CHECK_ERROR_BREAK(bwCtrl, GetBandwidthGroup(grpName.raw(), bwGroup.asOutParam()));
1527	CHECK_ERROR_BREAK(machine, GetNetworkAdapter(0, nic.asOutParam()));
1528	RTPrintf("Assigning the group to the first network adapter...\n");
1529	CHECK_ERROR_BREAK(nic, COMSETTER(BandwidthGroup)(bwGroup));
1530	CHECK_ERROR_BREAK(machine, SaveSettings());
1531	RTPrintf("Press enter to close this session...");
1532	getchar();
1533	session->UnlockMachine();
1534	}
1535	{
1536	// Get machine
1537	ComPtr<IMachine> machine;
1538	ComPtr<IBandwidthControl> bwCtrl;
1539	ComPtr<IBandwidthGroup> bwGroup;
1540	Bstr grpNameReadFromNic;
1541	ComPtr<INetworkAdapter> nic;
1542	RTPrintf("Getting a machine object named '%ls'...\n", name.raw());
1543	CHECK_ERROR_BREAK(virtualBox, FindMachine(name.raw(), machine.asOutParam()));
1544	/* open a session for the VM (new or shared) */
1545	CHECK_ERROR_BREAK(machine, LockMachine(session, LockType_Shared));
1546	/* get the mutable session machine */
1547	session->COMGETTER(Machine)(machine.asOutParam());
1548	CHECK_ERROR_BREAK(machine, COMGETTER(BandwidthControl)(bwCtrl.asOutParam()));
1549	CHECK_ERROR_BREAK(machine, GetNetworkAdapter(0, nic.asOutParam()));
1550
1551	RTPrintf("Reading the group back from the first network adapter...\n");
1552	CHECK_ERROR_BREAK(nic, COMGETTER(BandwidthGroup)(bwGroup.asOutParam()));
1553	if (bwGroup.isNull())
1554	RTPrintf("Error: Bandwidth group is null at the first network adapter!\n");
1555	else
1556	{
1557	CHECK_ERROR_BREAK(bwGroup, COMGETTER(Name)(grpNameReadFromNic.asOutParam()));
1558	if (grpName != grpNameReadFromNic)
1559	RTPrintf("Error: Bandwidth group names do not match (%ls != %ls)!\n", grpName.raw(), grpNameReadFromNic.raw());
1560	else
1561	RTPrintf("Successfully retrieved bandwidth group attribute from NIC (name=%ls)\n", grpNameReadFromNic.raw());
1562	ComPtr<IBandwidthGroup> bwGroupEmpty;
1563	RTPrintf("Assigning an empty group to the first network adapter...\n");
1564	CHECK_ERROR_BREAK(nic, COMSETTER(BandwidthGroup)(bwGroupEmpty));
1565	}
1566	RTPrintf("Removing bandwidth group named '%ls'...\n", grpName.raw());
1567	CHECK_ERROR_BREAK(bwCtrl, DeleteBandwidthGroup(grpName.raw()));
1568	CHECK_ERROR_BREAK(machine, SaveSettings());
1569	RTPrintf("Press enter to close this session...");
1570	getchar();
1571	session->UnlockMachine();
1572	}
1573	} while (FALSE);
1574	RTPrintf("\n");
1575	#endif
1576
1577	RTPrintf("Press enter to release Session and VirtualBox instances...");
1578	getchar();
1579
1580	// end "all-stuff" scope
1581	////////////////////////////////////////////////////////////////////////////
1582	}
1583	while (0);
1584
1585	RTPrintf("Press enter to shutdown COM...");
1586	getchar();
1587
1588	com::Shutdown();
1589
1590	RTPrintf("tstAPI FINISHED.\n");
1591
1592	return rc;
1593	}
1594
1595	#ifdef VBOX_WITH_RESOURCE_USAGE_API
1596	static void queryMetrics(ComPtr<IVirtualBox> aVirtualBox,
1597	ComPtr<IPerformanceCollector> collector,
1598	ComSafeArrayIn(IUnknown *, objects))
1599	{
1600	HRESULT rc;
1601
1602	//Bstr metricNames[] = { L"CPU/Load/User:avg,CPU/Load/System:avg,CPU/Load/Idle:avg,RAM/Usage/Total,RAM/Usage/Used:avg" };
1603	Bstr metricNames[] = { L"*" };
1604	com::SafeArray<BSTR> metrics(1);
1605	metricNames[0].cloneTo(&metrics[0]);
1606	com::SafeArray<BSTR> retNames;
1607	com::SafeIfaceArray<IUnknown> retObjects;
1608	com::SafeArray<BSTR> retUnits;
1609	com::SafeArray<ULONG> retScales;
1610	com::SafeArray<ULONG> retSequenceNumbers;
1611	com::SafeArray<ULONG> retIndices;
1612	com::SafeArray<ULONG> retLengths;
1613	com::SafeArray<LONG> retData;
1614	CHECK_ERROR(collector, QueryMetricsData(ComSafeArrayAsInParam(metrics),
1615	ComSafeArrayInArg(objects),
1616	ComSafeArrayAsOutParam(retNames),
1617	ComSafeArrayAsOutParam(retObjects),
1618	ComSafeArrayAsOutParam(retUnits),
1619	ComSafeArrayAsOutParam(retScales),
1620	ComSafeArrayAsOutParam(retSequenceNumbers),
1621	ComSafeArrayAsOutParam(retIndices),
1622	ComSafeArrayAsOutParam(retLengths),
1623	ComSafeArrayAsOutParam(retData)));
1624	RTPrintf("Object Metric Values\n"
1625	"---------- -------------------- --------------------------------------------\n");
1626	for (unsigned i = 0; i < retNames.size(); i++)
1627	{
1628	Bstr metricUnit(retUnits[i]);
1629	Bstr metricName(retNames[i]);
1630	RTPrintf("%-10ls %-20ls ", getObjectName(aVirtualBox, retObjects[i]).raw(), metricName.raw());
1631	const char *separator = "";
1632	for (unsigned j = 0; j < retLengths[i]; j++)
1633	{
1634	if (retScales[i] == 1)
1635	RTPrintf("%s%d %ls", separator, retData[retIndices[i] + j], metricUnit.raw());
1636	else
1637	RTPrintf("%s%d.%02d%ls", separator, retData[retIndices[i] + j] / retScales[i],
1638	(retData[retIndices[i] + j] * 100 / retScales[i]) % 100, metricUnit.raw());
1639	separator = ", ";
1640	}
1641	RTPrintf("\n");
1642	}
1643	}
1644
1645	static Bstr getObjectName(ComPtr<IVirtualBox> aVirtualBox,
1646	ComPtr<IUnknown> aObject)
1647	{
1648	HRESULT rc;
1649
1650	ComPtr<IHost> host = aObject;
1651	if (!host.isNull())
1652	return Bstr("host");
1653
1654	ComPtr<IMachine> machine = aObject;
1655	if (!machine.isNull())
1656	{
1657	Bstr name;
1658	CHECK_ERROR(machine, COMGETTER(Name)(name.asOutParam()));
1659	if (SUCCEEDED(rc))
1660	return name;
1661	}
1662	return Bstr("unknown");
1663	}
1664
1665	static void listAffectedMetrics(ComPtr<IVirtualBox> aVirtualBox,
1666	ComSafeArrayIn(IPerformanceMetric*, aMetrics))
1667	{
1668	HRESULT rc;
1669	com::SafeIfaceArray<IPerformanceMetric> metrics(ComSafeArrayInArg(aMetrics));
1670	if (metrics.size())
1671	{
1672	ComPtr<IUnknown> object;
1673	Bstr metricName;
1674	RTPrintf("The following metrics were modified:\n\n"
1675	"Object Metric\n"
1676	"---------- --------------------\n");
1677	for (size_t i = 0; i < metrics.size(); i++)
1678	{
1679	CHECK_ERROR(metrics[i], COMGETTER(Object)(object.asOutParam()));
1680	CHECK_ERROR(metrics[i], COMGETTER(MetricName)(metricName.asOutParam()));
1681	RTPrintf("%-10ls %-20ls\n",
1682	getObjectName(aVirtualBox, object).raw(), metricName.raw());
1683	}
1684	RTPrintf("\n");
1685	}
1686	else
1687	{
1688	RTPrintf("No metrics match the specified filter!\n");
1689	}
1690	}
1691
1692	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
1693	/* vim: set shiftwidth=4 tabstop=4 expandtab: */

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Main/testcase/tstAPI.cpp@ 53517

Download in other formats: