service.cpp@ 14295

Last change on this file since 14295 was 14261, checked in by vboxsync, 16 years ago
GuestProperties/service.cpp: DEBUG -> VBOX_STRICT.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 44.5 KB

Line
1	/** @file
2	*
3	* Guest Property Service:
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	* This HGCM service allows the guest to set and query values in a property
25	* store on the host. The service proxies the guest requests to the service
26	* owner on the host using a request callback provided by the owner, and is
27	* notified of changes to properties made by the host. It forwards these
28	* notifications to clients in the guest which have expressed interest and
29	* are waiting for notification.
30	*
31	* The service currently consists of two threads. One of these is the main
32	* HGCM service thread which deals with requests from the guest and from the
33	* host. The second thread sends the host asynchronous notifications of
34	* changes made by the guest and deals with notification timeouts.
35	*
36	* Guest requests to wait for notification are added to a list of open
37	* notification requests and completed when a corresponding guest property
38	* is changed or when the request times out.
39	*/
40
41	#define LOG_GROUP LOG_GROUP_HGCM
42
43	/*******************************************************************************
44	* Header Files *
45	*******************************************************************************/
46	#include <VBox/HostServices/GuestPropertySvc.h>
47
48	#include <VBox/log.h>
49	#include <iprt/err.h>
50	#include <iprt/assert.h>
51	#include <iprt/string.h>
52	#include <iprt/mem.h>
53	#include <iprt/autores.h>
54	#include <iprt/time.h>
55	#include <iprt/cpputils.h>
56	#include <iprt/req.h>
57	#include <iprt/thread.h>
58
59	#include <memory> /* for auto_ptr */
60	#include <string>
61	#include <list>
62
63	namespace guestProp {
64
65	/**
66	* Structure for holding a property
67	*/
68	struct Property
69	{
70	/** The name of the property */
71	std::string mName;
72	/** The property value */
73	std::string mValue;
74	/** The timestamp of the property */
75	uint64_t mTimestamp;
76	/** The property flags */
77	uint32_t mFlags;
78
79	/** Default constructor */
80	Property() : mTimestamp(0), mFlags(NILFLAG) {}
81	/** Constructor with const char * */
82	Property(const char pcszName, const char pcszValue,
83	uint64_t u64Timestamp, uint32_t u32Flags)
84	: mName(pcszName), mValue(pcszValue), mTimestamp(u64Timestamp),
85	mFlags(u32Flags) {}
86	/** Constructor with std::string */
87	Property(std::string name, std::string value, uint64_t u64Timestamp,
88	uint32_t u32Flags)
89	: mName(name), mValue(value), mTimestamp(u64Timestamp),
90	mFlags(u32Flags) {}
91
92	/** Does the property name match one of a set of patterns? */
93	bool Matches(const char *pszPatterns) const
94	{
95	return ( pszPatterns[0] == '\0' /* match all */
96	\|\| RTStrSimplePatternMultiMatch(pszPatterns, RTSTR_MAX,
97	mName.c_str(), RTSTR_MAX,
98	NULL)
99	);
100	}
101
102	/** Are two properties equal? */
103	bool operator== (const Property &prop)
104	{
105	return ( mName == prop.mName
106	&& mValue == prop.mValue
107	&& mTimestamp == prop.mTimestamp
108	&& mFlags == prop.mFlags
109	);
110	}
111
112	/* Is the property nil? */
113	bool isNull()
114	{
115	return mName.empty();
116	}
117	};
118	/** The properties list type */
119	typedef std::list <Property> PropertyList;
120
121	/**
122	* Structure for holding an uncompleted guest call
123	*/
124	struct GuestCall
125	{
126	/** The call handle */
127	VBOXHGCMCALLHANDLE mHandle;
128	/** The function that was requested */
129	uint32_t mFunction;
130	/** The call parameters */
131	VBOXHGCMSVCPARM *mParms;
132	/** The default return value, used for passing warnings */
133	int mRc;
134
135	/** The standard constructor */
136	GuestCall() : mFunction(0) {}
137	/** The normal contructor */
138	GuestCall(VBOXHGCMCALLHANDLE aHandle, uint32_t aFunction,
139	VBOXHGCMSVCPARM aParms[], int aRc)
140	: mHandle(aHandle), mFunction(aFunction), mParms(aParms),
141	mRc(aRc) {}
142	};
143	/** The guest call list type */
144	typedef std::list <GuestCall> CallList;
145
146	/**
147	* Class containing the shared information service functionality.
148	*/
149	class Service : public stdx::non_copyable
150	{
151	private:
152	/** Type definition for use in callback functions */
153	typedef Service SELF;
154	/** HGCM helper functions. */
155	PVBOXHGCMSVCHELPERS mpHelpers;
156	/** The property list */
157	PropertyList mProperties;
158	/** The list of property changes for guest notifications */
159	PropertyList mGuestNotifications;
160	/** The list of outstanding guest notification calls */
161	CallList mGuestWaiters;
162	/** @todo we should have classes for thread and request handler thread */
163	/** Queue of outstanding property change notifications */
164	RTREQQUEUE *mReqQueue;
165	/** Thread for processing the request queue */
166	RTTHREAD mReqThread;
167	/** Tell the thread that it should exit */
168	bool mfExitThread;
169	/** Callback function supplied by the host for notification of updates
170	* to properties */
171	PFNHGCMSVCEXT mpfnHostCallback;
172	/** User data pointer to be supplied to the host callback function */
173	void *mpvHostData;
174
175	/**
176	* Get the next property change notification from the queue of saved
177	* notification based on the timestamp of the last notification seen.
178	* Notifications will only be reported if the property name matches the
179	* pattern given.
180	*
181	* @returns iprt status value
182	* @returns VWRN_NOT_FOUND if the last notification was not found in the queue
183	* @param pszPatterns the patterns to match the property name against
184	* @param u64Timestamp the timestamp of the last notification
185	* @param pProp where to return the property found. If none is
186	* found this will be set to nil.
187	* @thread HGCM
188	*/
189	int getOldNotification(const char *pszPatterns, uint64_t u64Timestamp,
190	Property *pProp)
191	{
192	AssertPtrReturn(pszPatterns, VERR_INVALID_POINTER);
193	/* Zero means wait for a new notification. */
194	AssertReturn(u64Timestamp != 0, VERR_INVALID_PARAMETER);
195	AssertPtrReturn(pProp, VERR_INVALID_POINTER);
196	int rc = getOldNotificationInternal(pszPatterns, u64Timestamp, pProp);
197	#ifdef VBOX_STRICT
198	/*
199	* ENSURE that pProp is the first event in the notification queue that:
200	* - Appears later than u64Timestamp
201	* - Matches the pszPatterns
202	*/
203	PropertyList::const_iterator it = mGuestNotifications.begin();
204	for (; it != mGuestNotifications.end()
205	&& it->mTimestamp != u64Timestamp; ++it) {}
206	if (it == mGuestNotifications.end()) /* Not found */
207	it = mGuestNotifications.begin();
208	else
209	++it; /* Next event */
210	for (; it != mGuestNotifications.end()
211	&& it->mTimestamp != pProp->mTimestamp; ++it)
212	Assert(!it->Matches(pszPatterns));
213	if (pProp->mTimestamp != 0)
214	{
215	Assert(pProp == it);
216	Assert(pProp->Matches(pszPatterns));
217	}
218	#endif /* VBOX_STRICT */
219	return rc;
220	}
221
222	public:
223	explicit Service(PVBOXHGCMSVCHELPERS pHelpers)
224	: mpHelpers(pHelpers), mfExitThread(false), mpfnHostCallback(NULL),
225	mpvHostData(NULL)
226	{
227	int rc = RTReqCreateQueue(&mReqQueue);
228	#ifndef VBOX_GUEST_PROP_TEST_NOTHREAD
229	if (RT_SUCCESS(rc))
230	rc = RTThreadCreate(&mReqThread, reqThreadFn, this, 0,
231	RTTHREADTYPE_MSG_PUMP, RTTHREADFLAGS_WAITABLE,
232	"GuestPropReq");
233	#endif
234	if (RT_FAILURE(rc))
235	throw rc;
236	}
237
238	/**
239	* @copydoc VBOXHGCMSVCHELPERS::pfnUnload
240	* Simply deletes the service object
241	*/
242	static DECLCALLBACK(int) svcUnload (void *pvService)
243	{
244	AssertLogRelReturn(VALID_PTR(pvService), VERR_INVALID_PARAMETER);
245	SELF pSelf = reinterpret_cast<SELF >(pvService);
246	int rc = pSelf->uninit();
247	AssertRC(rc);
248	if (RT_SUCCESS(rc))
249	delete pSelf;
250	return rc;
251	}
252
253	/**
254	* @copydoc VBOXHGCMSVCHELPERS::pfnConnect
255	* Stub implementation of pfnConnect and pfnDisconnect.
256	*/
257	static DECLCALLBACK(int) svcConnectDisconnect (void * /* pvService */,
258	uint32_t /* u32ClientID */,
259	void * /* pvClient */)
260	{
261	return VINF_SUCCESS;
262	}
263
264	/**
265	* @copydoc VBOXHGCMSVCHELPERS::pfnCall
266	* Wraps to the call member function
267	*/
268	static DECLCALLBACK(void) svcCall (void * pvService,
269	VBOXHGCMCALLHANDLE callHandle,
270	uint32_t u32ClientID,
271	void *pvClient,
272	uint32_t u32Function,
273	uint32_t cParms,
274	VBOXHGCMSVCPARM paParms[])
275	{
276	AssertLogRelReturnVoid(VALID_PTR(pvService));
277	SELF pSelf = reinterpret_cast<SELF >(pvService);
278	pSelf->call(callHandle, u32ClientID, pvClient, u32Function, cParms, paParms);
279	}
280
281	/**
282	* @copydoc VBOXHGCMSVCHELPERS::pfnHostCall
283	* Wraps to the hostCall member function
284	*/
285	static DECLCALLBACK(int) svcHostCall (void *pvService,
286	uint32_t u32Function,
287	uint32_t cParms,
288	VBOXHGCMSVCPARM paParms[])
289	{
290	AssertLogRelReturn(VALID_PTR(pvService), VERR_INVALID_PARAMETER);
291	SELF pSelf = reinterpret_cast<SELF >(pvService);
292	return pSelf->hostCall(u32Function, cParms, paParms);
293	}
294
295	/**
296	* @copydoc VBOXHGCMSVCHELPERS::pfnRegisterExtension
297	* Installs a host callback for notifications of property changes.
298	*/
299	static DECLCALLBACK(int) svcRegisterExtension (void *pvService,
300	PFNHGCMSVCEXT pfnExtension,
301	void *pvExtension)
302	{
303	AssertLogRelReturn(VALID_PTR(pvService), VERR_INVALID_PARAMETER);
304	SELF pSelf = reinterpret_cast<SELF >(pvService);
305	pSelf->mpfnHostCallback = pfnExtension;
306	pSelf->mpvHostData = pvExtension;
307	return VINF_SUCCESS;
308	}
309	private:
310	static DECLCALLBACK(int) reqThreadFn(RTTHREAD ThreadSelf, void *pvUser);
311	int validateName(const char *pszName, uint32_t cbName);
312	int validateValue(const char *pszValue, uint32_t cbValue);
313	int setPropertyBlock(uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
314	int getProperty(uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
315	int setProperty(uint32_t cParms, VBOXHGCMSVCPARM paParms[], bool isGuest);
316	int delProperty(uint32_t cParms, VBOXHGCMSVCPARM paParms[], bool isGuest);
317	int enumProps(uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
318	int getNotification(VBOXHGCMCALLHANDLE callHandle, uint32_t cParms,
319	VBOXHGCMSVCPARM paParms[]);
320	int getOldNotificationInternal(const char *pszPattern,
321	uint64_t u64Timestamp, Property *pProp);
322	int getNotificationWriteOut(VBOXHGCMSVCPARM paParms[], Property prop);
323	void doNotifications(const char *pszProperty, uint64_t u64Timestamp);
324	static DECLCALLBACK(int) reqNotify(PFNHGCMSVCEXT pfnCallback,
325	void pvData, char pszName,
326	char *pszValue, uint32_t u32TimeHigh,
327	uint32_t u32TimeLow, char *pszFlags);
328	/**
329	* Empty request function for terminating the request thread.
330	* @returns VINF_EOF to cause the request processing function to return
331	* @todo return something more appropriate
332	*/
333	static DECLCALLBACK(int) reqVoid() { return VINF_EOF; }
334
335	void call (VBOXHGCMCALLHANDLE callHandle, uint32_t u32ClientID,
336	void *pvClient, uint32_t eFunction, uint32_t cParms,
337	VBOXHGCMSVCPARM paParms[]);
338	int hostCall (uint32_t eFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
339	int uninit ();
340	};
341
342
343	/**
344	* Thread function for processing the request queue
345	* @copydoc FNRTTHREAD
346	*/
347	DECLCALLBACK(int) Service::reqThreadFn(RTTHREAD ThreadSelf, void *pvUser)
348	{
349	SELF pSelf = reinterpret_cast<SELF >(pvUser);
350	while (!pSelf->mfExitThread)
351	RTReqProcess(pSelf->mReqQueue, RT_INDEFINITE_WAIT);
352	return VINF_SUCCESS;
353	}
354
355
356	/**
357	* Checking that the name passed by the guest fits our criteria for a
358	* property name.
359	*
360	* @returns IPRT status code
361	* @param pszName the name passed by the guest
362	* @param cbName the number of bytes pszName points to, including the
363	* terminating '\0'
364	* @thread HGCM
365	*/
366	int Service::validateName(const char *pszName, uint32_t cbName)
367	{
368	LogFlowFunc(("cbName=%d\n", cbName));
369
370	/*
371	* Validate the name, checking that it's proper UTF-8 and has
372	* a string terminator.
373	*/
374	int rc = VINF_SUCCESS;
375	if (RT_SUCCESS(rc) && (cbName < 2))
376	rc = VERR_INVALID_PARAMETER;
377	if (RT_SUCCESS(rc))
378	rc = RTStrValidateEncodingEx(pszName, RT_MIN(cbName, (uint32_t) MAX_NAME_LEN),
379	RTSTR_VALIDATE_ENCODING_ZERO_TERMINATED);
380
381	LogFlowFunc(("returning %Rrc\n", rc));
382	return rc;
383	}
384
385
386	/**
387	* Check that the data passed by the guest fits our criteria for the value of
388	* a guest property.
389	*
390	* @returns IPRT status code
391	* @param pszValue the value to store in the property
392	* @param cbValue the number of bytes in the buffer pszValue points to
393	* @thread HGCM
394	*/
395	int Service::validateValue(const char *pszValue, uint32_t cbValue)
396	{
397	LogFlowFunc(("cbValue=%d\n", cbValue));
398
399	/*
400	* Validate the value, checking that it's proper UTF-8 and has
401	* a string terminator.
402	*/
403	int rc = VINF_SUCCESS;
404	if (RT_SUCCESS(rc) && (cbValue < 2))
405	rc = VERR_INVALID_PARAMETER;
406	if (RT_SUCCESS(rc))
407	rc = RTStrValidateEncodingEx(pszValue, RT_MIN(cbValue, (uint32_t) MAX_VALUE_LEN),
408	RTSTR_VALIDATE_ENCODING_ZERO_TERMINATED);
409	if (RT_SUCCESS(rc))
410	LogFlow((" pszValue=%s\n", cbValue > 0 ? pszValue : NULL));
411	LogFlowFunc(("returning %Rrc\n", rc));
412	return rc;
413	}
414
415	/**
416	* Set a block of properties in the property registry, checking the validity
417	* of the arguments passed.
418	*
419	* @returns iprt status value
420	* @param cParms the number of HGCM parameters supplied
421	* @param paParms the array of HGCM parameters
422	* @thread HGCM
423	*/
424	int Service::setPropertyBlock(uint32_t cParms, VBOXHGCMSVCPARM paParms[])
425	{
426	char ppNames, ppValues, **ppFlags;
427	uint64_t *pTimestamps;
428	uint32_t cbDummy;
429	int rc = VINF_SUCCESS;
430
431	/*
432	* Get and validate the parameters
433	*/
434	if ( (cParms != 4)
435	\|\| RT_FAILURE(paParms[0].getPointer ((void **) &ppNames, &cbDummy))
436	\|\| RT_FAILURE(paParms[1].getPointer ((void **) &ppValues, &cbDummy))
437	\|\| RT_FAILURE(paParms[2].getPointer ((void **) &pTimestamps, &cbDummy))
438	\|\| RT_FAILURE(paParms[3].getPointer ((void **) &ppFlags, &cbDummy))
439	)
440	rc = VERR_INVALID_PARAMETER;
441
442	/*
443	* Add the properties to the end of the list. If we succeed then we
444	* will remove duplicates afterwards.
445	*/
446	/* Remember the last property before we started adding, for rollback or
447	* cleanup. */
448	PropertyList::iterator itEnd = mProperties.end();
449	if (!mProperties.empty())
450	--itEnd;
451	try
452	{
453	for (unsigned i = 0; RT_SUCCESS(rc) && ppNames[i] != NULL; ++i)
454	{
455	uint32_t fFlags;
456	if ( !VALID_PTR(ppNames[i])
457	\|\| !VALID_PTR(ppValues[i])
458	\|\| !VALID_PTR(ppFlags[i])
459	)
460	rc = VERR_INVALID_POINTER;
461	if (RT_SUCCESS(rc))
462	rc = validateFlags(ppFlags[i], &fFlags);
463	if (RT_SUCCESS(rc))
464	mProperties.push_back(Property(ppNames[i], ppValues[i],
465	pTimestamps[i], fFlags));
466	}
467	}
468	catch (std::bad_alloc)
469	{
470	rc = VERR_NO_MEMORY;
471	}
472
473	/*
474	* If all went well then remove the duplicate elements.
475	*/
476	if (RT_SUCCESS(rc) && itEnd != mProperties.end())
477	{
478	++itEnd;
479	for (unsigned i = 0; ppNames[i] != NULL; ++i)
480	{
481	bool found = false;
482	for (PropertyList::iterator it = mProperties.begin();
483	!found && it != itEnd; ++it)
484	if (it->mName.compare(ppNames[i]) == 0)
485	{
486	found = true;
487	mProperties.erase(it);
488	}
489	}
490	}
491
492	/*
493	* If something went wrong then rollback. This is possible because we
494	* haven't deleted anything yet.
495	*/
496	if (RT_FAILURE(rc))
497	{
498	if (itEnd != mProperties.end())
499	++itEnd;
500	mProperties.erase(itEnd, mProperties.end());
501	}
502	return rc;
503	}
504
505	/**
506	* Retrieve a value from the property registry by name, checking the validity
507	* of the arguments passed. If the guest has not allocated enough buffer
508	* space for the value then we return VERR_OVERFLOW and set the size of the
509	* buffer needed in the "size" HGCM parameter. If the name was not found at
510	* all, we return VERR_NOT_FOUND.
511	*
512	* @returns iprt status value
513	* @param cParms the number of HGCM parameters supplied
514	* @param paParms the array of HGCM parameters
515	* @thread HGCM
516	*/
517	int Service::getProperty(uint32_t cParms, VBOXHGCMSVCPARM paParms[])
518	{
519	int rc = VINF_SUCCESS;
520	const char *pcszName;
521	char *pchBuf;
522	uint32_t cchName, cchBuf;
523	uint32_t cchFlags, cchBufActual;
524	char szFlags[MAX_FLAGS_LEN];
525
526	/*
527	* Get and validate the parameters
528	*/
529	LogFlowThisFunc(("\n"));
530	if ( cParms != 4 /* Hardcoded value as the next lines depend on it. */
531	\|\| RT_FAILURE (paParms[0].getPointer ((const void *) &pcszName, &cchName)) / name */
532	\|\| RT_FAILURE (paParms[1].getPointer ((void *) &pchBuf, &cchBuf)) / buffer */
533	)
534	rc = VERR_INVALID_PARAMETER;
535	if (RT_SUCCESS(rc))
536	rc = validateName(pcszName, cchName);
537
538	/*
539	* Read and set the values we will return
540	*/
541
542	/* Get the value size */
543	PropertyList::const_iterator it;
544	bool found = false;
545	if (RT_SUCCESS(rc))
546	for (it = mProperties.begin(); it != mProperties.end(); ++it)
547	if (it->mName.compare(pcszName) == 0)
548	{
549	found = true;
550	break;
551	}
552	if (RT_SUCCESS(rc) && !found)
553	rc = VERR_NOT_FOUND;
554	if (RT_SUCCESS(rc))
555	rc = writeFlags(it->mFlags, szFlags);
556	if (RT_SUCCESS(rc))
557	cchFlags = strlen(szFlags);
558	/* Check that the buffer is big enough */
559	if (RT_SUCCESS(rc))
560	{
561	cchBufActual = it->mValue.size() + 1 + cchFlags;
562	paParms[3].setUInt32 (cchBufActual);
563	}
564	if (RT_SUCCESS(rc) && (cchBufActual > cchBuf))
565	rc = VERR_BUFFER_OVERFLOW;
566	/* Write the value, flags and timestamp */
567	if (RT_SUCCESS(rc))
568	{
569	it->mValue.copy(pchBuf, cchBuf, 0);
570	pchBuf[it->mValue.size()] = '\0'; /* Terminate the value */
571	strcpy(pchBuf + it->mValue.size() + 1, szFlags);
572	paParms[2].setUInt64 (it->mTimestamp);
573	}
574
575	/*
576	* Done! Do exit logging and return.
577	*/
578	if (RT_SUCCESS(rc))
579	Log2(("Queried string %s, value=%s, timestamp=%lld, flags=%s\n",
580	pcszName, it->mValue.c_str(), it->mTimestamp, szFlags));
581	LogFlowThisFunc(("rc = %Rrc\n", rc));
582	return rc;
583	}
584
585	/**
586	* Set a value in the property registry by name, checking the validity
587	* of the arguments passed.
588	*
589	* @returns iprt status value
590	* @param cParms the number of HGCM parameters supplied
591	* @param paParms the array of HGCM parameters
592	* @param isGuest is this call coming from the guest (or the host)?
593	* @throws std::bad_alloc if an out of memory condition occurs
594	* @thread HGCM
595	*/
596	int Service::setProperty(uint32_t cParms, VBOXHGCMSVCPARM paParms[], bool isGuest)
597	{
598	int rc = VINF_SUCCESS;
599	const char pcszName, pcszValue, *pcszFlags = NULL;
600	uint32_t cchName, cchValue, cchFlags = 0;
601	uint32_t fFlags = NILFLAG;
602	RTTIMESPEC time;
603	uint64_t u64TimeNano = RTTimeSpecGetNano(RTTimeNow(&time));
604
605	LogFlowThisFunc(("\n"));
606	/*
607	* First of all, make sure that we won't exceed the maximum number of properties.
608	*/
609	if (mProperties.size() >= MAX_PROPS)
610	rc = VERR_TOO_MUCH_DATA;
611
612	/*
613	* General parameter correctness checking.
614	*/
615	if ( RT_SUCCESS(rc)
616	&& ( (cParms < 2) \|\| (cParms > 3) /* Hardcoded value as the next lines depend on it. */
617	\|\| RT_FAILURE(paParms[0].getPointer ((const void **) &pcszName,
618	&cchName)) /* name */
619	\|\| RT_FAILURE(paParms[1].getPointer ((const void **) &pcszValue,
620	&cchValue)) /* value */
621	\|\| ( (3 == cParms)
622	&& RT_FAILURE(paParms[2].getPointer ((const void **) &pcszFlags,
623	&cchFlags)) /* flags */
624	)
625	)
626	)
627	rc = VERR_INVALID_PARAMETER;
628
629	/*
630	* Check the values passed in the parameters for correctness.
631	*/
632	if (RT_SUCCESS(rc))
633	rc = validateName(pcszName, cchName);
634	if (RT_SUCCESS(rc))
635	rc = validateValue(pcszValue, cchValue);
636	if ((3 == cParms) && RT_SUCCESS(rc))
637	rc = RTStrValidateEncodingEx(pcszFlags, cchFlags,
638	RTSTR_VALIDATE_ENCODING_ZERO_TERMINATED);
639	if ((3 == cParms) && RT_SUCCESS(rc))
640	rc = validateFlags(pcszFlags, &fFlags);
641
642	/*
643	* If the property already exists, check its flags to see if we are allowed
644	* to change it.
645	*/
646	PropertyList::iterator it;
647	bool found = false;
648	if (RT_SUCCESS(rc))
649	for (it = mProperties.begin(); it != mProperties.end(); ++it)
650	if (it->mName.compare(pcszName) == 0)
651	{
652	found = true;
653	break;
654	}
655	if (RT_SUCCESS(rc) && found)
656	if ( (isGuest && (it->mFlags & RDONLYGUEST))
657	\|\| (!isGuest && (it->mFlags & RDONLYHOST))
658	)
659	rc = VERR_PERMISSION_DENIED;
660
661	/*
662	* Set the actual value
663	*/
664	if (RT_SUCCESS(rc))
665	{
666	if (found)
667	{
668	it->mValue = pcszValue;
669	it->mTimestamp = u64TimeNano;
670	it->mFlags = fFlags;
671	}
672	else /* This can throw. No problem as we have nothing to roll back. */
673	mProperties.push_back(Property(pcszName, pcszValue, u64TimeNano, fFlags));
674	}
675
676	/*
677	* Send a notification to the host and return.
678	*/
679	if (RT_SUCCESS(rc))
680	{
681	// if (isGuest) /* Notify the host even for properties that the host
682	// * changed. Less efficient, but ensures consistency. */
683	doNotifications(pcszName, u64TimeNano);
684	Log2(("Set string %s, rc=%Rrc, value=%s\n", pcszName, rc, pcszValue));
685	}
686	LogFlowThisFunc(("rc = %Rrc\n", rc));
687	return rc;
688	}
689
690
691	/**
692	* Remove a value in the property registry by name, checking the validity
693	* of the arguments passed.
694	*
695	* @returns iprt status value
696	* @param cParms the number of HGCM parameters supplied
697	* @param paParms the array of HGCM parameters
698	* @param isGuest is this call coming from the guest (or the host)?
699	* @thread HGCM
700	*/
701	int Service::delProperty(uint32_t cParms, VBOXHGCMSVCPARM paParms[], bool isGuest)
702	{
703	int rc = VINF_SUCCESS;
704	const char *pcszName;
705	uint32_t cbName;
706
707	LogFlowThisFunc(("\n"));
708
709	/*
710	* Check the user-supplied parameters.
711	*/
712	if ( (cParms != 1) /* Hardcoded value as the next lines depend on it. */
713	\|\| RT_FAILURE(paParms[0].getPointer ((const void **) &pcszName,
714	&cbName)) /* name */
715	)
716	rc = VERR_INVALID_PARAMETER;
717	if (RT_SUCCESS(rc))
718	rc = validateName(pcszName, cbName);
719
720	/*
721	* If the property exists, check its flags to see if we are allowed
722	* to change it.
723	*/
724	PropertyList::iterator it;
725	bool found = false;
726	if (RT_SUCCESS(rc))
727	for (it = mProperties.begin(); it != mProperties.end(); ++it)
728	if (it->mName.compare(pcszName) == 0)
729	{
730	found = true;
731	break;
732	}
733	if (RT_SUCCESS(rc) && found)
734	if ( (isGuest && (it->mFlags & RDONLYGUEST))
735	\|\| (!isGuest && (it->mFlags & RDONLYHOST))
736	)
737	rc = VERR_PERMISSION_DENIED;
738
739	/*
740	* And delete the property if all is well.
741	*/
742	if (RT_SUCCESS(rc) && found)
743	{
744	RTTIMESPEC time;
745	uint64_t u64Timestamp = RTTimeSpecGetNano(RTTimeNow(&time));
746	mProperties.erase(it);
747	// if (isGuest) /* Notify the host even for properties that the host
748	// * changed. Less efficient, but ensures consistency. */
749	doNotifications(pcszName, u64Timestamp);
750	}
751	LogFlowThisFunc(("rc = %Rrc\n", rc));
752	return rc;
753	}
754
755	/**
756	* Enumerate guest properties by mask, checking the validity
757	* of the arguments passed.
758	*
759	* @returns iprt status value
760	* @param cParms the number of HGCM parameters supplied
761	* @param paParms the array of HGCM parameters
762	* @thread HGCM
763	*/
764	int Service::enumProps(uint32_t cParms, VBOXHGCMSVCPARM paParms[])
765	{
766	int rc = VINF_SUCCESS;
767
768	/*
769	* Get the HGCM function arguments.
770	*/
771	char pcchPatterns = NULL, pchBuf = NULL;
772	uint32_t cchPatterns = 0, cchBuf = 0;
773	LogFlowThisFunc(("\n"));
774	if ( (cParms != 3) /* Hardcoded value as the next lines depend on it. */
775	\|\| RT_FAILURE(paParms[0].getPointer ((const void **) &pcchPatterns,
776	&cchPatterns)) /* patterns */
777	\|\| RT_FAILURE(paParms[1].getPointer ((void *) &pchBuf, &cchBuf)) / return buffer */
778	)
779	rc = VERR_INVALID_PARAMETER;
780	if (RT_SUCCESS(rc) && cchPatterns > MAX_PATTERN_LEN)
781	rc = VERR_TOO_MUCH_DATA;
782
783	/*
784	* First repack the patterns into the format expected by RTStrSimplePatternMatch()
785	*/
786	char pszPatterns[MAX_PATTERN_LEN];
787	if (NULL == pcchPatterns)
788	pszPatterns[0] = '\0';
789	else
790	{
791	for (unsigned i = 0; i < cchPatterns - 1; ++i)
792	if (pcchPatterns[i] != '\0')
793	pszPatterns[i] = pcchPatterns[i];
794	else
795	pszPatterns[i] = '\|';
796	pszPatterns[cchPatterns - 1] = '\0';
797	}
798
799	/*
800	* Next enumerate into a temporary buffer. This can throw, but this is
801	* not a problem as we have nothing to roll back.
802	*/
803	std::string buffer;
804	for (PropertyList::const_iterator it = mProperties.begin();
805	RT_SUCCESS(rc) && (it != mProperties.end()); ++it)
806	{
807	if (it->Matches(pszPatterns))
808	{
809	char szFlags[MAX_FLAGS_LEN];
810	char szTimestamp[256];
811	uint32_t cchTimestamp;
812	buffer += it->mName;
813	buffer += '\0';
814	buffer += it->mValue;
815	buffer += '\0';
816	cchTimestamp = RTStrFormatNumber(szTimestamp, it->mTimestamp,
817	10, 0, 0, 0);
818	buffer.append(szTimestamp, cchTimestamp);
819	buffer += '\0';
820	rc = writeFlags(it->mFlags, szFlags);
821	if (RT_SUCCESS(rc))
822	buffer += szFlags;
823	buffer += '\0';
824	}
825	}
826	buffer.append(4, '\0'); /* The final terminators */
827
828	/*
829	* Finally write out the temporary buffer to the real one if it is not too
830	* small.
831	*/
832	if (RT_SUCCESS(rc))
833	{
834	paParms[2].setUInt32 (buffer.size());
835	/* Copy the memory if it fits into the guest buffer */
836	if (buffer.size() <= cchBuf)
837	buffer.copy(pchBuf, cchBuf);
838	else
839	rc = VERR_BUFFER_OVERFLOW;
840	}
841	return rc;
842	}
843
844	/** Helper query used by getOldNotification */
845	int Service::getOldNotificationInternal(const char *pszPatterns,
846	uint64_t u64Timestamp,
847	Property *pProp)
848	{
849	int rc = VINF_SUCCESS;
850	bool warn = false;
851
852	/* We count backwards, as the guest should normally be querying the
853	* most recent events. */
854	PropertyList::reverse_iterator it = mGuestNotifications.rbegin();
855	for (; it->mTimestamp != u64Timestamp && it != mGuestNotifications.rend();
856	++it) {}
857	/* Warn if the timestamp was not found. */
858	if (it->mTimestamp != u64Timestamp)
859	warn = true;
860	/* Now look for an event matching the patterns supplied. The base()
861	* member conveniently points to the following element. */
862	PropertyList::iterator base = it.base();
863	for (; !base->Matches(pszPatterns) && base != mGuestNotifications.end();
864	++base) {}
865	if (RT_SUCCESS(rc) && base != mGuestNotifications.end())
866	pProp = base;
867	else if (RT_SUCCESS(rc))
868	*pProp = Property();
869	if (warn)
870	rc = VWRN_NOT_FOUND;
871	return rc;
872	}
873
874	/** Helper query used by getNotification */
875	int Service::getNotificationWriteOut(VBOXHGCMSVCPARM paParms[], Property prop)
876	{
877	int rc = VINF_SUCCESS;
878	/* Format the data to write to the buffer. */
879	std::string buffer;
880	uint64_t u64Timestamp;
881	char *pchBuf;
882	uint32_t cchBuf;
883	rc = paParms[2].getPointer((void **) &pchBuf, &cchBuf);
884	if (RT_SUCCESS(rc))
885	{
886	char szFlags[MAX_FLAGS_LEN];
887	rc = writeFlags(prop.mFlags, szFlags);
888	if (RT_SUCCESS(rc))
889	{
890	buffer += prop.mName;
891	buffer += '\0';
892	buffer += prop.mValue;
893	buffer += '\0';
894	buffer += szFlags;
895	buffer += '\0';
896	u64Timestamp = prop.mTimestamp;
897	}
898	}
899	/* Write out the data. */
900	if (RT_SUCCESS(rc))
901	{
902	paParms[1].setUInt64(u64Timestamp);
903	paParms[3].setUInt32(buffer.size());
904	if (buffer.size() <= cchBuf)
905	buffer.copy(pchBuf, cchBuf);
906	else
907	rc = VERR_BUFFER_OVERFLOW;
908	}
909	return rc;
910	}
911
912	/**
913	* Get the next guest notification.
914	*
915	* @returns iprt status value
916	* @param cParms the number of HGCM parameters supplied
917	* @param paParms the array of HGCM parameters
918	* @thread HGCM
919	* @throws can throw std::bad_alloc
920	*/
921	int Service::getNotification(VBOXHGCMCALLHANDLE callHandle, uint32_t cParms,
922	VBOXHGCMSVCPARM paParms[])
923	{
924	int rc = VINF_SUCCESS;
925	char pszPatterns, pchBuf;
926	uint32_t cchPatterns = 0, cchBuf = 0;
927	uint64_t u64Timestamp;
928
929	/*
930	* Get the HGCM function arguments and perform basic verification.
931	*/
932	LogFlowThisFunc(("\n"));
933	if ( (cParms != 4) /* Hardcoded value as the next lines depend on it. */
934	\|\| RT_FAILURE(paParms[0].getPointer ((void *) &pszPatterns, &cchPatterns)) / patterns */
935	\|\| pszPatterns[cchPatterns - 1] != '\0' /* The patterns string must be zero-terminated */
936	\|\| RT_FAILURE(paParms[1].getUInt64 (&u64Timestamp)) /* timestamp */
937	\|\| RT_FAILURE(paParms[2].getPointer ((void *) &pchBuf, &cchBuf)) / return buffer */
938	\|\| cchBuf < 1
939	)
940	rc = VERR_INVALID_PARAMETER;
941
942	/*
943	* If no timestamp was supplied or no notification was found in the queue
944	* of old notifications, enqueue the request in the waiting queue.
945	*/
946	Property prop;
947	if (RT_SUCCESS(rc) && u64Timestamp != 0)
948	rc = getOldNotification(pszPatterns, u64Timestamp, &prop);
949	if (RT_SUCCESS(rc) && prop.isNull())
950	{
951	mGuestWaiters.push_back(GuestCall(callHandle, GET_NOTIFICATION,
952	paParms, rc));
953	rc = VINF_HGCM_ASYNC_EXECUTE;
954	}
955	/*
956	* Otherwise reply at once with the enqueued notification we found.
957	*/
958	else
959	{
960	int rc2 = getNotificationWriteOut(paParms, prop);
961	if (RT_FAILURE(rc2))
962	rc = rc2;
963	}
964	return rc;
965	}
966
967	/**
968	* Notify the service owner and the guest that a property has been
969	* added/deleted/changed
970	* @param pszProperty the name of the property which has changed
971	* @param u64Timestamp the time at which the change took place
972	* @note this call allocates memory which the reqNotify request is expected to
973	* free again, using RTStrFree().
974	*
975	* @thread HGCM service
976	*/
977	void Service::doNotifications(const char *pszProperty, uint64_t u64Timestamp)
978	{
979	int rc = VINF_SUCCESS;
980
981	AssertPtrReturnVoid(pszProperty);
982	/* Ensure that our timestamp is different to the last one. */
983	if ( !mGuestNotifications.empty()
984	&& u64Timestamp == mGuestNotifications.back().mTimestamp)
985	++u64Timestamp;
986
987	/*
988	* Try to find the property. Create a change event if we find it and a
989	* delete event if we do not.
990	*/
991	Property prop;
992	prop.mName = pszProperty;
993	prop.mTimestamp = u64Timestamp;
994	/* prop is currently a delete event for pszProperty */
995	bool found = false;
996	if (RT_SUCCESS(rc))
997	for (PropertyList::const_iterator it = mProperties.begin();
998	!found && it != mProperties.end(); ++it)
999	if (it->mName.compare(pszProperty) == 0)
1000	{
1001	found = true;
1002	/* Make prop into a change event. */
1003	prop.mValue = it->mValue;
1004	prop.mFlags = it->mFlags;
1005	}
1006
1007
1008	/* Release waiters if applicable and add the event to the queue for
1009	* guest notifications */
1010	if (RT_SUCCESS(rc))
1011	{
1012	try
1013	{
1014	for (CallList::iterator it = mGuestWaiters.begin();
1015	it != mGuestWaiters.end(); ++it)
1016	{
1017	const char *pszPatterns;
1018	uint32_t cchPatterns;
1019	it->mParms[0].getPointer((void **) &pszPatterns, &cchPatterns);
1020	if (prop.Matches(pszPatterns))
1021	{
1022	GuestCall call = mGuestWaiters.back();
1023	int rc2 = getNotificationWriteOut(call.mParms, prop);
1024	if (RT_SUCCESS(rc2))
1025	rc2 = call.mRc;
1026	mpHelpers->pfnCallComplete (call.mHandle, rc2);
1027	it = mGuestWaiters.erase(it);
1028	}
1029	}
1030	mGuestNotifications.push_back(prop);
1031	}
1032	catch (std::bad_alloc)
1033	{
1034	rc = VERR_NO_MEMORY;
1035	}
1036	}
1037	if (mGuestNotifications.size() > MAX_GUEST_NOTIFICATIONS)
1038	mGuestNotifications.pop_front();
1039
1040	#ifndef VBOX_GUEST_PROP_TEST_NOTHREAD
1041	/*
1042	* Host notifications - first case: if the property exists then send its
1043	* current value
1044	*/
1045	char pszName = NULL, pszValue = NULL, *pszFlags = NULL;
1046
1047	if (found && mpfnHostCallback != NULL)
1048	{
1049	char szFlags[MAX_FLAGS_LEN];
1050	/* Send out a host notification */
1051	rc = writeFlags(prop.mFlags, szFlags);
1052	if (RT_SUCCESS(rc))
1053	rc = RTStrDupEx(&pszName, pszProperty);
1054	if (RT_SUCCESS(rc))
1055	rc = RTStrDupEx(&pszValue, prop.mValue.c_str());
1056	if (RT_SUCCESS(rc))
1057	rc = RTStrDupEx(&pszFlags, szFlags);
1058	if (RT_SUCCESS(rc))
1059	rc = RTReqCallEx(mReqQueue, NULL, 0, RTREQFLAGS_NO_WAIT,
1060	(PFNRT)Service::reqNotify, 7, mpfnHostCallback,
1061	mpvHostData, pszName, pszValue,
1062	(uint32_t) RT_HIDWORD(u64Timestamp),
1063	(uint32_t) RT_LODWORD(u64Timestamp), pszFlags);
1064	}
1065
1066	/*
1067	* Host notifications - second case: if the property does not exist then
1068	* send the host an empty value
1069	*/
1070	if (!found && mpfnHostCallback != NULL)
1071	{
1072	/* Send out a host notification */
1073	rc = RTStrDupEx(&pszName, pszProperty);
1074	if (RT_SUCCESS(rc))
1075	rc = RTReqCallEx(mReqQueue, NULL, 0, RTREQFLAGS_NO_WAIT,
1076	(PFNRT)Service::reqNotify, 7, mpfnHostCallback,
1077	mpvHostData, pszName, NULL,
1078	(uint32_t) RT_HIDWORD(u64Timestamp),
1079	(uint32_t) RT_LODWORD(u64Timestamp), NULL);
1080	}
1081	if (RT_FAILURE(rc)) /* clean up if we failed somewhere */
1082	{
1083	RTStrFree(pszName);
1084	RTStrFree(pszValue);
1085	RTStrFree(pszFlags);
1086	}
1087	#endif /* VBOX_GUEST_PROP_TEST_NOTHREAD not defined */
1088	}
1089
1090	/**
1091	* Notify the service owner that a property has been added/deleted/changed.
1092	* asynchronous part.
1093	* @param pszProperty the name of the property which has changed
1094	* @note this call allocates memory which the reqNotify request is expected to
1095	* free again, using RTStrFree().
1096	*
1097	* @thread request thread
1098	*/
1099	int Service::reqNotify(PFNHGCMSVCEXT pfnCallback, void *pvData,
1100	char pszName, char pszValue, uint32_t u32TimeHigh,
1101	uint32_t u32TimeLow, char *pszFlags)
1102	{
1103	HOSTCALLBACKDATA HostCallbackData;
1104	HostCallbackData.u32Magic = HOSTCALLBACKMAGIC;
1105	HostCallbackData.pcszName = pszName;
1106	HostCallbackData.pcszValue = pszValue;
1107	HostCallbackData.u64Timestamp = RT_MAKE_U64(u32TimeLow, u32TimeHigh);
1108	HostCallbackData.pcszFlags = pszFlags;
1109	AssertRC(pfnCallback(pvData, 0, reinterpret_cast<void *>(&HostCallbackData),
1110	sizeof(HostCallbackData)));
1111	RTStrFree(pszName);
1112	RTStrFree(pszValue);
1113	RTStrFree(pszFlags);
1114	return VINF_SUCCESS;
1115	}
1116
1117
1118	/**
1119	* Handle an HGCM service call.
1120	* @copydoc VBOXHGCMSVCFNTABLE::pfnCall
1121	* @note All functions which do not involve an unreasonable delay will be
1122	* handled synchronously. If needed, we will add a request handler
1123	* thread in future for those which do.
1124	*
1125	* @thread HGCM
1126	*/
1127	void Service::call (VBOXHGCMCALLHANDLE callHandle, uint32_t u32ClientID,
1128	void * /* pvClient */, uint32_t eFunction, uint32_t cParms,
1129	VBOXHGCMSVCPARM paParms[])
1130	{
1131	int rc = VINF_SUCCESS;
1132	LogFlowFunc(("u32ClientID = %d, fn = %d, cParms = %d, pparms = %d\n",
1133	u32ClientID, eFunction, cParms, paParms));
1134
1135	try
1136	{
1137	switch (eFunction)
1138	{
1139	/* The guest wishes to read a property */
1140	case GET_PROP:
1141	LogFlowFunc(("GET_PROP\n"));
1142	rc = getProperty(cParms, paParms);
1143	break;
1144
1145	/* The guest wishes to set a property */
1146	case SET_PROP:
1147	LogFlowFunc(("SET_PROP\n"));
1148	rc = setProperty(cParms, paParms, true);
1149	break;
1150
1151	/* The guest wishes to set a property value */
1152	case SET_PROP_VALUE:
1153	LogFlowFunc(("SET_PROP_VALUE\n"));
1154	rc = setProperty(cParms, paParms, true);
1155	break;
1156
1157	/* The guest wishes to remove a configuration value */
1158	case DEL_PROP:
1159	LogFlowFunc(("DEL_PROP\n"));
1160	rc = delProperty(cParms, paParms, true);
1161	break;
1162
1163	/* The guest wishes to enumerate all properties */
1164	case ENUM_PROPS:
1165	LogFlowFunc(("ENUM_PROPS\n"));
1166	rc = enumProps(cParms, paParms);
1167	break;
1168
1169	/* The guest wishes to get the next property notification */
1170	case GET_NOTIFICATION:
1171	LogFlowFunc(("GET_NOTIFICATION\n"));
1172	rc = getNotification(callHandle, cParms, paParms);
1173	break;
1174
1175	default:
1176	rc = VERR_NOT_IMPLEMENTED;
1177	}
1178	}
1179	catch (std::bad_alloc)
1180	{
1181	rc = VERR_NO_MEMORY;
1182	}
1183	LogFlowFunc(("rc = %Rrc\n", rc));
1184	if (rc != VINF_HGCM_ASYNC_EXECUTE)
1185	{
1186	mpHelpers->pfnCallComplete (callHandle, rc);
1187	}
1188	}
1189
1190
1191	/**
1192	* Service call handler for the host.
1193	* @copydoc VBOXHGCMSVCFNTABLE::pfnHostCall
1194	* @thread hgcm
1195	*/
1196	int Service::hostCall (uint32_t eFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
1197	{
1198	int rc = VINF_SUCCESS;
1199
1200	LogFlowFunc(("fn = %d, cParms = %d, pparms = %d\n",
1201	eFunction, cParms, paParms));
1202
1203	try
1204	{
1205	switch (eFunction)
1206	{
1207	/* The host wishes to set a block of properties */
1208	case SET_PROPS_HOST:
1209	LogFlowFunc(("SET_PROPS_HOST\n"));
1210	rc = setPropertyBlock(cParms, paParms);
1211	break;
1212
1213	/* The host wishes to read a configuration value */
1214	case GET_PROP_HOST:
1215	LogFlowFunc(("GET_PROP_HOST\n"));
1216	rc = getProperty(cParms, paParms);
1217	break;
1218
1219	/* The host wishes to set a configuration value */
1220	case SET_PROP_HOST:
1221	LogFlowFunc(("SET_PROP_HOST\n"));
1222	rc = setProperty(cParms, paParms, false);
1223	break;
1224
1225	/* The host wishes to set a configuration value */
1226	case SET_PROP_VALUE_HOST:
1227	LogFlowFunc(("SET_PROP_VALUE_HOST\n"));
1228	rc = setProperty(cParms, paParms, false);
1229	break;
1230
1231	/* The host wishes to remove a configuration value */
1232	case DEL_PROP_HOST:
1233	LogFlowFunc(("DEL_PROP_HOST\n"));
1234	rc = delProperty(cParms, paParms, false);
1235	break;
1236
1237	/* The host wishes to enumerate all properties */
1238	case ENUM_PROPS_HOST:
1239	LogFlowFunc(("ENUM_PROPS\n"));
1240	rc = enumProps(cParms, paParms);
1241	break;
1242
1243	default:
1244	rc = VERR_NOT_SUPPORTED;
1245	break;
1246	}
1247	}
1248	catch (std::bad_alloc)
1249	{
1250	rc = VERR_NO_MEMORY;
1251	}
1252
1253	LogFlowFunc(("rc = %Rrc\n", rc));
1254	return rc;
1255	}
1256
1257	int Service::uninit()
1258	{
1259	int rc = VINF_SUCCESS;
1260	unsigned count = 0;
1261
1262	mfExitThread = true;
1263	#ifndef VBOX_GUEST_PROP_TEST_NOTHREAD
1264	rc = RTReqCallEx(mReqQueue, NULL, 0, RTREQFLAGS_NO_WAIT, (PFNRT)reqVoid, 0);
1265	if (RT_SUCCESS(rc))
1266	do
1267	{
1268	rc = RTThreadWait(mReqThread, 1000, NULL);
1269	++count;
1270	Assert(RT_SUCCESS(rc) \|\| ((VERR_TIMEOUT == rc) && (count != 5)));
1271	} while ((VERR_TIMEOUT == rc) && (count < 300));
1272	#endif /* VBOX_GUEST_PROP_TEST_NOTHREAD not defined */
1273	if (RT_SUCCESS(rc))
1274	RTReqDestroyQueue(mReqQueue);
1275	return rc;
1276	}
1277
1278	} /* namespace guestProp */
1279
1280	using guestProp::Service;
1281
1282	/**
1283	* @copydoc VBOXHGCMSVCLOAD
1284	*/
1285	extern "C" DECLCALLBACK(DECLEXPORT(int)) VBoxHGCMSvcLoad (VBOXHGCMSVCFNTABLE *ptable)
1286	{
1287	int rc = VINF_SUCCESS;
1288
1289	LogFlowFunc(("ptable = %p\n", ptable));
1290
1291	if (!VALID_PTR(ptable))
1292	{
1293	rc = VERR_INVALID_PARAMETER;
1294	}
1295	else
1296	{
1297	LogFlowFunc(("ptable->cbSize = %d, ptable->u32Version = 0x%08X\n", ptable->cbSize, ptable->u32Version));
1298
1299	if ( ptable->cbSize != sizeof (VBOXHGCMSVCFNTABLE)
1300	\|\| ptable->u32Version != VBOX_HGCM_SVC_VERSION)
1301	{
1302	rc = VERR_VERSION_MISMATCH;
1303	}
1304	else
1305	{
1306	std::auto_ptr<Service> apService;
1307	/* No exceptions may propogate outside. */
1308	try {
1309	apService = std::auto_ptr<Service>(new Service(ptable->pHelpers));
1310	} catch (int rcThrown) {
1311	rc = rcThrown;
1312	} catch (...) {
1313	rc = VERR_UNRESOLVED_ERROR;
1314	}
1315
1316	if (RT_SUCCESS(rc))
1317	{
1318	/* We do not maintain connections, so no client data is needed. */
1319	ptable->cbClient = 0;
1320
1321	ptable->pfnUnload = Service::svcUnload;
1322	ptable->pfnConnect = Service::svcConnectDisconnect;
1323	ptable->pfnDisconnect = Service::svcConnectDisconnect;
1324	ptable->pfnCall = Service::svcCall;
1325	ptable->pfnHostCall = Service::svcHostCall;
1326	ptable->pfnSaveState = NULL; /* The service is stateless, so the normal */
1327	ptable->pfnLoadState = NULL; /* construction done before restoring suffices */
1328	ptable->pfnRegisterExtension = Service::svcRegisterExtension;
1329
1330	/* Service specific initialization. */
1331	ptable->pvService = apService.release();
1332	}
1333	}
1334	}
1335
1336	LogFlowFunc(("returning %Rrc\n", rc));
1337	return rc;
1338	}

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

source: vbox/trunk/src/VBox/HostServices/GuestProperties/service.cpp@ 14295

Download in other formats: