service.cpp@ 30614

Last change on this file since 30614 was 30614, checked in by vboxsync, 14 years ago
Comments.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 30.9 KB

Line
1	/* $Id: service.cpp 30614 2010-07-05 12:57:34Z vboxsync $ */
2	/** @file
3	* Guest Control Service: Controlling the guest.
4	*/
5
6	/*
7	* Copyright (C) 2010 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_control Guest Control HGCM Service
19	*
20	* This service acts as a proxy for handling and buffering host command requests
21	* and clients on the guest. It tries to be as transparent as possible to let
22	* the guest (client) and host side do their protocol handling as desired.
23	*
24	* The following terms are used:
25	* - Host: A host process (e.g. VBoxManage or another tool utilizing the Main API)
26	* which wants to control something on the guest.
27	* - Client: A client (e.g. VBoxService) running inside the guest OS waiting for
28	* new host commands to perform. There can be multiple clients connected
29	* to a service. A client is represented by its HGCM client ID.
30	* - Context ID: A (almost) unique ID automatically generated on the host (Main API)
31	* to not only distinguish clients but individual requests. Because
32	* the host does not know anything about connected clients it needs
33	* an indicator which it can refer to later. This context ID gets
34	* internally bound by the service to a client which actually processes
35	* the command in order to have a relationship between client<->context ID(s).
36	*
37	* The host can trigger commands which get buffered by the service (with full HGCM
38	* parameter info). As soon as a client connects (or is ready to do some new work)
39	* it gets a buffered host command to process it. This command then will be immediately
40	* removed from the command list. If there are ready clients but no new commands to be
41	* processed, these clients will be set into a deferred state (that is being blocked
42	* to return until a new command is available).
43	*
44	* If a client needs to inform the host that something happend, it can send a
45	* message to a low level HGCM callback registered in Main. This callback contains
46	* the actual data as well as the context ID to let the host do the next necessary
47	* steps for this context. This context ID makes it possible to wait for an event
48	* inside the host's Main API function (like starting a process on the guest and
49	* wait for getting its PID returned by the client) as well as cancelling blocking
50	* host calls in order the client terminated/crashed (HGCM detects disconnected
51	* clients and reports it to this service's callback).
52	*/
53
54	/*******************************************************************************
55	* Header Files *
56	*******************************************************************************/
57	#define LOG_GROUP LOG_GROUP_HGCM
58	#include <VBox/HostServices/GuestControlSvc.h>
59
60	#include <VBox/log.h>
61	#include <iprt/asm.h> /* For ASMBreakpoint(). */
62	#include <iprt/assert.h>
63	#include <iprt/cpp/autores.h>
64	#include <iprt/cpp/utils.h>
65	#include <iprt/err.h>
66	#include <iprt/mem.h>
67	#include <iprt/req.h>
68	#include <iprt/string.h>
69	#include <iprt/thread.h>
70	#include <iprt/time.h>
71
72	#include <memory> /* for auto_ptr */
73	#include <string>
74	#include <list>
75
76	#include "gctrl.h"
77
78	namespace guestControl {
79
80	/**
81	* Structure for holding all clients with their
82	* generated host contexts. This is necessary for
83	* mainting the relationship between a client and its context IDs.
84	*/
85	struct ClientContexts
86	{
87	/** This client ID. */
88	uint32_t mClientID;
89	/** The list of contexts a client is assigned to. */
90	std::list< uint32_t > mContextList;
91
92	/** The normal contructor. */
93	ClientContexts(uint32_t aClientID)
94	: mClientID(aClientID) {}
95	};
96	/** The client list + iterator type */
97	typedef std::list< ClientContexts > ClientContextsList;
98	typedef std::list< ClientContexts >::iterator ClientContextsListIter;
99	typedef std::list< ClientContexts >::const_iterator ClientContextsListIterConst;
100
101	/**
102	* Structure for holding an uncompleted guest call.
103	*/
104	struct ClientWaiter
105	{
106	/** Client ID; a client can have multiple handles! */
107	uint32_t mClientID;
108	/** The call handle */
109	VBOXHGCMCALLHANDLE mHandle;
110	/** The call parameters */
111	VBOXHGCMSVCPARM *mParms;
112	/** Number of parameters */
113	uint32_t mNumParms;
114
115	/** The standard contructor. */
116	ClientWaiter() : mClientID(0), mHandle(0), mParms(NULL), mNumParms(0) {}
117	/** The normal contructor. */
118	ClientWaiter(uint32_t aClientID, VBOXHGCMCALLHANDLE aHandle,
119	VBOXHGCMSVCPARM aParms[], uint32_t cParms)
120	: mClientID(aClientID), mHandle(aHandle), mParms(aParms), mNumParms(cParms) {}
121	};
122	/** The guest call list type */
123	typedef std::list< ClientWaiter > ClientWaiterList;
124	typedef std::list< ClientWaiter >::iterator CallListIter;
125	typedef std::list< ClientWaiter >::const_iterator CallListIterConst;
126
127	/**
128	* Structure for holding a buffered host command.
129	*/
130	struct HostCmd
131	{
132	/** The context ID this command belongs to. Will be extracted
133	* from the HGCM parameters. */
134	uint32_t mContextID;
135	/** Dynamic structure for holding the HGCM parms */
136	VBOXGUESTCTRPARAMBUFFER mParmBuf;
137
138	/** The standard contructor. */
139	HostCmd() : mContextID(0) {}
140	};
141	/** The host cmd list + iterator type */
142	typedef std::list< HostCmd > HostCmdList;
143	typedef std::list< HostCmd >::iterator HostCmdListIter;
144	typedef std::list< HostCmd >::const_iterator HostCmdListIterConst;
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	/*
157	* Callback function supplied by the host for notification of updates
158	* to properties.
159	*/
160	PFNHGCMSVCEXT mpfnHostCallback;
161	/** User data pointer to be supplied to the host callback function. */
162	void *mpvHostData;
163	/** The deferred calls list. */
164	ClientWaiterList mClientWaiterList;
165	/** The host command list. */
166	HostCmdList mHostCmds;
167	/** Client contexts list. */
168	ClientContextsList mClientContextsList;
169
170	public:
171	explicit Service(PVBOXHGCMSVCHELPERS pHelpers)
172	: mpHelpers(pHelpers)
173	, mpfnHostCallback(NULL)
174	, mpvHostData(NULL)
175	{
176	}
177
178	/**
179	* @copydoc VBOXHGCMSVCHELPERS::pfnUnload
180	* Simply deletes the service object
181	*/
182	static DECLCALLBACK(int) svcUnload (void *pvService)
183	{
184	AssertLogRelReturn(VALID_PTR(pvService), VERR_INVALID_PARAMETER);
185	SELF pSelf = reinterpret_cast<SELF >(pvService);
186	int rc = pSelf->uninit();
187	AssertRC(rc);
188	if (RT_SUCCESS(rc))
189	delete pSelf;
190	return rc;
191	}
192
193	/**
194	* @copydoc VBOXHGCMSVCHELPERS::pfnConnect
195	* Stub implementation of pfnConnect and pfnDisconnect.
196	*/
197	static DECLCALLBACK(int) svcConnect (void *pvService,
198	uint32_t u32ClientID,
199	void *pvClient)
200	{
201	AssertLogRelReturn(VALID_PTR(pvService), VERR_INVALID_PARAMETER);
202	LogFlowFunc (("pvService=%p, u32ClientID=%u, pvClient=%p\n", pvService, u32ClientID, pvClient));
203	SELF pSelf = reinterpret_cast<SELF >(pvService);
204	int rc = pSelf->clientConnect(u32ClientID, pvClient);
205	LogFlowFunc (("rc=%Rrc\n", rc));
206	return rc;
207	}
208
209	/**
210	* @copydoc VBOXHGCMSVCHELPERS::pfnConnect
211	* Stub implementation of pfnConnect and pfnDisconnect.
212	*/
213	static DECLCALLBACK(int) svcDisconnect (void *pvService,
214	uint32_t u32ClientID,
215	void *pvClient)
216	{
217	AssertLogRelReturn(VALID_PTR(pvService), VERR_INVALID_PARAMETER);
218	LogFlowFunc (("pvService=%p, u32ClientID=%u, pvClient=%p\n", pvService, u32ClientID, pvClient));
219	SELF pSelf = reinterpret_cast<SELF >(pvService);
220	int rc = pSelf->clientDisconnect(u32ClientID, pvClient);
221	LogFlowFunc (("rc=%Rrc\n", rc));
222	return rc;
223	}
224
225	/**
226	* @copydoc VBOXHGCMSVCHELPERS::pfnCall
227	* Wraps to the call member function
228	*/
229	static DECLCALLBACK(void) svcCall (void * pvService,
230	VBOXHGCMCALLHANDLE callHandle,
231	uint32_t u32ClientID,
232	void *pvClient,
233	uint32_t u32Function,
234	uint32_t cParms,
235	VBOXHGCMSVCPARM paParms[])
236	{
237	AssertLogRelReturnVoid(VALID_PTR(pvService));
238	LogFlowFunc (("pvService=%p, callHandle=%p, u32ClientID=%u, pvClient=%p, u32Function=%u, cParms=%u, paParms=%p\n", pvService, callHandle, u32ClientID, pvClient, u32Function, cParms, paParms));
239	SELF pSelf = reinterpret_cast<SELF >(pvService);
240	pSelf->call(callHandle, u32ClientID, pvClient, u32Function, cParms, paParms);
241	LogFlowFunc (("returning\n"));
242	}
243
244	/**
245	* @copydoc VBOXHGCMSVCHELPERS::pfnHostCall
246	* Wraps to the hostCall member function
247	*/
248	static DECLCALLBACK(int) svcHostCall (void *pvService,
249	uint32_t u32Function,
250	uint32_t cParms,
251	VBOXHGCMSVCPARM paParms[])
252	{
253	AssertLogRelReturn(VALID_PTR(pvService), VERR_INVALID_PARAMETER);
254	LogFlowFunc (("pvService=%p, u32Function=%u, cParms=%u, paParms=%p\n", pvService, u32Function, cParms, paParms));
255	SELF pSelf = reinterpret_cast<SELF >(pvService);
256	int rc = pSelf->hostCall(u32Function, cParms, paParms);
257	LogFlowFunc (("rc=%Rrc\n", rc));
258	return rc;
259	}
260
261	/**
262	* @copydoc VBOXHGCMSVCHELPERS::pfnRegisterExtension
263	* Installs a host callback for notifications of property changes.
264	*/
265	static DECLCALLBACK(int) svcRegisterExtension (void *pvService,
266	PFNHGCMSVCEXT pfnExtension,
267	void *pvExtension)
268	{
269	AssertLogRelReturn(VALID_PTR(pvService), VERR_INVALID_PARAMETER);
270	SELF pSelf = reinterpret_cast<SELF >(pvService);
271	pSelf->mpfnHostCallback = pfnExtension;
272	pSelf->mpvHostData = pvExtension;
273	return VINF_SUCCESS;
274	}
275	private:
276	int paramBufferAllocate(PVBOXGUESTCTRPARAMBUFFER pBuf, uint32_t uMsg, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
277	void paramBufferFree(PVBOXGUESTCTRPARAMBUFFER pBuf);
278	int paramBufferAssign(PVBOXGUESTCTRPARAMBUFFER pBuf, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
279	int prepareExecute(uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
280	int clientConnect(uint32_t u32ClientID, void *pvClient);
281	int clientDisconnect(uint32_t u32ClientID, void *pvClient);
282	int sendHostCmdToGuest(HostCmd *pCmd, VBOXHGCMCALLHANDLE callHandle, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
283	int retrieveNextHostCmd(uint32_t u32ClientID, VBOXHGCMCALLHANDLE callHandle, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
284	int cancelPendingWaits(uint32_t u32ClientID);
285	int notifyHost(uint32_t eFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
286	int processHostCmd(uint32_t eFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
287	void call(VBOXHGCMCALLHANDLE callHandle, uint32_t u32ClientID,
288	void *pvClient, uint32_t eFunction, uint32_t cParms,
289	VBOXHGCMSVCPARM paParms[]);
290	int hostCall(uint32_t eFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
291	int uninit();
292	};
293
294
295	/** @todo Write some nice doc headers! */
296	/* Stores a HGCM request in an internal buffer (pEx). Needs to be freed later using execBufferFree(). */
297	int Service::paramBufferAllocate(PVBOXGUESTCTRPARAMBUFFER pBuf, uint32_t uMsg, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
298	{
299	AssertPtr(pBuf);
300	int rc = VINF_SUCCESS;
301
302	/* Paranoia. */
303	if (cParms > 256)
304	cParms = 256;
305
306	/*
307	* Don't verify anything here (yet), because this function only buffers
308	* the HGCM data into an internal structure and reaches it back to the guest (client)
309	* in an unmodified state.
310	*/
311	if (RT_SUCCESS(rc))
312	{
313	pBuf->uMsg = uMsg;
314	pBuf->uParmCount = cParms;
315	pBuf->pParms = (VBOXHGCMSVCPARM)RTMemAlloc(sizeof(VBOXHGCMSVCPARM) pBuf->uParmCount);
316	if (NULL == pBuf->pParms)
317	{
318	rc = VERR_NO_MEMORY;
319	}
320	else
321	{
322	for (uint32_t i = 0; i < pBuf->uParmCount; i++)
323	{
324	pBuf->pParms[i].type = paParms[i].type;
325	switch (paParms[i].type)
326	{
327	case VBOX_HGCM_SVC_PARM_32BIT:
328	pBuf->pParms[i].u.uint32 = paParms[i].u.uint32;
329	break;
330
331	case VBOX_HGCM_SVC_PARM_64BIT:
332	/* Not supported yet. */
333	break;
334
335	case VBOX_HGCM_SVC_PARM_PTR:
336	pBuf->pParms[i].u.pointer.size = paParms[i].u.pointer.size;
337	if (pBuf->pParms[i].u.pointer.size > 0)
338	{
339	pBuf->pParms[i].u.pointer.addr = RTMemAlloc(pBuf->pParms[i].u.pointer.size);
340	if (NULL == pBuf->pParms[i].u.pointer.addr)
341	{
342	rc = VERR_NO_MEMORY;
343	break;
344	}
345	else
346	memcpy(pBuf->pParms[i].u.pointer.addr,
347	paParms[i].u.pointer.addr,
348	pBuf->pParms[i].u.pointer.size);
349	}
350	break;
351
352	default:
353	break;
354	}
355	if (RT_FAILURE(rc))
356	break;
357	}
358	}
359	}
360	return rc;
361	}
362
363	/* Frees a buffered HGCM request. */
364	void Service::paramBufferFree(PVBOXGUESTCTRPARAMBUFFER pBuf)
365	{
366	AssertPtr(pBuf);
367	for (uint32_t i = 0; i < pBuf->uParmCount; i++)
368	{
369	switch (pBuf->pParms[i].type)
370	{
371	case VBOX_HGCM_SVC_PARM_PTR:
372	if (pBuf->pParms[i].u.pointer.size > 0)
373	RTMemFree(pBuf->pParms[i].u.pointer.addr);
374	break;
375	}
376	}
377	if (pBuf->uParmCount)
378	{
379	RTMemFree(pBuf->pParms);
380	pBuf->uParmCount = 0;
381	}
382	}
383
384	/* Assigns data from a buffered HGCM request to the current HGCM request. */
385	int Service::paramBufferAssign(PVBOXGUESTCTRPARAMBUFFER pBuf, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
386	{
387	AssertPtr(pBuf);
388	int rc = VINF_SUCCESS;
389	if (cParms != pBuf->uParmCount)
390	{
391	rc = VERR_INVALID_PARAMETER;
392	}
393	else
394	{
395	/** @todo Add check to verify if the HGCM request is the same type as the buffered one! */
396	for (uint32_t i = 0; i < pBuf->uParmCount; i++)
397	{
398	paParms[i].type = pBuf->pParms[i].type;
399	switch (paParms[i].type)
400	{
401	case VBOX_HGCM_SVC_PARM_32BIT:
402	paParms[i].u.uint32 = pBuf->pParms[i].u.uint32;
403	break;
404
405	case VBOX_HGCM_SVC_PARM_64BIT:
406	/* Not supported yet. */
407	break;
408
409	case VBOX_HGCM_SVC_PARM_PTR:
410	memcpy(paParms[i].u.pointer.addr,
411	pBuf->pParms[i].u.pointer.addr,
412	pBuf->pParms[i].u.pointer.size);
413	break;
414
415	default:
416	break;
417	}
418	}
419	}
420	return rc;
421	}
422
423	int Service::clientConnect(uint32_t u32ClientID, void *pvClient)
424	{
425	LogFlowFunc(("New client (%ld) connected\n", u32ClientID));
426	return VINF_SUCCESS;
427	}
428
429	int Service::clientDisconnect(uint32_t u32ClientID, void *pvClient)
430	{
431	LogFlowFunc(("Client (%ld) disconnected\n", u32ClientID));
432
433	/*
434	* Throw out all stale clients.
435	*/
436	int rc = VINF_SUCCESS;
437
438	CallListIter itCall = mClientWaiterList.begin();
439	while (itCall != mClientWaiterList.end())
440	{
441	if (itCall->mClientID == u32ClientID)
442	{
443	itCall = mClientWaiterList.erase(itCall);
444	}
445	else
446	itCall++;
447	}
448
449	ClientContextsListIter it = mClientContextsList.begin();
450	while ( it != mClientContextsList.end()
451	&& RT_SUCCESS(rc))
452	{
453	if (it->mClientID == u32ClientID)
454	{
455	std::list< uint32_t >::iterator itContext = it->mContextList.begin();
456	while ( itContext != it->mContextList.end()
457	&& RT_SUCCESS(rc))
458	{
459	LogFlowFunc(("Notifying host context %u of disconnect ...\n", (*itContext)));
460
461	/*
462	* Notify the host that clients with u32ClientID are no longer
463	* around and need to be cleaned up (canceling waits etc).
464	*/
465	if (mpfnHostCallback)
466	{
467	CALLBACKDATACLIENTDISCONNECTED data;
468	data.hdr.u32Magic = CALLBACKDATAMAGICCLIENTDISCONNECTED;
469	data.hdr.u32ContextID = (*itContext);
470	rc = mpfnHostCallback(mpvHostData, GUEST_DISCONNECTED, (void *)(&data), sizeof(data));
471	if (RT_FAILURE(rc))
472	LogFlowFunc(("Notification of host context %u failed with %Rrc\n", rc));
473	}
474	itContext++;
475	}
476	it = mClientContextsList.erase(it);
477	}
478	else
479	it++;
480	}
481	return rc;
482	}
483
484	int Service::sendHostCmdToGuest(HostCmd *pCmd, VBOXHGCMCALLHANDLE callHandle, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
485	{
486	AssertPtr(pCmd);
487	int rc;
488
489	/* Sufficient parameter space? */
490	if (pCmd->mParmBuf.uParmCount > cParms)
491	{
492	paParms[0].setUInt32(pCmd->mParmBuf.uMsg); /* Message ID */
493	paParms[1].setUInt32(pCmd->mParmBuf.uParmCount); /* Required parameters for message */
494
495	/*
496	* So this call apparently failed because the guest wanted to peek
497	* how much parameters it has to supply in order to successfully retrieve
498	* this command. Let's tell him so!
499	*/
500	rc = VERR_TOO_MUCH_DATA;
501	}
502	else
503	{
504	rc = paramBufferAssign(&pCmd->mParmBuf, cParms, paParms);
505	}
506	return rc;
507	}
508
509	/*
510	* Either fills in parameters from a pending host command into our guest context or
511	* defer the guest call until we have something from the host.
512	*/
513	int Service::retrieveNextHostCmd(uint32_t u32ClientID, VBOXHGCMCALLHANDLE callHandle,
514	uint32_t cParms, VBOXHGCMSVCPARM paParms[])
515	{
516	int rc = VINF_SUCCESS;
517
518	/*
519	* Lookup client in our list so that we can assign the context ID of
520	* a command to that client.
521	*/
522	std::list< ClientContexts >::reverse_iterator it = mClientContextsList.rbegin();
523	while (it != mClientContextsList.rend())
524	{
525	if (it->mClientID == u32ClientID)
526	break;
527	it++;
528	}
529
530	/* Not found? Add client to list. */
531	if (it == mClientContextsList.rend())
532	{
533	mClientContextsList.push_back(ClientContexts(u32ClientID));
534	it = mClientContextsList.rbegin();
535	}
536	Assert(it != mClientContextsList.rend());
537
538	/*
539	* If host command list is empty (nothing to do right now) just
540	* defer the call until we got something to do (makes the client
541	* wait, depending on the flags set).
542	*/
543	if (mHostCmds.empty()) /* If command list is empty, defer ... */
544	{
545	mClientWaiterList.push_back(ClientWaiter(u32ClientID, callHandle, paParms, cParms));
546	rc = VINF_HGCM_ASYNC_EXECUTE;
547	}
548	else
549	{
550	/*
551	* Get the next unassigned host command in the list.
552	*/
553	HostCmd curCmd = mHostCmds.front();
554	rc = sendHostCmdToGuest(&curCmd, callHandle, cParms, paParms);
555	if (RT_SUCCESS(rc))
556	{
557	/* Remember which client processes which context (for
558	* later reference & cleanup). */
559	Assert(curCmd.mContextID > 0);
560	/// @todo r=bird: check if already in the list.
561	it->mContextList.push_back(curCmd.mContextID);
562
563	/* Only if the guest really got and understood the message remove it from the list. */
564	paramBufferFree(&curCmd.mParmBuf);
565	mHostCmds.pop_front();
566	}
567	}
568	return rc;
569	}
570
571	/*
572	* Client asks itself (in another thread) to cancel all pending waits which are blocking the client
573	* from shutting down / doing something else.
574	*/
575	int Service::cancelPendingWaits(uint32_t u32ClientID)
576	{
577	int rc = VINF_SUCCESS;
578	CallListIter it = mClientWaiterList.begin();
579	while (it != mClientWaiterList.end())
580	{
581	if (it->mClientID == u32ClientID)
582	{
583	if (it->mNumParms >= 2)
584	{
585	it->mParms[0].setUInt32(GETHOSTMSG_EXEC_HOST_CANCEL_WAIT); /* Message ID. */
586	it->mParms[1].setUInt32(0); /* Required parameters for message. */
587	}
588	if (mpHelpers)
589	mpHelpers->pfnCallComplete(it->mHandle, rc);
590	it = mClientWaiterList.erase(it);
591	}
592	else
593	it++;
594	}
595	return rc;
596	}
597
598	int Service::notifyHost(uint32_t eFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
599	{
600	LogFlowFunc(("eFunction=%ld, cParms=%ld, paParms=%p\n",
601	eFunction, cParms, paParms));
602	int rc = VINF_SUCCESS;
603	if ( eFunction == GUEST_EXEC_SEND_STATUS
604	&& cParms == 5)
605	{
606	CALLBACKDATAEXECSTATUS data;
607	data.hdr.u32Magic = CALLBACKDATAMAGICEXECSTATUS;
608	paParms[0].getUInt32(&data.hdr.u32ContextID);
609
610	paParms[1].getUInt32(&data.u32PID);
611	paParms[2].getUInt32(&data.u32Status);
612	paParms[3].getUInt32(&data.u32Flags);
613	paParms[4].getPointer(&data.pvData, &data.cbData);
614
615	if (mpfnHostCallback)
616	rc = mpfnHostCallback(mpvHostData, eFunction,
617	(void *)(&data), sizeof(data));
618	}
619	else if ( eFunction == GUEST_EXEC_SEND_OUTPUT
620	&& cParms == 5)
621	{
622	CALLBACKDATAEXECOUT data;
623	data.hdr.u32Magic = CALLBACKDATAMAGICEXECOUT;
624	paParms[0].getUInt32(&data.hdr.u32ContextID);
625
626	paParms[1].getUInt32(&data.u32PID);
627	paParms[2].getUInt32(&data.u32HandleId);
628	paParms[3].getUInt32(&data.u32Flags);
629	paParms[4].getPointer(&data.pvData, &data.cbData);
630
631	if (mpfnHostCallback)
632	rc = mpfnHostCallback(mpvHostData, eFunction,
633	(void *)(&data), sizeof(data));
634	}
635	else
636	rc = VERR_NOT_SUPPORTED;
637	LogFlowFunc(("returning %Rrc\n", rc));
638	return rc;
639	}
640
641	int Service::processHostCmd(uint32_t eFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
642	{
643	int rc = VINF_SUCCESS;
644
645	HostCmd newCmd;
646	rc = paramBufferAllocate(&newCmd.mParmBuf, eFunction, cParms, paParms);
647	if ( RT_SUCCESS(rc)
648	&& newCmd.mParmBuf.uParmCount > 0)
649	{
650	/*
651	* Assume that the context ID always is the first parameter,
652	* assign the context ID to the command.
653	*/
654	newCmd.mParmBuf.pParms[0].getUInt32(&newCmd.mContextID);
655	Assert(newCmd.mContextID > 0);
656	}
657
658	bool fProcessed = false;
659	if (RT_SUCCESS(rc))
660	{
661	/* Can we wake up a waiting client on guest? */
662	if (!mClientWaiterList.empty())
663	{
664	ClientWaiter guest = mClientWaiterList.front();
665	rc = sendHostCmdToGuest(&newCmd,
666	guest.mHandle, guest.mNumParms, guest.mParms);
667
668	/* In any case the client did something, so wake up and remove from list. */
669	AssertPtr(mpHelpers);
670	mpHelpers->pfnCallComplete(guest.mHandle, rc);
671	mClientWaiterList.pop_front();
672
673	/* If we got VERR_TOO_MUCH_DATA we buffer the host command in the next block
674	* and return success to the host. */
675	if (rc == VERR_TOO_MUCH_DATA)
676	{
677	rc = VINF_SUCCESS;
678	}
679	else /* If command was understood by the client, free and remove from host commands list. */
680	{
681	paramBufferFree(&newCmd.mParmBuf);
682	fProcessed = true;
683	}
684	}
685
686	/* If not processed, buffer it ... */
687	if (!fProcessed)
688	{
689	mHostCmds.push_back(newCmd);
690	#if 0
691	/* Limit list size by deleting oldest element. */
692	if (mHostCmds.size() > 256) /** @todo Use a define! */
693	mHostCmds.pop_front();
694	#endif
695	}
696	}
697	return rc;
698	}
699
700	/**
701	* Handle an HGCM service call.
702	* @copydoc VBOXHGCMSVCFNTABLE::pfnCall
703	* @note All functions which do not involve an unreasonable delay will be
704	* handled synchronously. If needed, we will add a request handler
705	* thread in future for those which do.
706	*
707	* @thread HGCM
708	*/
709	void Service::call(VBOXHGCMCALLHANDLE callHandle, uint32_t u32ClientID,
710	void * /* pvClient */, uint32_t eFunction, uint32_t cParms,
711	VBOXHGCMSVCPARM paParms[])
712	{
713	int rc = VINF_SUCCESS;
714	LogFlowFunc(("u32ClientID = %d, fn = %d, cParms = %d, pparms = %d\n",
715	u32ClientID, eFunction, cParms, paParms));
716	try
717	{
718	switch (eFunction)
719	{
720	/*
721	* The guest asks the host for the next messsage to process.
722	*/
723	case GUEST_GET_HOST_MSG:
724	LogFlowFunc(("GUEST_GET_HOST_MSG\n"));
725	rc = retrieveNextHostCmd(u32ClientID, callHandle, cParms, paParms);
726	break;
727
728	/*
729	* The guest wants to shut down and asks us (this service) to cancel
730	* all blocking pending waits (VINF_HGCM_ASYNC_EXECUTE) so that the
731	* guest can gracefully shut down.
732	*/
733	case GUEST_CANCEL_PENDING_WAITS:
734	LogFlowFunc(("GUEST_CANCEL_PENDING_WAITS\n"));
735	rc = cancelPendingWaits(u32ClientID);
736	break;
737
738	/*
739	* The guest notifies the host that some output at stdout/stderr is available.
740	*/
741	case GUEST_EXEC_SEND_OUTPUT:
742	LogFlowFunc(("GUEST_EXEC_SEND_OUTPUT\n"));
743	rc = notifyHost(eFunction, cParms, paParms);
744	break;
745
746	/*
747	* The guest notifies the host of the current client status.
748	*/
749	case GUEST_EXEC_SEND_STATUS:
750	LogFlowFunc(("SEND_STATUS\n"));
751	rc = notifyHost(eFunction, cParms, paParms);
752	break;
753
754	default:
755	rc = VERR_NOT_SUPPORTED;
756	break;
757	}
758	if (rc != VINF_HGCM_ASYNC_EXECUTE)
759	{
760	/* Tell the client that the call is complete (unblocks waiting). */
761	AssertPtr(mpHelpers);
762	mpHelpers->pfnCallComplete(callHandle, rc);
763	}
764	}
765	catch (std::bad_alloc)
766	{
767	rc = VERR_NO_MEMORY;
768	}
769	LogFlowFunc(("rc = %Rrc\n", rc));
770	}
771
772	/**
773	* Service call handler for the host.
774	* @copydoc VBOXHGCMSVCFNTABLE::pfnHostCall
775	* @thread hgcm
776	*/
777	int Service::hostCall(uint32_t eFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
778	{
779	int rc = VINF_SUCCESS;
780	LogFlowFunc(("fn = %d, cParms = %d, pparms = %d\n",
781	eFunction, cParms, paParms));
782	try
783	{
784	switch (eFunction)
785	{
786	/* The host wants to execute something. */
787	case HOST_EXEC_CMD:
788	LogFlowFunc(("HOST_EXEC_CMD\n"));
789	rc = processHostCmd(eFunction, cParms, paParms);
790	break;
791
792	/* The host wants to send something to the guest's stdin pipe. */
793	case HOST_EXEC_SET_INPUT:
794	LogFlowFunc(("HOST_EXEC_SET_INPUT\n"));
795	break;
796
797	case HOST_EXEC_GET_OUTPUT:
798	LogFlowFunc(("HOST_EXEC_GET_OUTPUT\n"));
799	rc = processHostCmd(eFunction, cParms, paParms);
800	break;
801
802	default:
803	rc = VERR_NOT_SUPPORTED;
804	break;
805	}
806	}
807	catch (std::bad_alloc)
808	{
809	rc = VERR_NO_MEMORY;
810	}
811
812	LogFlowFunc(("rc = %Rrc\n", rc));
813	return rc;
814	}
815
816	int Service::uninit()
817	{
818	/* Free allocated buffered host commands. */
819	HostCmdListIter it;
820	for (it = mHostCmds.begin(); it != mHostCmds.end(); it++)
821	paramBufferFree(&it->mParmBuf);
822	mHostCmds.clear();
823
824	return VINF_SUCCESS;
825	}
826
827	} /* namespace guestControl */
828
829	using guestControl::Service;
830
831	/**
832	* @copydoc VBOXHGCMSVCLOAD
833	*/
834	extern "C" DECLCALLBACK(DECLEXPORT(int)) VBoxHGCMSvcLoad(VBOXHGCMSVCFNTABLE *ptable)
835	{
836	int rc = VINF_SUCCESS;
837
838	LogFlowFunc(("ptable = %p\n", ptable));
839
840	if (!VALID_PTR(ptable))
841	{
842	rc = VERR_INVALID_PARAMETER;
843	}
844	else
845	{
846	LogFlowFunc(("ptable->cbSize = %d, ptable->u32Version = 0x%08X\n", ptable->cbSize, ptable->u32Version));
847
848	if ( ptable->cbSize != sizeof (VBOXHGCMSVCFNTABLE)
849	\|\| ptable->u32Version != VBOX_HGCM_SVC_VERSION)
850	{
851	rc = VERR_VERSION_MISMATCH;
852	}
853	else
854	{
855	std::auto_ptr<Service> apService;
856	/* No exceptions may propogate outside. */
857	try {
858	apService = std::auto_ptr<Service>(new Service(ptable->pHelpers));
859	} catch (int rcThrown) {
860	rc = rcThrown;
861	} catch (...) {
862	rc = VERR_UNRESOLVED_ERROR;
863	}
864
865	if (RT_SUCCESS(rc))
866	{
867	/*
868	* We don't need an additional client data area on the host,
869	* because we're a class which can have members for that :-).
870	*/
871	ptable->cbClient = 0;
872
873	/* Register functions. */
874	ptable->pfnUnload = Service::svcUnload;
875	ptable->pfnConnect = Service::svcConnect;
876	ptable->pfnDisconnect = Service::svcDisconnect;
877	ptable->pfnCall = Service::svcCall;
878	ptable->pfnHostCall = Service::svcHostCall;
879	ptable->pfnSaveState = NULL; /* The service is stateless, so the normal */
880	ptable->pfnLoadState = NULL; /* construction done before restoring suffices */
881	ptable->pfnRegisterExtension = Service::svcRegisterExtension;
882
883	/* Service specific initialization. */
884	ptable->pvService = apService.release();
885	}
886	}
887	}
888
889	LogFlowFunc(("returning %Rrc\n", rc));
890	return rc;
891	}
892

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

source: vbox/trunk/src/VBox/HostServices/GuestControl/service.cpp@ 30614

Download in other formats: