VirtualBox

About
Screenshots
Downloads
Documentation
End-user docs
Technical docs
Contribute
Community

Browse Source

Context Navigation

source: vbox/trunk/src/VBox/Additions/common/VBoxControl/VBoxControl.cpp@ 63206

Last change on this file since 63206 was 62849, checked in by vboxsync, 8 years ago
GAs/common: warnings
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 62.0 KB

Line
1	/* $Id: VBoxControl.cpp 62849 2016-08-01 21:52:45Z vboxsync $ */
2	/** @file
3	* VBoxControl - Guest Additions Command Line Management Interface.
4	*/
5
6	/*
7	* Copyright (C) 2008-2016 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
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#include <iprt/alloca.h>
23	#include <iprt/cpp/autores.h>
24	#include <iprt/buildconfig.h>
25	#include <iprt/getopt.h>
26	#include <iprt/initterm.h>
27	#include <iprt/mem.h>
28	#include <iprt/message.h>
29	#include <iprt/path.h>
30	#include <iprt/string.h>
31	#include <iprt/stream.h>
32	#include <VBox/log.h>
33	#include <VBox/version.h>
34	#include <VBox/VBoxGuestLib.h>
35	#ifdef RT_OS_WINDOWS
36	# include <iprt/win/windows.h>
37	#endif
38	#ifdef VBOX_WITH_GUEST_PROPS
39	# include <VBox/HostServices/GuestPropertySvc.h>
40	#endif
41	#ifdef VBOX_WITH_DPC_LATENCY_CHECKER
42	# include <VBox/VBoxGuest.h>
43	# include "../VBoxGuestLib/VBGLR3Internal.h" /* HACK ALERT! Using vbglR3DoIOCtl directly!! */
44	#endif
45
46
47	/*********************************************************************************************************************************
48	* Global Variables *
49	*********************************************************************************************************************************/
50	/** The program name (derived from argv[0]). */
51	char const *g_pszProgName = "";
52	/** The current verbosity level. */
53	int g_cVerbosity = 0;
54
55
56	/** @name Displays the program usage message.
57	* @{
58	*/
59
60	/**
61	* Helper function that does indentation.
62	*
63	* @param pszLine Text.
64	* @param pszName Program name.
65	* @param pszCommand Command/option syntax.
66	*/
67	static void doUsage(char const pszLine, char const pszName = "", char const *pszCommand = "")
68	{
69	/* Allow for up to 15 characters command name length (VBoxControl.exe) with
70	* perfect column alignment. Beyond that there's at least one space between
71	* the command if there are command line parameters. */
72	RTPrintf("%s %-*s%s%s\n",
73	pszName,
74	*pszLine ? 35 - strlen(pszName) : 1, pszCommand,
75	*pszLine ? " " : "", pszLine);
76	}
77
78	/** Enumerate the different parts of the usage we might want to print out */
79	enum VBoxControlUsage
80	{
81	#ifdef RT_OS_WINDOWS
82	GET_VIDEO_ACCEL,
83	SET_VIDEO_ACCEL,
84	VIDEO_FLAGS,
85	LIST_CUST_MODES,
86	ADD_CUST_MODE,
87	REMOVE_CUST_MODE,
88	SET_VIDEO_MODE,
89	#endif
90	#ifdef VBOX_WITH_GUEST_PROPS
91	GUEST_PROP,
92	#endif
93	#ifdef VBOX_WITH_SHARED_FOLDERS
94	GUEST_SHAREDFOLDERS,
95	#endif
96	#if !defined(VBOX_CONTROL_TEST)
97	WRITE_CORE_DUMP,
98	#endif
99	WRITE_LOG,
100	TAKE_SNAPSHOT,
101	SAVE_STATE,
102	SUSPEND,
103	POWER_OFF,
104	VERSION,
105	HELP,
106	USAGE_ALL = UINT32_MAX
107	};
108
109	static RTEXITCODE usage(enum VBoxControlUsage eWhich = USAGE_ALL)
110	{
111	RTPrintf("Usage:\n\n");
112	doUsage("print version number and exit", g_pszProgName, "[-V\|--version]");
113	doUsage("suppress the logo", g_pszProgName, "--nologo ...");
114	RTPrintf("\n");
115
116	/* Exclude the Windows bits from the test version. Anyone who needs to
117	test them can fix this. */
118	#if defined(RT_OS_WINDOWS) && !defined(VBOX_CONTROL_TEST)
119	if (eWhich == GET_VIDEO_ACCEL \|\| eWhich == USAGE_ALL)
120	doUsage("", g_pszProgName, "getvideoacceleration");
121	if (eWhich == SET_VIDEO_ACCEL \|\| eWhich == USAGE_ALL)
122	doUsage("<on\|off>", g_pszProgName, "setvideoacceleration");
123	if (eWhich == VIDEO_FLAGS \|\| eWhich == USAGE_ALL)
124	doUsage("<get\|set\|clear\|delete> [hex mask]", g_pszProgName, "videoflags");
125	if (eWhich == LIST_CUST_MODES \|\| eWhich == USAGE_ALL)
126	doUsage("", g_pszProgName, "listcustommodes");
127	if (eWhich == ADD_CUST_MODE \|\| eWhich == USAGE_ALL)
128	doUsage("<width> <height> <bpp>", g_pszProgName, "addcustommode");
129	if (eWhich == REMOVE_CUST_MODE \|\| eWhich == USAGE_ALL)
130	doUsage("<width> <height> <bpp>", g_pszProgName, "removecustommode");
131	if (eWhich == SET_VIDEO_MODE \|\| eWhich == USAGE_ALL)
132	doUsage("<width> <height> <bpp> <screen>", g_pszProgName, "setvideomode");
133	#endif
134	#ifdef VBOX_WITH_GUEST_PROPS
135	if (eWhich == GUEST_PROP \|\| eWhich == USAGE_ALL)
136	{
137	doUsage("get <property> [--verbose]", g_pszProgName, "guestproperty");
138	doUsage("set <property> [<value> [--flags <flags>]]", g_pszProgName, "guestproperty");
139	doUsage("delete\|unset <property>", g_pszProgName, "guestproperty");
140	doUsage("enumerate [--patterns <patterns>]", g_pszProgName, "guestproperty");
141	doUsage("wait <patterns>", g_pszProgName, "guestproperty");
142	doUsage("[--timestamp <last timestamp>]");
143	doUsage("[--timeout <timeout in ms>");
144	}
145	#endif
146	#ifdef VBOX_WITH_SHARED_FOLDERS
147	if (eWhich == GUEST_SHAREDFOLDERS \|\| eWhich == USAGE_ALL)
148	{
149	doUsage("list [-automount]", g_pszProgName, "sharedfolder");
150	}
151	#endif
152
153	#if !defined(VBOX_CONTROL_TEST)
154	if (eWhich == WRITE_CORE_DUMP \|\| eWhich == USAGE_ALL)
155	doUsage("", g_pszProgName, "writecoredump");
156	#endif
157	if (eWhich == WRITE_LOG \|\| eWhich == USAGE_ALL)
158	doUsage("", g_pszProgName, "writelog [-n\|--no-newline] [--] <msg>");
159	if (eWhich == TAKE_SNAPSHOT \|\| eWhich == USAGE_ALL)
160	doUsage("", g_pszProgName, "takesnapshot");
161	if (eWhich == SAVE_STATE \|\| eWhich == USAGE_ALL)
162	doUsage("", g_pszProgName, "savestate");
163	if (eWhich == SUSPEND \|\| eWhich == USAGE_ALL)
164	doUsage("", g_pszProgName, "suspend");
165	if (eWhich == POWER_OFF \|\| eWhich == USAGE_ALL)
166	doUsage("", g_pszProgName, "poweroff");
167	if (eWhich == HELP \|\| eWhich == USAGE_ALL)
168	doUsage("[command]", g_pszProgName, "help");
169	if (eWhich == VERSION \|\| eWhich == USAGE_ALL)
170	doUsage("", g_pszProgName, "version");
171
172	return RTEXITCODE_SUCCESS;
173	}
174
175	/** @} */
176
177
178	/**
179	* Implementation of the '--version' option.
180	*
181	* @returns RTEXITCODE_SUCCESS
182	*/
183	static RTEXITCODE printVersion(void)
184	{
185	RTPrintf("%sr%u\n", VBOX_VERSION_STRING, RTBldCfgRevision());
186	return RTEXITCODE_SUCCESS;
187	}
188
189
190	/**
191	* Displays an error message.
192	*
193	* @returns RTEXITCODE_FAILURE.
194	* @param pszFormat The message text. No newline.
195	* @param ... Format arguments.
196	*/
197	static RTEXITCODE VBoxControlError(const char *pszFormat, ...)
198	{
199	/** @todo prefix with current command. */
200	va_list va;
201	va_start(va, pszFormat);
202	RTMsgErrorV(pszFormat, va);
203	va_end(va);
204	return RTEXITCODE_FAILURE;
205	}
206
207
208	/**
209	* Displays a getopt error.
210	*
211	* @returns RTEXITCODE_FAILURE.
212	* @param ch The RTGetOpt return value.
213	* @param pValueUnion The RTGetOpt return data.
214	*/
215	static RTEXITCODE VBoxCtrlGetOptError(int ch, PCRTGETOPTUNION pValueUnion)
216	{
217	/** @todo prefix with current command. */
218	return RTGetOptPrintError(ch, pValueUnion);
219	}
220
221
222	/**
223	* Displays an syntax error message.
224	*
225	* @returns RTEXITCODE_FAILURE.
226	* @param pszFormat The message text. No newline.
227	* @param ... Format arguments.
228	*/
229	static RTEXITCODE VBoxControlSyntaxError(const char *pszFormat, ...)
230	{
231	/** @todo prefix with current command. */
232	va_list va;
233	va_start(va, pszFormat);
234	RTMsgErrorV(pszFormat, va);
235	va_end(va);
236	return RTEXITCODE_FAILURE;
237	}
238
239	#if defined(RT_OS_WINDOWS) && !defined(VBOX_CONTROL_TEST)
240
241	LONG (WINAPI * gpfnChangeDisplaySettingsEx)(LPCTSTR lpszDeviceName, LPDEVMODE lpDevMode, HWND hwnd, DWORD dwflags, LPVOID lParam);
242
243	static unsigned nextAdjacentRectXP(RECTL const *paRects, unsigned cRects, unsigned iRect)
244	{
245	for (unsigned i = 0; i < cRects; i++)
246	if (paRects[iRect].right == paRects[i].left)
247	return i;
248	return ~0U;
249	}
250
251	static unsigned nextAdjacentRectXN(RECTL const *paRects, unsigned cRects, unsigned iRect)
252	{
253	for (unsigned i = 0; i < cRects; i++)
254	if (paRects[iRect].left == paRects[i].right)
255	return i;
256	return ~0U;
257	}
258
259	static unsigned nextAdjacentRectYP(RECTL const *paRects, unsigned cRects, unsigned iRect)
260	{
261	for (unsigned i = 0; i < cRects; i++)
262	if (paRects[iRect].bottom == paRects[i].top)
263	return i;
264	return ~0U;
265	}
266
267	unsigned nextAdjacentRectYN(RECTL const *paRects, unsigned cRects, unsigned iRect)
268	{
269	for (unsigned i = 0; i < cRects; i++)
270	if (paRects[iRect].top == paRects[i].bottom)
271	return i;
272	return ~0U;
273	}
274
275	void resizeRect(RECTL *paRects, unsigned cRects, unsigned iPrimary, unsigned iResized, int NewWidth, int NewHeight)
276	{
277	RECTL paNewRects = (RECTL )alloca(sizeof (RECTL) * cRects);
278	memcpy (paNewRects, paRects, sizeof(RECTL) * cRects);
279	paNewRects[iResized].right += NewWidth - (paNewRects[iResized].right - paNewRects[iResized].left);
280	paNewRects[iResized].bottom += NewHeight - (paNewRects[iResized].bottom - paNewRects[iResized].top);
281
282	/* Verify all pairs of originally adjacent rectangles for all 4 directions.
283	* If the pair has a "good" delta (that is the first rectangle intersects the second)
284	* at a direction and the second rectangle is not primary one (which can not be moved),
285	* move the second rectangle to make it adjacent to the first one.
286	*/
287
288	/* X positive. */
289	unsigned iRect;
290	for (iRect = 0; iRect < cRects; iRect++)
291	{
292	/* Find the next adjacent original rect in x positive direction. */
293	unsigned iNextRect = nextAdjacentRectXP (paRects, cRects, iRect);
294	Log(("next %d -> %d\n", iRect, iNextRect));
295
296	if (iNextRect == ~0 \|\| iNextRect == iPrimary)
297	{
298	continue;
299	}
300
301	/* Check whether there is an X intersection between these adjacent rects in the new rectangles
302	* and fix the intersection if delta is "good".
303	*/
304	int delta = paNewRects[iRect].right - paNewRects[iNextRect].left;
305
306	if (delta > 0)
307	{
308	Log(("XP intersection right %d left %d, diff %d\n",
309	paNewRects[iRect].right, paNewRects[iNextRect].left,
310	delta));
311
312	paNewRects[iNextRect].left += delta;
313	paNewRects[iNextRect].right += delta;
314	}
315	}
316
317	/* X negative. */
318	for (iRect = 0; iRect < cRects; iRect++)
319	{
320	/* Find the next adjacent original rect in x negative direction. */
321	unsigned iNextRect = nextAdjacentRectXN (paRects, cRects, iRect);
322	Log(("next %d -> %d\n", iRect, iNextRect));
323
324	if (iNextRect == ~0 \|\| iNextRect == iPrimary)
325	{
326	continue;
327	}
328
329	/* Check whether there is an X intersection between these adjacent rects in the new rectangles
330	* and fix the intersection if delta is "good".
331	*/
332	int delta = paNewRects[iRect].left - paNewRects[iNextRect].right;
333
334	if (delta < 0)
335	{
336	Log(("XN intersection left %d right %d, diff %d\n",
337	paNewRects[iRect].left, paNewRects[iNextRect].right,
338	delta));
339
340	paNewRects[iNextRect].left += delta;
341	paNewRects[iNextRect].right += delta;
342	}
343	}
344
345	/* Y positive (in the computer sense, top->down). */
346	for (iRect = 0; iRect < cRects; iRect++)
347	{
348	/* Find the next adjacent original rect in y positive direction. */
349	unsigned iNextRect = nextAdjacentRectYP (paRects, cRects, iRect);
350	Log(("next %d -> %d\n", iRect, iNextRect));
351
352	if (iNextRect == ~0 \|\| iNextRect == iPrimary)
353	{
354	continue;
355	}
356
357	/* Check whether there is an Y intersection between these adjacent rects in the new rectangles
358	* and fix the intersection if delta is "good".
359	*/
360	int delta = paNewRects[iRect].bottom - paNewRects[iNextRect].top;
361
362	if (delta > 0)
363	{
364	Log(("YP intersection bottom %d top %d, diff %d\n",
365	paNewRects[iRect].bottom, paNewRects[iNextRect].top,
366	delta));
367
368	paNewRects[iNextRect].top += delta;
369	paNewRects[iNextRect].bottom += delta;
370	}
371	}
372
373	/* Y negative (in the computer sense, down->top). */
374	for (iRect = 0; iRect < cRects; iRect++)
375	{
376	/* Find the next adjacent original rect in x negative direction. */
377	unsigned iNextRect = nextAdjacentRectYN (paRects, cRects, iRect);
378	Log(("next %d -> %d\n", iRect, iNextRect));
379
380	if (iNextRect == ~0 \|\| iNextRect == iPrimary)
381	{
382	continue;
383	}
384
385	/* Check whether there is an Y intersection between these adjacent rects in the new rectangles
386	* and fix the intersection if delta is "good".
387	*/
388	int delta = paNewRects[iRect].top - paNewRects[iNextRect].bottom;
389
390	if (delta < 0)
391	{
392	Log(("YN intersection top %d bottom %d, diff %d\n",
393	paNewRects[iRect].top, paNewRects[iNextRect].bottom,
394	delta));
395
396	paNewRects[iNextRect].top += delta;
397	paNewRects[iNextRect].bottom += delta;
398	}
399	}
400
401	memcpy (paRects, paNewRects, sizeof (RECTL) * cRects);
402	return;
403	}
404
405	/* Returns TRUE to try again. */
406	static BOOL ResizeDisplayDevice(ULONG Id, DWORD Width, DWORD Height, DWORD BitsPerPixel)
407	{
408	BOOL fModeReset = (Width == 0 && Height == 0 && BitsPerPixel == 0);
409
410	DISPLAY_DEVICE DisplayDevice;
411	RT_ZERO(DisplayDevice);
412	DisplayDevice.cb = sizeof(DisplayDevice);
413
414	/* Find out how many display devices the system has */
415	DWORD NumDevices = 0;
416	DWORD i = 0;
417	while (EnumDisplayDevices(NULL, i, &DisplayDevice, 0))
418	{
419	Log(("[%d] %s\n", i, DisplayDevice.DeviceName));
420
421	if (DisplayDevice.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE)
422	{
423	Log(("Found primary device. err %d\n", GetLastError()));
424	NumDevices++;
425	}
426	else if (!(DisplayDevice.StateFlags & DISPLAY_DEVICE_MIRRORING_DRIVER))
427	{
428
429	Log(("Found secondary device. err %d\n", GetLastError()));
430	NumDevices++;
431	}
432
433	RT_ZERO(DisplayDevice);
434	DisplayDevice.cb = sizeof(DisplayDevice);
435	i++;
436	}
437
438	Log(("Found total %d devices. err %d\n", NumDevices, GetLastError()));
439
440	if (NumDevices == 0 \|\| Id >= NumDevices)
441	{
442	Log(("Requested identifier %d is invalid. err %d\n", Id, GetLastError()));
443	return FALSE;
444	}
445
446	DISPLAY_DEVICE paDisplayDevices = (DISPLAY_DEVICE )alloca(sizeof (DISPLAY_DEVICE) * NumDevices);
447	DEVMODE paDeviceModes = (DEVMODE )alloca(sizeof (DEVMODE) * NumDevices);
448	RECTL paRects = (RECTL )alloca(sizeof (RECTL) * NumDevices);
449
450	/* Fetch information about current devices and modes. */
451	DWORD DevNum = 0;
452	DWORD DevPrimaryNum = 0;
453
454	RT_ZERO(DisplayDevice);
455	DisplayDevice.cb = sizeof(DISPLAY_DEVICE);
456
457	i = 0;
458	while (EnumDisplayDevices (NULL, i, &DisplayDevice, 0))
459	{
460	Log(("[%d(%d)] %s\n", i, DevNum, DisplayDevice.DeviceName));
461
462	BOOL fFetchDevice = FALSE;
463
464	if (DisplayDevice.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE)
465	{
466	Log(("Found primary device. err %d\n", GetLastError()));
467	DevPrimaryNum = DevNum;
468	fFetchDevice = TRUE;
469	}
470	else if (!(DisplayDevice.StateFlags & DISPLAY_DEVICE_MIRRORING_DRIVER))
471	{
472
473	Log(("Found secondary device. err %d\n", GetLastError()));
474	fFetchDevice = TRUE;
475	}
476
477	if (fFetchDevice)
478	{
479	if (DevNum >= NumDevices)
480	{
481	Log(("%d >= %d\n", NumDevices, DevNum));
482	return FALSE;
483	}
484
485	paDisplayDevices[DevNum] = DisplayDevice;
486
487	RT_BZERO(&paDeviceModes[DevNum], sizeof(DEVMODE));
488	paDeviceModes[DevNum].dmSize = sizeof(DEVMODE);
489	if (!EnumDisplaySettings((LPSTR)DisplayDevice.DeviceName, ENUM_REGISTRY_SETTINGS, &paDeviceModes[DevNum]))
490	{
491	Log(("EnumDisplaySettings err %d\n", GetLastError()));
492	return FALSE;
493	}
494
495	Log(("%dx%d at %d,%d\n",
496	paDeviceModes[DevNum].dmPelsWidth,
497	paDeviceModes[DevNum].dmPelsHeight,
498	paDeviceModes[DevNum].dmPosition.x,
499	paDeviceModes[DevNum].dmPosition.y));
500
501	paRects[DevNum].left = paDeviceModes[DevNum].dmPosition.x;
502	paRects[DevNum].top = paDeviceModes[DevNum].dmPosition.y;
503	paRects[DevNum].right = paDeviceModes[DevNum].dmPosition.x + paDeviceModes[DevNum].dmPelsWidth;
504	paRects[DevNum].bottom = paDeviceModes[DevNum].dmPosition.y + paDeviceModes[DevNum].dmPelsHeight;
505	DevNum++;
506	}
507
508	RT_ZERO(DisplayDevice);
509	DisplayDevice.cb = sizeof(DISPLAY_DEVICE);
510	i++;
511	}
512
513	if (Width == 0)
514	Width = paRects[Id].right - paRects[Id].left;
515
516	if (Height == 0)
517	Height = paRects[Id].bottom - paRects[Id].top;
518
519	/* Check whether a mode reset or a change is requested. */
520	if ( !fModeReset
521	&& paRects[Id].right - paRects[Id].left == (LONG)Width
522	&& paRects[Id].bottom - paRects[Id].top == (LONG)Height
523	&& paDeviceModes[Id].dmBitsPerPel == BitsPerPixel)
524	{
525	Log(("VBoxDisplayThread : already at desired resolution.\n"));
526	return FALSE;
527	}
528
529	resizeRect(paRects, NumDevices, DevPrimaryNum, Id, Width, Height);
530	#ifdef LOG_ENABLED
531	for (i = 0; i < NumDevices; i++)
532	Log(("[%d]: %d,%d %dx%d\n",
533	i, paRects[i].left, paRects[i].top,
534	paRects[i].right - paRects[i].left,
535	paRects[i].bottom - paRects[i].top));
536	#endif /* Log */
537
538	/* Without this, Windows will not ask the miniport for its
539	* mode table but uses an internal cache instead.
540	*/
541	DEVMODE tempDevMode;
542	RT_ZERO(tempDevMode);
543	tempDevMode.dmSize = sizeof(DEVMODE);
544	EnumDisplaySettings(NULL, 0xffffff, &tempDevMode);
545
546	/* Assign the new rectangles to displays. */
547	for (i = 0; i < NumDevices; i++)
548	{
549	paDeviceModes[i].dmPosition.x = paRects[i].left;
550	paDeviceModes[i].dmPosition.y = paRects[i].top;
551	paDeviceModes[i].dmPelsWidth = paRects[i].right - paRects[i].left;
552	paDeviceModes[i].dmPelsHeight = paRects[i].bottom - paRects[i].top;
553
554	paDeviceModes[i].dmFields = DM_POSITION \| DM_PELSHEIGHT \| DM_PELSWIDTH;
555
556	if ( i == Id
557	&& BitsPerPixel != 0)
558	{
559	paDeviceModes[i].dmFields \|= DM_BITSPERPEL;
560	paDeviceModes[i].dmBitsPerPel = BitsPerPixel;
561	}
562	Log(("calling pfnChangeDisplaySettingsEx %x\n", gpfnChangeDisplaySettingsEx));
563	gpfnChangeDisplaySettingsEx((LPSTR)paDisplayDevices[i].DeviceName,
564	&paDeviceModes[i], NULL, CDS_NORESET \| CDS_UPDATEREGISTRY, NULL);
565	Log(("ChangeDisplaySettings position err %d\n", GetLastError()));
566	}
567
568	/* A second call to ChangeDisplaySettings updates the monitor. */
569	LONG status = ChangeDisplaySettings(NULL, 0);
570	Log(("ChangeDisplaySettings update status %d\n", status));
571	if (status == DISP_CHANGE_SUCCESSFUL \|\| status == DISP_CHANGE_BADMODE)
572	{
573	/* Successfully set new video mode or our driver can not set the requested mode. Stop trying. */
574	return FALSE;
575	}
576
577	/* Retry the request. */
578	return TRUE;
579	}
580
581	static DECLCALLBACK(RTEXITCODE) handleSetVideoMode(int argc, char *argv[])
582	{
583	if (argc != 3 && argc != 4)
584	{
585	usage(SET_VIDEO_MODE);
586	return RTEXITCODE_FAILURE;
587	}
588
589	DWORD xres = atoi(argv[0]);
590	DWORD yres = atoi(argv[1]);
591	DWORD bpp = atoi(argv[2]);
592	DWORD scr = 0;
593	if (argc == 4)
594	scr = atoi(argv[3]);
595
596	HMODULE hUser = GetModuleHandle("user32.dll");
597	if (hUser)
598	{
599	(uintptr_t )&gpfnChangeDisplaySettingsEx = (uintptr_t)GetProcAddress(hUser, "ChangeDisplaySettingsExA");
600	Log(("VBoxService: pChangeDisplaySettingsEx = %p\n", gpfnChangeDisplaySettingsEx));
601
602	if (gpfnChangeDisplaySettingsEx)
603	{
604	/* The screen index is 0 based in the ResizeDisplayDevice call. */
605	scr = scr > 0 ? scr - 1 : 0;
606
607	/* Horizontal resolution must be a multiple of 8, round down. */
608	xres &= ~0x7;
609
610	RTPrintf("Setting resolution of display %d to %dx%dx%d ...", scr, xres, yres, bpp);
611	ResizeDisplayDevice(scr, xres, yres, bpp);
612	RTPrintf("done.\n");
613	}
614	else
615	VBoxControlError("Error retrieving API for display change!");
616	}
617	else
618	VBoxControlError("Error retrieving handle to user32.dll!");
619
620	return RTEXITCODE_SUCCESS;
621	}
622
623	static int checkVBoxVideoKey(HKEY hkeyVideo)
624	{
625	RTUTF16 wszValue[128];
626	DWORD cbValue = sizeof(wszValue);
627	DWORD dwKeyType;
628	LONG status = RegQueryValueExW(hkeyVideo, L"Device Description", NULL, &dwKeyType, (LPBYTE)wszValue, &cbValue);
629	if (status == ERROR_SUCCESS)
630	{
631	/* WDDM has additional chars after "Adapter" */
632	static char s_szDeviceDescription[] = "VirtualBox Graphics Adapter";
633	wszValue[sizeof(s_szDeviceDescription) - 1] = '\0';
634	if (RTUtf16ICmpAscii(wszValue, s_szDeviceDescription) == 0)
635	return VINF_SUCCESS;
636	}
637
638	return VERR_NOT_FOUND;
639	}
640
641	static HKEY getVideoKey(bool writable)
642	{
643	HKEY hkeyDeviceMap = 0;
644	LONG status = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "HARDWARE\\DEVICEMAP\\VIDEO", 0, KEY_READ, &hkeyDeviceMap);
645	if (status != ERROR_SUCCESS \|\| !hkeyDeviceMap)
646	{
647	VBoxControlError("Error opening video device map registry key!\n");
648	return 0;
649	}
650
651	HKEY hkeyVideo = 0;
652	ULONG iDevice;
653	DWORD dwKeyType;
654
655	/*
656	* Scan all '\Device\VideoX' REG_SZ keys to find VBox video driver entry.
657	* 'ObjectNumberList' REG_BINARY is an array of 32 bit device indexes (X).
658	*/
659
660	/* Get the 'ObjectNumberList' */
661	ULONG cDevices = 0;
662	DWORD adwObjectNumberList[256];
663	DWORD cbValue = sizeof(adwObjectNumberList);
664	status = RegQueryValueExA(hkeyDeviceMap, "ObjectNumberList", NULL, &dwKeyType, (LPBYTE)&adwObjectNumberList[0], &cbValue);
665
666	if ( status == ERROR_SUCCESS
667	&& dwKeyType == REG_BINARY)
668	cDevices = cbValue / sizeof(DWORD);
669	else
670	{
671	/* The list might not exists. Use 'MaxObjectNumber' REG_DWORD and build a list. */
672	DWORD dwMaxObjectNumber = 0;
673	cbValue = sizeof(dwMaxObjectNumber);
674	status = RegQueryValueExA(hkeyDeviceMap, "MaxObjectNumber", NULL, &dwKeyType, (LPBYTE)&dwMaxObjectNumber, &cbValue);
675	if ( status == ERROR_SUCCESS
676	&& dwKeyType == REG_DWORD)
677	{
678	/* 'MaxObjectNumber' is inclusive. */
679	cDevices = RT_MIN(dwMaxObjectNumber + 1, RT_ELEMENTS(adwObjectNumberList));
680	for (iDevice = 0; iDevice < cDevices; iDevice++)
681	adwObjectNumberList[iDevice] = iDevice;
682	}
683	}
684
685	if (cDevices == 0)
686	{
687	/* Always try '\Device\Video0' as the old code did. Enum can be used in this case in principle. */
688	adwObjectNumberList[0] = 0;
689	cDevices = 1;
690	}
691
692	/* Scan device entries */
693	for (iDevice = 0; iDevice < cDevices; iDevice++)
694	{
695	char szValueName[64];
696	RTStrPrintf(szValueName, sizeof(szValueName), "\\Device\\Video%u", adwObjectNumberList[iDevice]);
697
698	char szVideoLocation[256];
699	cbValue = sizeof(szVideoLocation);
700	status = RegQueryValueExA(hkeyDeviceMap, szValueName, NULL, &dwKeyType, (LPBYTE)&szVideoLocation[0], &cbValue);
701
702	/* This value starts with '\REGISTRY\Machine' */
703	if ( status == ERROR_SUCCESS
704	&& dwKeyType == REG_SZ
705	&& _strnicmp(szVideoLocation, "\\REGISTRY\\Machine", 17) == 0)
706	{
707	status = RegOpenKeyExA(HKEY_LOCAL_MACHINE, &szVideoLocation[18], 0,
708	KEY_READ \| (writable ? KEY_WRITE : 0), &hkeyVideo);
709	if (status == ERROR_SUCCESS)
710	{
711	int rc = checkVBoxVideoKey(hkeyVideo);
712	if (RT_SUCCESS(rc))
713	{
714	/* Found, return hkeyVideo to the caller. */
715	break;
716	}
717
718	RegCloseKey(hkeyVideo);
719	hkeyVideo = 0;
720	}
721	}
722	}
723
724	if (hkeyVideo == 0)
725	{
726	VBoxControlError("Error opening video registry key!\n");
727	}
728
729	RegCloseKey(hkeyDeviceMap);
730	return hkeyVideo;
731	}
732
733	static DECLCALLBACK(RTEXITCODE) handleGetVideoAcceleration(int argc, char *argv[])
734	{
735	RT_NOREF2(argc, argv);
736	ULONG status;
737	HKEY hkeyVideo = getVideoKey(false);
738
739	if (hkeyVideo)
740	{
741	/* query the actual value */
742	DWORD fAcceleration = 1;
743	DWORD cbValue = sizeof(fAcceleration);
744	DWORD dwKeyType;
745	status = RegQueryValueExA(hkeyVideo, "EnableVideoAccel", NULL, &dwKeyType, (LPBYTE)&fAcceleration, &cbValue);
746	if (status != ERROR_SUCCESS)
747	RTPrintf("Video acceleration: default\n");
748	else
749	RTPrintf("Video acceleration: %s\n", fAcceleration ? "on" : "off");
750	RegCloseKey(hkeyVideo);
751	}
752	return RTEXITCODE_SUCCESS;
753	}
754
755	static DECLCALLBACK(RTEXITCODE) handleSetVideoAcceleration(int argc, char *argv[])
756	{
757	ULONG status;
758	HKEY hkeyVideo;
759
760	/* must have exactly one argument: the new offset */
761	if ( (argc != 1)
762	\|\| ( RTStrICmp(argv[0], "on")
763	&& RTStrICmp(argv[0], "off")))
764	{
765	usage(SET_VIDEO_ACCEL);
766	return RTEXITCODE_FAILURE;
767	}
768
769	hkeyVideo = getVideoKey(true);
770
771	if (hkeyVideo)
772	{
773	int fAccel = 0;
774	if (RTStrICmp(argv[0], "on") == 0)
775	fAccel = 1;
776	/* set a new value */
777	status = RegSetValueExA(hkeyVideo, "EnableVideoAccel", 0, REG_DWORD, (LPBYTE)&fAccel, sizeof(fAccel));
778	if (status != ERROR_SUCCESS)
779	{
780	VBoxControlError("Error %d writing video acceleration status!\n", status);
781	}
782	RegCloseKey(hkeyVideo);
783	}
784	return RTEXITCODE_SUCCESS;
785	}
786
787	static DECLCALLBACK(RTEXITCODE) videoFlagsGet(void)
788	{
789	HKEY hkeyVideo = getVideoKey(false);
790
791	if (hkeyVideo)
792	{
793	DWORD dwFlags = 0;
794	DWORD cbValue = sizeof(dwFlags);
795	DWORD dwKeyType;
796	ULONG status = RegQueryValueExA(hkeyVideo, "VBoxVideoFlags", NULL, &dwKeyType, (LPBYTE)&dwFlags, &cbValue);
797	if (status != ERROR_SUCCESS)
798	RTPrintf("Video flags: default\n");
799	else
800	RTPrintf("Video flags: 0x%08X\n", dwFlags);
801	RegCloseKey(hkeyVideo);
802	return RTEXITCODE_SUCCESS;
803	}
804
805	return RTEXITCODE_FAILURE;
806	}
807
808	static DECLCALLBACK(RTEXITCODE) videoFlagsDelete(void)
809	{
810	HKEY hkeyVideo = getVideoKey(true);
811
812	if (hkeyVideo)
813	{
814	ULONG status = RegDeleteValueA(hkeyVideo, "VBoxVideoFlags");
815	if (status != ERROR_SUCCESS)
816	VBoxControlError("Error %d deleting video flags.\n", status);
817	RegCloseKey(hkeyVideo);
818	return RTEXITCODE_SUCCESS;
819	}
820
821	return RTEXITCODE_FAILURE;
822	}
823
824	static DECLCALLBACK(RTEXITCODE) videoFlagsModify(bool fSet, int argc, char *argv[])
825	{
826	if (argc != 1)
827	{
828	VBoxControlError("Mask required.\n");
829	return RTEXITCODE_FAILURE;
830	}
831
832	uint32_t u32Mask = 0;
833	int rc = RTStrToUInt32Full(argv[0], 16, &u32Mask);
834	if (RT_FAILURE(rc))
835	{
836	VBoxControlError("Invalid video flags mask.\n");
837	return RTEXITCODE_FAILURE;
838	}
839
840	RTEXITCODE exitCode = RTEXITCODE_SUCCESS;
841
842	HKEY hkeyVideo = getVideoKey(true);
843	if (hkeyVideo)
844	{
845	DWORD dwFlags = 0;
846	DWORD cbValue = sizeof(dwFlags);
847	DWORD dwKeyType;
848	ULONG status = RegQueryValueExA(hkeyVideo, "VBoxVideoFlags", NULL, &dwKeyType, (LPBYTE)&dwFlags, &cbValue);
849	if (status != ERROR_SUCCESS)
850	dwFlags = 0;
851
852	dwFlags = fSet ? dwFlags \| u32Mask : dwFlags & ~u32Mask;
853
854	status = RegSetValueExA(hkeyVideo, "VBoxVideoFlags", 0, REG_DWORD, (LPBYTE)&dwFlags, sizeof(dwFlags));
855	if (status != ERROR_SUCCESS)
856	{
857	VBoxControlError("Error %d writing video flags.\n", status);
858	exitCode = RTEXITCODE_FAILURE;
859	}
860
861	RegCloseKey(hkeyVideo);
862	}
863	else
864	{
865	exitCode = RTEXITCODE_FAILURE;
866	}
867
868	return exitCode;
869	}
870
871	static DECLCALLBACK(RTEXITCODE) handleVideoFlags(int argc, char *argv[])
872	{
873	/* Must have a keyword and optional value (32 bit hex string). */
874	if (argc != 1 && argc != 2)
875	{
876	VBoxControlError("Invalid number of arguments.\n");
877	usage(VIDEO_FLAGS);
878	return RTEXITCODE_FAILURE;
879	}
880
881	RTEXITCODE exitCode = RTEXITCODE_SUCCESS;
882
883	if (RTStrICmp(argv[0], "get") == 0)
884	{
885	exitCode = videoFlagsGet();
886	}
887	else if (RTStrICmp(argv[0], "delete") == 0)
888	{
889	exitCode = videoFlagsDelete();
890	}
891	else if (RTStrICmp(argv[0], "set") == 0)
892	{
893	exitCode = videoFlagsModify(true, argc - 1, &argv[1]);
894	}
895	else if (RTStrICmp(argv[0], "clear") == 0)
896	{
897	exitCode = videoFlagsModify(false, argc - 1, &argv[1]);
898	}
899	else
900	{
901	VBoxControlError("Invalid command.\n");
902	exitCode = RTEXITCODE_FAILURE;
903	}
904
905	if (exitCode != RTEXITCODE_SUCCESS)
906	{
907	usage(VIDEO_FLAGS);
908	}
909
910	return exitCode;
911	}
912
913	#define MAX_CUSTOM_MODES 128
914
915	/* the table of custom modes */
916	struct
917	{
918	DWORD xres;
919	DWORD yres;
920	DWORD bpp;
921	} customModes[MAX_CUSTOM_MODES] = {0};
922
923	void getCustomModes(HKEY hkeyVideo)
924	{
925	ULONG status;
926	int curMode = 0;
927
928	/* null out the table */
929	RT_ZERO(customModes);
930
931	do
932	{
933	char valueName[20];
934	DWORD xres, yres, bpp = 0;
935	DWORD dwType;
936	DWORD dwLen = sizeof(DWORD);
937
938	RTStrPrintf(valueName, sizeof(valueName), "CustomMode%dWidth", curMode);
939	status = RegQueryValueExA(hkeyVideo, valueName, NULL, &dwType, (LPBYTE)&xres, &dwLen);
940	if (status != ERROR_SUCCESS)
941	break;
942	RTStrPrintf(valueName, sizeof(valueName), "CustomMode%dHeight", curMode);
943	status = RegQueryValueExA(hkeyVideo, valueName, NULL, &dwType, (LPBYTE)&yres, &dwLen);
944	if (status != ERROR_SUCCESS)
945	break;
946	RTStrPrintf(valueName, sizeof(valueName), "CustomMode%dBPP", curMode);
947	status = RegQueryValueExA(hkeyVideo, valueName, NULL, &dwType, (LPBYTE)&bpp, &dwLen);
948	if (status != ERROR_SUCCESS)
949	break;
950
951	/* check if the mode is OK */
952	if ( (xres > (1 << 16))
953	\|\| (yres > (1 << 16))
954	\|\| ( (bpp != 16)
955	&& (bpp != 24)
956	&& (bpp != 32)))
957	break;
958
959	/* add mode to table */
960	customModes[curMode].xres = xres;
961	customModes[curMode].yres = yres;
962	customModes[curMode].bpp = bpp;
963
964	++curMode;
965
966	if (curMode >= MAX_CUSTOM_MODES)
967	break;
968	} while(1);
969	}
970
971	void writeCustomModes(HKEY hkeyVideo)
972	{
973	ULONG status;
974	int tableIndex = 0;
975	int modeIndex = 0;
976
977	/* first remove all values */
978	for (int i = 0; i < MAX_CUSTOM_MODES; i++)
979	{
980	char valueName[20];
981	RTStrPrintf(valueName, sizeof(valueName), "CustomMode%dWidth", i);
982	RegDeleteValueA(hkeyVideo, valueName);
983	RTStrPrintf(valueName, sizeof(valueName), "CustomMode%dHeight", i);
984	RegDeleteValueA(hkeyVideo, valueName);
985	RTStrPrintf(valueName, sizeof(valueName), "CustomMode%dBPP", i);
986	RegDeleteValueA(hkeyVideo, valueName);
987	}
988
989	do
990	{
991	if (tableIndex >= MAX_CUSTOM_MODES)
992	break;
993
994	/* is the table entry present? */
995	if ( (!customModes[tableIndex].xres)
996	\|\| (!customModes[tableIndex].yres)
997	\|\| (!customModes[tableIndex].bpp))
998	{
999	tableIndex++;
1000	continue;
1001	}
1002
1003	RTPrintf("writing mode %d (%dx%dx%d)\n", modeIndex, customModes[tableIndex].xres, customModes[tableIndex].yres, customModes[tableIndex].bpp);
1004	char valueName[20];
1005	RTStrPrintf(valueName, sizeof(valueName), "CustomMode%dWidth", modeIndex);
1006	status = RegSetValueExA(hkeyVideo, valueName, 0, REG_DWORD, (LPBYTE)&customModes[tableIndex].xres,
1007	sizeof(customModes[tableIndex].xres));
1008	RTStrPrintf(valueName, sizeof(valueName), "CustomMode%dHeight", modeIndex);
1009	RegSetValueExA(hkeyVideo, valueName, 0, REG_DWORD, (LPBYTE)&customModes[tableIndex].yres,
1010	sizeof(customModes[tableIndex].yres));
1011	RTStrPrintf(valueName, sizeof(valueName), "CustomMode%dBPP", modeIndex);
1012	RegSetValueExA(hkeyVideo, valueName, 0, REG_DWORD, (LPBYTE)&customModes[tableIndex].bpp,
1013	sizeof(customModes[tableIndex].bpp));
1014
1015	modeIndex++;
1016	tableIndex++;
1017
1018	} while(1);
1019
1020	}
1021
1022	static DECLCALLBACK(RTEXITCODE) handleListCustomModes(int argc, char *argv[])
1023	{
1024	RT_NOREF1(argv);
1025	if (argc != 0)
1026	{
1027	usage(LIST_CUST_MODES);
1028	return RTEXITCODE_FAILURE;
1029	}
1030
1031	HKEY hkeyVideo = getVideoKey(false);
1032
1033	if (hkeyVideo)
1034	{
1035	getCustomModes(hkeyVideo);
1036	for (int i = 0; i < (sizeof(customModes) / sizeof(customModes[0])); i++)
1037	{
1038	if ( !customModes[i].xres
1039	\|\| !customModes[i].yres
1040	\|\| !customModes[i].bpp)
1041	continue;
1042
1043	RTPrintf("Mode: %d x %d x %d\n",
1044	customModes[i].xres, customModes[i].yres, customModes[i].bpp);
1045	}
1046	RegCloseKey(hkeyVideo);
1047	}
1048	return RTEXITCODE_SUCCESS;
1049	}
1050
1051	static DECLCALLBACK(RTEXITCODE) handleAddCustomMode(int argc, char *argv[])
1052	{
1053	if (argc != 3)
1054	{
1055	usage(ADD_CUST_MODE);
1056	return RTEXITCODE_FAILURE;
1057	}
1058
1059	DWORD xres = atoi(argv[0]);
1060	DWORD yres = atoi(argv[1]);
1061	DWORD bpp = atoi(argv[2]);
1062
1063	/** @todo better check including xres mod 8 = 0! */
1064	if ( (xres > (1 << 16))
1065	\|\| (yres > (1 << 16))
1066	\|\| ( (bpp != 16)
1067	&& (bpp != 24)
1068	&& (bpp != 32)))
1069	{
1070	VBoxControlError("invalid mode specified!\n");
1071	return RTEXITCODE_FAILURE;
1072	}
1073
1074	HKEY hkeyVideo = getVideoKey(true);
1075
1076	if (hkeyVideo)
1077	{
1078	int i;
1079	int fModeExists = 0;
1080	getCustomModes(hkeyVideo);
1081	for (i = 0; i < MAX_CUSTOM_MODES; i++)
1082	{
1083	/* mode exists? */
1084	if ( customModes[i].xres == xres
1085	&& customModes[i].yres == yres
1086	&& customModes[i].bpp == bpp
1087	)
1088	{
1089	fModeExists = 1;
1090	}
1091	}
1092	if (!fModeExists)
1093	{
1094	for (i = 0; i < MAX_CUSTOM_MODES; i++)
1095	{
1096	/* item free? */
1097	if (!customModes[i].xres)
1098	{
1099	customModes[i].xres = xres;
1100	customModes[i].yres = yres;
1101	customModes[i].bpp = bpp;
1102	break;
1103	}
1104	}
1105	writeCustomModes(hkeyVideo);
1106	}
1107	RegCloseKey(hkeyVideo);
1108	}
1109	return RTEXITCODE_SUCCESS;
1110	}
1111
1112	static DECLCALLBACK(RTEXITCODE) handleRemoveCustomMode(int argc, char *argv[])
1113	{
1114	if (argc != 3)
1115	{
1116	usage(REMOVE_CUST_MODE);
1117	return RTEXITCODE_FAILURE;
1118	}
1119
1120	DWORD xres = atoi(argv[0]);
1121	DWORD yres = atoi(argv[1]);
1122	DWORD bpp = atoi(argv[2]);
1123
1124	HKEY hkeyVideo = getVideoKey(true);
1125
1126	if (hkeyVideo)
1127	{
1128	getCustomModes(hkeyVideo);
1129	for (int i = 0; i < MAX_CUSTOM_MODES; i++)
1130	{
1131	/* correct item? */
1132	if ( (customModes[i].xres == xres)
1133	&& (customModes[i].yres == yres)
1134	&& (customModes[i].bpp == bpp))
1135	{
1136	RTPrintf("found mode at index %d\n", i);
1137	RT_ZERO(customModes[i]);
1138	break;
1139	}
1140	}
1141	writeCustomModes(hkeyVideo);
1142	RegCloseKey(hkeyVideo);
1143	}
1144
1145	return RTEXITCODE_SUCCESS;
1146	}
1147
1148	#endif /* RT_OS_WINDOWS */
1149
1150	#ifdef VBOX_WITH_GUEST_PROPS
1151	/**
1152	* Retrieves a value from the guest property store.
1153	* This is accessed through the "VBoxGuestPropSvc" HGCM service.
1154	*
1155	* @returns Command exit code.
1156	* @note see the command line API description for parameters
1157	*/
1158	static RTEXITCODE getGuestProperty(int argc, char **argv)
1159	{
1160	using namespace guestProp;
1161
1162	bool fVerbose = false;
1163	if ( argc == 2
1164	&& ( strcmp(argv[1], "-verbose") == 0
1165	\|\| strcmp(argv[1], "--verbose") == 0)
1166	)
1167	fVerbose = true;
1168	else if (argc != 1)
1169	{
1170	usage(GUEST_PROP);
1171	return RTEXITCODE_FAILURE;
1172	}
1173
1174	uint32_t u32ClientId = 0;
1175	int rc = VINF_SUCCESS;
1176
1177	rc = VbglR3GuestPropConnect(&u32ClientId);
1178	if (RT_FAILURE(rc))
1179	VBoxControlError("Failed to connect to the guest property service, error %Rrc\n", rc);
1180
1181	/*
1182	* Here we actually retrieve the value from the host.
1183	*/
1184	const char *pszName = argv[0];
1185	char *pszValue = NULL;
1186	uint64_t u64Timestamp = 0;
1187	char *pszFlags = NULL;
1188	/* The buffer for storing the data and its initial size. We leave a bit
1189	* of space here in case the maximum values are raised. */
1190	void *pvBuf = NULL;
1191	uint32_t cbBuf = MAX_VALUE_LEN + MAX_FLAGS_LEN + 1024;
1192	if (RT_SUCCESS(rc))
1193	{
1194	/* Because there is a race condition between our reading the size of a
1195	* property and the guest updating it, we loop a few times here and
1196	* hope. Actually this should never go wrong, as we are generous
1197	* enough with buffer space. */
1198	bool fFinished = false;
1199	for (unsigned i = 0; i < 10 && !fFinished; ++i)
1200	{
1201	void *pvTmpBuf = RTMemRealloc(pvBuf, cbBuf);
1202	if (NULL == pvTmpBuf)
1203	{
1204	rc = VERR_NO_MEMORY;
1205	VBoxControlError("Out of memory\n");
1206	}
1207	else
1208	{
1209	pvBuf = pvTmpBuf;
1210	rc = VbglR3GuestPropRead(u32ClientId, pszName, pvBuf, cbBuf,
1211	&pszValue, &u64Timestamp, &pszFlags,
1212	&cbBuf);
1213	}
1214	if (VERR_BUFFER_OVERFLOW == rc)
1215	/* Leave a bit of extra space to be safe */
1216	cbBuf += 1024;
1217	else
1218	fFinished = true;
1219	}
1220	if (VERR_TOO_MUCH_DATA == rc)
1221	VBoxControlError("Temporarily unable to retrieve the property\n");
1222	else if (RT_FAILURE(rc) && rc != VERR_NOT_FOUND)
1223	VBoxControlError("Failed to retrieve the property value, error %Rrc\n", rc);
1224	}
1225
1226	/*
1227	* And display it on the guest console.
1228	*/
1229	if (VERR_NOT_FOUND == rc)
1230	RTPrintf("No value set!\n");
1231	else if (RT_SUCCESS(rc))
1232	{
1233	RTPrintf("Value: %s\n", pszValue);
1234	if (fVerbose)
1235	{
1236	RTPrintf("Timestamp: %lld ns\n", u64Timestamp);
1237	RTPrintf("Flags: %s\n", pszFlags);
1238	}
1239	}
1240
1241	if (u32ClientId != 0)
1242	VbglR3GuestPropDisconnect(u32ClientId);
1243	RTMemFree(pvBuf);
1244	return RT_SUCCESS(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1245	}
1246
1247
1248	/**
1249	* Writes a value to the guest property store.
1250	* This is accessed through the "VBoxGuestPropSvc" HGCM service.
1251	*
1252	* @returns Command exit code.
1253	* @note see the command line API description for parameters
1254	*/
1255	static RTEXITCODE setGuestProperty(int argc, char *argv[])
1256	{
1257	/*
1258	* Check the syntax. We can deduce the correct syntax from the number of
1259	* arguments.
1260	*/
1261	bool fUsageOK = true;
1262	const char *pszName = NULL;
1263	const char *pszValue = NULL;
1264	const char *pszFlags = NULL;
1265	if (2 == argc)
1266	{
1267	pszValue = argv[1];
1268	}
1269	else if (3 == argc)
1270	fUsageOK = false;
1271	else if (4 == argc)
1272	{
1273	pszValue = argv[1];
1274	if ( strcmp(argv[2], "-flags") != 0
1275	&& strcmp(argv[2], "--flags") != 0)
1276	fUsageOK = false;
1277	pszFlags = argv[3];
1278	}
1279	else if (argc != 1)
1280	fUsageOK = false;
1281	if (!fUsageOK)
1282	{
1283	usage(GUEST_PROP);
1284	return RTEXITCODE_FAILURE;
1285	}
1286	/* This is always needed. */
1287	pszName = argv[0];
1288
1289	/*
1290	* Do the actual setting.
1291	*/
1292	uint32_t u32ClientId = 0;
1293	int rc = VINF_SUCCESS;
1294	rc = VbglR3GuestPropConnect(&u32ClientId);
1295	if (RT_FAILURE(rc))
1296	VBoxControlError("Failed to connect to the guest property service, error %Rrc\n", rc);
1297	else
1298	{
1299	if (pszFlags != NULL)
1300	rc = VbglR3GuestPropWrite(u32ClientId, pszName, pszValue, pszFlags);
1301	else
1302	rc = VbglR3GuestPropWriteValue(u32ClientId, pszName, pszValue);
1303	if (RT_FAILURE(rc))
1304	VBoxControlError("Failed to store the property value, error %Rrc\n", rc);
1305	}
1306
1307	if (u32ClientId != 0)
1308	VbglR3GuestPropDisconnect(u32ClientId);
1309	return RT_SUCCESS(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1310	}
1311
1312
1313	/**
1314	* Deletes a guest property from the guest property store.
1315	* This is accessed through the "VBoxGuestPropSvc" HGCM service.
1316	*
1317	* @returns Command exit code.
1318	* @note see the command line API description for parameters
1319	*/
1320	static RTEXITCODE deleteGuestProperty(int argc, char *argv[])
1321	{
1322	/*
1323	* Check the syntax. We can deduce the correct syntax from the number of
1324	* arguments.
1325	*/
1326	bool fUsageOK = true;
1327	const char *pszName = NULL;
1328	if (argc < 1)
1329	fUsageOK = false;
1330	if (!fUsageOK)
1331	{
1332	usage(GUEST_PROP);
1333	return RTEXITCODE_FAILURE;
1334	}
1335	/* This is always needed. */
1336	pszName = argv[0];
1337
1338	/*
1339	* Do the actual setting.
1340	*/
1341	uint32_t u32ClientId = 0;
1342	int rc = VbglR3GuestPropConnect(&u32ClientId);
1343	if (RT_FAILURE(rc))
1344	VBoxControlError("Failed to connect to the guest property service, error %Rrc\n", rc);
1345	else
1346	{
1347	rc = VbglR3GuestPropDelete(u32ClientId, pszName);
1348	if (RT_FAILURE(rc))
1349	VBoxControlError("Failed to delete the property value, error %Rrc\n", rc);
1350	}
1351
1352	if (u32ClientId != 0)
1353	VbglR3GuestPropDisconnect(u32ClientId);
1354	return RT_SUCCESS(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1355	}
1356
1357
1358	/**
1359	* Enumerates the properties in the guest property store.
1360	* This is accessed through the "VBoxGuestPropSvc" HGCM service.
1361	*
1362	* @returns Command exit code.
1363	* @note see the command line API description for parameters
1364	*/
1365	static RTEXITCODE enumGuestProperty(int argc, char *argv[])
1366	{
1367	/*
1368	* Check the syntax. We can deduce the correct syntax from the number of
1369	* arguments.
1370	*/
1371	char const * const *papszPatterns = NULL;
1372	uint32_t cPatterns = 0;
1373	if ( argc > 1
1374	&& ( strcmp(argv[0], "-patterns") == 0
1375	\|\| strcmp(argv[0], "--patterns") == 0))
1376	{
1377	papszPatterns = (char const * const *)&argv[1];
1378	cPatterns = argc - 1;
1379	}
1380	else if (argc != 0)
1381	{
1382	usage(GUEST_PROP);
1383	return RTEXITCODE_FAILURE;
1384	}
1385
1386	/*
1387	* Do the actual enumeration.
1388	*/
1389	uint32_t u32ClientId = 0;
1390	int rc = VbglR3GuestPropConnect(&u32ClientId);
1391	if (RT_SUCCESS(rc))
1392	{
1393	PVBGLR3GUESTPROPENUM pHandle;
1394	const char pszName, pszValue, *pszFlags;
1395	uint64_t u64Timestamp;
1396
1397	rc = VbglR3GuestPropEnum(u32ClientId, papszPatterns, cPatterns, &pHandle,
1398	&pszName, &pszValue, &u64Timestamp, &pszFlags);
1399	if (RT_SUCCESS(rc))
1400	{
1401	while (RT_SUCCESS(rc) && pszName)
1402	{
1403	RTPrintf("Name: %s, value: %s, timestamp: %lld, flags: %s\n",
1404	pszName, pszValue, u64Timestamp, pszFlags);
1405
1406	rc = VbglR3GuestPropEnumNext(pHandle, &pszName, &pszValue, &u64Timestamp, &pszFlags);
1407	if (RT_FAILURE(rc))
1408	VBoxControlError("Error while enumerating guest properties: %Rrc\n", rc);
1409	}
1410
1411	VbglR3GuestPropEnumFree(pHandle);
1412	}
1413	else if (VERR_NOT_FOUND == rc)
1414	RTPrintf("No properties found.\n");
1415	else
1416	VBoxControlError("Failed to enumerate the guest properties! Error: %Rrc\n", rc);
1417	VbglR3GuestPropDisconnect(u32ClientId);
1418	}
1419	else
1420	VBoxControlError("Failed to connect to the guest property service! Error: %Rrc\n", rc);
1421	return RT_SUCCESS(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1422	}
1423
1424
1425	/**
1426	* Waits for notifications of changes to guest properties.
1427	* This is accessed through the "VBoxGuestPropSvc" HGCM service.
1428	*
1429	* @returns Command exit code.
1430	* @note see the command line API description for parameters
1431	*/
1432	static RTEXITCODE waitGuestProperty(int argc, char **argv)
1433	{
1434	using namespace guestProp;
1435
1436	/*
1437	* Handle arguments
1438	*/
1439	const char *pszPatterns = NULL;
1440	uint64_t u64TimestampIn = 0;
1441	uint32_t u32Timeout = RT_INDEFINITE_WAIT;
1442	bool fUsageOK = true;
1443	if (argc < 1)
1444	fUsageOK = false;
1445	pszPatterns = argv[0];
1446	for (int i = 1; fUsageOK && i < argc; ++i)
1447	{
1448	if ( strcmp(argv[i], "-timeout") == 0
1449	\|\| strcmp(argv[i], "--timeout") == 0)
1450	{
1451	if ( i + 1 >= argc
1452	\|\| RTStrToUInt32Full(argv[i + 1], 10, &u32Timeout)
1453	!= VINF_SUCCESS
1454	)
1455	fUsageOK = false;
1456	else
1457	++i;
1458	}
1459	else if ( strcmp(argv[i], "-timestamp") == 0
1460	\|\| strcmp(argv[i], "--timestamp") == 0)
1461	{
1462	if ( i + 1 >= argc
1463	\|\| RTStrToUInt64Full(argv[i + 1], 10, &u64TimestampIn)
1464	!= VINF_SUCCESS
1465	)
1466	fUsageOK = false;
1467	else
1468	++i;
1469	}
1470	else
1471	fUsageOK = false;
1472	}
1473	if (!fUsageOK)
1474	{
1475	usage(GUEST_PROP);
1476	return RTEXITCODE_FAILURE;
1477	}
1478
1479	/*
1480	* Connect to the service
1481	*/
1482	uint32_t u32ClientId = 0;
1483	int rc = VINF_SUCCESS;
1484
1485	rc = VbglR3GuestPropConnect(&u32ClientId);
1486	if (RT_FAILURE(rc))
1487	VBoxControlError("Failed to connect to the guest property service, error %Rrc\n", rc);
1488
1489	/*
1490	* Retrieve the notification from the host
1491	*/
1492	char *pszName = NULL;
1493	char *pszValue = NULL;
1494	uint64_t u64TimestampOut = 0;
1495	char *pszFlags = NULL;
1496	/* The buffer for storing the data and its initial size. We leave a bit
1497	* of space here in case the maximum values are raised. */
1498	void *pvBuf = NULL;
1499	uint32_t cbBuf = MAX_NAME_LEN + MAX_VALUE_LEN + MAX_FLAGS_LEN + 1024;
1500	/* Because there is a race condition between our reading the size of a
1501	* property and the guest updating it, we loop a few times here and
1502	* hope. Actually this should never go wrong, as we are generous
1503	* enough with buffer space. */
1504	bool fFinished = false;
1505	for (unsigned i = 0; (RT_SUCCESS(rc) \|\| rc == VERR_BUFFER_OVERFLOW) && !fFinished && i < 10; i++)
1506	{
1507	void *pvTmpBuf = RTMemRealloc(pvBuf, cbBuf);
1508	if (NULL == pvTmpBuf)
1509	{
1510	rc = VERR_NO_MEMORY;
1511	VBoxControlError("Out of memory\n");
1512	}
1513	else
1514	{
1515	pvBuf = pvTmpBuf;
1516	rc = VbglR3GuestPropWait(u32ClientId, pszPatterns, pvBuf, cbBuf,
1517	u64TimestampIn, u32Timeout,
1518	&pszName, &pszValue, &u64TimestampOut,
1519	&pszFlags, &cbBuf);
1520	}
1521	if (VERR_BUFFER_OVERFLOW == rc)
1522	/* Leave a bit of extra space to be safe */
1523	cbBuf += 1024;
1524	else
1525	fFinished = true;
1526	if (rc == VERR_TOO_MUCH_DATA)
1527	VBoxControlError("Temporarily unable to get a notification\n");
1528	else if (rc == VERR_INTERRUPTED)
1529	VBoxControlError("The request timed out or was interrupted\n");
1530	#ifndef RT_OS_WINDOWS /* Windows guests do not do this right */
1531	else if (RT_FAILURE(rc) && rc != VERR_NOT_FOUND)
1532	VBoxControlError("Failed to get a notification, error %Rrc\n", rc);
1533	#endif
1534	}
1535
1536	/*
1537	* And display it on the guest console.
1538	*/
1539	if (VERR_NOT_FOUND == rc)
1540	RTPrintf("No value set!\n");
1541	else if (rc == VERR_BUFFER_OVERFLOW)
1542	RTPrintf("Internal error: unable to determine the size of the data!\n");
1543	else if (RT_SUCCESS(rc))
1544	{
1545	RTPrintf("Name: %s\n", pszName);
1546	RTPrintf("Value: %s\n", pszValue);
1547	RTPrintf("Timestamp: %lld ns\n", u64TimestampOut);
1548	RTPrintf("Flags: %s\n", pszFlags);
1549	}
1550
1551	if (u32ClientId != 0)
1552	VbglR3GuestPropDisconnect(u32ClientId);
1553	RTMemFree(pvBuf);
1554	return RT_SUCCESS(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1555	}
1556
1557
1558	/**
1559	* Access the guest property store through the "VBoxGuestPropSvc" HGCM
1560	* service.
1561	*
1562	* @returns 0 on success, 1 on failure
1563	* @note see the command line API description for parameters
1564	*/
1565	static DECLCALLBACK(RTEXITCODE) handleGuestProperty(int argc, char *argv[])
1566	{
1567	if (argc == 0)
1568	{
1569	usage(GUEST_PROP);
1570	return RTEXITCODE_FAILURE;
1571	}
1572	if (!strcmp(argv[0], "get"))
1573	return getGuestProperty(argc - 1, argv + 1);
1574	if (!strcmp(argv[0], "set"))
1575	return setGuestProperty(argc - 1, argv + 1);
1576	if (!strcmp(argv[0], "delete") \|\| !strcmp(argv[0], "unset"))
1577	return deleteGuestProperty(argc - 1, argv + 1);
1578	if (!strcmp(argv[0], "enumerate"))
1579	return enumGuestProperty(argc - 1, argv + 1);
1580	if (!strcmp(argv[0], "wait"))
1581	return waitGuestProperty(argc - 1, argv + 1);
1582	/* unknown cmd */
1583	usage(GUEST_PROP);
1584	return RTEXITCODE_FAILURE;
1585	}
1586	#endif
1587
1588	#ifdef VBOX_WITH_SHARED_FOLDERS
1589	/**
1590	* Lists the Shared Folders provided by the host.
1591	*/
1592	static RTEXITCODE listSharedFolders(int argc, char **argv)
1593	{
1594	bool fUsageOK = true;
1595	bool fOnlyShowAutoMount = false;
1596	if (argc == 1)
1597	{
1598	if ( !strcmp(argv[0], "-automount")
1599	\|\| !strcmp(argv[0], "--automount"))
1600	fOnlyShowAutoMount = true;
1601	else
1602	fUsageOK = false;
1603	}
1604	else if (argc > 1)
1605	fUsageOK = false;
1606	if (!fUsageOK)
1607	{
1608	usage(GUEST_SHAREDFOLDERS);
1609	return RTEXITCODE_FAILURE;
1610	}
1611
1612	uint32_t u32ClientId;
1613	int rc = VbglR3SharedFolderConnect(&u32ClientId);
1614	if (RT_FAILURE(rc))
1615	VBoxControlError("Failed to connect to the shared folder service, error %Rrc\n", rc);
1616	else
1617	{
1618	PVBGLR3SHAREDFOLDERMAPPING paMappings;
1619	uint32_t cMappings;
1620	rc = VbglR3SharedFolderGetMappings(u32ClientId, fOnlyShowAutoMount, &paMappings, &cMappings);
1621	if (RT_SUCCESS(rc))
1622	{
1623	if (fOnlyShowAutoMount)
1624	RTPrintf("Auto-mounted Shared Folder mappings (%u):\n\n", cMappings);
1625	else
1626	RTPrintf("Shared Folder mappings (%u):\n\n", cMappings);
1627
1628	for (uint32_t i = 0; i < cMappings; i++)
1629	{
1630	char *pszName;
1631	rc = VbglR3SharedFolderGetName(u32ClientId, paMappings[i].u32Root, &pszName);
1632	if (RT_SUCCESS(rc))
1633	{
1634	RTPrintf("%02u - %s\n", i + 1, pszName);
1635	RTStrFree(pszName);
1636	}
1637	else
1638	VBoxControlError("Error while getting the shared folder name for root node = %u, rc = %Rrc\n",
1639	paMappings[i].u32Root, rc);
1640	}
1641	if (!cMappings)
1642	RTPrintf("No Shared Folders available.\n");
1643	VbglR3SharedFolderFreeMappings(paMappings);
1644	}
1645	else
1646	VBoxControlError("Error while getting the shared folder mappings, rc = %Rrc\n", rc);
1647	VbglR3SharedFolderDisconnect(u32ClientId);
1648	}
1649	return RT_SUCCESS(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1650	}
1651
1652	/**
1653	* Handles Shared Folders control.
1654	*
1655	* @returns 0 on success, 1 on failure
1656	* @note see the command line API description for parameters
1657	* (r=bird: yeah, right. The API description contains nil about params)
1658	*/
1659	static DECLCALLBACK(RTEXITCODE) handleSharedFolder(int argc, char *argv[])
1660	{
1661	if (argc == 0)
1662	{
1663	usage(GUEST_SHAREDFOLDERS);
1664	return RTEXITCODE_FAILURE;
1665	}
1666	if (!strcmp(argv[0], "list"))
1667	return listSharedFolders(argc - 1, argv + 1);
1668	/* else */
1669	usage(GUEST_SHAREDFOLDERS);
1670	return RTEXITCODE_FAILURE;
1671	}
1672	#endif
1673
1674	#if !defined(VBOX_CONTROL_TEST)
1675	/**
1676	* @callback_method_impl{FNVBOXCTRLCMDHANDLER, Command: writecoredump}
1677	*/
1678	static DECLCALLBACK(RTEXITCODE) handleWriteCoreDump(int argc, char *argv[])
1679	{
1680	RT_NOREF2(argc, argv);
1681	int rc = VbglR3WriteCoreDump();
1682	if (RT_SUCCESS(rc))
1683	{
1684	RTPrintf("Guest core dump successful.\n");
1685	return RTEXITCODE_SUCCESS;
1686	}
1687	else
1688	{
1689	VBoxControlError("Error while taking guest core dump. rc=%Rrc\n", rc);
1690	return RTEXITCODE_FAILURE;
1691	}
1692	}
1693	#endif
1694
1695	#ifdef VBOX_WITH_DPC_LATENCY_CHECKER
1696	/**
1697	* @callback_method_impl{FNVBOXCTRLCMDHANDLER, Command: help}
1698	*/
1699	static DECLCALLBACK(RTEXITCODE) handleDpc(int argc, char *argv[])
1700	{
1701	# ifndef VBOX_CONTROL_TEST
1702	int rc;
1703	for (int i = 0; i < 30; i++)
1704	{
1705	rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_DPC_LATENCY_CHECKER, NULL, 0);
1706	if (RT_FAILURE(rc))
1707	break;
1708	RTPrintf("%d\n", i);
1709	}
1710	# else
1711	int rc = VERR_NOT_IMPLEMENTED;
1712	# endif
1713	if (RT_FAILURE(rc))
1714	return VBoxControlError("Error. rc=%Rrc\n", rc);
1715	RTPrintf("Samples collection completed.\n");
1716	return RTEXITCODE_SUCCESS;
1717	}
1718	#endif /* VBOX_WITH_DPC_LATENCY_CHECKER */
1719
1720
1721	/**
1722	* @callback_method_impl{FNVBOXCTRLCMDHANDLER, Command: writelog}
1723	*/
1724	static DECLCALLBACK(RTEXITCODE) handleWriteLog(int argc, char *argv[])
1725	{
1726	static const RTGETOPTDEF s_aOptions[] =
1727	{
1728	{ "--no-newline", 'n', RTGETOPT_REQ_NOTHING },
1729	};
1730	bool fNoNewline = false;
1731
1732	RTGETOPTSTATE GetOptState;
1733	int rc = RTGetOptInit(&GetOptState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions),
1734	0 /iFirst/, RTGETOPTINIT_FLAGS_OPTS_FIRST);
1735	if (RT_SUCCESS(rc))
1736	{
1737	RTGETOPTUNION ValueUnion;
1738	int ch;
1739	while ((ch = RTGetOpt(&GetOptState, &ValueUnion)) != 0)
1740	{
1741	switch (ch)
1742	{
1743	case VINF_GETOPT_NOT_OPTION:
1744	{
1745	size_t cch = strlen(ValueUnion.psz);
1746	if ( fNoNewline
1747	\|\| (cch > 0 && ValueUnion.psz[cch - 1] == '\n') )
1748	rc = VbglR3WriteLog(ValueUnion.psz, cch);
1749	else
1750	{
1751	char pszDup = (char )RTMemDupEx(ValueUnion.psz, cch, 2);
1752	if (RT_SUCCESS(rc))
1753	{
1754	pszDup[cch++] = '\n';
1755	pszDup[cch] = '\0';
1756	rc = VbglR3WriteLog(pszDup, cch);
1757	RTMemFree(pszDup);
1758	}
1759	else
1760	rc = VERR_NO_MEMORY;
1761	}
1762	if (RT_FAILURE(rc))
1763	return VBoxControlError("VbglR3WriteLog: %Rrc", rc);
1764	break;
1765	}
1766
1767	case 'n':
1768	fNoNewline = true;
1769	break;
1770
1771	case 'h': return usage(WRITE_LOG);
1772	case 'V': return printVersion();
1773	default:
1774	return VBoxCtrlGetOptError(ch, &ValueUnion);
1775	}
1776	}
1777	}
1778	else
1779	return VBoxControlError("RTGetOptInit: %Rrc", rc);
1780	return RTEXITCODE_SUCCESS;
1781	}
1782
1783
1784	/**
1785	* @callback_method_impl{FNVBOXCTRLCMDHANDLER, Command: takesnapshot}
1786	*/
1787	static DECLCALLBACK(RTEXITCODE) handleTakeSnapshot(int argc, char *argv[])
1788	{
1789	RT_NOREF2(argc, argv); //VbglR3VmTakeSnapshot(argv[0], argv[1]);
1790	return VBoxControlError("not implemented");
1791	}
1792
1793	/**
1794	* @callback_method_impl{FNVBOXCTRLCMDHANDLER, Command: savestate}
1795	*/
1796	static DECLCALLBACK(RTEXITCODE) handleSaveState(int argc, char *argv[])
1797	{
1798	RT_NOREF2(argc, argv); //VbglR3VmSaveState();
1799	return VBoxControlError("not implemented");
1800	}
1801
1802	/**
1803	* @callback_method_impl{FNVBOXCTRLCMDHANDLER, Command: suspend\|pause}
1804	*/
1805	static DECLCALLBACK(RTEXITCODE) handleSuspend(int argc, char *argv[])
1806	{
1807	RT_NOREF2(argc, argv); //VbglR3VmSuspend();
1808	return VBoxControlError("not implemented");
1809	}
1810
1811	/**
1812	* @callback_method_impl{FNVBOXCTRLCMDHANDLER, Command: poweroff\|powerdown}
1813	*/
1814	static DECLCALLBACK(RTEXITCODE) handlePowerOff(int argc, char *argv[])
1815	{
1816	RT_NOREF2(argc, argv); //VbglR3VmPowerOff();
1817	return VBoxControlError("not implemented");
1818	}
1819
1820	/**
1821	* @callback_method_impl{FNVBOXCTRLCMDHANDLER, Command: version}
1822	*/
1823	static DECLCALLBACK(RTEXITCODE) handleVersion(int argc, char *argv[])
1824	{
1825	RT_NOREF1(argv);
1826	if (argc)
1827	return VBoxControlSyntaxError("getversion does not take any arguments");
1828	return printVersion();
1829	}
1830
1831	/**
1832	* @callback_method_impl{FNVBOXCTRLCMDHANDLER, Command: help}
1833	*/
1834	static DECLCALLBACK(RTEXITCODE) handleHelp(int argc, char *argv[])
1835	{
1836	RT_NOREF2(argc, argv); /* ignore arguments for now. */
1837	usage();
1838	return RTEXITCODE_SUCCESS;
1839	}
1840
1841
1842	/** command handler type */
1843	typedef DECLCALLBACK(RTEXITCODE) FNVBOXCTRLCMDHANDLER(int argc, char *argv[]);
1844	typedef FNVBOXCTRLCMDHANDLER *PFNVBOXCTRLCMDHANDLER;
1845
1846	/** The table of all registered command handlers. */
1847	struct COMMANDHANDLER
1848	{
1849	const char *pszCommand;
1850	PFNVBOXCTRLCMDHANDLER pfnHandler;
1851	} g_aCommandHandlers[] =
1852	{
1853	#if defined(RT_OS_WINDOWS) && !defined(VBOX_CONTROL_TEST)
1854	{ "getvideoacceleration", handleGetVideoAcceleration },
1855	{ "setvideoacceleration", handleSetVideoAcceleration },
1856	{ "videoflags", handleVideoFlags },
1857	{ "listcustommodes", handleListCustomModes },
1858	{ "addcustommode", handleAddCustomMode },
1859	{ "removecustommode", handleRemoveCustomMode },
1860	{ "setvideomode", handleSetVideoMode },
1861	#endif
1862	#ifdef VBOX_WITH_GUEST_PROPS
1863	{ "guestproperty", handleGuestProperty },
1864	#endif
1865	#ifdef VBOX_WITH_SHARED_FOLDERS
1866	{ "sharedfolder", handleSharedFolder },
1867	#endif
1868	#if !defined(VBOX_CONTROL_TEST)
1869	{ "writecoredump", handleWriteCoreDump },
1870	#endif
1871	#ifdef VBOX_WITH_DPC_LATENCY_CHECKER
1872	{ "dpc", handleDpc },
1873	#endif
1874	{ "writelog", handleWriteLog },
1875	{ "takesnapshot", handleTakeSnapshot },
1876	{ "savestate", handleSaveState },
1877	{ "suspend", handleSuspend },
1878	{ "pause", handleSuspend },
1879	{ "poweroff", handlePowerOff },
1880	{ "powerdown", handlePowerOff },
1881	{ "getversion", handleVersion },
1882	{ "version", handleVersion },
1883	{ "help", handleHelp }
1884	};
1885
1886	/** Main function */
1887	int main(int argc, char **argv)
1888	{
1889	/** The application's global return code */
1890	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
1891	/** An IPRT return code for local use */
1892	int rrc = VINF_SUCCESS;
1893	/** The index of the command line argument we are currently processing */
1894	int iArg = 1;
1895	/** Should we show the logo text? */
1896	bool fShowLogo = true;
1897	/** Should we print the usage after the logo? For the -help switch. */
1898	bool fDoHelp = false;
1899	/** Will we be executing a command or just printing information? */
1900	bool fOnlyInfo = false;
1901
1902	rrc = RTR3InitExe(argc, &argv, 0);
1903	if (RT_FAILURE(rrc))
1904	return RTMsgInitFailure(rrc);
1905
1906	/*
1907	* Start by handling command line switches
1908	*/
1909	/** @todo RTGetOpt conversion of the whole file. */
1910	bool done = false; /*< Are we finished with handling switches? /
1911	while (!done && (iArg < argc))
1912	{
1913	if ( !strcmp(argv[iArg], "-V")
1914	\|\| !strcmp(argv[iArg], "-v")
1915	\|\| !strcmp(argv[iArg], "--version")
1916	\|\| !strcmp(argv[iArg], "-version")
1917	)
1918	{
1919	/* Print version number, and do nothing else. */
1920	printVersion();
1921	fOnlyInfo = true;
1922	fShowLogo = false;
1923	done = true;
1924	}
1925	else if ( !strcmp(argv[iArg], "-nologo")
1926	\|\| !strcmp(argv[iArg], "--nologo"))
1927	fShowLogo = false;
1928	else if ( !strcmp(argv[iArg], "-help")
1929	\|\| !strcmp(argv[iArg], "--help"))
1930	{
1931	fOnlyInfo = true;
1932	fDoHelp = true;
1933	done = true;
1934	}
1935	else
1936	/* We have found an argument which isn't a switch. Exit to the
1937	* command processing bit. */
1938	done = true;
1939	if (!done)
1940	++iArg;
1941	}
1942
1943	/*
1944	* Find the application name, show our logo if the user hasn't suppressed it,
1945	* and show the usage if the user asked us to
1946	*/
1947	g_pszProgName = RTPathFilename(argv[0]);
1948	if (fShowLogo)
1949	RTPrintf(VBOX_PRODUCT " Guest Additions Command Line Management Interface Version "
1950	VBOX_VERSION_STRING "\n"
1951	"(C) 2008-" VBOX_C_YEAR " " VBOX_VENDOR "\n"
1952	"All rights reserved.\n\n");
1953	if (fDoHelp)
1954	usage();
1955
1956	/*
1957	* Do global initialisation for the programme if we will be handling a command
1958	*/
1959	if (!fOnlyInfo)
1960	{
1961	rrc = VbglR3Init();
1962	if (RT_FAILURE(rrc))
1963	{
1964	VBoxControlError("Could not contact the host system. Make sure that you are running this\n"
1965	"application inside a VirtualBox guest system, and that you have sufficient\n"
1966	"user permissions.\n");
1967	rcExit = RTEXITCODE_FAILURE;
1968	}
1969	}
1970
1971	/*
1972	* Now look for an actual command in the argument list and handle it.
1973	*/
1974
1975	if (!fOnlyInfo && rcExit == RTEXITCODE_SUCCESS)
1976	{
1977	if (argc > iArg)
1978	{
1979	/*
1980	* Try locate the command and execute it, complain if not found.
1981	*/
1982	unsigned i;
1983	for (i = 0; i < RT_ELEMENTS(g_aCommandHandlers); i++)
1984	if (!strcmp(argv[iArg], g_aCommandHandlers[i].pszCommand))
1985	{
1986	rcExit = g_aCommandHandlers[i].pfnHandler(argc - iArg - 1, argv + iArg + 1);
1987	break;
1988	}
1989	if (i >= RT_ELEMENTS(g_aCommandHandlers))
1990	{
1991	rcExit = RTEXITCODE_FAILURE;
1992	usage();
1993	}
1994	}
1995	else
1996	{
1997	/* The user didn't specify a command. */
1998	rcExit = RTEXITCODE_FAILURE;
1999	usage();
2000	}
2001	}
2002
2003	/*
2004	* And exit, returning the status
2005	*/
2006	return rcExit;
2007	}
2008

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

Download in other formats:

© 2023 Oracle
Contact – Privacy policy – Terms of Use