VBoxGuestR3LibGuestProp.cpp@ 60337

Last change on this file since 60337 was 58204, checked in by vboxsync, 9 years ago
VBoxGuestLib: Fixed doxygen warnings.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 36.2 KB

Line
1	/* $Id: VBoxGuestR3LibGuestProp.cpp 58204 2015-10-12 16:10:11Z vboxsync $ */
2	/** @file
3	* VBoxGuestR3Lib - Ring-3 Support Library for VirtualBox guest additions, guest properties.
4	*/
5
6	/*
7	* Copyright (C) 2007-2015 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*/
26
27	#if defined(VBOX_VBGLR3_XFREE86) \|\| defined(VBOX_VBGLR3_XORG)
28	# define VBOX_VBGLR3_XSERVER
29	#endif
30
31
32	/*********************************************************************************************************************************
33	* Header Files *
34	*********************************************************************************************************************************/
35	#include <iprt/string.h>
36	#ifndef VBOX_VBGLR3_XSERVER
37	# include <iprt/mem.h>
38	#endif
39	#include <iprt/assert.h>
40	#include <iprt/stdarg.h>
41	#include <VBox/log.h>
42	#include <VBox/HostServices/GuestPropertySvc.h>
43
44	#include "VBGLR3Internal.h"
45
46	#ifdef VBOX_VBGLR3_XFREE86
47	/* Rather than try to resolve all the header file conflicts, I will just
48	prototype what we need here. */
49	extern "C" char* xf86strcpy(char,const char);
50	# undef strcpy
51	# define strcpy xf86strcpy
52	extern "C" void* xf86memchr(const void*,int,xf86size_t);
53	# undef memchr
54	# define memchr xf86memchr
55	extern "C" void* xf86memset(const void*,int,xf86size_t);
56	# undef memset
57	# define memset xf86memset
58
59	#endif /* VBOX_VBGLR3_XFREE86 */
60
61	#ifdef VBOX_VBGLR3_XSERVER
62
63	# undef RTStrEnd
64	# define RTStrEnd xf86RTStrEnd
65
66	DECLINLINE(char const ) RTStrEnd(char const pszString, size_t cchMax)
67	{
68	/* Avoid potential issues with memchr seen in glibc.
69	* See sysdeps/x86_64/memchr.S in glibc versions older than 2.11 */
70	while (cchMax > RTSTR_MEMCHR_MAX)
71	{
72	char const pszRet = (char const )memchr(pszString, '\0', RTSTR_MEMCHR_MAX);
73	if (RT_LIKELY(pszRet))
74	return pszRet;
75	pszString += RTSTR_MEMCHR_MAX;
76	cchMax -= RTSTR_MEMCHR_MAX;
77	}
78	return (char const *)memchr(pszString, '\0', cchMax);
79	}
80
81	DECLINLINE(char ) RTStrEnd(char pszString, size_t cchMax)
82	{
83	/* Avoid potential issues with memchr seen in glibc.
84	* See sysdeps/x86_64/memchr.S in glibc versions older than 2.11 */
85	while (cchMax > RTSTR_MEMCHR_MAX)
86	{
87	char pszRet = (char )memchr(pszString, '\0', RTSTR_MEMCHR_MAX);
88	if (RT_LIKELY(pszRet))
89	return pszRet;
90	pszString += RTSTR_MEMCHR_MAX;
91	cchMax -= RTSTR_MEMCHR_MAX;
92	}
93	return (char *)memchr(pszString, '\0', cchMax);
94	}
95
96	#endif /* VBOX_VBGLR3_XSERVER */
97
98
99	/*********************************************************************************************************************************
100	* Structures and Typedefs *
101	*********************************************************************************************************************************/
102	/**
103	* Structure containing information needed to enumerate through guest
104	* properties.
105	*
106	* @remarks typedef in VBoxGuestLib.h.
107	*/
108	struct VBGLR3GUESTPROPENUM
109	{
110	/** @todo add a magic and validate the handle. */
111	/** The buffer containing the raw enumeration data */
112	char *pchBuf;
113	/** The end of the buffer */
114	char *pchBufEnd;
115	/** Pointer to the next entry to enumerate inside the buffer */
116	char *pchNext;
117	};
118
119	using namespace guestProp;
120
121	/**
122	* Connects to the guest property service.
123	*
124	* @returns VBox status code
125	* @returns VERR_NOT_SUPPORTED if guest properties are not available on the host.
126	* @param pidClient Where to put the client ID on success. The client ID
127	* must be passed to all the other calls to the service.
128	*/
129	VBGLR3DECL(int) VbglR3GuestPropConnect(HGCMCLIENTID *pidClient)
130	{
131	VBoxGuestHGCMConnectInfo Info;
132	Info.result = VERR_WRONG_ORDER;
133	Info.Loc.type = VMMDevHGCMLoc_LocalHost_Existing;
134	RT_ZERO(Info.Loc.u);
135	strcpy(Info.Loc.u.host.achName, "VBoxGuestPropSvc");
136	Info.u32ClientID = UINT32_MAX; /* try make valgrind shut up. */
137
138	int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CONNECT, &Info, sizeof(Info));
139	if (RT_SUCCESS(rc))
140	{
141	rc = Info.result;
142	if (RT_SUCCESS(rc))
143	*pidClient = Info.u32ClientID;
144	if (rc == VERR_NOT_IMPLEMENTED \|\| rc == VERR_HGCM_SERVICE_NOT_FOUND)
145	rc = VERR_NOT_SUPPORTED;
146	}
147	return rc;
148	}
149
150
151	/**
152	* Disconnect from the guest property service.
153	*
154	* @returns VBox status code.
155	* @param idClient The client id returned by VbglR3InfoSvcConnect().
156	*/
157	VBGLR3DECL(int) VbglR3GuestPropDisconnect(HGCMCLIENTID idClient)
158	{
159	VBoxGuestHGCMDisconnectInfo Info;
160	Info.result = VERR_WRONG_ORDER;
161	Info.u32ClientID = idClient;
162
163	int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_DISCONNECT, &Info, sizeof(Info));
164	if (RT_SUCCESS(rc))
165	rc = Info.result;
166	return rc;
167	}
168
169
170	/**
171	* Write a property value.
172	*
173	* @returns VBox status code.
174	* @param idClient The client id returned by VbglR3InvsSvcConnect().
175	* @param pszName The property to save to. Utf8
176	* @param pszValue The value to store. Utf8. If this is NULL then
177	* the property will be removed.
178	* @param pszFlags The flags for the property
179	*/
180	VBGLR3DECL(int) VbglR3GuestPropWrite(HGCMCLIENTID idClient, const char pszName, const char pszValue, const char *pszFlags)
181	{
182	int rc;
183
184	if (pszValue != NULL)
185	{
186	SetProperty Msg;
187
188	Msg.hdr.result = VERR_WRONG_ORDER;
189	Msg.hdr.u32ClientID = idClient;
190	Msg.hdr.u32Function = SET_PROP_VALUE;
191	Msg.hdr.cParms = 3;
192	VbglHGCMParmPtrSetString(&Msg.name, pszName);
193	VbglHGCMParmPtrSetString(&Msg.value, pszValue);
194	VbglHGCMParmPtrSetString(&Msg.flags, pszFlags);
195	rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
196	if (RT_SUCCESS(rc))
197	rc = Msg.hdr.result;
198	}
199	else
200	{
201	DelProperty Msg;
202
203	Msg.hdr.result = VERR_WRONG_ORDER;
204	Msg.hdr.u32ClientID = idClient;
205	Msg.hdr.u32Function = DEL_PROP;
206	Msg.hdr.cParms = 1;
207	VbglHGCMParmPtrSetString(&Msg.name, pszName);
208	rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
209	if (RT_SUCCESS(rc))
210	rc = Msg.hdr.result;
211	}
212	return rc;
213	}
214
215
216	/**
217	* Write a property value.
218	*
219	* @returns VBox status code.
220	*
221	* @param idClient The client id returned by VbglR3InvsSvcConnect().
222	* @param pszName The property to save to. Must be valid UTF-8.
223	* @param pszValue The value to store. Must be valid UTF-8.
224	* If this is NULL then the property will be removed.
225	*
226	* @note if the property already exists and pszValue is not NULL then the
227	* property's flags field will be left unchanged
228	*/
229	VBGLR3DECL(int) VbglR3GuestPropWriteValue(HGCMCLIENTID idClient, const char pszName, const char pszValue)
230	{
231	int rc;
232
233	if (pszValue != NULL)
234	{
235	SetPropertyValue Msg;
236
237	Msg.hdr.result = VERR_WRONG_ORDER;
238	Msg.hdr.u32ClientID = idClient;
239	Msg.hdr.u32Function = SET_PROP_VALUE;
240	Msg.hdr.cParms = 2;
241	VbglHGCMParmPtrSetString(&Msg.name, pszName);
242	VbglHGCMParmPtrSetString(&Msg.value, pszValue);
243	rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
244	if (RT_SUCCESS(rc))
245	rc = Msg.hdr.result;
246	}
247	else
248	{
249	DelProperty Msg;
250
251	Msg.hdr.result = VERR_WRONG_ORDER;
252	Msg.hdr.u32ClientID = idClient;
253	Msg.hdr.u32Function = DEL_PROP;
254	Msg.hdr.cParms = 1;
255	VbglHGCMParmPtrSetString(&Msg.name, pszName);
256	rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
257	if (RT_SUCCESS(rc))
258	rc = Msg.hdr.result;
259	}
260	return rc;
261	}
262
263	#ifndef VBOX_VBGLR3_XSERVER
264	/**
265	* Write a property value where the value is formatted in RTStrPrintfV fashion.
266	*
267	* @returns The same as VbglR3GuestPropWriteValue with the addition of VERR_NO_STR_MEMORY.
268	*
269	* @param idClient The client ID returned by VbglR3InvsSvcConnect().
270	* @param pszName The property to save to. Must be valid UTF-8.
271	* @param pszValueFormat The value format. This must be valid UTF-8 when fully formatted.
272	* @param va The format arguments.
273	*/
274	VBGLR3DECL(int) VbglR3GuestPropWriteValueV(HGCMCLIENTID idClient, const char pszName, const char pszValueFormat, va_list va)
275	{
276	/*
277	* Format the value and pass it on to the setter.
278	*/
279	int rc = VERR_NO_STR_MEMORY;
280	char *pszValue;
281	if (RTStrAPrintfV(&pszValue, pszValueFormat, va) >= 0)
282	{
283	rc = VbglR3GuestPropWriteValue(idClient, pszName, pszValue);
284	RTStrFree(pszValue);
285	}
286	return rc;
287	}
288
289
290	/**
291	* Write a property value where the value is formatted in RTStrPrintf fashion.
292	*
293	* @returns The same as VbglR3GuestPropWriteValue with the addition of VERR_NO_STR_MEMORY.
294	*
295	* @param idClient The client ID returned by VbglR3InvsSvcConnect().
296	* @param pszName The property to save to. Must be valid UTF-8.
297	* @param pszValueFormat The value format. This must be valid UTF-8 when fully formatted.
298	* @param ... The format arguments.
299	*/
300	VBGLR3DECL(int) VbglR3GuestPropWriteValueF(HGCMCLIENTID idClient, const char pszName, const char pszValueFormat, ...)
301	{
302	va_list va;
303	va_start(va, pszValueFormat);
304	int rc = VbglR3GuestPropWriteValueV(idClient, pszName, pszValueFormat, va);
305	va_end(va);
306	return rc;
307	}
308	#endif /* VBOX_VBGLR3_XSERVER */
309
310	/**
311	* Retrieve a property.
312	*
313	* @returns VBox status code.
314	* @retval VINF_SUCCESS on success, pszValue, pu64Timestamp and pszFlags
315	* containing valid data.
316	* @retval VERR_BUFFER_OVERFLOW if the scratch buffer @a pcBuf is not large
317	* enough. In this case the size needed will be placed in
318	* @a pcbBufActual if it is not NULL.
319	* @retval VERR_NOT_FOUND if the key wasn't found.
320	*
321	* @param idClient The client id returned by VbglR3GuestPropConnect().
322	* @param pszName The value to read. Utf8
323	* @param pvBuf A scratch buffer to store the data retrieved into.
324	* The returned data is only valid for it's lifetime.
325	* @a ppszValue will point to the start of this buffer.
326	* @param cbBuf The size of @a pcBuf
327	* @param ppszValue Where to store the pointer to the value retrieved.
328	* Optional.
329	* @param pu64Timestamp Where to store the timestamp. Optional.
330	* @param ppszFlags Where to store the pointer to the flags. Optional.
331	* @param pcbBufActual If @a pcBuf is not large enough, the size needed.
332	* Optional.
333	*/
334	VBGLR3DECL(int) VbglR3GuestPropRead(HGCMCLIENTID idClient, const char *pszName,
335	void *pvBuf, uint32_t cbBuf,
336	char *ppszValue, uint64_t pu64Timestamp,
337	char **ppszFlags,
338	uint32_t *pcbBufActual)
339	{
340	/*
341	* Create the GET_PROP message and call the host.
342	*/
343	GetProperty Msg;
344
345	Msg.hdr.result = VERR_WRONG_ORDER;
346	Msg.hdr.u32ClientID = idClient;
347	Msg.hdr.u32Function = GET_PROP;
348	Msg.hdr.cParms = 4;
349	VbglHGCMParmPtrSetString(&Msg.name, pszName);
350	VbglHGCMParmPtrSet(&Msg.buffer, pvBuf, cbBuf);
351	VbglHGCMParmUInt64Set(&Msg.timestamp, 0);
352	VbglHGCMParmUInt32Set(&Msg.size, 0);
353
354	int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
355	if (RT_SUCCESS(rc))
356	rc = Msg.hdr.result;
357
358	/*
359	* The cbBufActual parameter is also returned on overflow so the call can
360	* adjust his/her buffer.
361	*/
362	if ( rc == VERR_BUFFER_OVERFLOW
363	\|\| pcbBufActual != NULL)
364	{
365	int rc2 = VbglHGCMParmUInt32Get(&Msg.size, pcbBufActual);
366	AssertRCReturn(rc2, RT_FAILURE(rc) ? rc : rc2);
367	}
368	if (RT_FAILURE(rc))
369	return rc;
370
371	/*
372	* Buffer layout: Value\0Flags\0.
373	*
374	* If the caller cares about any of these strings, make sure things are
375	* properly terminated (paranoia).
376	*/
377	if ( RT_SUCCESS(rc)
378	&& (ppszValue != NULL \|\| ppszFlags != NULL))
379	{
380	/* Validate / skip 'Name'. */
381	char pszFlags = RTStrEnd((char )pvBuf, cbBuf) + 1;
382	AssertPtrReturn(pszFlags, VERR_TOO_MUCH_DATA);
383	if (ppszValue)
384	ppszValue = (char )pvBuf;
385
386	if (ppszFlags)
387	{
388	/* Validate 'Flags'. */
389	char pszEos = RTStrEnd(pszFlags, cbBuf - (pszFlags - (char )pvBuf));
390	AssertPtrReturn(pszEos, VERR_TOO_MUCH_DATA);
391	*ppszFlags = pszFlags;
392	}
393	}
394
395	/* And the timestamp, if requested. */
396	if (pu64Timestamp != NULL)
397	{
398	rc = VbglHGCMParmUInt64Get(&Msg.timestamp, pu64Timestamp);
399	AssertRCReturn(rc, rc);
400	}
401
402	return VINF_SUCCESS;
403	}
404
405	#ifndef VBOX_VBGLR3_XSERVER
406	/**
407	* Retrieve a property value, allocating space for it.
408	*
409	* @returns VBox status code.
410	* @retval VINF_SUCCESS on success, *ppszValue containing valid data.
411	* @retval VERR_NOT_FOUND if the key wasn't found.
412	* @retval VERR_TOO_MUCH_DATA if we were unable to determine the right size
413	* to allocate for the buffer. This can happen as the result of a
414	* race between our allocating space and the host changing the
415	* property value.
416	*
417	* @param idClient The client id returned by VbglR3GuestPropConnect().
418	* @param pszName The value to read. Must be valid UTF-8.
419	* @param ppszValue Where to store the pointer to the value returned.
420	* This is always set to NULL or to the result, even
421	* on failure.
422	*/
423	VBGLR3DECL(int) VbglR3GuestPropReadValueAlloc(HGCMCLIENTID idClient, const char pszName, char *ppszValue)
424	{
425	/*
426	* Quick input validation.
427	*/
428	AssertPtr(ppszValue);
429	*ppszValue = NULL;
430	AssertPtrReturn(pszName, VERR_INVALID_PARAMETER);
431
432	/*
433	* There is a race here between our reading the property size and the
434	* host changing the value before we read it. Try up to ten times and
435	* report the problem if that fails.
436	*/
437	char *pszValue = NULL;
438	void *pvBuf = NULL;
439	uint32_t cchBuf = MAX_VALUE_LEN;
440	int rc = VERR_BUFFER_OVERFLOW;
441	for (unsigned i = 0; i < 10 && rc == VERR_BUFFER_OVERFLOW; ++i)
442	{
443	/* We leave a bit of space here in case the maximum value is raised. */
444	cchBuf += 1024;
445	void *pvTmpBuf = RTMemRealloc(pvBuf, cchBuf);
446	if (pvTmpBuf)
447	{
448	pvBuf = pvTmpBuf;
449	rc = VbglR3GuestPropRead(idClient, pszName, pvBuf, cchBuf,
450	&pszValue, NULL, NULL, &cchBuf);
451	}
452	else
453	rc = VERR_NO_MEMORY;
454	}
455	if (RT_SUCCESS(rc))
456	{
457	Assert(pszValue == (char *)pvBuf);
458	*ppszValue = pszValue;
459	}
460	else
461	{
462	RTMemFree(pvBuf);
463	if (rc == VERR_BUFFER_OVERFLOW)
464	/* VERR_BUFFER_OVERFLOW has a different meaning here as a
465	* return code, but we need to report the race. */
466	rc = VERR_TOO_MUCH_DATA;
467	}
468
469	return rc;
470	}
471
472
473	/**
474	* Free the memory used by VbglR3GuestPropReadValueAlloc for returning a
475	* value.
476	*
477	* @param pszValue the memory to be freed. NULL pointers will be ignored.
478	*/
479	VBGLR3DECL(void) VbglR3GuestPropReadValueFree(char *pszValue)
480	{
481	RTMemFree(pszValue);
482	}
483	#endif /* VBOX_VBGLR3_XSERVER */
484
485	/**
486	* Retrieve a property value, using a user-provided buffer to store it.
487	*
488	* @returns VBox status code.
489	* @retval VINF_SUCCESS on success, pszValue containing valid data.
490	* @retval VERR_BUFFER_OVERFLOW and the size needed in pcchValueActual if the
491	* buffer provided was too small
492	* @retval VERR_NOT_FOUND if the key wasn't found.
493	*
494	* @note There is a race here between obtaining the size of the buffer
495	* needed to hold the value and the value being updated.
496	*
497	* @param idClient The client id returned by VbglR3GuestPropConnect().
498	* @param pszName The value to read. Utf8
499	* @param pszValue Where to store the value retrieved.
500	* @param cchValue The size of the buffer pointed to by @a pszValue
501	* @param pcchValueActual Where to store the size of the buffer needed if
502	* the buffer supplied is too small. Optional.
503	*/
504	VBGLR3DECL(int) VbglR3GuestPropReadValue(HGCMCLIENTID idClient, const char *pszName,
505	char *pszValue, uint32_t cchValue,
506	uint32_t *pcchValueActual)
507	{
508	void *pvBuf = pszValue;
509	uint32_t cchValueActual;
510	int rc = VbglR3GuestPropRead(idClient, pszName, pvBuf, cchValue, &pszValue, NULL, NULL, &cchValueActual);
511	if (pcchValueActual != NULL)
512	*pcchValueActual = cchValueActual;
513	return rc;
514	}
515
516
517	#ifndef VBOX_VBGLR3_XSERVER
518	/**
519	* Raw API for enumerating guest properties which match a given pattern.
520	*
521	* @returns VBox status code.
522	* @retval VINF_SUCCESS on success and pcBuf points to a packed array
523	* of the form \<name\>, \<value\>, \<timestamp string\>, \<flags\>,
524	* terminated by four empty strings. pcbBufActual will contain the
525	* total size of the array.
526	* @retval VERR_BUFFER_OVERFLOW if the buffer provided was too small. In
527	* this case pcbBufActual will contain the size of the buffer needed.
528	* @returns IPRT error code in other cases, and pchBufActual is undefined.
529	*
530	* @param idClient The client ID returned by VbglR3GuestPropConnect
531	* @param pszzPatterns A packed array of zero terminated strings, terminated
532	* by an empty string.
533	* @param pcBuf The buffer to store the results to.
534	* @param cbBuf The size of the buffer
535	* @param pcbBufActual Where to store the size of the returned data on
536	* success or the buffer size needed if @a pcBuf is too
537	* small.
538	*/
539	VBGLR3DECL(int) VbglR3GuestPropEnumRaw(HGCMCLIENTID idClient,
540	const char *pszzPatterns,
541	char *pcBuf,
542	uint32_t cbBuf,
543	uint32_t *pcbBufActual)
544	{
545	EnumProperties Msg;
546
547	Msg.hdr.result = VERR_WRONG_ORDER;
548	Msg.hdr.u32ClientID = idClient;
549	Msg.hdr.u32Function = ENUM_PROPS;
550	Msg.hdr.cParms = 3;
551	/* Get the length of the patterns array... */
552	size_t cchPatterns = 0;
553	for (size_t cchCurrent = strlen(pszzPatterns); cchCurrent != 0;
554	cchCurrent = strlen(pszzPatterns + cchPatterns))
555	cchPatterns += cchCurrent + 1;
556	/* ...including the terminator. */
557	++cchPatterns;
558	VbglHGCMParmPtrSet(&Msg.patterns, (char *)pszzPatterns, (uint32_t)cchPatterns);
559	VbglHGCMParmPtrSet(&Msg.strings, pcBuf, cbBuf);
560	VbglHGCMParmUInt32Set(&Msg.size, 0);
561
562	int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
563	if (RT_SUCCESS(rc))
564	rc = Msg.hdr.result;
565	if ( pcbBufActual
566	&& ( RT_SUCCESS(rc)
567	\|\| rc == VERR_BUFFER_OVERFLOW))
568	{
569	int rc2 = VbglHGCMParmUInt32Get(&Msg.size, pcbBufActual);
570	if (RT_FAILURE(rc2))
571	rc = rc2;
572	}
573	return rc;
574	}
575
576
577	/**
578	* Start enumerating guest properties which match a given pattern.
579	*
580	* This function creates a handle which can be used to continue enumerating.
581	*
582	* @returns VBox status code.
583	* @retval VINF_SUCCESS on success, *ppHandle points to a handle for continuing
584	* the enumeration and ppszName, ppszValue, *pu64Timestamp and
585	* *ppszFlags are set.
586	* @retval VERR_TOO_MUCH_DATA if it was not possible to determine the amount
587	* of local space needed to store all the enumeration data. This is
588	* due to a race between allocating space and the host adding new
589	* data, so retrying may help here. Other parameters are left
590	* uninitialised
591	*
592	* @param idClient The client id returned by VbglR3InfoSvcConnect().
593	* @param papszPatterns The patterns against which the properties are
594	* matched. Pass NULL if everything should be matched.
595	* @param cPatterns The number of patterns in @a papszPatterns. 0 means
596	* match everything.
597	* @param ppHandle where the handle for continued enumeration is stored
598	* on success. This must be freed with
599	* VbglR3GuestPropEnumFree when it is no longer needed.
600	* @param ppszName Where to store the next property name. This will be
601	* set to NULL if there are no more properties to
602	* enumerate. This pointer should not be freed. Optional.
603	* @param ppszValue Where to store the next property value. This will be
604	* set to NULL if there are no more properties to
605	* enumerate. This pointer should not be freed. Optional.
606	* @param pu64Timestamp Where to store the next property timestamp. This
607	* will be set to zero if there are no more properties
608	* to enumerate. Optional.
609	* @param ppszFlags Where to store the next property flags. This will be
610	* set to NULL if there are no more properties to
611	* enumerate. This pointer should not be freed. Optional.
612	*
613	* @remarks While all output parameters are optional, you need at least one to
614	* figure out when to stop.
615	*/
616	VBGLR3DECL(int) VbglR3GuestPropEnum(HGCMCLIENTID idClient,
617	char const * const *papszPatterns,
618	uint32_t cPatterns,
619	PVBGLR3GUESTPROPENUM *ppHandle,
620	char const **ppszName,
621	char const **ppszValue,
622	uint64_t *pu64Timestamp,
623	char const **ppszFlags)
624	{
625	/* Create the handle. */
626	PVBGLR3GUESTPROPENUM pHandle = (PVBGLR3GUESTPROPENUM)RTMemAllocZ(sizeof(VBGLR3GUESTPROPENUM));
627	if (RT_LIKELY(pHandle))
628	{/* likely */}
629	else
630	return VERR_NO_MEMORY;
631
632	/* Get the length of the pattern string, including the final terminator. */
633	size_t cbPatterns = 1;
634	for (uint32_t i = 0; i < cPatterns; ++i)
635	cbPatterns += strlen(papszPatterns[i]) + 1;
636
637	/* Pack the pattern array. */
638	char pszzPatterns = (char )RTMemAlloc(cbPatterns);
639	size_t off = 0;
640	for (uint32_t i = 0; i < cPatterns; ++i)
641	{
642	size_t cb = strlen(papszPatterns[i]) + 1;
643	memcpy(&pszzPatterns[off], papszPatterns[i], cb);
644	off += cb;
645	}
646	pszzPatterns[off] = '\0';
647
648	/* In reading the guest property data we are racing against the host
649	* adding more of it, so loop a few times and retry on overflow. */
650	uint32_t cbBuf = 4096; /* picked out of thin air */
651	char *pchBuf = NULL;
652	int rc = VINF_SUCCESS;
653	for (int i = 0; i < 10; ++i)
654	{
655	void *pvNew = RTMemRealloc(pchBuf, cbBuf);
656	if (pvNew)
657	pchBuf = (char *)pvNew;
658	else
659	{
660	rc = VERR_NO_MEMORY;
661	break;
662	}
663	rc = VbglR3GuestPropEnumRaw(idClient, pszzPatterns, pchBuf, cbBuf, &cbBuf);
664	if (rc != VERR_BUFFER_OVERFLOW)
665	break;
666	cbBuf += 4096; /* Just to increase our chances */
667	}
668	RTMemFree(pszzPatterns);
669	if (RT_SUCCESS(rc))
670	{
671	/*
672	* Complete the handle and call VbglR3GuestPropEnumNext to retrieve the first entry.
673	*/
674	pHandle->pchNext = pchBuf;
675	pHandle->pchBuf = pchBuf;
676	pHandle->pchBufEnd = pchBuf + cbBuf;
677
678	const char *pszNameTmp;
679	if (!ppszName)
680	ppszName = &pszNameTmp;
681	rc = VbglR3GuestPropEnumNext(pHandle, ppszName, ppszValue, pu64Timestamp, ppszFlags);
682	if (RT_SUCCESS(rc))
683	{
684	*ppHandle = pHandle;
685	return rc;
686	}
687	}
688	else if (rc == VERR_BUFFER_OVERFLOW)
689	rc = VERR_TOO_MUCH_DATA;
690	RTMemFree(pchBuf);
691	RTMemFree(pHandle);
692	return rc;
693	}
694
695
696	/**
697	* Get the next guest property.
698	*
699	* See @a VbglR3GuestPropEnum.
700	*
701	* @returns VBox status code.
702	*
703	* @param pHandle Handle obtained from @a VbglR3GuestPropEnum.
704	* @param ppszName Where to store the next property name. This will be
705	* set to NULL if there are no more properties to
706	* enumerate. This pointer should not be freed. Optional.
707	* @param ppszValue Where to store the next property value. This will be
708	* set to NULL if there are no more properties to
709	* enumerate. This pointer should not be freed. Optional.
710	* @param pu64Timestamp Where to store the next property timestamp. This
711	* will be set to zero if there are no more properties
712	* to enumerate. Optional.
713	* @param ppszFlags Where to store the next property flags. This will be
714	* set to NULL if there are no more properties to
715	* enumerate. This pointer should not be freed. Optional.
716	*
717	* @remarks While all output parameters are optional, you need at least one to
718	* figure out when to stop.
719	*/
720	VBGLR3DECL(int) VbglR3GuestPropEnumNext(PVBGLR3GUESTPROPENUM pHandle,
721	char const **ppszName,
722	char const **ppszValue,
723	uint64_t *pu64Timestamp,
724	char const **ppszFlags)
725	{
726	/*
727	* The VBGLR3GUESTPROPENUM structure contains a buffer containing the raw
728	* properties data and a pointer into the buffer which tracks how far we
729	* have parsed so far. The buffer contains packed strings in groups of
730	* four - name, value, timestamp (as a decimal string) and flags. It is
731	* terminated by four empty strings. We can rely on this layout unless
732	* the caller has been poking about in the structure internals, in which
733	* case they must take responsibility for the results.
734	*
735	* Layout:
736	* Name\0Value\0Timestamp\0Flags\0
737	*/
738	char pchNext = pHandle->pchNext; / The cursor. */
739	char pchEnd = pHandle->pchBufEnd; / End of buffer, for size calculations. */
740
741	char *pszName = pchNext;
742	char *pszValue = pchNext = RTStrEnd(pchNext, pchEnd - pchNext) + 1;
743	AssertPtrReturn(pchNext, VERR_PARSE_ERROR); /* 0x1 is also an invalid pointer :) */
744
745	char *pszTimestamp = pchNext = RTStrEnd(pchNext, pchEnd - pchNext) + 1;
746	AssertPtrReturn(pchNext, VERR_PARSE_ERROR);
747
748	char *pszFlags = pchNext = RTStrEnd(pchNext, pchEnd - pchNext) + 1;
749	AssertPtrReturn(pchNext, VERR_PARSE_ERROR);
750
751	/*
752	* Don't move the index pointer if we found the terminating "\0\0\0\0" entry.
753	* Don't try convert the timestamp either.
754	*/
755	uint64_t u64Timestamp;
756	if (*pszName != '\0')
757	{
758	pchNext = RTStrEnd(pchNext, pchEnd - pchNext) + 1;
759	AssertPtrReturn(pchNext, VERR_PARSE_ERROR);
760
761	/* Convert the timestamp string into a number. */
762	int rc = RTStrToUInt64Full(pszTimestamp, 0, &u64Timestamp);
763	AssertRCSuccessReturn(rc, VERR_PARSE_ERROR);
764
765	pHandle->pchNext = pchNext;
766	AssertPtr(pchNext);
767	}
768	else
769	{
770	u64Timestamp = 0;
771	AssertMsgReturn(!pszValue && !pszTimestamp && !*pszFlags,
772	("'%s' '%s' '%s'\n", pszValue, pszTimestamp, pszFlags),
773	VERR_PARSE_ERROR);
774	}
775
776	/*
777	* Everything is fine, set the return values.
778	*/
779	if (ppszName)
780	ppszName = pszName != '\0' ? pszName : NULL;
781	if (ppszValue)
782	ppszValue = pszValue != '\0' ? pszValue : NULL;
783	if (pu64Timestamp)
784	*pu64Timestamp = u64Timestamp;
785	if (ppszFlags)
786	ppszFlags = pszFlags != '\0' ? pszFlags : NULL;
787	return VINF_SUCCESS;
788	}
789
790
791	/**
792	* Free an enumeration handle returned by @a VbglR3GuestPropEnum.
793	* @param pHandle the handle to free
794	*/
795	VBGLR3DECL(void) VbglR3GuestPropEnumFree(PVBGLR3GUESTPROPENUM pHandle)
796	{
797	if (!pHandle)
798	return;
799	RTMemFree(pHandle->pchBuf);
800	RTMemFree(pHandle);
801	}
802
803
804	/**
805	* Deletes a guest property.
806	*
807	* @returns VBox status code.
808	* @param idClient The client id returned by VbglR3InvsSvcConnect().
809	* @param pszName The property to delete. Utf8
810	*/
811	VBGLR3DECL(int) VbglR3GuestPropDelete(HGCMCLIENTID idClient, const char *pszName)
812	{
813	AssertPtrReturn(pszName, VERR_INVALID_POINTER);
814
815	DelProperty Msg;
816
817	Msg.hdr.result = VERR_WRONG_ORDER;
818	Msg.hdr.u32ClientID = idClient;
819	Msg.hdr.u32Function = DEL_PROP;
820	Msg.hdr.cParms = 1;
821	VbglHGCMParmPtrSetString(&Msg.name, pszName);
822	int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
823	if (RT_SUCCESS(rc))
824	rc = Msg.hdr.result;
825
826	return rc;
827	}
828
829
830	/**
831	* Deletes a set of keys.
832	*
833	* The set is specified in the same way as for VbglR3GuestPropEnum.
834	*
835	* @returns VBox status code. Stops on first failure.
836	* See also VbglR3GuestPropEnum.
837	*
838	* @param idClient The client id returned by VbglR3InfoSvcConnect().
839	* @param papszPatterns The patterns against which the properties are
840	* matched. Pass NULL if everything should be matched.
841	* @param cPatterns The number of patterns in @a papszPatterns. 0 means
842	* match everything.
843	*/
844	VBGLR3DECL(int) VbglR3GuestPropDelSet(HGCMCLIENTID idClient,
845	const char * const *papszPatterns,
846	uint32_t cPatterns)
847	{
848	PVBGLR3GUESTPROPENUM pHandle;
849	char const pszName, pszValue, *pszFlags;
850	uint64_t pu64Timestamp;
851	int rc = VbglR3GuestPropEnum(idClient,
852	(char )papszPatterns, / @todo fix this cast. */
853	cPatterns,
854	&pHandle,
855	&pszName,
856	&pszValue,
857	&pu64Timestamp,
858	&pszFlags);
859
860	while (RT_SUCCESS(rc) && pszName)
861	{
862	rc = VbglR3GuestPropWriteValue(idClient, pszName, NULL);
863	if (RT_FAILURE(rc))
864	break;
865
866	rc = VbglR3GuestPropEnumNext(pHandle,
867	&pszName,
868	&pszValue,
869	&pu64Timestamp,
870	&pszFlags);
871	}
872
873	VbglR3GuestPropEnumFree(pHandle);
874	return rc;
875	}
876
877
878	/**
879	* Wait for notification of changes to a guest property. If this is called in
880	* a loop, the timestamp of the last notification seen can be passed as a
881	* parameter to be sure that no notifications are missed.
882	*
883	* @returns VBox status code.
884	* @retval VINF_SUCCESS on success, @a ppszName, @a ppszValue,
885	* @a pu64Timestamp and @a ppszFlags containing valid data.
886	* @retval VINF_NOT_FOUND if no previous notification could be found with the
887	* timestamp supplied. This will normally mean that a large number
888	* of notifications occurred in between.
889	* @retval VERR_BUFFER_OVERFLOW if the scratch buffer @a pvBuf is not large
890	* enough. In this case the size needed will be placed in
891	* @a pcbBufActual if it is not NULL.
892	* @retval VERR_TIMEOUT if a timeout occurred before a notification was seen.
893	*
894	* @param idClient The client id returned by VbglR3GuestPropConnect().
895	* @param pszPatterns The patterns that the property names must matchfor
896	* the change to be reported.
897	* @param pvBuf A scratch buffer to store the data retrieved into.
898	* The returned data is only valid for it's lifetime.
899	* @a ppszValue will point to the start of this buffer.
900	* @param cbBuf The size of @a pvBuf
901	* @param u64Timestamp The timestamp of the last event seen. Pass zero
902	* to wait for the next event.
903	* @param cMillies Timeout in milliseconds. Use RT_INDEFINITE_WAIT
904	* to wait indefinitely.
905	* @param ppszName Where to store the pointer to the name retrieved.
906	* Optional.
907	* @param ppszValue Where to store the pointer to the value retrieved.
908	* Optional.
909	* @param pu64Timestamp Where to store the timestamp. Optional.
910	* @param ppszFlags Where to store the pointer to the flags. Optional.
911	* @param pcbBufActual If @a pcBuf is not large enough, the size needed.
912	* Optional.
913	*/
914	VBGLR3DECL(int) VbglR3GuestPropWait(HGCMCLIENTID idClient,
915	const char *pszPatterns,
916	void *pvBuf, uint32_t cbBuf,
917	uint64_t u64Timestamp, uint32_t cMillies,
918	char ppszName, char ppszValue,
919	uint64_t pu64Timestamp, char *ppszFlags,
920	uint32_t *pcbBufActual)
921	{
922	/*
923	* Create the GET_NOTIFICATION message and call the host.
924	*/
925	GetNotification Msg;
926
927	Msg.hdr.u32Timeout = cMillies;
928	Msg.hdr.fInterruptible = true;
929	Msg.hdr.info.result = VERR_WRONG_ORDER;
930	Msg.hdr.info.u32ClientID = idClient;
931	Msg.hdr.info.u32Function = GET_NOTIFICATION;
932	Msg.hdr.info.cParms = 4;
933	VbglHGCMParmPtrSetString(&Msg.patterns, pszPatterns);
934	Msg.buffer.SetPtr(pvBuf, cbBuf);
935	Msg.timestamp.SetUInt64(u64Timestamp);
936	Msg.size.SetUInt32(0);
937
938	int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL_TIMED(sizeof(Msg)), &Msg, sizeof(Msg));
939	if (RT_SUCCESS(rc))
940	rc = Msg.hdr.info.result;
941
942	/*
943	* The cbBufActual parameter is also returned on overflow so the caller can
944	* adjust their buffer.
945	*/
946	if ( rc == VERR_BUFFER_OVERFLOW
947	\|\| pcbBufActual != NULL)
948	{
949	int rc2 = Msg.size.GetUInt32(pcbBufActual);
950	AssertRCReturn(rc2, RT_FAILURE(rc) ? rc : rc2);
951	}
952	if (RT_FAILURE(rc))
953	return rc;
954
955	/*
956	* Buffer layout: Name\0Value\0Flags\0.
957	*
958	* If the caller cares about any of these strings, make sure things are
959	* properly terminated (paranoia).
960	*/
961	if ( RT_SUCCESS(rc)
962	&& (ppszName != NULL \|\| ppszValue != NULL \|\| ppszFlags != NULL))
963	{
964	/* Validate / skip 'Name'. */
965	char pszValue = RTStrEnd((char )pvBuf, cbBuf) + 1;
966	AssertPtrReturn(pszValue, VERR_TOO_MUCH_DATA);
967	if (ppszName)
968	ppszName = (char )pvBuf;
969
970	/* Validate / skip 'Value'. */
971	char pszFlags = RTStrEnd(pszValue, cbBuf - (pszValue - (char )pvBuf)) + 1;
972	AssertPtrReturn(pszFlags, VERR_TOO_MUCH_DATA);
973	if (ppszValue)
974	*ppszValue = pszValue;
975
976	if (ppszFlags)
977	{
978	/* Validate 'Flags'. */
979	char pszEos = RTStrEnd(pszFlags, cbBuf - (pszFlags - (char )pvBuf));
980	AssertPtrReturn(pszEos, VERR_TOO_MUCH_DATA);
981	*ppszFlags = pszFlags;
982	}
983	}
984
985	/* And the timestamp, if requested. */
986	if (pu64Timestamp != NULL)
987	{
988	rc = Msg.timestamp.GetUInt64(pu64Timestamp);
989	AssertRCReturn(rc, rc);
990	}
991
992	return VINF_SUCCESS;
993	}
994	#endif /* VBOX_VBGLR3_XSERVER */

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

source: vbox/trunk/src/VBox/Additions/common/VBoxGuestLib/VBoxGuestR3LibGuestProp.cpp@ 60337

Download in other formats: