VirtualBox

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

Last change on this file since 69218 was 65706, checked in by vboxsync, 8 years ago

HostServices/GuestProperties: free all properties during uninit()
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 55.2 KB
Line 
1/* $Id: service.cpp 65706 2017-02-09 16:50:47Z vboxsync $ */
2/** @file
3 * Guest Property Service: Host service entry points.
4 */
5
6/*
7 * Copyright (C) 2008-2016 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18/** @page pg_svc_guest_properties Guest Property HGCM Service
19 *
20 * This HGCM service allows the guest to set and query values in a property
21 * store on the host. The service proxies the guest requests to the service
22 * owner on the host using a request callback provided by the owner, and is
23 * notified of changes to properties made by the host. It forwards these
24 * notifications to clients in the guest which have expressed interest and
25 * are waiting for notification.
26 *
27 * The service currently consists of two threads. One of these is the main
28 * HGCM service thread which deals with requests from the guest and from the
29 * host. The second thread sends the host asynchronous notifications of
30 * changes made by the guest and deals with notification timeouts.
31 *
32 * Guest requests to wait for notification are added to a list of open
33 * notification requests and completed when a corresponding guest property
34 * is changed or when the request times out.
35 */
36
37
38/*********************************************************************************************************************************
39* Header Files *
40*********************************************************************************************************************************/
41#define LOG_GROUP LOG_GROUP_HGCM
42#include <VBox/HostServices/GuestPropertySvc.h>
43
44#include <VBox/log.h>
45#include <iprt/asm.h>
46#include <iprt/assert.h>
47#include <iprt/cpp/autores.h>
48#include <iprt/cpp/utils.h>
49#include <iprt/err.h>
50#include <iprt/mem.h>
51#include <iprt/req.h>
52#include <iprt/string.h>
53#include <iprt/thread.h>
54#include <iprt/time.h>
55#include <VBox/vmm/dbgf.h>
56
57#include <string>
58#include <list>
59
60/** @todo Delete the old !ASYNC_HOST_NOTIFY code and remove this define. */
61#define ASYNC_HOST_NOTIFY
62
63namespace guestProp {
64
65/**
66 * Structure for holding a property
67 */
68struct Property
69{
70 /** The string space core record. */
71 RTSTRSPACECORE mStrCore;
72 /** The name of the property */
73 std::string mName;
74 /** The property value */
75 std::string mValue;
76 /** The timestamp of the property */
77 uint64_t mTimestamp;
78 /** The property flags */
79 uint32_t mFlags;
80
81 /** Default constructor */
82 Property() : mTimestamp(0), mFlags(NILFLAG)
83 {
84 RT_ZERO(mStrCore);
85 }
86 /** Constructor with const char * */
87 Property(const char *pcszName, const char *pcszValue,
88 uint64_t u64Timestamp, uint32_t u32Flags)
89 : mName(pcszName), mValue(pcszValue), mTimestamp(u64Timestamp),
90 mFlags(u32Flags)
91 {
92 RT_ZERO(mStrCore);
93 mStrCore.pszString = mName.c_str();
94 }
95 /** Constructor with std::string */
96 Property(std::string name, std::string value, uint64_t u64Timestamp,
97 uint32_t u32Flags)
98 : mName(name), mValue(value), mTimestamp(u64Timestamp),
99 mFlags(u32Flags) {}
100
101 /** Does the property name match one of a set of patterns? */
102 bool Matches(const char *pszPatterns) const
103 {
104 return ( pszPatterns[0] == '\0' /* match all */
105 || RTStrSimplePatternMultiMatch(pszPatterns, RTSTR_MAX,
106 mName.c_str(), RTSTR_MAX,
107 NULL)
108 );
109 }
110
111 /** Are two properties equal? */
112 bool operator==(const Property &prop)
113 {
114 if (mTimestamp != prop.mTimestamp)
115 return false;
116 if (mFlags != prop.mFlags)
117 return false;
118 if (mName != prop.mName)
119 return false;
120 if (mValue != prop.mValue)
121 return false;
122 return true;
123 }
124
125 /* Is the property nil? */
126 bool isNull()
127 {
128 return mName.empty();
129 }
130};
131/** The properties list type */
132typedef std::list <Property> PropertyList;
133
134/**
135 * Structure for holding an uncompleted guest call
136 */
137struct GuestCall
138{
139 uint32_t u32ClientId;
140 /** The call handle */
141 VBOXHGCMCALLHANDLE mHandle;
142 /** The function that was requested */
143 uint32_t mFunction;
144 /** Number of call parameters. */
145 uint32_t mParmsCnt;
146 /** The call parameters */
147 VBOXHGCMSVCPARM *mParms;
148 /** The default return value, used for passing warnings */
149 int mRc;
150
151 /** The standard constructor */
152 GuestCall(void) : u32ClientId(0), mFunction(0), mParmsCnt(0) {}
153 /** The normal constructor */
154 GuestCall(uint32_t aClientId, VBOXHGCMCALLHANDLE aHandle, uint32_t aFunction,
155 uint32_t aParmsCnt, VBOXHGCMSVCPARM aParms[], int aRc)
156 : u32ClientId(aClientId), mHandle(aHandle), mFunction(aFunction),
157 mParmsCnt(aParmsCnt), mParms(aParms), mRc(aRc) {}
158};
159/** The guest call list type */
160typedef std::list <GuestCall> CallList;
161
162/**
163 * Class containing the shared information service functionality.
164 */
165class Service : public RTCNonCopyable
166{
167private:
168 /** Type definition for use in callback functions */
169 typedef Service SELF;
170 /** HGCM helper functions. */
171 PVBOXHGCMSVCHELPERS mpHelpers;
172 /** Global flags for the service */
173 ePropFlags meGlobalFlags;
174 /** The property string space handle. */
175 RTSTRSPACE mhProperties;
176 /** The number of properties. */
177 unsigned mcProperties;
178 /** The list of property changes for guest notifications;
179 * only used for timestamp tracking in notifications at the moment */
180 PropertyList mGuestNotifications;
181 /** The list of outstanding guest notification calls */
182 CallList mGuestWaiters;
183 /** @todo we should have classes for thread and request handler thread */
184 /** Callback function supplied by the host for notification of updates
185 * to properties */
186 PFNHGCMSVCEXT mpfnHostCallback;
187 /** User data pointer to be supplied to the host callback function */
188 void *mpvHostData;
189 /** The previous timestamp.
190 * This is used by getCurrentTimestamp() to decrease the chance of
191 * generating duplicate timestamps. */
192 uint64_t mPrevTimestamp;
193 /** The number of consecutive timestamp adjustments that we've made.
194 * Together with mPrevTimestamp, this defines a set of obsolete timestamp
195 * values: {(mPrevTimestamp - mcTimestampAdjustments), ..., mPrevTimestamp} */
196 uint64_t mcTimestampAdjustments;
197
198 /**
199 * Get the next property change notification from the queue of saved
200 * notification based on the timestamp of the last notification seen.
201 * Notifications will only be reported if the property name matches the
202 * pattern given.
203 *
204 * @returns iprt status value
205 * @returns VWRN_NOT_FOUND if the last notification was not found in the queue
206 * @param pszPatterns the patterns to match the property name against
207 * @param u64Timestamp the timestamp of the last notification
208 * @param pProp where to return the property found. If none is
209 * found this will be set to nil.
210 * @thread HGCM
211 */
212 int getOldNotification(const char *pszPatterns, uint64_t u64Timestamp,
213 Property *pProp)
214 {
215 AssertPtrReturn(pszPatterns, VERR_INVALID_POINTER);
216 /* Zero means wait for a new notification. */
217 AssertReturn(u64Timestamp != 0, VERR_INVALID_PARAMETER);
218 AssertPtrReturn(pProp, VERR_INVALID_POINTER);
219 int rc = getOldNotificationInternal(pszPatterns, u64Timestamp, pProp);
220#ifdef VBOX_STRICT
221 /*
222 * ENSURE that pProp is the first event in the notification queue that:
223 * - Appears later than u64Timestamp
224 * - Matches the pszPatterns
225 */
226 /** @todo r=bird: This incorrectly ASSUMES that mTimestamp is unique.
227 * The timestamp resolution can be very coarse on windows for instance. */
228 PropertyList::const_iterator it = mGuestNotifications.begin();
229 for (; it != mGuestNotifications.end()
230 && it->mTimestamp != u64Timestamp; ++it)
231 {}
232 if (it == mGuestNotifications.end()) /* Not found */
233 it = mGuestNotifications.begin();
234 else
235 ++it; /* Next event */
236 for (; it != mGuestNotifications.end()
237 && it->mTimestamp != pProp->mTimestamp; ++it)
238 Assert(!it->Matches(pszPatterns));
239 if (pProp->mTimestamp != 0)
240 {
241 Assert(*pProp == *it);
242 Assert(pProp->Matches(pszPatterns));
243 }
244#endif /* VBOX_STRICT */
245 return rc;
246 }
247
248 /**
249 * Check whether we have permission to change a property.
250 *
251 * @returns Strict VBox status code.
252 * @retval VINF_SUCCESS if we do.
253 * @retval VERR_PERMISSION_DENIED if the value is read-only for the requesting
254 * side.
255 * @retval VINF_PERMISSION_DENIED if the side is globally marked read-only.
256 *
257 * @param eFlags the flags on the property in question
258 * @param isGuest is the guest or the host trying to make the change?
259 */
260 int checkPermission(ePropFlags eFlags, bool isGuest)
261 {
262 if (eFlags & (isGuest ? RDONLYGUEST : RDONLYHOST))
263 return VERR_PERMISSION_DENIED;
264 if (isGuest && (meGlobalFlags & RDONLYGUEST))
265 return VINF_PERMISSION_DENIED;
266 return VINF_SUCCESS;
267 }
268
269 /**
270 * Gets a property.
271 *
272 * @returns Pointer to the property if found, NULL if not.
273 *
274 * @param pszName The name of the property to get.
275 */
276 Property *getPropertyInternal(const char *pszName)
277 {
278 return (Property *)RTStrSpaceGet(&mhProperties, pszName);
279 }
280
281public:
282 explicit Service(PVBOXHGCMSVCHELPERS pHelpers)
283 : mpHelpers(pHelpers)
284 , meGlobalFlags(NILFLAG)
285 , mhProperties(NULL)
286 , mcProperties(0)
287 , mpfnHostCallback(NULL)
288 , mpvHostData(NULL)
289 , mPrevTimestamp(0)
290 , mcTimestampAdjustments(0)
291#ifdef ASYNC_HOST_NOTIFY
292 , mhThreadNotifyHost(NIL_RTTHREAD)
293 , mhReqQNotifyHost(NIL_RTREQQUEUE)
294#endif
295 { }
296
297 /**
298 * @interface_method_impl{VBOXHGCMSVCFNTABLE,pfnUnload}
299 * Simply deletes the service object
300 */
301 static DECLCALLBACK(int) svcUnload(void *pvService)
302 {
303 AssertLogRelReturn(VALID_PTR(pvService), VERR_INVALID_PARAMETER);
304 SELF *pSelf = reinterpret_cast<SELF *>(pvService);
305 int rc = pSelf->uninit();
306 AssertRC(rc);
307 if (RT_SUCCESS(rc))
308 delete pSelf;
309 return rc;
310 }
311
312 /**
313 * @interface_method_impl{VBOXHGCMSVCFNTABLE,pfnConnect}
314 * Stub implementation of pfnConnect and pfnDisconnect.
315 */
316 static DECLCALLBACK(int) svcConnectDisconnect(void * /* pvService */,
317 uint32_t /* u32ClientID */,
318 void * /* pvClient */)
319 {
320 return VINF_SUCCESS;
321 }
322
323 /**
324 * @interface_method_impl{VBOXHGCMSVCFNTABLE,pfnCall}
325 * Wraps to the call member function
326 */
327 static DECLCALLBACK(void) svcCall(void * pvService,
328 VBOXHGCMCALLHANDLE callHandle,
329 uint32_t u32ClientID,
330 void *pvClient,
331 uint32_t u32Function,
332 uint32_t cParms,
333 VBOXHGCMSVCPARM paParms[])
334 {
335 AssertLogRelReturnVoid(VALID_PTR(pvService));
336 LogFlowFunc(("pvService=%p, callHandle=%p, u32ClientID=%u, pvClient=%p, u32Function=%u, cParms=%u, paParms=%p\n", pvService, callHandle, u32ClientID, pvClient, u32Function, cParms, paParms));
337 SELF *pSelf = reinterpret_cast<SELF *>(pvService);
338 pSelf->call(callHandle, u32ClientID, pvClient, u32Function, cParms, paParms);
339 LogFlowFunc(("returning\n"));
340 }
341
342 /**
343 * @interface_method_impl{VBOXHGCMSVCFNTABLE,pfnHostCall}
344 * Wraps to the hostCall member function
345 */
346 static DECLCALLBACK(int) svcHostCall(void *pvService,
347 uint32_t u32Function,
348 uint32_t cParms,
349 VBOXHGCMSVCPARM paParms[])
350 {
351 AssertLogRelReturn(VALID_PTR(pvService), VERR_INVALID_PARAMETER);
352 LogFlowFunc(("pvService=%p, u32Function=%u, cParms=%u, paParms=%p\n", pvService, u32Function, cParms, paParms));
353 SELF *pSelf = reinterpret_cast<SELF *>(pvService);
354 int rc = pSelf->hostCall(u32Function, cParms, paParms);
355 LogFlowFunc(("rc=%Rrc\n", rc));
356 return rc;
357 }
358
359 /**
360 * @interface_method_impl{VBOXHGCMSVCFNTABLE,pfnRegisterExtension}
361 * Installs a host callback for notifications of property changes.
362 */
363 static DECLCALLBACK(int) svcRegisterExtension(void *pvService,
364 PFNHGCMSVCEXT pfnExtension,
365 void *pvExtension)
366 {
367 AssertLogRelReturn(VALID_PTR(pvService), VERR_INVALID_PARAMETER);
368 SELF *pSelf = reinterpret_cast<SELF *>(pvService);
369 pSelf->mpfnHostCallback = pfnExtension;
370 pSelf->mpvHostData = pvExtension;
371 return VINF_SUCCESS;
372 }
373
374#ifdef ASYNC_HOST_NOTIFY
375 int initialize();
376#endif
377
378private:
379 static DECLCALLBACK(int) reqThreadFn(RTTHREAD ThreadSelf, void *pvUser);
380 uint64_t getCurrentTimestamp(void);
381 int validateName(const char *pszName, uint32_t cbName);
382 int validateValue(const char *pszValue, uint32_t cbValue);
383 int setPropertyBlock(uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
384 int getProperty(uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
385 int setProperty(uint32_t cParms, VBOXHGCMSVCPARM paParms[], bool isGuest);
386 int delProperty(uint32_t cParms, VBOXHGCMSVCPARM paParms[], bool isGuest);
387 int enumProps(uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
388 int getNotification(uint32_t u32ClientId, VBOXHGCMCALLHANDLE callHandle, uint32_t cParms,
389 VBOXHGCMSVCPARM paParms[]);
390 int getOldNotificationInternal(const char *pszPattern,
391 uint64_t u64Timestamp, Property *pProp);
392 int getNotificationWriteOut(uint32_t cParms, VBOXHGCMSVCPARM paParms[], Property prop);
393 int doNotifications(const char *pszProperty, uint64_t u64Timestamp);
394 int notifyHost(const char *pszName, const char *pszValue,
395 uint64_t u64Timestamp, const char *pszFlags);
396
397 void call(VBOXHGCMCALLHANDLE callHandle, uint32_t u32ClientID,
398 void *pvClient, uint32_t eFunction, uint32_t cParms,
399 VBOXHGCMSVCPARM paParms[]);
400 int hostCall(uint32_t eFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
401 int uninit();
402 void dbgInfoShow(PCDBGFINFOHLP pHlp);
403 static DECLCALLBACK(void) dbgInfo(void *pvUser, PCDBGFINFOHLP pHlp, const char *pszArgs);
404
405#ifdef ASYNC_HOST_NOTIFY
406 /* Thread for handling host notifications. */
407 RTTHREAD mhThreadNotifyHost;
408 /* Queue for handling requests for notifications. */
409 RTREQQUEUE mhReqQNotifyHost;
410 static DECLCALLBACK(int) threadNotifyHost(RTTHREAD self, void *pvUser);
411#endif
412
413 DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(Service);
414};
415
416
417/**
418 * Gets the current timestamp.
419 *
420 * Since the RTTimeNow resolution can be very coarse, this method takes some
421 * simple steps to try avoid returning the same timestamp for two consecutive
422 * calls. Code like getOldNotification() more or less assumes unique
423 * timestamps.
424 *
425 * @returns Nanosecond timestamp.
426 */
427uint64_t Service::getCurrentTimestamp(void)
428{
429 RTTIMESPEC time;
430 uint64_t u64NanoTS = RTTimeSpecGetNano(RTTimeNow(&time));
431 if (mPrevTimestamp - u64NanoTS > mcTimestampAdjustments)
432 mcTimestampAdjustments = 0;
433 else
434 {
435 mcTimestampAdjustments++;
436 u64NanoTS = mPrevTimestamp + 1;
437 }
438 this->mPrevTimestamp = u64NanoTS;
439 return u64NanoTS;
440}
441
442/**
443 * Check that a string fits our criteria for a property name.
444 *
445 * @returns IPRT status code
446 * @param pszName the string to check, must be valid Utf8
447 * @param cbName the number of bytes @a pszName points to, including the
448 * terminating '\0'
449 * @thread HGCM
450 */
451int Service::validateName(const char *pszName, uint32_t cbName)
452{
453 LogFlowFunc(("cbName=%d\n", cbName));
454 int rc = VINF_SUCCESS;
455 if (RT_SUCCESS(rc) && (cbName < 2))
456 rc = VERR_INVALID_PARAMETER;
457 for (unsigned i = 0; RT_SUCCESS(rc) && i < cbName; ++i)
458 if (pszName[i] == '*' || pszName[i] == '?' || pszName[i] == '|')
459 rc = VERR_INVALID_PARAMETER;
460 LogFlowFunc(("returning %Rrc\n", rc));
461 return rc;
462}
463
464
465/**
466 * Check a string fits our criteria for the value of a guest property.
467 *
468 * @returns IPRT status code
469 * @param pszValue the string to check, must be valid Utf8
470 * @param cbValue the length in bytes of @a pszValue, including the
471 * terminator
472 * @thread HGCM
473 */
474int Service::validateValue(const char *pszValue, uint32_t cbValue)
475{
476 LogFlowFunc(("cbValue=%d\n", cbValue)); RT_NOREF1(pszValue);
477
478 int rc = VINF_SUCCESS;
479 if (RT_SUCCESS(rc) && cbValue == 0)
480 rc = VERR_INVALID_PARAMETER;
481 if (RT_SUCCESS(rc))
482 LogFlow((" pszValue=%s\n", cbValue > 0 ? pszValue : NULL));
483 LogFlowFunc(("returning %Rrc\n", rc));
484 return rc;
485}
486
487/**
488 * Set a block of properties in the property registry, checking the validity
489 * of the arguments passed.
490 *
491 * @returns iprt status value
492 * @param cParms the number of HGCM parameters supplied
493 * @param paParms the array of HGCM parameters
494 * @thread HGCM
495 */
496int Service::setPropertyBlock(uint32_t cParms, VBOXHGCMSVCPARM paParms[])
497{
498 const char **papszNames;
499 const char **papszValues;
500 const char **papszFlags;
501 uint64_t *pau64Timestamps;
502 uint32_t cbDummy;
503 int rc = VINF_SUCCESS;
504
505 /*
506 * Get and validate the parameters
507 */
508 if ( cParms != 4
509 || RT_FAILURE(paParms[0].getPointer((void **)&papszNames, &cbDummy))
510 || RT_FAILURE(paParms[1].getPointer((void **)&papszValues, &cbDummy))
511 || RT_FAILURE(paParms[2].getPointer((void **)&pau64Timestamps, &cbDummy))
512 || RT_FAILURE(paParms[3].getPointer((void **)&papszFlags, &cbDummy))
513 )
514 rc = VERR_INVALID_PARAMETER;
515 /** @todo validate the array sizes... */
516 else
517 {
518 for (unsigned i = 0; RT_SUCCESS(rc) && papszNames[i] != NULL; ++i)
519 {
520 if ( !RT_VALID_PTR(papszNames[i])
521 || !RT_VALID_PTR(papszValues[i])
522 || !RT_VALID_PTR(papszFlags[i])
523 )
524 rc = VERR_INVALID_POINTER;
525 else
526 {
527 uint32_t fFlagsIgn;
528 rc = validateFlags(papszFlags[i], &fFlagsIgn);
529 }
530 }
531 if (RT_SUCCESS(rc))
532 {
533 /*
534 * Add the properties. No way to roll back here.
535 */
536 for (unsigned i = 0; papszNames[i] != NULL; ++i)
537 {
538 uint32_t fFlags;
539 rc = validateFlags(papszFlags[i], &fFlags);
540 AssertRCBreak(rc);
541
542 Property *pProp = getPropertyInternal(papszNames[i]);
543 if (pProp)
544 {
545 /* Update existing property. */
546 pProp->mValue = papszValues[i];
547 pProp->mTimestamp = pau64Timestamps[i];
548 pProp->mFlags = fFlags;
549 }
550 else
551 {
552 /* Create a new property */
553 pProp = new Property(papszNames[i], papszValues[i], pau64Timestamps[i], fFlags);
554 if (!pProp)
555 {
556 rc = VERR_NO_MEMORY;
557 break;
558 }
559 if (RTStrSpaceInsert(&mhProperties, &pProp->mStrCore))
560 mcProperties++;
561 else
562 {
563 delete pProp;
564 rc = VERR_INTERNAL_ERROR_3;
565 AssertFailedBreak();
566 }
567 }
568 }
569 }
570 }
571
572 return rc;
573}
574
575/**
576 * Retrieve a value from the property registry by name, checking the validity
577 * of the arguments passed. If the guest has not allocated enough buffer
578 * space for the value then we return VERR_OVERFLOW and set the size of the
579 * buffer needed in the "size" HGCM parameter. If the name was not found at
580 * all, we return VERR_NOT_FOUND.
581 *
582 * @returns iprt status value
583 * @param cParms the number of HGCM parameters supplied
584 * @param paParms the array of HGCM parameters
585 * @thread HGCM
586 */
587int Service::getProperty(uint32_t cParms, VBOXHGCMSVCPARM paParms[])
588{
589 int rc;
590 const char *pcszName = NULL; /* shut up gcc */
591 char *pchBuf = NULL; /* shut up MSC */
592 uint32_t cbName;
593 uint32_t cbBuf = 0; /* shut up MSC */
594
595 /*
596 * Get and validate the parameters
597 */
598 LogFlowThisFunc(("\n"));
599 if ( cParms != 4 /* Hardcoded value as the next lines depend on it. */
600 || RT_FAILURE(paParms[0].getString(&pcszName, &cbName)) /* name */
601 || RT_FAILURE(paParms[1].getBuffer((void **)&pchBuf, &cbBuf)) /* buffer */
602 )
603 rc = VERR_INVALID_PARAMETER;
604 else
605 rc = validateName(pcszName, cbName);
606 if (RT_FAILURE(rc))
607 {
608 LogFlowThisFunc(("rc = %Rrc\n", rc));
609 return rc;
610 }
611
612 /*
613 * Read and set the values we will return
614 */
615
616 /* Get the property. */
617 Property *pProp = getPropertyInternal(pcszName);
618 if (pProp)
619 {
620 char szFlags[MAX_FLAGS_LEN];
621 rc = writeFlags(pProp->mFlags, szFlags);
622 if (RT_SUCCESS(rc))
623 {
624 /* Check that the buffer is big enough */
625 size_t const cbFlags = strlen(szFlags) + 1;
626 size_t const cbValue = pProp->mValue.size() + 1;
627 size_t const cbNeeded = cbValue + cbFlags;
628 paParms[3].setUInt32((uint32_t)cbNeeded);
629 if (cbBuf >= cbNeeded)
630 {
631 /* Write the value, flags and timestamp */
632 memcpy(pchBuf, pProp->mValue.c_str(), cbValue);
633 memcpy(pchBuf + cbValue, szFlags, cbFlags);
634
635 paParms[2].setUInt64(pProp->mTimestamp);
636
637 /*
638 * Done! Do exit logging and return.
639 */
640 Log2(("Queried string %s, value=%s, timestamp=%lld, flags=%s\n",
641 pcszName, pProp->mValue.c_str(), pProp->mTimestamp, szFlags));
642 }
643 else
644 rc = VERR_BUFFER_OVERFLOW;
645 }
646 }
647 else
648 rc = VERR_NOT_FOUND;
649
650 LogFlowThisFunc(("rc = %Rrc (%s)\n", rc, pcszName));
651 return rc;
652}
653
654/**
655 * Set a value in the property registry by name, checking the validity
656 * of the arguments passed.
657 *
658 * @returns iprt status value
659 * @param cParms the number of HGCM parameters supplied
660 * @param paParms the array of HGCM parameters
661 * @param isGuest is this call coming from the guest (or the host)?
662 * @throws std::bad_alloc if an out of memory condition occurs
663 * @thread HGCM
664 */
665int Service::setProperty(uint32_t cParms, VBOXHGCMSVCPARM paParms[], bool isGuest)
666{
667 int rc = VINF_SUCCESS;
668 const char *pcszName = NULL; /* shut up gcc */
669 const char *pcszValue = NULL; /* ditto */
670 const char *pcszFlags = NULL;
671 uint32_t cchName = 0; /* ditto */
672 uint32_t cchValue = 0; /* ditto */
673 uint32_t cchFlags = 0;
674 uint32_t fFlags = NILFLAG;
675 uint64_t u64TimeNano = getCurrentTimestamp();
676
677 LogFlowThisFunc(("\n"));
678
679 /*
680 * General parameter correctness checking.
681 */
682 if ( RT_SUCCESS(rc)
683 && ( (cParms < 2) || (cParms > 3) /* Hardcoded value as the next lines depend on it. */
684 || RT_FAILURE(paParms[0].getString(&pcszName, &cchName)) /* name */
685 || RT_FAILURE(paParms[1].getString(&pcszValue, &cchValue)) /* value */
686 || ( (3 == cParms)
687 && RT_FAILURE(paParms[2].getString(&pcszFlags, &cchFlags)) /* flags */
688 )
689 )
690 )
691 rc = VERR_INVALID_PARAMETER;
692
693 /*
694 * Check the values passed in the parameters for correctness.
695 */
696 if (RT_SUCCESS(rc))
697 rc = validateName(pcszName, cchName);
698 if (RT_SUCCESS(rc))
699 rc = validateValue(pcszValue, cchValue);
700 if ((3 == cParms) && RT_SUCCESS(rc))
701 rc = RTStrValidateEncodingEx(pcszFlags, cchFlags,
702 RTSTR_VALIDATE_ENCODING_ZERO_TERMINATED);
703 if ((3 == cParms) && RT_SUCCESS(rc))
704 rc = validateFlags(pcszFlags, &fFlags);
705 if (RT_FAILURE(rc))
706 {
707 LogFlowThisFunc(("rc = %Rrc\n", rc));
708 return rc;
709 }
710
711 /*
712 * If the property already exists, check its flags to see if we are allowed
713 * to change it.
714 */
715 Property *pProp = getPropertyInternal(pcszName);
716 rc = checkPermission(pProp ? (ePropFlags)pProp->mFlags : NILFLAG, isGuest);
717 if (rc == VINF_SUCCESS)
718 {
719 /*
720 * Set the actual value
721 */
722 if (pProp)
723 {
724 pProp->mValue = pcszValue;
725 pProp->mTimestamp = u64TimeNano;
726 pProp->mFlags = fFlags;
727 }
728 else if (mcProperties < MAX_PROPS)
729 {
730 try
731 {
732 /* Create a new string space record. */
733 pProp = new Property(pcszName, pcszValue, u64TimeNano, fFlags);
734 AssertPtr(pProp);
735
736 if (RTStrSpaceInsert(&mhProperties, &pProp->mStrCore))
737 mcProperties++;
738 else
739 {
740 AssertFailed();
741 delete pProp;
742
743 rc = VERR_ALREADY_EXISTS;
744 }
745 }
746 catch (std::bad_alloc)
747 {
748 rc = VERR_NO_MEMORY;
749 }
750 }
751 else
752 rc = VERR_TOO_MUCH_DATA;
753
754 /*
755 * Send a notification to the guest and host and return.
756 */
757 // if (isGuest) /* Notify the host even for properties that the host
758 // * changed. Less efficient, but ensures consistency. */
759 int rc2 = doNotifications(pcszName, u64TimeNano);
760 if (RT_SUCCESS(rc))
761 rc = rc2;
762 }
763
764 LogFlowThisFunc(("%s=%s, rc=%Rrc\n", pcszName, pcszValue, rc));
765 return rc;
766}
767
768
769/**
770 * Remove a value in the property registry by name, checking the validity
771 * of the arguments passed.
772 *
773 * @returns iprt status value
774 * @param cParms the number of HGCM parameters supplied
775 * @param paParms the array of HGCM parameters
776 * @param isGuest is this call coming from the guest (or the host)?
777 * @thread HGCM
778 */
779int Service::delProperty(uint32_t cParms, VBOXHGCMSVCPARM paParms[], bool isGuest)
780{
781 int rc;
782 const char *pcszName = NULL; /* shut up gcc */
783 uint32_t cbName;
784
785 LogFlowThisFunc(("\n"));
786
787 /*
788 * Check the user-supplied parameters.
789 */
790 if ( (cParms == 1) /* Hardcoded value as the next lines depend on it. */
791 && RT_SUCCESS(paParms[0].getString(&pcszName, &cbName)) /* name */
792 )
793 rc = validateName(pcszName, cbName);
794 else
795 rc = VERR_INVALID_PARAMETER;
796 if (RT_FAILURE(rc))
797 {
798 LogFlowThisFunc(("rc=%Rrc\n", rc));
799 return rc;
800 }
801
802 /*
803 * If the property exists, check its flags to see if we are allowed
804 * to change it.
805 */
806 Property *pProp = getPropertyInternal(pcszName);
807 if (pProp)
808 rc = checkPermission((ePropFlags)pProp->mFlags, isGuest);
809
810 /*
811 * And delete the property if all is well.
812 */
813 if (rc == VINF_SUCCESS && pProp)
814 {
815 uint64_t u64Timestamp = getCurrentTimestamp();
816 PRTSTRSPACECORE pStrCore = RTStrSpaceRemove(&mhProperties, pProp->mStrCore.pszString);
817 AssertPtr(pStrCore); NOREF(pStrCore);
818 mcProperties--;
819 delete pProp;
820 // if (isGuest) /* Notify the host even for properties that the host
821 // * changed. Less efficient, but ensures consistency. */
822 int rc2 = doNotifications(pcszName, u64Timestamp);
823 if (RT_SUCCESS(rc))
824 rc = rc2;
825 }
826
827 LogFlowThisFunc(("%s: rc=%Rrc\n", pcszName, rc));
828 return rc;
829}
830
831/**
832 * Enumeration data shared between enumPropsCallback and Service::enumProps.
833 */
834typedef struct ENUMDATA
835{
836 const char *pszPattern; /**< The pattern to match properties against. */
837 char *pchCur; /**< The current buffer postion. */
838 size_t cbLeft; /**< The amount of available buffer space. */
839 size_t cbNeeded; /**< The amount of needed buffer space. */
840} ENUMDATA;
841
842/**
843 * @callback_method_impl{FNRTSTRSPACECALLBACK}
844 */
845static DECLCALLBACK(int) enumPropsCallback(PRTSTRSPACECORE pStr, void *pvUser)
846{
847 Property *pProp = (Property *)pStr;
848 ENUMDATA *pEnum = (ENUMDATA *)pvUser;
849
850 /* Included in the enumeration? */
851 if (!pProp->Matches(pEnum->pszPattern))
852 return 0;
853
854 /* Convert the non-string members into strings. */
855 char szTimestamp[256];
856 size_t const cbTimestamp = RTStrFormatNumber(szTimestamp, pProp->mTimestamp, 10, 0, 0, 0) + 1;
857
858 char szFlags[MAX_FLAGS_LEN];
859 int rc = writeFlags(pProp->mFlags, szFlags);
860 if (RT_FAILURE(rc))
861 return rc;
862 size_t const cbFlags = strlen(szFlags) + 1;
863
864 /* Calculate the buffer space requirements. */
865 size_t const cbName = pProp->mName.length() + 1;
866 size_t const cbValue = pProp->mValue.length() + 1;
867 size_t const cbRequired = cbName + cbValue + cbTimestamp + cbFlags;
868 pEnum->cbNeeded += cbRequired;
869
870 /* Sufficient buffer space? */
871 if (cbRequired > pEnum->cbLeft)
872 {
873 pEnum->cbLeft = 0;
874 return 0; /* don't quit */
875 }
876 pEnum->cbLeft -= cbRequired;
877
878 /* Append the property to the buffer. */
879 char *pchCur = pEnum->pchCur;
880 pEnum->pchCur += cbRequired;
881
882 memcpy(pchCur, pProp->mName.c_str(), cbName);
883 pchCur += cbName;
884
885 memcpy(pchCur, pProp->mValue.c_str(), cbValue);
886 pchCur += cbValue;
887
888 memcpy(pchCur, szTimestamp, cbTimestamp);
889 pchCur += cbTimestamp;
890
891 memcpy(pchCur, szFlags, cbFlags);
892 pchCur += cbFlags;
893
894 Assert(pchCur == pEnum->pchCur);
895 return 0;
896}
897
898/**
899 * Enumerate guest properties by mask, checking the validity
900 * of the arguments passed.
901 *
902 * @returns iprt status value
903 * @param cParms the number of HGCM parameters supplied
904 * @param paParms the array of HGCM parameters
905 * @thread HGCM
906 */
907int Service::enumProps(uint32_t cParms, VBOXHGCMSVCPARM paParms[])
908{
909 int rc = VINF_SUCCESS;
910
911 /*
912 * Get the HGCM function arguments.
913 */
914 char const *pchPatterns = NULL;
915 char *pchBuf = NULL;
916 uint32_t cbPatterns = 0;
917 uint32_t cbBuf = 0;
918 LogFlowThisFunc(("\n"));
919 if ( (cParms != 3) /* Hardcoded value as the next lines depend on it. */
920 || RT_FAILURE(paParms[0].getString(&pchPatterns, &cbPatterns)) /* patterns */
921 || RT_FAILURE(paParms[1].getBuffer((void **)&pchBuf, &cbBuf)) /* return buffer */
922 )
923 rc = VERR_INVALID_PARAMETER;
924 if (RT_SUCCESS(rc) && cbPatterns > MAX_PATTERN_LEN)
925 rc = VERR_TOO_MUCH_DATA;
926
927 /*
928 * First repack the patterns into the format expected by RTStrSimplePatternMatch()
929 */
930 char szPatterns[MAX_PATTERN_LEN];
931 if (RT_SUCCESS(rc))
932 {
933 for (unsigned i = 0; i < cbPatterns - 1; ++i)
934 if (pchPatterns[i] != '\0')
935 szPatterns[i] = pchPatterns[i];
936 else
937 szPatterns[i] = '|';
938 szPatterns[cbPatterns - 1] = '\0';
939 }
940
941 /*
942 * Next enumerate into the buffer.
943 */
944 if (RT_SUCCESS(rc))
945 {
946 ENUMDATA EnumData;
947 EnumData.pszPattern = szPatterns;
948 EnumData.pchCur = pchBuf;
949 EnumData.cbLeft = cbBuf;
950 EnumData.cbNeeded = 0;
951 rc = RTStrSpaceEnumerate(&mhProperties, enumPropsCallback, &EnumData);
952 AssertRCSuccess(rc);
953 if (RT_SUCCESS(rc))
954 {
955 paParms[2].setUInt32((uint32_t)(EnumData.cbNeeded + 4));
956 if (EnumData.cbLeft >= 4)
957 {
958 /* The final terminators. */
959 EnumData.pchCur[0] = '\0';
960 EnumData.pchCur[1] = '\0';
961 EnumData.pchCur[2] = '\0';
962 EnumData.pchCur[3] = '\0';
963 }
964 else
965 rc = VERR_BUFFER_OVERFLOW;
966 }
967 }
968
969 return rc;
970}
971
972
973/** Helper query used by getOldNotification */
974int Service::getOldNotificationInternal(const char *pszPatterns,
975 uint64_t u64Timestamp,
976 Property *pProp)
977{
978 /* We count backwards, as the guest should normally be querying the
979 * most recent events. */
980 int rc = VWRN_NOT_FOUND;
981 PropertyList::reverse_iterator it = mGuestNotifications.rbegin();
982 for (; it != mGuestNotifications.rend(); ++it)
983 if (it->mTimestamp == u64Timestamp)
984 {
985 rc = VINF_SUCCESS;
986 break;
987 }
988
989 /* Now look for an event matching the patterns supplied. The base()
990 * member conveniently points to the following element. */
991 PropertyList::iterator base = it.base();
992 for (; base != mGuestNotifications.end(); ++base)
993 if (base->Matches(pszPatterns))
994 {
995 *pProp = *base;
996 return rc;
997 }
998 *pProp = Property();
999 return rc;
1000}
1001
1002
1003/** Helper query used by getNotification */
1004int Service::getNotificationWriteOut(uint32_t cParms, VBOXHGCMSVCPARM paParms[], Property prop)
1005{
1006 AssertReturn(cParms == 4, VERR_INVALID_PARAMETER); /* Basic sanity checking. */
1007
1008 /* Format the data to write to the buffer. */
1009 std::string buffer;
1010 uint64_t u64Timestamp;
1011 char *pchBuf;
1012 uint32_t cbBuf;
1013
1014 int rc = paParms[2].getBuffer((void **)&pchBuf, &cbBuf);
1015 if (RT_SUCCESS(rc))
1016 {
1017 char szFlags[MAX_FLAGS_LEN];
1018 rc = writeFlags(prop.mFlags, szFlags);
1019 if (RT_SUCCESS(rc))
1020 {
1021 buffer += prop.mName;
1022 buffer += '\0';
1023 buffer += prop.mValue;
1024 buffer += '\0';
1025 buffer += szFlags;
1026 buffer += '\0';
1027 u64Timestamp = prop.mTimestamp;
1028
1029 /* Write out the data. */
1030 if (RT_SUCCESS(rc))
1031 {
1032 paParms[1].setUInt64(u64Timestamp);
1033 paParms[3].setUInt32((uint32_t)buffer.size());
1034 if (buffer.size() <= cbBuf)
1035 buffer.copy(pchBuf, cbBuf);
1036 else
1037 rc = VERR_BUFFER_OVERFLOW;
1038 }
1039 }
1040 }
1041 return rc;
1042}
1043
1044
1045/**
1046 * Get the next guest notification.
1047 *
1048 * @returns iprt status value
1049 * @param u32ClientId the client ID
1050 * @param callHandle handle
1051 * @param cParms the number of HGCM parameters supplied
1052 * @param paParms the array of HGCM parameters
1053 * @thread HGCM
1054 * @throws can throw std::bad_alloc
1055 */
1056int Service::getNotification(uint32_t u32ClientId, VBOXHGCMCALLHANDLE callHandle,
1057 uint32_t cParms, VBOXHGCMSVCPARM paParms[])
1058{
1059 int rc = VINF_SUCCESS;
1060 char *pszPatterns = NULL; /* shut up gcc */
1061 char *pchBuf;
1062 uint32_t cchPatterns = 0;
1063 uint32_t cbBuf = 0;
1064 uint64_t u64Timestamp;
1065
1066 /*
1067 * Get the HGCM function arguments and perform basic verification.
1068 */
1069 LogFlowThisFunc(("\n"));
1070 if ( cParms != 4 /* Hardcoded value as the next lines depend on it. */
1071 || RT_FAILURE(paParms[0].getString(&pszPatterns, &cchPatterns)) /* patterns */
1072 || RT_FAILURE(paParms[1].getUInt64(&u64Timestamp)) /* timestamp */
1073 || RT_FAILURE(paParms[2].getBuffer((void **)&pchBuf, &cbBuf)) /* return buffer */
1074 )
1075 rc = VERR_INVALID_PARAMETER;
1076 else
1077 {
1078 LogFlow(("pszPatterns=%s, u64Timestamp=%llu\n", pszPatterns, u64Timestamp));
1079
1080 /*
1081 * If no timestamp was supplied or no notification was found in the queue
1082 * of old notifications, enqueue the request in the waiting queue.
1083 */
1084 Property prop;
1085 if (RT_SUCCESS(rc) && u64Timestamp != 0)
1086 rc = getOldNotification(pszPatterns, u64Timestamp, &prop);
1087 if (RT_SUCCESS(rc))
1088 {
1089 if (prop.isNull())
1090 {
1091 /*
1092 * Check if the client already had the same request.
1093 * Complete the old request with an error in this case.
1094 * Protection against clients, which cancel and resubmits requests.
1095 */
1096 CallList::iterator it = mGuestWaiters.begin();
1097 while (it != mGuestWaiters.end())
1098 {
1099 const char *pszPatternsExisting;
1100 uint32_t cchPatternsExisting;
1101 int rc3 = it->mParms[0].getString(&pszPatternsExisting, &cchPatternsExisting);
1102
1103 if ( RT_SUCCESS(rc3)
1104 && u32ClientId == it->u32ClientId
1105 && RTStrCmp(pszPatterns, pszPatternsExisting) == 0)
1106 {
1107 /* Complete the old request. */
1108 mpHelpers->pfnCallComplete(it->mHandle, VERR_INTERRUPTED);
1109 it = mGuestWaiters.erase(it);
1110 }
1111 else
1112 ++it;
1113 }
1114
1115 mGuestWaiters.push_back(GuestCall(u32ClientId, callHandle, GET_NOTIFICATION,
1116 cParms, paParms, rc));
1117 rc = VINF_HGCM_ASYNC_EXECUTE;
1118 }
1119 /*
1120 * Otherwise reply at once with the enqueued notification we found.
1121 */
1122 else
1123 {
1124 int rc2 = getNotificationWriteOut(cParms, paParms, prop);
1125 if (RT_FAILURE(rc2))
1126 rc = rc2;
1127 }
1128 }
1129 }
1130
1131 LogFlowThisFunc(("returning rc=%Rrc\n", rc));
1132 return rc;
1133}
1134
1135
1136/**
1137 * Notify the service owner and the guest that a property has been
1138 * added/deleted/changed
1139 * @param pszProperty the name of the property which has changed
1140 * @param u64Timestamp the time at which the change took place
1141 *
1142 * @thread HGCM service
1143 */
1144int Service::doNotifications(const char *pszProperty, uint64_t u64Timestamp)
1145{
1146 AssertPtrReturn(pszProperty, VERR_INVALID_POINTER);
1147 LogFlowThisFunc(("pszProperty=%s, u64Timestamp=%llu\n", pszProperty, u64Timestamp));
1148 /* Ensure that our timestamp is different to the last one. */
1149 if ( !mGuestNotifications.empty()
1150 && u64Timestamp == mGuestNotifications.back().mTimestamp)
1151 ++u64Timestamp;
1152
1153 /*
1154 * Try to find the property. Create a change event if we find it and a
1155 * delete event if we do not.
1156 */
1157 Property prop;
1158 prop.mName = pszProperty;
1159 prop.mTimestamp = u64Timestamp;
1160 /* prop is currently a delete event for pszProperty */
1161 Property const * const pProp = getPropertyInternal(pszProperty);
1162 if (pProp)
1163 {
1164 /* Make prop into a change event. */
1165 prop.mValue = pProp->mValue;
1166 prop.mFlags = pProp->mFlags;
1167 }
1168
1169 /* Release guest waiters if applicable and add the event
1170 * to the queue for guest notifications */
1171 int rc = VINF_SUCCESS;
1172 try
1173 {
1174 CallList::iterator it = mGuestWaiters.begin();
1175 while (it != mGuestWaiters.end())
1176 {
1177 const char *pszPatterns;
1178 uint32_t cchPatterns;
1179 it->mParms[0].getString(&pszPatterns, &cchPatterns);
1180 if (prop.Matches(pszPatterns))
1181 {
1182 GuestCall curCall = *it;
1183 int rc2 = getNotificationWriteOut(curCall.mParmsCnt, curCall.mParms, prop);
1184 if (RT_SUCCESS(rc2))
1185 rc2 = curCall.mRc;
1186 mpHelpers->pfnCallComplete(curCall.mHandle, rc2);
1187 it = mGuestWaiters.erase(it);
1188 }
1189 else
1190 ++it;
1191 }
1192
1193 mGuestNotifications.push_back(prop);
1194
1195 /** @todo r=andy This list does not have a purpose but for tracking
1196 * the timestamps ... */
1197 if (mGuestNotifications.size() > MAX_GUEST_NOTIFICATIONS)
1198 mGuestNotifications.pop_front();
1199 }
1200 catch (std::bad_alloc)
1201 {
1202 rc = VERR_NO_MEMORY;
1203 }
1204
1205 if ( RT_SUCCESS(rc)
1206 && mpfnHostCallback)
1207 {
1208 /*
1209 * Host notifications - first case: if the property exists then send its
1210 * current value
1211 */
1212 if (pProp)
1213 {
1214 char szFlags[MAX_FLAGS_LEN];
1215 /* Send out a host notification */
1216 const char *pszValue = prop.mValue.c_str();
1217 rc = writeFlags(prop.mFlags, szFlags);
1218 if (RT_SUCCESS(rc))
1219 rc = notifyHost(pszProperty, pszValue, u64Timestamp, szFlags);
1220 }
1221 /*
1222 * Host notifications - second case: if the property does not exist then
1223 * send the host an empty value
1224 */
1225 else
1226 {
1227 /* Send out a host notification */
1228 rc = notifyHost(pszProperty, "", u64Timestamp, "");
1229 }
1230 }
1231
1232 LogFlowThisFunc(("returning rc=%Rrc\n", rc));
1233 return rc;
1234}
1235
1236#ifdef ASYNC_HOST_NOTIFY
1237static DECLCALLBACK(void) notifyHostAsyncWorker(PFNHGCMSVCEXT pfnHostCallback,
1238 void *pvHostData,
1239 HOSTCALLBACKDATA *pHostCallbackData)
1240{
1241 pfnHostCallback(pvHostData, 0 /*u32Function*/,
1242 (void *)pHostCallbackData,
1243 sizeof(HOSTCALLBACKDATA));
1244 RTMemFree(pHostCallbackData);
1245}
1246#endif
1247
1248/**
1249 * Notify the service owner that a property has been added/deleted/changed.
1250 * @returns IPRT status value
1251 * @param pszName the property name
1252 * @param pszValue the new value, or NULL if the property was deleted
1253 * @param u64Timestamp the time of the change
1254 * @param pszFlags the new flags string
1255 */
1256int Service::notifyHost(const char *pszName, const char *pszValue,
1257 uint64_t u64Timestamp, const char *pszFlags)
1258{
1259 LogFlowFunc(("pszName=%s, pszValue=%s, u64Timestamp=%llu, pszFlags=%s\n",
1260 pszName, pszValue, u64Timestamp, pszFlags));
1261#ifdef ASYNC_HOST_NOTIFY
1262 int rc = VINF_SUCCESS;
1263
1264 /* Allocate buffer for the callback data and strings. */
1265 size_t cbName = pszName? strlen(pszName): 0;
1266 size_t cbValue = pszValue? strlen(pszValue): 0;
1267 size_t cbFlags = pszFlags? strlen(pszFlags): 0;
1268 size_t cbAlloc = sizeof(HOSTCALLBACKDATA) + cbName + cbValue + cbFlags + 3;
1269 HOSTCALLBACKDATA *pHostCallbackData = (HOSTCALLBACKDATA *)RTMemAlloc(cbAlloc);
1270 if (pHostCallbackData)
1271 {
1272 uint8_t *pu8 = (uint8_t *)pHostCallbackData;
1273 pu8 += sizeof(HOSTCALLBACKDATA);
1274
1275 pHostCallbackData->u32Magic = HOSTCALLBACKMAGIC;
1276
1277 pHostCallbackData->pcszName = (const char *)pu8;
1278 memcpy(pu8, pszName, cbName);
1279 pu8 += cbName;
1280 *pu8++ = 0;
1281
1282 pHostCallbackData->pcszValue = (const char *)pu8;
1283 memcpy(pu8, pszValue, cbValue);
1284 pu8 += cbValue;
1285 *pu8++ = 0;
1286
1287 pHostCallbackData->u64Timestamp = u64Timestamp;
1288
1289 pHostCallbackData->pcszFlags = (const char *)pu8;
1290 memcpy(pu8, pszFlags, cbFlags);
1291 pu8 += cbFlags;
1292 *pu8++ = 0;
1293
1294 rc = RTReqQueueCallEx(mhReqQNotifyHost, NULL, 0, RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
1295 (PFNRT)notifyHostAsyncWorker, 3,
1296 mpfnHostCallback, mpvHostData, pHostCallbackData);
1297 if (RT_FAILURE(rc))
1298 {
1299 RTMemFree(pHostCallbackData);
1300 }
1301 }
1302 else
1303 {
1304 rc = VERR_NO_MEMORY;
1305 }
1306#else
1307 HOSTCALLBACKDATA HostCallbackData;
1308 HostCallbackData.u32Magic = HOSTCALLBACKMAGIC;
1309 HostCallbackData.pcszName = pszName;
1310 HostCallbackData.pcszValue = pszValue;
1311 HostCallbackData.u64Timestamp = u64Timestamp;
1312 HostCallbackData.pcszFlags = pszFlags;
1313 int rc = mpfnHostCallback(mpvHostData, 0 /*u32Function*/,
1314 (void *)(&HostCallbackData),
1315 sizeof(HostCallbackData));
1316#endif
1317 LogFlowFunc(("returning rc=%Rrc\n", rc));
1318 return rc;
1319}
1320
1321
1322/**
1323 * Handle an HGCM service call.
1324 * @interface_method_impl{VBOXHGCMSVCFNTABLE,pfnCall}
1325 * @note All functions which do not involve an unreasonable delay will be
1326 * handled synchronously. If needed, we will add a request handler
1327 * thread in future for those which do.
1328 *
1329 * @thread HGCM
1330 */
1331void Service::call (VBOXHGCMCALLHANDLE callHandle, uint32_t u32ClientID,
1332 void * /* pvClient */, uint32_t eFunction, uint32_t cParms,
1333 VBOXHGCMSVCPARM paParms[])
1334{
1335 int rc = VINF_SUCCESS;
1336 LogFlowFunc(("u32ClientID = %d, fn = %d, cParms = %d, pparms = %p\n",
1337 u32ClientID, eFunction, cParms, paParms));
1338
1339 try
1340 {
1341 switch (eFunction)
1342 {
1343 /* The guest wishes to read a property */
1344 case GET_PROP:
1345 LogFlowFunc(("GET_PROP\n"));
1346 rc = getProperty(cParms, paParms);
1347 break;
1348
1349 /* The guest wishes to set a property */
1350 case SET_PROP:
1351 LogFlowFunc(("SET_PROP\n"));
1352 rc = setProperty(cParms, paParms, true);
1353 break;
1354
1355 /* The guest wishes to set a property value */
1356 case SET_PROP_VALUE:
1357 LogFlowFunc(("SET_PROP_VALUE\n"));
1358 rc = setProperty(cParms, paParms, true);
1359 break;
1360
1361 /* The guest wishes to remove a configuration value */
1362 case DEL_PROP:
1363 LogFlowFunc(("DEL_PROP\n"));
1364 rc = delProperty(cParms, paParms, true);
1365 break;
1366
1367 /* The guest wishes to enumerate all properties */
1368 case ENUM_PROPS:
1369 LogFlowFunc(("ENUM_PROPS\n"));
1370 rc = enumProps(cParms, paParms);
1371 break;
1372
1373 /* The guest wishes to get the next property notification */
1374 case GET_NOTIFICATION:
1375 LogFlowFunc(("GET_NOTIFICATION\n"));
1376 rc = getNotification(u32ClientID, callHandle, cParms, paParms);
1377 break;
1378
1379 default:
1380 rc = VERR_NOT_IMPLEMENTED;
1381 }
1382 }
1383 catch (std::bad_alloc)
1384 {
1385 rc = VERR_NO_MEMORY;
1386 }
1387 LogFlowFunc(("rc = %Rrc\n", rc));
1388 if (rc != VINF_HGCM_ASYNC_EXECUTE)
1389 {
1390 mpHelpers->pfnCallComplete (callHandle, rc);
1391 }
1392}
1393
1394/**
1395 * Enumeration data shared between dbgInfoCallback and Service::dbgInfoShow.
1396 */
1397typedef struct ENUMDBGINFO
1398{
1399 PCDBGFINFOHLP pHlp;
1400} ENUMDBGINFO;
1401
1402static DECLCALLBACK(int) dbgInfoCallback(PRTSTRSPACECORE pStr, void *pvUser)
1403{
1404 Property *pProp = (Property *)pStr;
1405 PCDBGFINFOHLP pHlp = ((ENUMDBGINFO*)pvUser)->pHlp;
1406
1407 char szFlags[MAX_FLAGS_LEN];
1408 int rc = writeFlags(pProp->mFlags, szFlags);
1409 if (RT_FAILURE(rc))
1410 RTStrPrintf(szFlags, sizeof(szFlags), "???");
1411
1412 pHlp->pfnPrintf(pHlp, "%s: '%s', %RU64",
1413 pProp->mName.c_str(), pProp->mValue.c_str(), pProp->mTimestamp);
1414 if (strlen(szFlags))
1415 pHlp->pfnPrintf(pHlp, " (%s)", szFlags);
1416 pHlp->pfnPrintf(pHlp, "\n");
1417 return 0;
1418}
1419
1420void Service::dbgInfoShow(PCDBGFINFOHLP pHlp)
1421{
1422 ENUMDBGINFO EnumData = { pHlp };
1423 RTStrSpaceEnumerate(&mhProperties, dbgInfoCallback, &EnumData);
1424}
1425
1426/**
1427 * Handler for debug info.
1428 *
1429 * @param pvUser user pointer.
1430 * @param pHlp The info helper functions.
1431 * @param pszArgs Arguments, ignored.
1432 */
1433void Service::dbgInfo(void *pvUser, PCDBGFINFOHLP pHlp, const char *pszArgs)
1434{
1435 RT_NOREF1(pszArgs);
1436 SELF *pSelf = reinterpret_cast<SELF *>(pvUser);
1437 pSelf->dbgInfoShow(pHlp);
1438}
1439
1440
1441/**
1442 * Service call handler for the host.
1443 * @interface_method_impl{VBOXHGCMSVCFNTABLE,pfnHostCall}
1444 * @thread hgcm
1445 */
1446int Service::hostCall (uint32_t eFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
1447{
1448 int rc = VINF_SUCCESS;
1449
1450 LogFlowFunc(("fn = %d, cParms = %d, pparms = %p\n",
1451 eFunction, cParms, paParms));
1452
1453 try
1454 {
1455 switch (eFunction)
1456 {
1457 /* The host wishes to set a block of properties */
1458 case SET_PROPS_HOST:
1459 LogFlowFunc(("SET_PROPS_HOST\n"));
1460 rc = setPropertyBlock(cParms, paParms);
1461 break;
1462
1463 /* The host wishes to read a configuration value */
1464 case GET_PROP_HOST:
1465 LogFlowFunc(("GET_PROP_HOST\n"));
1466 rc = getProperty(cParms, paParms);
1467 break;
1468
1469 /* The host wishes to set a configuration value */
1470 case SET_PROP_HOST:
1471 LogFlowFunc(("SET_PROP_HOST\n"));
1472 rc = setProperty(cParms, paParms, false);
1473 break;
1474
1475 /* The host wishes to set a configuration value */
1476 case SET_PROP_VALUE_HOST:
1477 LogFlowFunc(("SET_PROP_VALUE_HOST\n"));
1478 rc = setProperty(cParms, paParms, false);
1479 break;
1480
1481 /* The host wishes to remove a configuration value */
1482 case DEL_PROP_HOST:
1483 LogFlowFunc(("DEL_PROP_HOST\n"));
1484 rc = delProperty(cParms, paParms, false);
1485 break;
1486
1487 /* The host wishes to enumerate all properties */
1488 case ENUM_PROPS_HOST:
1489 LogFlowFunc(("ENUM_PROPS\n"));
1490 rc = enumProps(cParms, paParms);
1491 break;
1492
1493 /* The host wishes to set global flags for the service */
1494 case SET_GLOBAL_FLAGS_HOST:
1495 LogFlowFunc(("SET_GLOBAL_FLAGS_HOST\n"));
1496 if (cParms == 1)
1497 {
1498 uint32_t eFlags;
1499 rc = paParms[0].getUInt32(&eFlags);
1500 if (RT_SUCCESS(rc))
1501 meGlobalFlags = (ePropFlags)eFlags;
1502 }
1503 else
1504 rc = VERR_INVALID_PARAMETER;
1505 break;
1506
1507 case GET_DBGF_INFO_FN:
1508 if (cParms != 2)
1509 return VERR_INVALID_PARAMETER;
1510 paParms[0].u.pointer.addr = (void*)(uintptr_t)dbgInfo;
1511 paParms[1].u.pointer.addr = (void*)this;
1512 break;
1513
1514 default:
1515 rc = VERR_NOT_SUPPORTED;
1516 break;
1517 }
1518 }
1519 catch (std::bad_alloc)
1520 {
1521 rc = VERR_NO_MEMORY;
1522 }
1523
1524 LogFlowFunc(("rc = %Rrc\n", rc));
1525 return rc;
1526}
1527
1528#ifdef ASYNC_HOST_NOTIFY
1529/* static */
1530DECLCALLBACK(int) Service::threadNotifyHost(RTTHREAD hThreadSelf, void *pvUser)
1531{
1532 RT_NOREF1(hThreadSelf);
1533 Service *pThis = (Service *)pvUser;
1534 int rc = VINF_SUCCESS;
1535
1536 LogFlowFunc(("ENTER: %p\n", pThis));
1537
1538 for (;;)
1539 {
1540 rc = RTReqQueueProcess(pThis->mhReqQNotifyHost, RT_INDEFINITE_WAIT);
1541
1542 AssertMsg(rc == VWRN_STATE_CHANGED,
1543 ("Left RTReqProcess and error code is not VWRN_STATE_CHANGED rc=%Rrc\n",
1544 rc));
1545 if (rc == VWRN_STATE_CHANGED)
1546 {
1547 break;
1548 }
1549 }
1550
1551 LogFlowFunc(("LEAVE: %Rrc\n", rc));
1552 return rc;
1553}
1554
1555static DECLCALLBACK(int) wakeupNotifyHost(void)
1556{
1557 /* Returning a VWRN_* will cause RTReqQueueProcess return. */
1558 return VWRN_STATE_CHANGED;
1559}
1560
1561int Service::initialize()
1562{
1563 /* The host notification thread and queue. */
1564 int rc = RTReqQueueCreate(&mhReqQNotifyHost);
1565 if (RT_SUCCESS(rc))
1566 {
1567 rc = RTThreadCreate(&mhThreadNotifyHost,
1568 threadNotifyHost,
1569 this,
1570 0 /* default stack size */,
1571 RTTHREADTYPE_DEFAULT,
1572 RTTHREADFLAGS_WAITABLE,
1573 "GSTPROPNTFY");
1574 }
1575
1576 if (RT_FAILURE(rc))
1577 {
1578 if (mhReqQNotifyHost != NIL_RTREQQUEUE)
1579 {
1580 RTReqQueueDestroy(mhReqQNotifyHost);
1581 mhReqQNotifyHost = NIL_RTREQQUEUE;
1582 }
1583 }
1584
1585 return rc;
1586}
1587
1588/**
1589 * @callback_method_impl{FNRTSTRSPACECALLBACK, Destroys Property.}
1590 */
1591static DECLCALLBACK(int) destroyProperty(PRTSTRSPACECORE pStr, void *pvUser)
1592{
1593 RT_NOREF(pvUser);
1594 Property *pProp = RT_FROM_MEMBER(pStr, struct Property, mStrCore);
1595 delete pProp;
1596 return 0;
1597}
1598
1599#endif
1600
1601int Service::uninit()
1602{
1603#ifdef ASYNC_HOST_NOTIFY
1604 if (mhReqQNotifyHost != NIL_RTREQQUEUE)
1605 {
1606 /* Stop the thread */
1607 PRTREQ pReq;
1608 int rc = RTReqQueueCall(mhReqQNotifyHost, &pReq, 10000, (PFNRT)wakeupNotifyHost, 0);
1609 if (RT_SUCCESS(rc))
1610 RTReqRelease(pReq);
1611 rc = RTThreadWait(mhThreadNotifyHost, 10000, NULL);
1612 AssertRC(rc);
1613 rc = RTReqQueueDestroy(mhReqQNotifyHost);
1614 AssertRC(rc);
1615 mhReqQNotifyHost = NIL_RTREQQUEUE;
1616 mhThreadNotifyHost = NIL_RTTHREAD;
1617 RTStrSpaceDestroy(&mhProperties, destroyProperty, NULL);
1618 mhProperties = NULL;
1619 }
1620#endif
1621
1622 return VINF_SUCCESS;
1623}
1624
1625} /* namespace guestProp */
1626
1627using guestProp::Service;
1628
1629/**
1630 * @copydoc VBOXHGCMSVCLOAD
1631 */
1632extern "C" DECLCALLBACK(DECLEXPORT(int)) VBoxHGCMSvcLoad (VBOXHGCMSVCFNTABLE *ptable)
1633{
1634 int rc = VERR_IPE_UNINITIALIZED_STATUS;
1635
1636 LogFlowFunc(("ptable = %p\n", ptable));
1637
1638 if (!RT_VALID_PTR(ptable))
1639 rc = VERR_INVALID_PARAMETER;
1640 else
1641 {
1642 LogFlowFunc(("ptable->cbSize = %d, ptable->u32Version = 0x%08X\n", ptable->cbSize, ptable->u32Version));
1643
1644 if ( ptable->cbSize != sizeof(VBOXHGCMSVCFNTABLE)
1645 || ptable->u32Version != VBOX_HGCM_SVC_VERSION)
1646 rc = VERR_VERSION_MISMATCH;
1647 else
1648 {
1649 Service *pService = NULL;
1650 /* No exceptions may propagate outside. */
1651 try
1652 {
1653 pService = new Service(ptable->pHelpers);
1654 rc = VINF_SUCCESS;
1655 }
1656 catch (int rcThrown)
1657 {
1658 rc = rcThrown;
1659 }
1660 catch (...)
1661 {
1662 rc = VERR_UNEXPECTED_EXCEPTION;
1663 }
1664
1665 if (RT_SUCCESS(rc))
1666 {
1667 /* We do not maintain connections, so no client data is needed. */
1668 ptable->cbClient = 0;
1669
1670 ptable->pfnUnload = Service::svcUnload;
1671 ptable->pfnConnect = Service::svcConnectDisconnect;
1672 ptable->pfnDisconnect = Service::svcConnectDisconnect;
1673 ptable->pfnCall = Service::svcCall;
1674 ptable->pfnHostCall = Service::svcHostCall;
1675 ptable->pfnSaveState = NULL; /* The service is stateless, so the normal */
1676 ptable->pfnLoadState = NULL; /* construction done before restoring suffices */
1677 ptable->pfnRegisterExtension = Service::svcRegisterExtension;
1678
1679 /* Service specific initialization. */
1680 ptable->pvService = pService;
1681
1682#ifdef ASYNC_HOST_NOTIFY
1683 rc = pService->initialize();
1684 if (RT_FAILURE(rc))
1685 {
1686 delete pService;
1687 pService = NULL;
1688 }
1689#endif
1690 }
1691 else
1692 Assert(!pService);
1693 }
1694 }
1695
1696 LogFlowFunc(("returning %Rrc\n", rc));
1697 return rc;
1698}
1699
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette