GuestCtrlImpl.cpp@ 61572

Last change on this file since 61572 was 60622, checked in by vboxsync, 9 years ago
Guest Control: Added proper handling for (VBoxService) toolbox exit codes, resolving various copyto/copyfrom bugs.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 19.6 KB

Line
1	/* $Id: GuestCtrlImpl.cpp 60622 2016-04-21 13:00:20Z vboxsync $ */
2	/** @file
3	* VirtualBox COM class implementation: Guest
4	*/
5
6	/*
7	* Copyright (C) 2006-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	#include "GuestImpl.h"
19	#ifdef VBOX_WITH_GUEST_CONTROL
20	# include "GuestSessionImpl.h"
21	# include "GuestCtrlImplPrivate.h"
22	#endif
23
24	#include "Global.h"
25	#include "ConsoleImpl.h"
26	#include "ProgressImpl.h"
27	#include "VBoxEvents.h"
28	#include "VMMDev.h"
29
30	#include "AutoCaller.h"
31
32	#include <VBox/VMMDev.h>
33	#ifdef VBOX_WITH_GUEST_CONTROL
34	# include <VBox/com/array.h>
35	# include <VBox/com/ErrorInfo.h>
36	#endif
37	#include <iprt/cpp/utils.h>
38	#include <iprt/file.h>
39	#include <iprt/getopt.h>
40	#include <iprt/isofs.h>
41	#include <iprt/list.h>
42	#include <iprt/path.h>
43	#include <VBox/vmm/pgm.h>
44
45	#include <memory>
46
47	#ifdef LOG_GROUP
48	#undef LOG_GROUP
49	#endif
50	#define LOG_GROUP LOG_GROUP_GUEST_CONTROL
51	#include <VBox/log.h>
52
53
54	/*
55	* This #ifdef goes almost to the end of the file where there are a couple of
56	* IGuest method implementations.
57	*/
58	#ifdef VBOX_WITH_GUEST_CONTROL
59
60
61	// public methods only for internal purposes
62	/////////////////////////////////////////////////////////////////////////////
63
64	/**
65	* Static callback function for receiving updates on guest control commands
66	* from the guest. Acts as a dispatcher for the actual class instance.
67	*
68	* @returns VBox status code.
69	*
70	* @todo
71	*
72	*/
73	/* static */
74	DECLCALLBACK(int) Guest::i_notifyCtrlDispatcher(void *pvExtension,
75	uint32_t u32Function,
76	void *pvData,
77	uint32_t cbData)
78	{
79	using namespace guestControl;
80
81	/*
82	* No locking, as this is purely a notification which does not make any
83	* changes to the object state.
84	*/
85	LogFlowFunc(("pvExtension=%p, u32Function=%RU32, pvParms=%p, cbParms=%RU32\n",
86	pvExtension, u32Function, pvData, cbData));
87	ComObjPtr<Guest> pGuest = reinterpret_cast<Guest *>(pvExtension);
88	Assert(!pGuest.isNull());
89
90	/*
91	* For guest control 2.0 using the legacy commands we need to do the following here:
92	* - Get the callback header to access the context ID
93	* - Get the context ID of the callback
94	* - Extract the session ID out of the context ID
95	* - Dispatch the whole stuff to the appropriate session (if still exists)
96	*/
97	if (cbData != sizeof(VBOXGUESTCTRLHOSTCALLBACK))
98	return VERR_NOT_SUPPORTED;
99	PVBOXGUESTCTRLHOSTCALLBACK pSvcCb = (PVBOXGUESTCTRLHOSTCALLBACK)pvData;
100	AssertPtr(pSvcCb);
101
102	if (!pSvcCb->mParms) /* At least context ID must be present. */
103	return VERR_INVALID_PARAMETER;
104
105	uint32_t uContextID;
106	int rc = pSvcCb->mpaParms[0].getUInt32(&uContextID);
107	AssertMsgRCReturn(rc, ("Unable to extract callback context ID, pvData=%p\n", pSvcCb), rc);
108	#ifdef DEBUG
109	LogFlowFunc(("CID=%RU32, uSession=%RU32, uObject=%RU32, uCount=%RU32\n",
110	uContextID,
111	VBOX_GUESTCTRL_CONTEXTID_GET_SESSION(uContextID),
112	VBOX_GUESTCTRL_CONTEXTID_GET_OBJECT(uContextID),
113	VBOX_GUESTCTRL_CONTEXTID_GET_COUNT(uContextID)));
114	#endif
115
116	VBOXGUESTCTRLHOSTCBCTX ctxCb = { u32Function, uContextID };
117	rc = pGuest->i_dispatchToSession(&ctxCb, pSvcCb);
118
119	LogFlowFunc(("Returning rc=%Rrc\n", rc));
120	return rc;
121	}
122
123	// private methods
124	/////////////////////////////////////////////////////////////////////////////
125
126	int Guest::i_dispatchToSession(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb)
127	{
128	LogFlowFunc(("pCtxCb=%p, pSvcCb=%p\n", pCtxCb, pSvcCb));
129
130	AssertPtrReturn(pCtxCb, VERR_INVALID_POINTER);
131	AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER);
132
133	LogFlowFunc(("uFunction=%RU32, uContextID=%RU32, uProtocol=%RU32\n",
134	pCtxCb->uFunction, pCtxCb->uContextID, pCtxCb->uProtocol));
135
136	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
137
138	uint32_t uSessionID = VBOX_GUESTCTRL_CONTEXTID_GET_SESSION(pCtxCb->uContextID);
139	#ifdef DEBUG
140	LogFlowFunc(("uSessionID=%RU32 (%zu total)\n",
141	uSessionID, mData.mGuestSessions.size()));
142	#endif
143	GuestSessions::const_iterator itSession
144	= mData.mGuestSessions.find(uSessionID);
145
146	int rc;
147	if (itSession != mData.mGuestSessions.end())
148	{
149	ComObjPtr<GuestSession> pSession(itSession->second);
150	Assert(!pSession.isNull());
151
152	alock.release();
153
154	bool fDispatch = true;
155	#ifdef DEBUG
156	/*
157	* Pre-check: If we got a status message with an error and VERR_TOO_MUCH_DATA
158	* it means that that guest could not handle the entire message
159	* because of its exceeding size. This should not happen on daily
160	* use but testcases might try this. It then makes no sense to dispatch
161	* this further because we don't have a valid context ID.
162	*/
163	if ( pCtxCb->uFunction == GUEST_EXEC_STATUS
164	&& pSvcCb->mParms >= 5)
165	{
166	CALLBACKDATA_PROC_STATUS dataCb;
167	/* pSvcCb->mpaParms[0] always contains the context ID. */
168	pSvcCb->mpaParms[1].getUInt32(&dataCb.uPID);
169	pSvcCb->mpaParms[2].getUInt32(&dataCb.uStatus);
170	pSvcCb->mpaParms[3].getUInt32(&dataCb.uFlags);
171	pSvcCb->mpaParms[4].getPointer(&dataCb.pvData, &dataCb.cbData);
172
173	if ( ( dataCb.uStatus == PROC_STS_ERROR)
174	/** @todo Note: Due to legacy reasons we cannot change uFlags to
175	* int32_t, so just cast it for now. */
176	&& ((int32_t)dataCb.uFlags == VERR_TOO_MUCH_DATA))
177	{
178	LogFlowFunc(("Requested command with too much data, skipping dispatching ...\n"));
179
180	Assert(dataCb.uPID == 0);
181	fDispatch = false;
182	}
183	}
184	#endif
185	if (fDispatch)
186	{
187	switch (pCtxCb->uFunction)
188	{
189	case GUEST_DISCONNECTED:
190	rc = pSession->i_dispatchToThis(pCtxCb, pSvcCb);
191	break;
192
193	case GUEST_EXEC_STATUS:
194	case GUEST_EXEC_OUTPUT:
195	case GUEST_EXEC_INPUT_STATUS:
196	case GUEST_EXEC_IO_NOTIFY:
197	rc = pSession->i_dispatchToProcess(pCtxCb, pSvcCb);
198	break;
199
200	case GUEST_FILE_NOTIFY:
201	rc = pSession->i_dispatchToFile(pCtxCb, pSvcCb);
202	break;
203
204	case GUEST_SESSION_NOTIFY:
205	rc = pSession->i_dispatchToThis(pCtxCb, pSvcCb);
206	break;
207
208	default:
209	/*
210	* Try processing generic messages which might
211	* (or might not) supported by certain objects.
212	* If the message either is not found or supported
213	* by the approprirate object, try handling it
214	* in this session object.
215	*/
216	rc = pSession->i_dispatchToObject(pCtxCb, pSvcCb);
217	if ( rc == VERR_NOT_FOUND
218	\|\| rc == VERR_NOT_SUPPORTED)
219	{
220	alock.acquire();
221
222	rc = pSession->dispatchGeneric(pCtxCb, pSvcCb);
223	}
224	#ifndef DEBUG_andy
225	if (rc == VERR_NOT_IMPLEMENTED)
226	AssertMsgFailed(("Received not handled function %RU32\n", pCtxCb->uFunction));
227	#endif
228	break;
229	}
230	}
231	else
232	rc = VERR_NOT_FOUND;
233	}
234	else
235	rc = VERR_NOT_FOUND;
236
237	LogFlowFuncLeaveRC(rc);
238	return rc;
239	}
240
241	int Guest::i_sessionRemove(GuestSession *pSession)
242	{
243	AssertPtrReturn(pSession, VERR_INVALID_POINTER);
244
245	LogFlowThisFuncEnter();
246
247	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
248
249	int rc = VERR_NOT_FOUND;
250
251	LogFlowThisFunc(("Removing session (ID=%RU32) ...\n", pSession->i_getId()));
252
253	GuestSessions::iterator itSessions = mData.mGuestSessions.begin();
254	while (itSessions != mData.mGuestSessions.end())
255	{
256	if (pSession == itSessions->second)
257	{
258	#ifdef DEBUG_andy
259	ULONG cRefs = pSession->AddRef();
260	Assert(cRefs >= 2);
261	LogFlowThisFunc(("pCurSession=%p, cRefs=%RU32\n", pSession, cRefs - 2));
262	pSession->Release();
263	#endif
264	/* Make sure to consume the pointer before the one of the
265	* iterator gets released. */
266	ComObjPtr<GuestSession> pCurSession = pSession;
267
268	LogFlowThisFunc(("Removing session (pSession=%p, ID=%RU32) (now total %ld sessions)\n",
269	pSession, pSession->i_getId(), mData.mGuestSessions.size() - 1));
270
271	rc = pSession->i_onRemove();
272	mData.mGuestSessions.erase(itSessions);
273
274	alock.release(); /* Release lock before firing off event. */
275
276	fireGuestSessionRegisteredEvent(mEventSource, pCurSession,
277	false /* Unregistered */);
278	pCurSession.setNull();
279	break;
280	}
281
282	++itSessions;
283	}
284
285	LogFlowFuncLeaveRC(rc);
286	return rc;
287	}
288
289	int Guest::i_sessionCreate(const GuestSessionStartupInfo &ssInfo,
290	const GuestCredentials &guestCreds, ComObjPtr<GuestSession> &pGuestSession)
291	{
292	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
293
294	int rc = VERR_MAX_PROCS_REACHED;
295	if (mData.mGuestSessions.size() >= VBOX_GUESTCTRL_MAX_SESSIONS)
296	return rc;
297
298	try
299	{
300	/* Create a new session ID and assign it. */
301	uint32_t uNewSessionID = VBOX_GUESTCTRL_SESSION_ID_BASE;
302	uint32_t uTries = 0;
303
304	for (;;)
305	{
306	/* Is the context ID already used? */
307	if (!i_sessionExists(uNewSessionID))
308	{
309	rc = VINF_SUCCESS;
310	break;
311	}
312	uNewSessionID++;
313	if (uNewSessionID >= VBOX_GUESTCTRL_MAX_SESSIONS)
314	uNewSessionID = VBOX_GUESTCTRL_SESSION_ID_BASE;
315
316	if (++uTries == VBOX_GUESTCTRL_MAX_SESSIONS)
317	break; /* Don't try too hard. */
318	}
319	if (RT_FAILURE(rc)) throw rc;
320
321	/* Create the session object. */
322	HRESULT hr = pGuestSession.createObject();
323	if (FAILED(hr)) throw VERR_COM_UNEXPECTED;
324
325	/** @todo Use an overloaded copy operator. Later. */
326	GuestSessionStartupInfo startupInfo;
327	startupInfo.mID = uNewSessionID; /* Assign new session ID. */
328	startupInfo.mName = ssInfo.mName;
329	startupInfo.mOpenFlags = ssInfo.mOpenFlags;
330	startupInfo.mOpenTimeoutMS = ssInfo.mOpenTimeoutMS;
331
332	GuestCredentials guestCredentials;
333	if (!guestCreds.mUser.isEmpty())
334	{
335	/** @todo Use an overloaded copy operator. Later. */
336	guestCredentials.mUser = guestCreds.mUser;
337	guestCredentials.mPassword = guestCreds.mPassword;
338	guestCredentials.mDomain = guestCreds.mDomain;
339	}
340	else
341	{
342	/* Internal (annonymous) session. */
343	startupInfo.mIsInternal = true;
344	}
345
346	rc = pGuestSession->init(this, startupInfo, guestCredentials);
347	if (RT_FAILURE(rc)) throw rc;
348
349	/*
350	* Add session object to our session map. This is necessary
351	* before calling openSession because the guest calls back
352	* with the creation result of this session.
353	*/
354	mData.mGuestSessions[uNewSessionID] = pGuestSession;
355
356	alock.release(); /* Release lock before firing off event. */
357
358	fireGuestSessionRegisteredEvent(mEventSource, pGuestSession,
359	true /* Registered */);
360	}
361	catch (int rc2)
362	{
363	rc = rc2;
364	}
365
366	LogFlowFuncLeaveRC(rc);
367	return rc;
368	}
369
370	inline bool Guest::i_sessionExists(uint32_t uSessionID)
371	{
372	GuestSessions::const_iterator itSessions = mData.mGuestSessions.find(uSessionID);
373	return (itSessions == mData.mGuestSessions.end()) ? false : true;
374	}
375
376	#endif /* VBOX_WITH_GUEST_CONTROL */
377
378
379	// implementation of public methods
380	/////////////////////////////////////////////////////////////////////////////
381	HRESULT Guest::createSession(const com::Utf8Str &aUser, const com::Utf8Str &aPassword, const com::Utf8Str &aDomain,
382	const com::Utf8Str &aSessionName, ComPtr<IGuestSession> &aGuestSession)
383
384	{
385	#ifndef VBOX_WITH_GUEST_CONTROL
386	ReturnComNotImplemented();
387	#else /* VBOX_WITH_GUEST_CONTROL */
388
389	LogFlowFuncEnter();
390
391	/* Do not allow anonymous sessions (with system rights) with public API. */
392	if (RT_UNLIKELY(!aUser.length()))
393	return setError(E_INVALIDARG, tr("No user name specified"));
394
395	GuestSessionStartupInfo startupInfo;
396	startupInfo.mName = aSessionName;
397
398	GuestCredentials guestCreds;
399	guestCreds.mUser = aUser;
400	guestCreds.mPassword = aPassword;
401	guestCreds.mDomain = aDomain;
402
403	ComObjPtr<GuestSession> pSession;
404	int rc = i_sessionCreate(startupInfo, guestCreds, pSession);
405	if (RT_SUCCESS(rc))
406	{
407	/* Return guest session to the caller. */
408	HRESULT hr2 = pSession.queryInterfaceTo(aGuestSession.asOutParam());
409	if (FAILED(hr2))
410	rc = VERR_COM_OBJECT_NOT_FOUND;
411	}
412
413	if (RT_SUCCESS(rc))
414	/* Start (fork) the session asynchronously
415	* on the guest. */
416	rc = pSession->i_startSessionAsync();
417
418	HRESULT hr = S_OK;
419
420	if (RT_FAILURE(rc))
421	{
422	switch (rc)
423	{
424	case VERR_MAX_PROCS_REACHED:
425	hr = setError(VBOX_E_IPRT_ERROR, tr("Maximum number of concurrent guest sessions (%ld) reached"),
426	VBOX_GUESTCTRL_MAX_SESSIONS);
427	break;
428
429	/** @todo Add more errors here. */
430
431	default:
432	hr = setError(VBOX_E_IPRT_ERROR, tr("Could not create guest session: %Rrc"), rc);
433	break;
434	}
435	}
436
437	LogFlowThisFunc(("Returning rc=%Rhrc\n", hr));
438	return hr;
439	#endif /* VBOX_WITH_GUEST_CONTROL */
440	}
441
442	HRESULT Guest::findSession(const com::Utf8Str &aSessionName, std::vector<ComPtr<IGuestSession> > &aSessions)
443	{
444	#ifndef VBOX_WITH_GUEST_CONTROL
445	ReturnComNotImplemented();
446	#else /* VBOX_WITH_GUEST_CONTROL */
447
448	LogFlowFuncEnter();
449
450	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
451
452	Utf8Str strName(aSessionName);
453	std::list < ComObjPtr<GuestSession> > listSessions;
454
455	GuestSessions::const_iterator itSessions = mData.mGuestSessions.begin();
456	while (itSessions != mData.mGuestSessions.end())
457	{
458	if (strName.contains(itSessions->second->i_getName())) /** @todo Use a (simple) pattern match (IPRT?). */
459	listSessions.push_back(itSessions->second);
460	++itSessions;
461	}
462
463	LogFlowFunc(("Sessions with \"%s\" = %RU32\n",
464	aSessionName.c_str(), listSessions.size()));
465
466	aSessions.resize(listSessions.size());
467	if (!listSessions.empty())
468	{
469	size_t i = 0;
470	for (std::list < ComObjPtr<GuestSession> >::const_iterator it = listSessions.begin(); it != listSessions.end(); ++it, ++i)
471	(*it).queryInterfaceTo(aSessions[i].asOutParam());
472
473	return S_OK;
474
475	}
476
477	return setErrorNoLog(VBOX_E_OBJECT_NOT_FOUND,
478	tr("Could not find sessions with name '%s'"),
479	aSessionName.c_str());
480	#endif /* VBOX_WITH_GUEST_CONTROL */
481	}
482
483	HRESULT Guest::updateGuestAdditions(const com::Utf8Str &aSource, const std::vector<com::Utf8Str> &aArguments,
484	const std::vector<AdditionsUpdateFlag_T> &aFlags, ComPtr<IProgress> &aProgress)
485	{
486	#ifndef VBOX_WITH_GUEST_CONTROL
487	ReturnComNotImplemented();
488	#else /* VBOX_WITH_GUEST_CONTROL */
489
490	/* Validate flags. */
491	uint32_t fFlags = AdditionsUpdateFlag_None;
492	if (aFlags.size())
493	for (size_t i = 0; i < aFlags.size(); ++i)
494	fFlags \|= aFlags[i];
495
496	if (fFlags && !(fFlags & AdditionsUpdateFlag_WaitForUpdateStartOnly))
497	return setError(E_INVALIDARG, tr("Unknown flags (%#x)"), fFlags);
498
499	int rc = VINF_SUCCESS;
500
501	ProcessArguments aArgs;
502	aArgs.resize(0);
503
504	if (aArguments.size())
505	{
506	try
507	{
508	for (size_t i = 0; i < aArguments.size(); ++i)
509	aArgs.push_back(aArguments[i]);
510	}
511	catch(std::bad_alloc &)
512	{
513	rc = VERR_NO_MEMORY;
514	}
515	}
516
517	HRESULT hr = S_OK;
518
519	/*
520	* Create an anonymous session. This is required to run the Guest Additions
521	* update process with administrative rights.
522	*/
523	GuestSessionStartupInfo startupInfo;
524	startupInfo.mName = "Updating Guest Additions";
525
526	GuestCredentials guestCreds;
527	RT_ZERO(guestCreds);
528
529	ComObjPtr<GuestSession> pSession;
530	if (RT_SUCCESS(rc))
531	rc = i_sessionCreate(startupInfo, guestCreds, pSession);
532	if (RT_FAILURE(rc))
533	{
534	switch (rc)
535	{
536	case VERR_MAX_PROCS_REACHED:
537	hr = setError(VBOX_E_IPRT_ERROR, tr("Maximum number of concurrent guest sessions (%ld) reached"),
538	VBOX_GUESTCTRL_MAX_SESSIONS);
539	break;
540
541	/** @todo Add more errors here. */
542
543	default:
544	hr = setError(VBOX_E_IPRT_ERROR, tr("Could not create guest session: %Rrc"), rc);
545	break;
546	}
547	}
548	else
549	{
550	Assert(!pSession.isNull());
551	int guestRc;
552	rc = pSession->i_startSessionInternal(&guestRc);
553	if (RT_FAILURE(rc))
554	{
555	/** @todo Handle guestRc! */
556
557	hr = setError(VBOX_E_IPRT_ERROR, tr("Could not open guest session: %Rrc"), rc);
558	}
559	else
560	{
561
562	ComObjPtr<Progress> pProgress;
563	SessionTaskUpdateAdditions *pTask = NULL;
564	try
565	{
566	try
567	{
568	pTask = new SessionTaskUpdateAdditions(pSession /* GuestSession */, aSource, aArgs, fFlags);
569	}
570	catch(...)
571	{
572	hr = setError(VBOX_E_IPRT_ERROR, tr("Failed to create SessionTaskUpdateAdditions object "));
573	throw;
574	}
575
576
577	hr = pTask->Init(Utf8StrFmt(tr("Updating Guest Additions")));
578	if (FAILED(hr))
579	{
580	delete pTask;
581	hr = setError(VBOX_E_IPRT_ERROR,
582	tr("Creating progress object for SessionTaskUpdateAdditions object failed"));
583	throw hr;
584	}
585
586	hr = pTask->createThread(NULL, RTTHREADTYPE_MAIN_HEAVY_WORKER);
587
588	if (SUCCEEDED(hr))
589	{
590	/* Return progress to the caller. */
591	pProgress = pTask->GetProgressObject();
592	hr = pProgress.queryInterfaceTo(aProgress.asOutParam());
593	}
594	else
595	hr = setError(VBOX_E_IPRT_ERROR,
596	tr("Starting thread for updating Guest Additions on the guest failed "));
597	}
598	catch(std::bad_alloc &)
599	{
600	hr = E_OUTOFMEMORY;
601	}
602	catch(...)
603	{
604	LogFlowThisFunc(("Exception was caught in the function\n"));
605	}
606	}
607	}
608
609	LogFlowFunc(("Returning hr=%Rhrc\n", hr));
610	return hr;
611	#endif /* VBOX_WITH_GUEST_CONTROL */
612	}
613

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

source: vbox/trunk/src/VBox/Main/src-client/GuestCtrlImpl.cpp@ 61572

Download in other formats: