GuestCtrlImpl.cpp@ 72045

Last change on this file since 72045 was 71976, checked in by vboxsync, 7 years ago
Guest Control/Main: Added stubs for IGuestSession:copy[From\|To]Guest() (@bugref{9135}) and implemented internal source specification handling for sharing as much code as possible across all the guest session copy methods. Work in progress.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 18.8 KB

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

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

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

Download in other formats: