VBoxControl.cpp@ 11156

Last change on this file since 11156 was 11114, checked in by vboxsync, 17 years ago
Additions/VBoxControl: use the right error printer
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 38.7 KB

Line
1	/** $Id: VBoxControl.cpp 11114 2008-08-04 16:48:29Z vboxsync $ */
2	/** @file
3	* VBoxControl - Guest Additions Command Line Management Interface
4	*/
5
6	/*
7	* Copyright (C) 2007 Sun Microsystems, Inc.
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18	* Clara, CA 95054 USA or visit http://www.sun.com if you need
19	* additional information or have any questions.
20	*/
21
22
23
24	/*******************************************************************************
25	* Header Files *
26	*******************************************************************************/
27	#include <iprt/mem.h>
28	#include <iprt/string.h>
29	#include <iprt/stream.h>
30	#include <iprt/path.h>
31	#include <iprt/initterm.h>
32	#include <iprt/autores.h>
33	#include <VBox/log.h>
34	#include <VBox/VBoxGuest.h>
35	#include <VBox/version.h>
36	#ifdef RT_OS_WINDOWS
37	# include <windows.h>
38	# include <malloc.h> /* for alloca */
39	#endif
40	#ifdef VBOX_WITH_GUEST_PROPS
41	# include <VBox/HostServices/GuestPropertySvc.h>
42	#endif
43	#include "VBoxControl.h"
44
45	/*******************************************************************************
46	* Global Variables *
47	*******************************************************************************/
48	/** The program name (derived from argv[0]). */
49	char const *g_pszProgName = "";
50	/** The current verbosity level. */
51	int g_cVerbosity = 0;
52
53
54	/**
55	* Displays the program usage message.
56	*
57	* @param u64Which
58	*
59	* @{
60	*/
61
62	/** Helper function */
63	static void doUsage(char const line, char const name = "", char const *command = "")
64	{
65	RTPrintf("%s %-*s%s", name, 32 - strlen(name), command, line);
66	}
67
68	/** Enumerate the different parts of the usage we might want to print out */
69	enum g_eUsage
70	{
71	#ifdef RT_OS_WINDOWS
72	GET_VIDEO_ACCEL,
73	SET_VIDEO_ACCEL,
74	LIST_CUST_MODES,
75	ADD_CUST_MODE,
76	REMOVE_CUST_MODE,
77	SET_VIDEO_MODE,
78	#endif
79	#ifdef VBOX_WITH_GUEST_PROPS
80	GUEST_PROP,
81	#endif
82	USAGE_ALL = UINT32_MAX
83	};
84
85	static void usage(g_eUsage eWhich = USAGE_ALL)
86	{
87	RTPrintf("Usage:\n\n");
88	RTPrintf("%s [-v\|-version] print version number and exit\n", g_pszProgName);
89	RTPrintf("%s -nologo ... suppress the logo\n\n", g_pszProgName);
90
91	#ifdef RT_OS_WINDOWS
92	if ((GET_VIDEO_ACCEL == eWhich) \|\| (USAGE_ALL == eWhich))
93	doUsage("\n", g_pszProgName, "getvideoacceleration");
94	if ((SET_VIDEO_ACCEL == eWhich) \|\| (USAGE_ALL == eWhich))
95	doUsage("<on\|off>\n", g_pszProgName, "setvideoacceleration");
96	if ((LIST_CUST_MODES == eWhich) \|\| (USAGE_ALL == eWhich))
97	doUsage("\n", g_pszProgName, "listcustommodes");
98	if ((ADD_CUST_MODE == eWhich) \|\| (USAGE_ALL == eWhich))
99	doUsage("<width> <height> <bpp>\n", g_pszProgName, "addcustommode");
100	if ((REMOVE_CUST_MODE == eWhich) \|\| (USAGE_ALL == eWhich))
101	doUsage("<width> <height> <bpp>\n", g_pszProgName, "removecustommode");
102	if ((SET_VIDEO_MODE == eWhich) \|\| (USAGE_ALL == eWhich))
103	doUsage("<width> <height> <bpp> <screen>\n", g_pszProgName, "setvideomode");
104	#endif
105	#ifdef VBOX_WITH_GUEST_PROPS
106	if ((GUEST_PROP == eWhich) \|\| (USAGE_ALL == eWhich))
107	{
108	doUsage("get <property> [-verbose]\n", g_pszProgName, "guestproperty");
109	doUsage("set <property> [<value> [-flags <flags>]]\n", g_pszProgName, "guestproperty");
110	doUsage("enumerate [-patterns <patterns>]\n", g_pszProgName, "guestproperty");
111	}
112	#endif
113	}
114	/** @} */
115
116	/**
117	* Displays an error message.
118	*
119	* @param pszFormat The message text.
120	* @param ... Format arguments.
121	*/
122	static void VBoxControlError(const char *pszFormat, ...)
123	{
124	// RTStrmPrintf(g_pStdErr, "%s: error: ", g_pszProgName);
125
126	va_list va;
127	va_start(va, pszFormat);
128	RTStrmPrintfV(g_pStdErr, pszFormat, va);
129	va_end(va);
130	}
131
132	#ifdef RT_OS_WINDOWS
133
134	LONG (WINAPI * gpfnChangeDisplaySettingsEx)(LPCTSTR lpszDeviceName, LPDEVMODE lpDevMode, HWND hwnd, DWORD dwflags, LPVOID lParam);
135
136	static unsigned nextAdjacentRectXP (RECTL *paRects, unsigned nRects, unsigned iRect)
137	{
138	unsigned i;
139	for (i = 0; i < nRects; i++)
140	{
141	if (paRects[iRect].right == paRects[i].left)
142	{
143	return i;
144	}
145	}
146	return ~0;
147	}
148
149	static unsigned nextAdjacentRectXN (RECTL *paRects, unsigned nRects, unsigned iRect)
150	{
151	unsigned i;
152	for (i = 0; i < nRects; i++)
153	{
154	if (paRects[iRect].left == paRects[i].right)
155	{
156	return i;
157	}
158	}
159	return ~0;
160	}
161
162	static unsigned nextAdjacentRectYP (RECTL *paRects, unsigned nRects, unsigned iRect)
163	{
164	unsigned i;
165	for (i = 0; i < nRects; i++)
166	{
167	if (paRects[iRect].bottom == paRects[i].top)
168	{
169	return i;
170	}
171	}
172	return ~0;
173	}
174
175	unsigned nextAdjacentRectYN (RECTL *paRects, unsigned nRects, unsigned iRect)
176	{
177	unsigned i;
178	for (i = 0; i < nRects; i++)
179	{
180	if (paRects[iRect].top == paRects[i].bottom)
181	{
182	return i;
183	}
184	}
185	return ~0;
186	}
187
188	void resizeRect(RECTL *paRects, unsigned nRects, unsigned iPrimary, unsigned iResized, int NewWidth, int NewHeight)
189	{
190	RECTL paNewRects = (RECTL )alloca (sizeof (RECTL) * nRects);
191	memcpy (paNewRects, paRects, sizeof (RECTL) * nRects);
192	paNewRects[iResized].right += NewWidth - (paNewRects[iResized].right - paNewRects[iResized].left);
193	paNewRects[iResized].bottom += NewHeight - (paNewRects[iResized].bottom - paNewRects[iResized].top);
194
195	/* Verify all pairs of originally adjacent rectangles for all 4 directions.
196	* If the pair has a "good" delta (that is the first rectangle intersects the second)
197	* at a direction and the second rectangle is not primary one (which can not be moved),
198	* move the second rectangle to make it adjacent to the first one.
199	*/
200
201	/* X positive. */
202	unsigned iRect;
203	for (iRect = 0; iRect < nRects; iRect++)
204	{
205	/* Find the next adjacent original rect in x positive direction. */
206	unsigned iNextRect = nextAdjacentRectXP (paRects, nRects, iRect);
207	Log(("next %d -> %d\n", iRect, iNextRect));
208
209	if (iNextRect == ~0 \|\| iNextRect == iPrimary)
210	{
211	continue;
212	}
213
214	/* Check whether there is an X intesection between these adjacent rects in the new rectangles
215	* and fix the intersection if delta is "good".
216	*/
217	int delta = paNewRects[iRect].right - paNewRects[iNextRect].left;
218
219	if (delta > 0)
220	{
221	Log(("XP intersection right %d left %d, diff %d\n",
222	paNewRects[iRect].right, paNewRects[iNextRect].left,
223	delta));
224
225	paNewRects[iNextRect].left += delta;
226	paNewRects[iNextRect].right += delta;
227	}
228	}
229
230	/* X negative. */
231	for (iRect = 0; iRect < nRects; iRect++)
232	{
233	/* Find the next adjacent original rect in x negative direction. */
234	unsigned iNextRect = nextAdjacentRectXN (paRects, nRects, iRect);
235	Log(("next %d -> %d\n", iRect, iNextRect));
236
237	if (iNextRect == ~0 \|\| iNextRect == iPrimary)
238	{
239	continue;
240	}
241
242	/* Check whether there is an X intesection between these adjacent rects in the new rectangles
243	* and fix the intersection if delta is "good".
244	*/
245	int delta = paNewRects[iRect].left - paNewRects[iNextRect].right;
246
247	if (delta < 0)
248	{
249	Log(("XN intersection left %d right %d, diff %d\n",
250	paNewRects[iRect].left, paNewRects[iNextRect].right,
251	delta));
252
253	paNewRects[iNextRect].left += delta;
254	paNewRects[iNextRect].right += delta;
255	}
256	}
257
258	/* Y positive (in the computer sence, top->down). */
259	for (iRect = 0; iRect < nRects; iRect++)
260	{
261	/* Find the next adjacent original rect in y positive direction. */
262	unsigned iNextRect = nextAdjacentRectYP (paRects, nRects, iRect);
263	Log(("next %d -> %d\n", iRect, iNextRect));
264
265	if (iNextRect == ~0 \|\| iNextRect == iPrimary)
266	{
267	continue;
268	}
269
270	/* Check whether there is an Y intesection between these adjacent rects in the new rectangles
271	* and fix the intersection if delta is "good".
272	*/
273	int delta = paNewRects[iRect].bottom - paNewRects[iNextRect].top;
274
275	if (delta > 0)
276	{
277	Log(("YP intersection bottom %d top %d, diff %d\n",
278	paNewRects[iRect].bottom, paNewRects[iNextRect].top,
279	delta));
280
281	paNewRects[iNextRect].top += delta;
282	paNewRects[iNextRect].bottom += delta;
283	}
284	}
285
286	/* Y negative (in the computer sence, down->top). */
287	for (iRect = 0; iRect < nRects; iRect++)
288	{
289	/* Find the next adjacent original rect in x negative direction. */
290	unsigned iNextRect = nextAdjacentRectYN (paRects, nRects, iRect);
291	Log(("next %d -> %d\n", iRect, iNextRect));
292
293	if (iNextRect == ~0 \|\| iNextRect == iPrimary)
294	{
295	continue;
296	}
297
298	/* Check whether there is an Y intesection between these adjacent rects in the new rectangles
299	* and fix the intersection if delta is "good".
300	*/
301	int delta = paNewRects[iRect].top - paNewRects[iNextRect].bottom;
302
303	if (delta < 0)
304	{
305	Log(("YN intersection top %d bottom %d, diff %d\n",
306	paNewRects[iRect].top, paNewRects[iNextRect].bottom,
307	delta));
308
309	paNewRects[iNextRect].top += delta;
310	paNewRects[iNextRect].bottom += delta;
311	}
312	}
313
314	memcpy (paRects, paNewRects, sizeof (RECTL) * nRects);
315	return;
316	}
317
318	/* Returns TRUE to try again. */
319	static BOOL ResizeDisplayDevice(ULONG Id, DWORD Width, DWORD Height, DWORD BitsPerPixel)
320	{
321	BOOL fModeReset = (Width == 0 && Height == 0 && BitsPerPixel == 0);
322
323	DISPLAY_DEVICE DisplayDevice;
324
325	ZeroMemory(&DisplayDevice, sizeof(DisplayDevice));
326	DisplayDevice.cb = sizeof(DisplayDevice);
327
328	/* Find out how many display devices the system has */
329	DWORD NumDevices = 0;
330	DWORD i = 0;
331	while (EnumDisplayDevices (NULL, i, &DisplayDevice, 0))
332	{
333	Log(("[%d] %s\n", i, DisplayDevice.DeviceName));
334
335	if (DisplayDevice.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE)
336	{
337	Log(("Found primary device. err %d\n", GetLastError ()));
338	NumDevices++;
339	}
340	else if (!(DisplayDevice.StateFlags & DISPLAY_DEVICE_MIRRORING_DRIVER))
341	{
342
343	Log(("Found secondary device. err %d\n", GetLastError ()));
344	NumDevices++;
345	}
346
347	ZeroMemory(&DisplayDevice, sizeof(DisplayDevice));
348	DisplayDevice.cb = sizeof(DisplayDevice);
349	i++;
350	}
351
352	Log(("Found total %d devices. err %d\n", NumDevices, GetLastError ()));
353
354	if (NumDevices == 0 \|\| Id >= NumDevices)
355	{
356	Log(("Requested identifier %d is invalid. err %d\n", Id, GetLastError ()));
357	return FALSE;
358	}
359
360	DISPLAY_DEVICE paDisplayDevices = (DISPLAY_DEVICE )alloca (sizeof (DISPLAY_DEVICE) * NumDevices);
361	DEVMODE paDeviceModes = (DEVMODE )alloca (sizeof (DEVMODE) * NumDevices);
362	RECTL paRects = (RECTL )alloca (sizeof (RECTL) * NumDevices);
363
364	/* Fetch information about current devices and modes. */
365	DWORD DevNum = 0;
366	DWORD DevPrimaryNum = 0;
367
368	ZeroMemory(&DisplayDevice, sizeof(DISPLAY_DEVICE));
369	DisplayDevice.cb = sizeof(DISPLAY_DEVICE);
370
371	i = 0;
372	while (EnumDisplayDevices (NULL, i, &DisplayDevice, 0))
373	{
374	Log(("[%d(%d)] %s\n", i, DevNum, DisplayDevice.DeviceName));
375
376	BOOL bFetchDevice = FALSE;
377
378	if (DisplayDevice.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE)
379	{
380	Log(("Found primary device. err %d\n", GetLastError ()));
381	DevPrimaryNum = DevNum;
382	bFetchDevice = TRUE;
383	}
384	else if (!(DisplayDevice.StateFlags & DISPLAY_DEVICE_MIRRORING_DRIVER))
385	{
386
387	Log(("Found secondary device. err %d\n", GetLastError ()));
388	bFetchDevice = TRUE;
389	}
390
391	if (bFetchDevice)
392	{
393	if (DevNum >= NumDevices)
394	{
395	Log(("%d >= %d\n", NumDevices, DevNum));
396	return FALSE;
397	}
398
399	paDisplayDevices[DevNum] = DisplayDevice;
400
401	ZeroMemory(&paDeviceModes[DevNum], sizeof(DEVMODE));
402	paDeviceModes[DevNum].dmSize = sizeof(DEVMODE);
403	if (!EnumDisplaySettings((LPSTR)DisplayDevice.DeviceName,
404	ENUM_REGISTRY_SETTINGS, &paDeviceModes[DevNum]))
405	{
406	Log(("EnumDisplaySettings err %d\n", GetLastError ()));
407	return FALSE;
408	}
409
410	Log(("%dx%d at %d,%d\n",
411	paDeviceModes[DevNum].dmPelsWidth,
412	paDeviceModes[DevNum].dmPelsHeight,
413	paDeviceModes[DevNum].dmPosition.x,
414	paDeviceModes[DevNum].dmPosition.y));
415
416	paRects[DevNum].left = paDeviceModes[DevNum].dmPosition.x;
417	paRects[DevNum].top = paDeviceModes[DevNum].dmPosition.y;
418	paRects[DevNum].right = paDeviceModes[DevNum].dmPosition.x + paDeviceModes[DevNum].dmPelsWidth;
419	paRects[DevNum].bottom = paDeviceModes[DevNum].dmPosition.y + paDeviceModes[DevNum].dmPelsHeight;
420	DevNum++;
421	}
422
423	ZeroMemory(&DisplayDevice, sizeof(DISPLAY_DEVICE));
424	DisplayDevice.cb = sizeof(DISPLAY_DEVICE);
425	i++;
426	}
427
428	if (Width == 0)
429	{
430	Width = paRects[Id].right - paRects[Id].left;
431	}
432
433	if (Height == 0)
434	{
435	Height = paRects[Id].bottom - paRects[Id].top;
436	}
437
438	/* Check whether a mode reset or a change is requested. */
439	if ( !fModeReset
440	&& paRects[Id].right - paRects[Id].left == Width
441	&& paRects[Id].bottom - paRects[Id].top == Height
442	&& paDeviceModes[Id].dmBitsPerPel == BitsPerPixel)
443	{
444	Log(("VBoxDisplayThread : already at desired resolution.\n"));
445	return FALSE;
446	}
447
448	resizeRect(paRects, NumDevices, DevPrimaryNum, Id, Width, Height);
449	#ifdef Log
450	for (i = 0; i < NumDevices; i++)
451	{
452	Log(("[%d]: %d,%d %dx%d\n",
453	i, paRects[i].left, paRects[i].top,
454	paRects[i].right - paRects[i].left,
455	paRects[i].bottom - paRects[i].top));
456	}
457	#endif /* Log */
458
459	/* Without this, Windows will not ask the miniport for its
460	* mode table but uses an internal cache instead.
461	*/
462	DEVMODE tempDevMode;
463	ZeroMemory (&tempDevMode, sizeof (tempDevMode));
464	tempDevMode.dmSize = sizeof(DEVMODE);
465	EnumDisplaySettings(NULL, 0xffffff, &tempDevMode);
466
467	/* Assign the new rectangles to displays. */
468	for (i = 0; i < NumDevices; i++)
469	{
470	paDeviceModes[i].dmPosition.x = paRects[i].left;
471	paDeviceModes[i].dmPosition.y = paRects[i].top;
472	paDeviceModes[i].dmPelsWidth = paRects[i].right - paRects[i].left;
473	paDeviceModes[i].dmPelsHeight = paRects[i].bottom - paRects[i].top;
474
475	paDeviceModes[i].dmFields = DM_POSITION \| DM_PELSHEIGHT \| DM_PELSWIDTH;
476
477	if ( i == Id
478	&& BitsPerPixel != 0)
479	{
480	paDeviceModes[i].dmFields \|= DM_BITSPERPEL;
481	paDeviceModes[i].dmBitsPerPel = BitsPerPixel;
482	}
483	Log(("calling pfnChangeDisplaySettingsEx %x\n", gpfnChangeDisplaySettingsEx));
484	gpfnChangeDisplaySettingsEx((LPSTR)paDisplayDevices[i].DeviceName,
485	&paDeviceModes[i], NULL, CDS_NORESET \| CDS_UPDATEREGISTRY, NULL);
486	Log(("ChangeDisplaySettings position err %d\n", GetLastError ()));
487	}
488
489	/* A second call to ChangeDisplaySettings updates the monitor. */
490	LONG status = ChangeDisplaySettings(NULL, 0);
491	Log(("ChangeDisplaySettings update status %d\n", status));
492	if (status == DISP_CHANGE_SUCCESSFUL \|\| status == DISP_CHANGE_BADMODE)
493	{
494	/* Successfully set new video mode or our driver can not set the requested mode. Stop trying. */
495	return FALSE;
496	}
497
498	/* Retry the request. */
499	return TRUE;
500	}
501
502	int handleSetVideoMode(int argc, char *argv[])
503	{
504	if (argc != 3 && argc != 4)
505	{
506	usage(SET_VIDEO_MODE);
507	return 1;
508	}
509
510	DWORD xres = atoi(argv[0]);
511	DWORD yres = atoi(argv[1]);
512	DWORD bpp = atoi(argv[2]);
513	DWORD scr = 0;
514
515	if (argc == 4)
516	{
517	scr = atoi(argv[3]);
518	}
519
520	HMODULE hUser = GetModuleHandle("USER32");
521
522	if (hUser)
523	{
524	(uintptr_t )&gpfnChangeDisplaySettingsEx = (uintptr_t)GetProcAddress(hUser, "ChangeDisplaySettingsExA");
525	Log(("VBoxService: pChangeDisplaySettingsEx = %p\n", gpfnChangeDisplaySettingsEx));
526
527	if (gpfnChangeDisplaySettingsEx)
528	{
529	/* The screen index is 0 based in the ResizeDisplayDevice call. */
530	scr = scr > 0? scr - 1: 0;
531
532	/* Horizontal resolution must be a multiple of 8, round down. */
533	xres &= ~0x7;
534
535	ResizeDisplayDevice(scr, xres, yres, bpp);
536	}
537	}
538	return 0;
539	}
540
541	HKEY getVideoKey(bool writable)
542	{
543	HKEY hkeyDeviceMap = 0;
544	HKEY hkeyVideo = 0;
545	LONG status;
546
547	status = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "HARDWARE\\DEVICEMAP\\VIDEO", 0, KEY_READ, &hkeyDeviceMap);
548	if ((status != ERROR_SUCCESS) \|\| !hkeyDeviceMap)
549	{
550	VBoxControlError("Error opening video device map registry key!\n");
551	return 0;
552	}
553	char szVideoLocation[256];
554	DWORD dwKeyType;
555	szVideoLocation[0] = 0;
556	DWORD len = sizeof(szVideoLocation);
557	status = RegQueryValueExA(hkeyDeviceMap, "\\Device\\Video0", NULL, &dwKeyType, (LPBYTE)szVideoLocation, &len);
558	/*
559	* This value will start with a weird value: \REGISTRY\Machine
560	* Make sure this is true.
561	*/
562	if ( (status == ERROR_SUCCESS)
563	&& (dwKeyType == REG_SZ)
564	&& (_strnicmp(szVideoLocation, "\\REGISTRY\\Machine", 17) == 0))
565	{
566	/* open that branch */
567	status = RegOpenKeyExA(HKEY_LOCAL_MACHINE, &szVideoLocation[18], 0, KEY_READ \| (writable ? KEY_WRITE : 0), &hkeyVideo);
568	}
569	else
570	{
571	VBoxControlError("Error opening registry key '%s'\n", &szVideoLocation[18]);
572	}
573	RegCloseKey(hkeyDeviceMap);
574	return hkeyVideo;
575	}
576
577	int handleGetVideoAcceleration(int argc, char *argv[])
578	{
579	ULONG status;
580	HKEY hkeyVideo = getVideoKey(false);
581
582	if (hkeyVideo)
583	{
584	/* query the actual value */
585	DWORD fAcceleration = 1;
586	DWORD len = sizeof(fAcceleration);
587	DWORD dwKeyType;
588	status = RegQueryValueExA(hkeyVideo, "EnableVideoAccel", NULL, &dwKeyType, (LPBYTE)&fAcceleration, &len);
589	if (status != ERROR_SUCCESS)
590	RTPrintf("Video acceleration: default\n");
591	else
592	RTPrintf("Video acceleration: %s\n", fAcceleration ? "on" : "off");
593	RegCloseKey(hkeyVideo);
594	}
595	return 0;
596	}
597
598	int handleSetVideoAcceleration(int argc, char *argv[])
599	{
600	ULONG status;
601	HKEY hkeyVideo;
602
603	/* must have exactly one argument: the new offset */
604	if ( (argc != 1)
605	\|\| ( strcmp(argv[0], "on")
606	&& strcmp(argv[0], "off")))
607	{
608	usage(SET_VIDEO_ACCEL);
609	return 1;
610	}
611
612	hkeyVideo = getVideoKey(true);
613
614	if (hkeyVideo)
615	{
616	int fAccel = 0;
617	if (!strcmp(argv[0], "on"))
618	fAccel = 1;
619	/* set a new value */
620	status = RegSetValueExA(hkeyVideo, "EnableVideoAccel", 0, REG_DWORD, (LPBYTE)&fAccel, sizeof(fAccel));
621	if (status != ERROR_SUCCESS)
622	{
623	VBoxControlError("Error %d writing video acceleration status!\n", status);
624	}
625	RegCloseKey(hkeyVideo);
626	}
627	return 0;
628	}
629
630	#define MAX_CUSTOM_MODES 128
631
632	/* the table of custom modes */
633	struct
634	{
635	DWORD xres;
636	DWORD yres;
637	DWORD bpp;
638	} customModes[MAX_CUSTOM_MODES] = {0};
639
640	void getCustomModes(HKEY hkeyVideo)
641	{
642	ULONG status;
643	int curMode = 0;
644
645	/* null out the table */
646	memset(customModes, 0, sizeof(customModes));
647
648	do
649	{
650	char valueName[20];
651	DWORD xres, yres, bpp = 0;
652	DWORD dwType;
653	DWORD dwLen = sizeof(DWORD);
654
655	RTStrPrintf(valueName, sizeof(valueName), "CustomMode%dWidth", curMode);
656	status = RegQueryValueExA(hkeyVideo, valueName, NULL, &dwType, (LPBYTE)&xres, &dwLen);
657	if (status != ERROR_SUCCESS)
658	break;
659	RTStrPrintf(valueName, sizeof(valueName), "CustomMode%dHeight", curMode);
660	status = RegQueryValueExA(hkeyVideo, valueName, NULL, &dwType, (LPBYTE)&yres, &dwLen);
661	if (status != ERROR_SUCCESS)
662	break;
663	RTStrPrintf(valueName, sizeof(valueName), "CustomMode%dBPP", curMode);
664	status = RegQueryValueExA(hkeyVideo, valueName, NULL, &dwType, (LPBYTE)&bpp, &dwLen);
665	if (status != ERROR_SUCCESS)
666	break;
667
668	/* check if the mode is OK */
669	if ( (xres > (1 << 16))
670	&& (yres > (1 << 16))
671	&& ( (bpp != 16)
672	\|\| (bpp != 24)
673	\|\| (bpp != 32)))
674	break;
675
676	/* add mode to table */
677	customModes[curMode].xres = xres;
678	customModes[curMode].yres = yres;
679	customModes[curMode].bpp = bpp;
680
681	++curMode;
682
683	if (curMode >= MAX_CUSTOM_MODES)
684	break;
685	} while(1);
686	}
687
688	void writeCustomModes(HKEY hkeyVideo)
689	{
690	ULONG status;
691	int tableIndex = 0;
692	int modeIndex = 0;
693
694	/* first remove all values */
695	for (int i = 0; i < MAX_CUSTOM_MODES; i++)
696	{
697	char valueName[20];
698	RTStrPrintf(valueName, sizeof(valueName), "CustomMode%dWidth", i);
699	RegDeleteValueA(hkeyVideo, valueName);
700	RTStrPrintf(valueName, sizeof(valueName), "CustomMode%dHeight", i);
701	RegDeleteValueA(hkeyVideo, valueName);
702	RTStrPrintf(valueName, sizeof(valueName), "CustomMode%dBPP", i);
703	RegDeleteValueA(hkeyVideo, valueName);
704	}
705
706	do
707	{
708	if (tableIndex >= MAX_CUSTOM_MODES)
709	break;
710
711	/* is the table entry present? */
712	if ( (!customModes[tableIndex].xres)
713	\|\| (!customModes[tableIndex].yres)
714	\|\| (!customModes[tableIndex].bpp))
715	{
716	tableIndex++;
717	continue;
718	}
719
720	RTPrintf("writing mode %d (%dx%dx%d)\n", modeIndex, customModes[tableIndex].xres, customModes[tableIndex].yres, customModes[tableIndex].bpp);
721	char valueName[20];
722	RTStrPrintf(valueName, sizeof(valueName), "CustomMode%dWidth", modeIndex);
723	status = RegSetValueExA(hkeyVideo, valueName, 0, REG_DWORD, (LPBYTE)&customModes[tableIndex].xres,
724	sizeof(customModes[tableIndex].xres));
725	RTStrPrintf(valueName, sizeof(valueName), "CustomMode%dHeight", modeIndex);
726	RegSetValueExA(hkeyVideo, valueName, 0, REG_DWORD, (LPBYTE)&customModes[tableIndex].yres,
727	sizeof(customModes[tableIndex].yres));
728	RTStrPrintf(valueName, sizeof(valueName), "CustomMode%dBPP", modeIndex);
729	RegSetValueExA(hkeyVideo, valueName, 0, REG_DWORD, (LPBYTE)&customModes[tableIndex].bpp,
730	sizeof(customModes[tableIndex].bpp));
731
732	modeIndex++;
733	tableIndex++;
734
735	} while(1);
736
737	}
738
739	int handleListCustomModes(int argc, char *argv[])
740	{
741	if (argc != 0)
742	{
743	usage(LIST_CUST_MODES);
744	return 1;
745	}
746
747	HKEY hkeyVideo = getVideoKey(false);
748
749	if (hkeyVideo)
750	{
751	getCustomModes(hkeyVideo);
752	for (int i = 0; i < (sizeof(customModes) / sizeof(customModes[0])); i++)
753	{
754	if ( !customModes[i].xres
755	\|\| !customModes[i].yres
756	\|\| !customModes[i].bpp)
757	continue;
758
759	RTPrintf("Mode: %d x %d x %d\n",
760	customModes[i].xres, customModes[i].yres, customModes[i].bpp);
761	}
762	RegCloseKey(hkeyVideo);
763	}
764	return 0;
765	}
766
767	int handleAddCustomMode(int argc, char *argv[])
768	{
769	if (argc != 3)
770	{
771	usage(ADD_CUST_MODE);
772	return 1;
773	}
774
775	DWORD xres = atoi(argv[0]);
776	DWORD yres = atoi(argv[1]);
777	DWORD bpp = atoi(argv[2]);
778
779	/** @todo better check including xres mod 8 = 0! */
780	if ( (xres > (1 << 16))
781	&& (yres > (1 << 16))
782	&& ( (bpp != 16)
783	\|\| (bpp != 24)
784	\|\| (bpp != 32)))
785	{
786	VBoxControlError("Error: invalid mode specified!\n");
787	return 1;
788	}
789
790	HKEY hkeyVideo = getVideoKey(true);
791
792	if (hkeyVideo)
793	{
794	int i;
795	int fModeExists = 0;
796	getCustomModes(hkeyVideo);
797	for (i = 0; i < MAX_CUSTOM_MODES; i++)
798	{
799	/* mode exists? */
800	if ( customModes[i].xres == xres
801	&& customModes[i].yres == yres
802	&& customModes[i].bpp == bpp
803	)
804	{
805	fModeExists = 1;
806	}
807	}
808	if (!fModeExists)
809	{
810	for (i = 0; i < MAX_CUSTOM_MODES; i++)
811	{
812	/* item free? */
813	if (!customModes[i].xres)
814	{
815	customModes[i].xres = xres;
816	customModes[i].yres = yres;
817	customModes[i].bpp = bpp;
818	break;
819	}
820	}
821	writeCustomModes(hkeyVideo);
822	}
823	RegCloseKey(hkeyVideo);
824	}
825	return 0;
826	}
827
828	int handleRemoveCustomMode(int argc, char *argv[])
829	{
830	if (argc != 3)
831	{
832	usage(REMOVE_CUST_MODE);
833	return 1;
834	}
835
836	DWORD xres = atoi(argv[0]);
837	DWORD yres = atoi(argv[1]);
838	DWORD bpp = atoi(argv[2]);
839
840	HKEY hkeyVideo = getVideoKey(true);
841
842	if (hkeyVideo)
843	{
844	getCustomModes(hkeyVideo);
845	for (int i = 0; i < MAX_CUSTOM_MODES; i++)
846	{
847	/* correct item? */
848	if ( (customModes[i].xres == xres)
849	&& (customModes[i].yres == yres)
850	&& (customModes[i].bpp == bpp))
851	{
852	RTPrintf("found mode at index %d\n", i);
853	memset(&customModes[i], 0, sizeof(customModes[i]));
854	break;
855	}
856	}
857	writeCustomModes(hkeyVideo);
858	RegCloseKey(hkeyVideo);
859	}
860	}
861
862	#endif /* RT_OS_WINDOWS */
863
864	#ifdef VBOX_WITH_GUEST_PROPS
865	/**
866	* Retrieves a value from the guest property store.
867	* This is accessed through the "VBoxGuestPropSvc" HGCM service.
868	*
869	* @returns 0 on success, 1 on failure
870	* @note see the command line API description for parameters
871	*/
872	int getGuestProperty(int argc, char **argv)
873	{
874	using namespace guestProp;
875
876	bool verbose = false;
877	if ((2 == argc) && (0 == strcmp(argv[1], "-verbose")))
878	verbose = true;
879	else if (argc != 1)
880	{
881	usage(GUEST_PROP);
882	return 1;
883	}
884
885	uint32_t u32ClientId = 0;
886	int rc = VINF_SUCCESS;
887
888	rc = VbglR3GuestPropConnect(&u32ClientId);
889	if (!RT_SUCCESS(rc))
890	VBoxControlError("Failed to connect to the guest property service, error %Rrc\n", rc);
891
892	/*
893	* Here we actually retrieve the value from the host.
894	*/
895	const char *pszName = argv[0];
896	char *pszValue = NULL;
897	uint64_t u64Timestamp = 0;
898	char *pszFlags = NULL;
899	/* The buffer for storing the data and its initial size. We leave a bit
900	* of space here in case the maximum values are raised. */
901	void *pvBuf = NULL;
902	uint32_t cbBuf = MAX_VALUE_LEN + MAX_FLAGS_LEN + 1024;
903	if (RT_SUCCESS(rc))
904	{
905	/* Because there is a race condition between our reading the size of a
906	* property and the guest updating it, we loop a few times here and
907	* hope. Actually this should never go wrong, as we are generous
908	* enough with buffer space. */
909	bool finish = false;
910	for (unsigned i = 0; (i < 10) && !finish; ++i)
911	{
912	void *pvTmpBuf = RTMemRealloc(pvBuf, cbBuf);
913	if (NULL == pvTmpBuf)
914	{
915	rc = VERR_NO_MEMORY;
916	VBoxControlError("Out of memory\n");
917	}
918	else
919	{
920	pvBuf = pvTmpBuf;
921	rc = VbglR3GuestPropRead(u32ClientId, pszName, pvBuf, cbBuf,
922	&pszValue, &u64Timestamp, &pszFlags,
923	&cbBuf);
924	}
925	if (VERR_BUFFER_OVERFLOW == rc)
926	/* Leave a bit of extra space to be safe */
927	cbBuf += 1024;
928	else
929	finish = true;
930	}
931	if (VERR_TOO_MUCH_DATA == rc)
932	VBoxControlError("Temporarily unable to retrieve the property\n");
933	else if (!RT_SUCCESS(rc) && (rc != VERR_NOT_FOUND))
934	VBoxControlError("Failed to retrieve the property value, error %Rrc\n", rc);
935	}
936	/*
937	* And display it on the guest console.
938	*/
939	if (VERR_NOT_FOUND == rc)
940	RTPrintf("No value set!\n");
941	else if (RT_SUCCESS(rc))
942	{
943	RTPrintf("Value: %S\n", pszValue);
944	if (verbose)
945	{
946	RTPrintf("Timestamp: %lld ns\n", u64Timestamp);
947	RTPrintf("Flags: %S\n", pszFlags);
948	}
949	}
950
951	if (u32ClientId != 0)
952	VbglR3GuestPropDisconnect(u32ClientId);
953	RTMemFree(pvBuf);
954	return RT_SUCCESS(rc) ? 0 : 1;
955	}
956
957
958	/**
959	* Writes a value to the guest property store.
960	* This is accessed through the "VBoxGuestPropSvc" HGCM service.
961	*
962	* @returns 0 on success, 1 on failure
963	* @note see the command line API description for parameters
964	*/
965	static int setGuestProperty(int argc, char *argv[])
966	{
967	/*
968	* Check the syntax. We can deduce the correct syntax from the number of
969	* arguments.
970	*/
971	bool usageOK = true;
972	const char *pszName = NULL;
973	const char *pszValue = NULL;
974	const char *pszFlags = NULL;
975	if (2 == argc)
976	{
977	pszValue = argv[1];
978	}
979	else if (3 == argc)
980	{
981	if (strcmp(argv[1], "-flags") != 0)
982	usageOK = false;
983	else
984	{
985	VBoxControlError("You may not specify flags without a value");
986	return 1;
987	}
988	}
989	else if (4 == argc)
990	{
991	pszValue = argv[1];
992	if (strcmp(argv[2], "-flags") != 0)
993	usageOK = false;
994	pszFlags = argv[3];
995	}
996	else if (argc != 1)
997	usageOK = false;
998	if (!usageOK)
999	{
1000	usage(GUEST_PROP);
1001	return 1;
1002	}
1003	/* This is always needed. */
1004	pszName = argv[0];
1005
1006	/*
1007	* Do the actual setting.
1008	*/
1009	uint32_t u32ClientId = 0;
1010	int rc = VINF_SUCCESS;
1011	rc = VbglR3GuestPropConnect(&u32ClientId);
1012	if (!RT_SUCCESS(rc))
1013	VBoxControlError("Failed to connect to the guest property service, error %Rrc\n", rc);
1014	if (RT_SUCCESS(rc))
1015	{
1016	if (pszFlags != NULL)
1017	rc = VbglR3GuestPropWrite(u32ClientId, pszName, pszValue, pszFlags);
1018	else
1019	rc = VbglR3GuestPropWriteValue(u32ClientId, pszName, pszValue);
1020	if (!RT_SUCCESS(rc))
1021	VBoxControlError("Failed to store the property value, error %Rrc\n", rc);
1022	}
1023
1024	if (u32ClientId != 0)
1025	VbglR3GuestPropDisconnect(u32ClientId);
1026	return RT_SUCCESS(rc) ? 0 : 1;
1027	}
1028
1029
1030	/**
1031	* Enumerates the properties in the guest property store.
1032	* This is accessed through the "VBoxGuestPropSvc" HGCM service.
1033	*
1034	* @returns 0 on success, 1 on failure
1035	* @note see the command line API description for parameters
1036	*/
1037	static int enumGuestProperty(int argc, char *argv[])
1038	{
1039	/*
1040	* Check the syntax. We can deduce the correct syntax from the number of
1041	* arguments.
1042	*/
1043	const char *paszPatterns = NULL;
1044	if ((argc > 1) && (0 == strcmp(argv[0], "-patterns")))
1045	paszPatterns = argv[1];
1046	else if (argc != 0)
1047	{
1048	usage(GUEST_PROP);
1049	return 1;
1050	}
1051
1052	/*
1053	* Do the actual enumeration.
1054	*/
1055	uint32_t u32ClientId = 0;
1056	PVBGLR3GUESTPROPENUM pHandle = NULL;
1057	RTMemAutoPtr<VBGLR3GUESTPROPENUM, VbglR3GuestPropEnumFree> Handle;
1058	char pszName = NULL, pszValue = NULL, *pszFlags = NULL;
1059	uint64_t u64Timestamp = 0;
1060	int rc = VINF_SUCCESS;
1061	rc = VbglR3GuestPropConnect(&u32ClientId);
1062	if (!RT_SUCCESS(rc))
1063	VBoxControlError("Failed to connect to the guest property service, error %Rrc\n", rc);
1064	if (RT_SUCCESS(rc))
1065	{
1066	char **ppaszPatterns = argc > 1 ? argv + 1 : NULL;
1067	int cPatterns = argc > 1 ? argc - 1 : 0;
1068	rc = VbglR3GuestPropEnum(u32ClientId, ppaszPatterns, cPatterns, &pHandle,
1069	&pszName, &pszValue, &u64Timestamp, &pszFlags);
1070	if (RT_SUCCESS(rc))
1071	{
1072	Handle = pHandle;
1073	}
1074	else if (VERR_NOT_FOUND == rc)
1075	RTPrintf("No properties found.\n");
1076	else
1077	VBoxControlError("Failed to enumerate the guest properties, error %Rrc.\n", rc);
1078	}
1079	while (RT_SUCCESS(rc) && (pszName != NULL))
1080	{
1081	RTPrintf("Name: %s, value: %s, timestamp: %lld, flags: %s\n",
1082	pszName, pszValue, u64Timestamp, pszFlags);
1083	rc = VbglR3GuestPropEnumNext(Handle.get(), &pszName, &pszValue, &u64Timestamp, &pszFlags);
1084	if (!RT_SUCCESS(rc))
1085	VBoxControlError("Error while enumerating guest propertied: %Rrc\n", rc);
1086	}
1087
1088	if (u32ClientId != 0)
1089	VbglR3GuestPropDisconnect(u32ClientId);
1090	return RT_SUCCESS(rc) ? 0 : 1;
1091	}
1092
1093
1094	/**
1095	* Access the guest property store through the "VBoxGuestPropSvc" HGCM
1096	* service.
1097	*
1098	* @returns 0 on success, 1 on failure
1099	* @note see the command line API description for parameters
1100	*/
1101	static int handleGuestProperty(int argc, char *argv[])
1102	{
1103	if (0 == argc)
1104	{
1105	usage(GUEST_PROP);
1106	return 1;
1107	}
1108	if (0 == strcmp(argv[0], "get"))
1109	return getGuestProperty(argc - 1, argv + 1);
1110	else if (0 == strcmp(argv[0], "set"))
1111	return setGuestProperty(argc - 1, argv + 1);
1112	else if (0 == strcmp(argv[0], "enumerate"))
1113	return enumGuestProperty(argc - 1, argv + 1);
1114	/* else */
1115	usage(GUEST_PROP);
1116	return 1;
1117	}
1118
1119	#endif
1120
1121	/** command handler type */
1122	typedef DECLCALLBACK(int) FNHANDLER(int argc, char *argv[]);
1123	typedef FNHANDLER *PFNHANDLER;
1124
1125	/** The table of all registered command handlers. */
1126	struct COMMANDHANDLER
1127	{
1128	const char *command;
1129	PFNHANDLER handler;
1130	} g_commandHandlers[] =
1131	{
1132	#ifdef RT_OS_WINDOWS
1133	{ "getvideoacceleration", handleGetVideoAcceleration },
1134	{ "setvideoacceleration", handleSetVideoAcceleration },
1135	{ "listcustommodes", handleListCustomModes },
1136	{ "addcustommode", handleAddCustomMode },
1137	{ "removecustommode", handleRemoveCustomMode },
1138	{ "setvideomode", handleSetVideoMode },
1139	#endif
1140	#ifdef VBOX_WITH_GUEST_PROPS
1141	{ "guestproperty", handleGuestProperty },
1142	#endif
1143	{ NULL, NULL } /* terminator */
1144	};
1145
1146	/** Main function */
1147	int main(int argc, char **argv)
1148	{
1149	/** The application's global return code */
1150	int rc = 0;
1151	/** An IPRT return code for local use */
1152	int rrc = VINF_SUCCESS;
1153	/** The index of the command line argument we are currently processing */
1154	int iArg = 1;
1155	/** Should we show the logo text? */
1156	bool showlogo = true;
1157	/** Should we print the usage after the logo? For the -help switch. */
1158	bool dohelp = false;
1159	/** Will we be executing a command or just printing information? */
1160	bool onlyinfo = false;
1161
1162	/*
1163	* Start by handling command line switches
1164	*/
1165
1166	/** Are we finished with handling switches? */
1167	bool done = false;
1168	while (!done && (iArg < argc))
1169	{
1170	if ( (0 == strcmp(argv[iArg], "-v"))
1171	\|\| (0 == strcmp(argv[iArg], "--version"))
1172	\|\| (0 == strcmp(argv[iArg], "-version"))
1173	\|\| (0 == strcmp(argv[iArg], "getversion"))
1174	)
1175	{
1176	/* Print version number, and do nothing else. */
1177	RTPrintf("%sr%d\n", VBOX_VERSION_STRING, VBoxSVNRev ());
1178	onlyinfo = true;
1179	showlogo = false;
1180	done = true;
1181	}
1182	else if (0 == strcmp(argv[iArg], "-nologo"))
1183	showlogo = false;
1184	else if (0 == strcmp(argv[iArg], "-help"))
1185	{
1186	onlyinfo = true;
1187	dohelp = true;
1188	done = true;
1189	}
1190	else
1191	/* We have found an argument which isn't a switch. Exit to the
1192	* command processing bit. */
1193	done = true;
1194	if (!done)
1195	++iArg;
1196	}
1197
1198	/*
1199	* Find the application name, show our logo if the user hasn't suppressed it,
1200	* and show the usage if the user asked us to
1201	*/
1202
1203	g_pszProgName = RTPathFilename(argv[0]);
1204	if (showlogo)
1205	RTPrintf("VirtualBox Guest Additions Command Line Management Interface Version "
1206	VBOX_VERSION_STRING "\n"
1207	"(C) 2008 Sun Microsystems, Inc.\n"
1208	"All rights reserved\n\n");
1209	if (dohelp)
1210	usage();
1211
1212	/*
1213	* Do global initialisation for the programme if we will be handling a command
1214	*/
1215
1216	if (!onlyinfo)
1217	{
1218	rrc = RTR3Init(false, 0);
1219	if (!RT_SUCCESS(rrc))
1220	{
1221	VBoxControlError("Failed to initialise the VirtualBox runtime - error %Rrc\n", rrc);
1222	rc = 1;
1223	}
1224	if (0 == rc)
1225	{
1226	if (!RT_SUCCESS(VbglR3Init()))
1227	{
1228	VBoxControlError("Could not contact the host system. Make sure that you are running this\n"
1229	"application inside a VirtualBox guest system, and that you have sufficient\n"
1230	"user permissions.\n");
1231	rc = 1;
1232	}
1233	}
1234	}
1235
1236	/*
1237	* Now look for an actual command in the argument list and handle it.
1238	*/
1239
1240	if (!onlyinfo && (0 == rc))
1241	{
1242	/*
1243	* The input is in the guest OS'es codepage (NT guarantees ACP).
1244	* For VBox we use UTF-8. For simplicity, just convert the argv[] array
1245	* here.
1246	*/
1247	for (int i = iArg; i < argc; i++)
1248	{
1249	char *converted;
1250	RTStrCurrentCPToUtf8(&converted, argv[i]);
1251	argv[i] = converted;
1252	}
1253
1254	if (argc > iArg)
1255	{
1256	/** Is next parameter a known command? */
1257	bool found = false;
1258	/** And if so, what is its position in the table? */
1259	unsigned index = 0;
1260	while ( index < RT_ELEMENTS(g_commandHandlers)
1261	&& !found
1262	&& (g_commandHandlers[index].command != NULL))
1263	{
1264	if (0 == strcmp(argv[iArg], g_commandHandlers[index].command))
1265	found = true;
1266	else
1267	++index;
1268	}
1269	if (found)
1270	rc = g_commandHandlers[index].handler(argc - iArg - 1, argv + iArg + 1);
1271	else
1272	{
1273	rc = 1;
1274	usage();
1275	}
1276	}
1277	else
1278	{
1279	/* The user didn't specify a command. */
1280	rc = 1;
1281	usage();
1282	}
1283
1284	/*
1285	* Free converted argument vector
1286	*/
1287	for (int i = iArg; i < argc; i++)
1288	RTStrFree(argv[i]);
1289
1290	}
1291
1292	/*
1293	* And exit, returning the status
1294	*/
1295
1296	return rc;
1297	}

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

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

Download in other formats: