service.cpp@ 9917

Last change on this file since 9917 was 9917, checked in by vboxsync, 17 years ago
Corrected hungarian spelling and added a todo.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 17.8 KB

Line
1	/** @file
2	*
3	* Shared Information Services:
4	* Host service entry points.
5	*/
6
7	/*
8	* Copyright (C) 2008 Sun Microsystems, Inc.
9	*
10	* This file is part of VirtualBox Open Source Edition (OSE), as
11	* available from http://www.virtualbox.org. This file is free software;
12	* you can redistribute it and/or modify it under the terms of the GNU
13	* General Public License (GPL) as published by the Free Software
14	* Foundation, in version 2 as it comes in the "COPYING" file of the
15	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
16	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
17	*
18	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
19	* Clara, CA 95054 USA or visit http://www.sun.com if you need
20	* additional information or have any questions.
21	*/
22
23	/**
24	* An HGCM service for passing requests which do not need any persistant state
25	* to handle. We currently only support two types of request - set guest
26	* configuration key (SET_CONFIG_KEY and SET_CONFIG_KEY_HOST) and get
27	* configuration key (GET_CONFIG_KEY and GET_CONFIG_KEY_HOST). These may be
28	* used to read and to write configuration information which is available to
29	* both guest and host. This configuration information is stored in a CFGM
30	* node using the CFGM APIs. It is the responsibility of whoever creates the
31	* service to create this node and to tell the service about it using the
32	* SET_CFGM_NODE host call. It is also the responsibility of the service
33	* creator to save this information to disk and to retrieve it when needed.
34	* Since the CFGM APIs are single threaded, the creator must also ensure that
35	* no-one else accesses the configuration node while the service is running.
36	*
37	* If this service is extended to deal with new requests it would probably be a
38	* good idea to split it up into several files.
39	*/
40
41	#define LOG_GROUP LOG_GROUP_HGCM
42
43	/*******************************************************************************
44	* Header Files *
45	*******************************************************************************/
46	#include <VBox/HostServices/VBoxInfoSvc.h>
47
48	#include <memory> /* for auto_ptr */
49
50	#include <iprt/err.h>
51	#include <iprt/assert.h>
52	#include <VBox/log.h>
53
54	#include <VBox/cfgm.h>
55
56	#include "noncopyable.h"
57
58	/*******************************************************************************
59	* Internal functions *
60	*******************************************************************************/
61	/** Extract a pointer value from an HGCM parameter structure */
62	static int VBoxHGCMParmPtrGet (VBOXHGCMSVCPARM pParm, void ppv, uint32_t pcb)
63	{
64	if (pParm->type == VBOX_HGCM_SVC_PARM_PTR)
65	{
66	*ppv = pParm->u.pointer.addr;
67	*pcb = pParm->u.pointer.size;
68	return VINF_SUCCESS;
69	}
70
71	return VERR_INVALID_PARAMETER;
72	}
73
74	/** Set a uint32_t value to an HGCM parameter structure */
75	static void VBoxHGCMParmUInt32Set (VBOXHGCMSVCPARM *pParm, uint32_t u32)
76	{
77	pParm->type = VBOX_HGCM_SVC_PARM_32BIT;
78	pParm->u.uint32 = u32;
79	}
80
81
82	namespace svcInfo {
83
84	/**
85	* Class containing the shared information service functionality.
86	*/
87	class Service : public noncopyable
88	{
89	private:
90	/** Type definition for use in callback functions */
91	typedef Service SELF;
92	/** HGCM helper functions. */
93	PVBOXHGCMSVCHELPERS mpHelpers;
94	/** Pointer to our configuration node. */
95	PCFGMNODE mpNode;
96
97	public:
98	explicit Service(PVBOXHGCMSVCHELPERS pHelpers)
99	: mpHelpers(pHelpers), mpNode(NULL) {}
100
101	/**
102	* @copydoc VBOXHGCMSVCHELPERS::pfnUnload
103	* Simply deletes the service object
104	*/
105	static DECLCALLBACK(int) svcUnload (void *pvService)
106	{
107	AssertLogRelReturn(VALID_PTR(pvService), VERR_INVALID_PARAMETER);
108	SELF pSelf = reinterpret_cast<SELF >(pvService);
109	delete pSelf;
110	return VINF_SUCCESS;
111	}
112
113	/**
114	* @copydoc VBOXHGCMSVCHELPERS::pfnConnect
115	* Stub implementation of pfnConnect and pfnDisconnect.
116	*/
117	static DECLCALLBACK(int) svcConnectDisconnect (void * /* pvService */,
118	uint32_t /* u32ClientID */,
119	void * /* pvClient */)
120	{
121	return VINF_SUCCESS;
122	}
123
124	/**
125	* @copydoc VBOXHGCMSVCHELPERS::pfnCall
126	* Wraps to the call member function
127	*/
128	static DECLCALLBACK(void) svcCall (void * pvService,
129	VBOXHGCMCALLHANDLE callHandle,
130	uint32_t u32ClientID,
131	void *pvClient,
132	uint32_t u32Function,
133	uint32_t cParms,
134	VBOXHGCMSVCPARM paParms[])
135	{
136	AssertLogRelReturnVoid(VALID_PTR(pvService));
137	SELF pSelf = reinterpret_cast<SELF >(pvService);
138	pSelf->call(callHandle, u32ClientID, pvClient, u32Function, cParms, paParms);
139	}
140
141	/**
142	* @copydoc VBOXHGCMSVCHELPERS::pfnHostCall
143	* Wraps to the hostCall member function
144	*/
145	static DECLCALLBACK(int) svcHostCall (void *pvService,
146	uint32_t u32Function,
147	uint32_t cParms,
148	VBOXHGCMSVCPARM paParms[])
149	{
150	AssertLogRelReturn(VALID_PTR(pvService), VERR_INVALID_PARAMETER);
151	SELF pSelf = reinterpret_cast<SELF >(pvService);
152	return pSelf->hostCall(u32Function, cParms, paParms);
153	}
154	private:
155	int getKey(uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
156	int validateGetKey(const char pszKey, uint32_t cbKey, char pszValue, uint32_t cbValue);
157	int setKey(uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
158	int validateSetKey(const char pszKey, uint32_t cbKey, char pszValue, uint32_t cbValue);
159	void call (VBOXHGCMCALLHANDLE callHandle, uint32_t u32ClientID,
160	void *pvClient, uint32_t eFunction, uint32_t cParms,
161	VBOXHGCMSVCPARM paParms[]);
162	int hostCall (uint32_t eFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
163	};
164
165
166	/**
167	* Retrieve a value from the guest registry by key, checking the validity
168	* of the arguments passed.
169	*
170	* @returns iprt status value
171	* @param cParms the number of HGCM parameters supplied
172	* @param paParms the array of HGCM parameters
173	* @thread HGCM
174	*/
175	int Service::getKey(uint32_t cParms, VBOXHGCMSVCPARM paParms[])
176	{
177	int rc = VINF_SUCCESS;
178	char pszKey, pszValue;
179	uint32_t cbKey, cbValue;
180	size_t cbValueActual;
181
182	LogFlowThisFunc(("\n"));
183	if ( (cParms != 3) /* Hardcoded value as the next lines depend on it. */
184	\|\| (paParms[0].type != VBOX_HGCM_SVC_PARM_PTR) /* key */
185	\|\| (paParms[1].type != VBOX_HGCM_SVC_PARM_PTR) /* value */
186	)
187	rc = VERR_INVALID_PARAMETER;
188	if (RT_SUCCESS(rc))
189	rc = VBoxHGCMParmPtrGet(&paParms[0], (void **) &pszKey, &cbKey);
190	if (RT_SUCCESS(rc))
191	rc = VBoxHGCMParmPtrGet(&paParms[1], (void **) &pszValue, &cbValue);
192	if (RT_SUCCESS(rc))
193	rc = validateGetKey(pszKey, cbKey, pszValue, cbValue);
194	if (RT_SUCCESS(rc))
195	rc = CFGMR3QuerySize(mpNode, pszKey, &cbValueActual);
196	if (RT_SUCCESS(rc))
197	VBoxHGCMParmUInt32Set(&paParms[2], cbValueActual);
198	if (RT_SUCCESS(rc) && (cbValueActual > cbValue))
199	rc = VINF_BUFFER_OVERFLOW;
200	if (RT_SUCCESS(rc) && (rc != VINF_BUFFER_OVERFLOW))
201	rc = CFGMR3QueryString(mpNode, pszKey, pszValue, cbValue);
202	if (RT_SUCCESS(rc) && (rc != VINF_BUFFER_OVERFLOW))
203	Log2(("Queried string %s, rc=%Rrc, value=%.*s\n", pszKey, rc, cbValue, pszValue));
204	else if (VERR_CFGM_VALUE_NOT_FOUND == rc)
205	{
206	VBoxHGCMParmUInt32Set(&paParms[2], 0);
207	rc = VINF_SUCCESS;
208	}
209	LogFlowThisFunc(("rc = %Rrc\n", rc));
210	return rc;
211	}
212
213
214	/**
215	* Checking that the data passed by the guest fits our criteria for getting the
216	* value of a configuration key (currently stored as extra data in the machine
217	* XML file)
218	*
219	* @returns IPRT status code
220	* @param pszKey the key passed by the guest
221	* @param cbKey the number of bytes pszKey points to, including the terminating '\0'
222	* @param pszValue the buffer to store the key name into
223	* @param cbValue the size of the array for storing the key value
224	* @thread HGCM
225	*/
226	int Service::validateGetKey(const char pszKey, uint32_t cbKey, char pszValue, uint32_t cbValue)
227	{
228	LogFlowFunc(("cbKey=%d, cbValue=%d\n", cbKey, cbValue));
229
230	unsigned count;
231	int rc = VINF_SUCCESS;
232
233	/* Validate the format of the key. */
234	if (cbKey < sizeof(VBOX_SHARED_INFO_KEY_PREFIX))
235	rc = VERR_INVALID_PARAMETER;
236	/* Only accept names in printable ASCII without spaces */
237	for (count = 0; (count < cbKey) && (pszKey[count] != '\0'); ++count)
238	if ((pszKey[count] < 33) \|\| (pszKey[count] > 126))
239	rc = VERR_INVALID_PARAMETER;
240	if (RT_SUCCESS(rc) && (count == cbKey))
241	/* This would mean that no null terminator was found */
242	rc = VERR_INVALID_PARAMETER;
243	if (RT_SUCCESS(rc) && (count > KEY_MAX_LEN))
244	rc = VERR_INVALID_PARAMETER;
245
246	if (RT_SUCCESS(rc))
247	LogFlow((" pszKey=%s\n", pszKey));
248	LogFlowFunc(("returning %Rrc\n", rc));
249	return rc;
250	}
251
252
253	/**
254	* Set a value in the guest registry by key, checking the validity
255	* of the arguments passed.
256	*
257	* @returns iprt status value
258	* @param cParms the number of HGCM parameters supplied
259	* @param paParms the array of HGCM parameters
260	* @thread HGCM
261	*/
262	int Service::setKey(uint32_t cParms, VBOXHGCMSVCPARM paParms[])
263	{
264	int rc = VINF_SUCCESS;
265	char pszKey, pszValue;
266	uint32_t cbKey, cbValue;
267
268	LogFlowThisFunc(("\n"));
269	if ( (cParms != 2) /* Hardcoded value as the next lines depend on it. */
270	\|\| (paParms[0].type != VBOX_HGCM_SVC_PARM_PTR) /* key */
271	\|\| (paParms[1].type != VBOX_HGCM_SVC_PARM_PTR) /* value */
272	)
273	rc = VERR_INVALID_PARAMETER;
274	if (RT_SUCCESS(rc))
275	rc = VBoxHGCMParmPtrGet(&paParms[0], (void **) &pszKey, &cbKey);
276	if (RT_SUCCESS(rc))
277	rc = VBoxHGCMParmPtrGet(&paParms[1], (void **) &pszValue, &cbValue);
278	if (RT_SUCCESS(rc))
279	rc = validateSetKey(pszKey, cbKey, pszValue, cbValue);
280	if (RT_SUCCESS(rc))
281	{
282	/* Limit the number of keys that we can set. */
283	unsigned cChildren = 0;
284	for (PCFGMNODE pChild = CFGMR3GetFirstChild(mpNode); pChild != 0; pChild = CFGMR3GetNextChild(pChild))
285	++cChildren;
286	if (cChildren >= KEY_MAX_KEYS)
287	rc = VERR_TOO_MUCH_DATA;
288	}
289	if (RT_SUCCESS(rc))
290	{
291	CFGMR3RemoveValue(mpNode, pszKey);
292	if (pszValue > 0)
293	rc = CFGMR3InsertString(mpNode, pszKey, pszValue);
294	}
295	if (RT_SUCCESS(rc))
296	Log2(("Set string %s, rc=%Rrc, value=%s\n", pszKey, rc, pszValue));
297	LogFlowThisFunc(("rc = %Rrc\n", rc));
298	return rc;
299	}
300
301
302	/**
303	* Check that the data passed by the guest fits our criteria for setting the
304	* value of a configuration key (currently stored as extra data in the machine
305	* XML file)
306	*
307	* @returns IPRT status code
308	* @param pszKey the key passed by the guest
309	* @param cbKey the number of bytes in the buffer pszKey points to
310	* @param pszValue the value to store in the key
311	* @param cbValue the number of bytes in the buffer pszValue points to
312	* @thread HGCM
313	*/
314	int Service::validateSetKey(const char pszKey, uint32_t cbKey, char pszValue,
315	uint32_t cbValue)
316	{
317	LogFlowFunc(("cbKey=%d, cbValue=%d\n", cbKey, cbValue));
318
319	unsigned count;
320	int rc = VINF_SUCCESS;
321
322	/* Validate the format of the key. */
323	if (cbKey < sizeof(VBOX_SHARED_INFO_KEY_PREFIX))
324	rc = VERR_INVALID_PARAMETER;
325	/** @todo duplicate check in validateGetKey, use separate method. mixing unsigned and uint32_t. */
326	/* Only accept names in printable ASCII without spaces */
327	for (count = 0; (count < cbKey) && (pszKey[count] != '\0'); ++count)
328	if ((pszKey[count] < 33) \|\| (pszKey[count] > 126))
329	rc = VERR_INVALID_PARAMETER;
330	if (RT_SUCCESS(rc) && (count == cbKey))
331	/* This would mean that no null terminator was found */
332	rc = VERR_INVALID_PARAMETER;
333	if (RT_SUCCESS(rc) && (count > KEY_MAX_LEN))
334	rc = VERR_INVALID_PARAMETER;
335
336	if (cbValue != 0)
337	{
338	/* Validate the format of the value. */
339	/* Only accept values in printable ASCII without spaces */
340	for (count = 0; (count < cbValue) && (pszValue[count] != '\0'); ++count)
341	if ((pszValue[count] < 33) \|\| (pszValue[count] > 126))
342	rc = VERR_INVALID_PARAMETER;
343	if (RT_SUCCESS(rc) && (count == cbValue))
344	/* This would mean that no null terminator was found */
345	rc = VERR_INVALID_PARAMETER;
346	if (RT_SUCCESS(rc) && (count > KEY_MAX_VALUE_LEN))
347	rc = VERR_INVALID_PARAMETER;
348	}
349
350	if (RT_SUCCESS(rc))
351	LogFlow((" pszKey=%s, pszValue=%s\n", pszKey, cbValue > 0 ? pszValue : NULL));
352	LogFlowFunc(("returning %Rrc\n", rc));
353	return rc;
354	}
355
356
357	/**
358	* Handle an HGCM service call.
359	* @copydoc VBOXHGCMSVCFNTABLE::pfnCall
360	* @note All functions which do not involve an unreasonable delay will be
361	* handled synchronously. If needed, we will add a request handler
362	* thread in future for those which do.
363	*
364	* @thread HGCM
365	*/
366	void Service::call (VBOXHGCMCALLHANDLE callHandle, uint32_t u32ClientID,
367	void * /* pvClient */, uint32_t eFunction, uint32_t cParms,
368	VBOXHGCMSVCPARM paParms[])
369	{
370	int rc = VINF_SUCCESS;
371	bool fCallSync = true;
372
373	LogFlowFunc(("u32ClientID = %d, fn = %d, cParms = %d, pparms = %d\n",
374	u32ClientID, eFunction, cParms, paParms));
375
376	switch (eFunction)
377	{
378	/* The guest wishes to read a configuration value */
379	case GET_CONFIG_KEY:
380	LogFlowFunc(("GET_CONFIG_KEY\n"));
381	rc = getKey(cParms, paParms);
382	break;
383
384	/* The guest wishes to set a configuration value */
385	case SET_CONFIG_KEY:
386	LogFlowFunc(("SET_CONFIG_KEY\n"));
387	if (RT_SUCCESS(rc))
388	rc = setKey(cParms, paParms);
389	break;
390
391	default:
392	rc = VERR_NOT_IMPLEMENTED;
393	}
394	if (fCallSync)
395	{
396	LogFlowFunc(("rc = %Rrc\n", rc));
397	mpHelpers->pfnCallComplete (callHandle, rc);
398	}
399	}
400
401
402	/**
403	* Service call handler for the host.
404	* @copydoc VBOXHGCMSVCFNTABLE::pfnHostCall
405	* @thread hgcm
406	*/
407	int Service::hostCall (uint32_t eFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
408	{
409	int rc = VINF_SUCCESS;
410
411	LogFlowFunc(("fn = %d, cParms = %d, pparms = %d\n",
412	eFunction, cParms, paParms));
413
414	switch (eFunction)
415	{
416	/* Set the root CFGM node used. This should be called when instantiating
417	* the service. */
418	case SET_CFGM_NODE:
419	{
420	LogFlowFunc(("SET_CFGM_NODE\n"));
421
422	if (cParms != 1)
423	{
424	rc = VERR_INVALID_PARAMETER;
425	}
426	else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_PTR /* pNode */
427	)
428	{
429	rc = VERR_INVALID_PARAMETER;
430	}
431	else
432	{
433	PCFGMNODE pNode = NULL;
434	uint32_t cbDummy;
435
436	rc = VBoxHGCMParmPtrGet (&paParms[0], (void **) &pNode, &cbDummy);
437	mpNode = pNode;
438	}
439	} break;
440
441	/* The host wishes to read a configuration value */
442	case GET_CONFIG_KEY_HOST:
443	LogFlowFunc(("GET_CONFIG_KEY_HOST\n"));
444	rc = getKey(cParms, paParms);
445	break;
446
447	/* The host wishes to set a configuration value */
448	case SET_CONFIG_KEY_HOST:
449	LogFlowFunc(("SET_CONFIG_KEY_HOST\n"));
450	if (RT_SUCCESS(rc))
451	rc = setKey(cParms, paParms);
452	break;
453
454	default:
455	rc = VERR_NOT_SUPPORTED;
456	break;
457	}
458
459	LogFlowFunc(("rc = %Vrc\n", rc));
460	return rc;
461	}
462
463	} /* namespace svcInfo */
464
465	using svcInfo::Service;
466
467	/**
468	* @copydoc VBOXHGCMSVCLOAD
469	*/
470	extern "C" DECLCALLBACK(DECLEXPORT(int)) VBoxHGCMSvcLoad (VBOXHGCMSVCFNTABLE *ptable)
471	{
472	int rc = VINF_SUCCESS;
473
474	LogFlowFunc(("ptable = %p\n", ptable));
475
476	if (!VALID_PTR(ptable))
477	{
478	rc = VERR_INVALID_PARAMETER;
479	}
480	else
481	{
482	LogFlowFunc(("ptable->cbSize = %d, ptable->u32Version = 0x%08X\n", ptable->cbSize, ptable->u32Version));
483
484	if ( ptable->cbSize != sizeof (VBOXHGCMSVCFNTABLE)
485	\|\| ptable->u32Version != VBOX_HGCM_SVC_VERSION)
486	{
487	rc = VERR_VERSION_MISMATCH;
488	}
489	else
490	{
491	std::auto_ptr<Service> apService;
492	try {
493	apService = std::auto_ptr<Service>(new Service(ptable->pHelpers));
494	} catch (...) {
495	/* No exceptions may propogate outside. */
496	rc = VERR_UNRESOLVED_ERROR;
497	}
498
499	if (RT_SUCCESS(rc))
500	{
501	/* We do not maintain connections, so no client data is needed. */
502	ptable->cbClient = 0;
503
504	ptable->pfnUnload = Service::svcUnload;
505	ptable->pfnConnect = Service::svcConnectDisconnect;
506	ptable->pfnDisconnect = Service::svcConnectDisconnect;
507	ptable->pfnCall = Service::svcCall;
508	ptable->pfnHostCall = Service::svcHostCall;
509	ptable->pfnSaveState = NULL; /* The service is stateless by definition, so the */
510	ptable->pfnLoadState = NULL; /* normal construction done before restoring suffices */
511	ptable->pfnRegisterExtension = NULL;
512
513	/* Service specific initialization. */
514	ptable->pvService = apService.release();
515	}
516	}
517	}
518
519	LogFlowFunc(("returning %Rrc\n", rc));
520	return rc;
521	}

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

source: vbox/trunk/src/VBox/HostServices/SharedInfoServices/service.cpp@ 9917

Download in other formats: