GuestCtrlImpl.cpp@ 67914

Last change on this file since 67914 was 67914, checked in by vboxsync, 7 years ago
src-client: Define LOG_GROUP according to interface or similar.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 19.5 KB

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

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

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

Download in other formats: