GuestCtrlImpl.cpp@ 93622

Last change on this file since 93622 was 93166, checked in by vboxsync, 3 years ago
Guest Control/Main: Renamed Guest::i_sessionRemove() -> Guest::i_sessionDestroy() to better match the function's meaning (also to Guest::i_sessionCreate()).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 24.3 KB

Line
1	/* $Id: GuestCtrlImpl.cpp 93166 2022-01-10 16:43:04Z vboxsync $ */
2	/** @file
3	* VirtualBox COM class implementation: Guest
4	*/
5
6	/*
7	* Copyright (C) 2006-2022 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/list.h>
45	#include <iprt/path.h>
46	#include <VBox/vmm/pgm.h>
47	#include <VBox/AssertGuest.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 messages
64	* from the guest. Acts as a dispatcher for the actual class instance.
65	*
66	* @returns VBox status code.
67	* @param pvExtension Pointer to HGCM service extension.
68	* @param idMessage HGCM message ID the callback was called for.
69	* @param pvData Pointer to user-supplied callback data.
70	* @param cbData Size (in bytes) of user-supplied callback data.
71	*/
72	/* static */
73	DECLCALLBACK(int) Guest::i_notifyCtrlDispatcher(void *pvExtension,
74	uint32_t idMessage,
75	void *pvData,
76	uint32_t cbData)
77	{
78	using namespace guestControl;
79
80	/*
81	* No locking, as this is purely a notification which does not make any
82	* changes to the object state.
83	*/
84	Log2Func(("pvExtension=%p, idMessage=%RU32, pvParms=%p, cbParms=%RU32\n", pvExtension, idMessage, pvData, cbData));
85
86	ComObjPtr<Guest> pGuest = reinterpret_cast<Guest *>(pvExtension);
87	AssertReturn(pGuest.isNotNull(), VERR_WRONG_ORDER);
88
89	/*
90	* The data packet should ever be a problem, but check to be sure.
91	*/
92	AssertMsgReturn(cbData == sizeof(VBOXGUESTCTRLHOSTCALLBACK),
93	("Guest control host callback data has wrong size (expected %zu, got %zu) - buggy host service!\n",
94	sizeof(VBOXGUESTCTRLHOSTCALLBACK), cbData), VERR_INVALID_PARAMETER);
95	PVBOXGUESTCTRLHOSTCALLBACK pSvcCb = (PVBOXGUESTCTRLHOSTCALLBACK)pvData;
96	AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER);
97
98	/*
99	* Deal with GUEST_MSG_REPORT_FEATURES here as it shouldn't be handed
100	* i_dispatchToSession() and has different parameters.
101	*/
102	if (idMessage == GUEST_MSG_REPORT_FEATURES)
103	{
104	Assert(pSvcCb->mParms == 2);
105	Assert(pSvcCb->mpaParms[0].type == VBOX_HGCM_SVC_PARM_64BIT);
106	Assert(pSvcCb->mpaParms[1].type == VBOX_HGCM_SVC_PARM_64BIT);
107	Assert(pSvcCb->mpaParms[1].u.uint64 & VBOX_GUESTCTRL_GF_1_MUST_BE_ONE);
108	pGuest->mData.mfGuestFeatures0 = pSvcCb->mpaParms[0].u.uint64;
109	pGuest->mData.mfGuestFeatures1 = pSvcCb->mpaParms[1].u.uint64;
110	LogRel(("Guest Control: GUEST_MSG_REPORT_FEATURES: %#RX64, %#RX64\n",
111	pGuest->mData.mfGuestFeatures0, pGuest->mData.mfGuestFeatures1));
112	return VINF_SUCCESS;
113	}
114
115	/*
116	* For guest control 2.0 using the legacy messages we need to do the following here:
117	* - Get the callback header to access the context ID
118	* - Get the context ID of the callback
119	* - Extract the session ID out of the context ID
120	* - Dispatch the whole stuff to the appropriate session (if still exists)
121	*
122	* At least context ID parameter must always be present.
123	*/
124	ASSERT_GUEST_RETURN(pSvcCb->mParms > 0, VERR_WRONG_PARAMETER_COUNT);
125	ASSERT_GUEST_MSG_RETURN(pSvcCb->mpaParms[0].type == VBOX_HGCM_SVC_PARM_32BIT,
126	("type=%d\n", pSvcCb->mpaParms[0].type), VERR_WRONG_PARAMETER_TYPE);
127	uint32_t const idContext = pSvcCb->mpaParms[0].u.uint32;
128
129	VBOXGUESTCTRLHOSTCBCTX CtxCb = { idMessage, idContext };
130	int rc = pGuest->i_dispatchToSession(&CtxCb, pSvcCb);
131
132	Log2Func(("CID=%#x, idSession=%RU32, uObject=%RU32, uCount=%RU32, rc=%Rrc\n",
133	idContext, VBOX_GUESTCTRL_CONTEXTID_GET_SESSION(idContext), VBOX_GUESTCTRL_CONTEXTID_GET_OBJECT(idContext),
134	VBOX_GUESTCTRL_CONTEXTID_GET_COUNT(idContext), rc));
135	return rc;
136	}
137
138	// private methods
139	/////////////////////////////////////////////////////////////////////////////
140
141	/**
142	* Dispatches a host service callback to the appropriate guest control session object.
143	*
144	* @returns VBox status code.
145	* @param pCtxCb Pointer to host callback context.
146	* @param pSvcCb Pointer to callback parameters.
147	*/
148	int Guest::i_dispatchToSession(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb)
149	{
150	LogFlowFunc(("pCtxCb=%p, pSvcCb=%p\n", pCtxCb, pSvcCb));
151
152	AssertPtrReturn(pCtxCb, VERR_INVALID_POINTER);
153	AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER);
154
155	Log2Func(("uMessage=%RU32, uContextID=%RU32, uProtocol=%RU32\n", pCtxCb->uMessage, pCtxCb->uContextID, pCtxCb->uProtocol));
156
157	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
158
159	const uint32_t uSessionID = VBOX_GUESTCTRL_CONTEXTID_GET_SESSION(pCtxCb->uContextID);
160
161	Log2Func(("uSessionID=%RU32 (%zu total)\n", uSessionID, mData.mGuestSessions.size()));
162
163	GuestSessions::const_iterator itSession = mData.mGuestSessions.find(uSessionID);
164
165	int rc;
166	if (itSession != mData.mGuestSessions.end())
167	{
168	ComObjPtr<GuestSession> pSession(itSession->second);
169	Assert(!pSession.isNull());
170
171	alock.release();
172
173	#ifdef DEBUG
174	/*
175	* Pre-check: If we got a status message with an error and VERR_TOO_MUCH_DATA
176	* it means that that guest could not handle the entire message
177	* because of its exceeding size. This should not happen on daily
178	* use but testcases might try this. It then makes no sense to dispatch
179	* this further because we don't have a valid context ID.
180	*/
181	bool fDispatch = true;
182	rc = VERR_INVALID_FUNCTION;
183	if ( pCtxCb->uMessage == GUEST_MSG_EXEC_STATUS
184	&& pSvcCb->mParms >= 5)
185	{
186	CALLBACKDATA_PROC_STATUS dataCb;
187	/* pSvcCb->mpaParms[0] always contains the context ID. */
188	HGCMSvcGetU32(&pSvcCb->mpaParms[1], &dataCb.uPID);
189	HGCMSvcGetU32(&pSvcCb->mpaParms[2], &dataCb.uStatus);
190	HGCMSvcGetU32(&pSvcCb->mpaParms[3], &dataCb.uFlags);
191	HGCMSvcGetPv(&pSvcCb->mpaParms[4], &dataCb.pvData, &dataCb.cbData);
192
193	if ( dataCb.uStatus == PROC_STS_ERROR
194	&& (int32_t)dataCb.uFlags == VERR_TOO_MUCH_DATA)
195	{
196	LogFlowFunc(("Requested message with too much data, skipping dispatching ...\n"));
197	Assert(dataCb.uPID == 0);
198	fDispatch = false;
199	}
200	}
201	if (fDispatch)
202	#endif
203	{
204	switch (pCtxCb->uMessage)
205	{
206	case GUEST_MSG_DISCONNECTED:
207	rc = pSession->i_dispatchToThis(pCtxCb, pSvcCb);
208	break;
209
210	/* Process stuff. */
211	case GUEST_MSG_EXEC_STATUS:
212	case GUEST_MSG_EXEC_OUTPUT:
213	case GUEST_MSG_EXEC_INPUT_STATUS:
214	case GUEST_MSG_EXEC_IO_NOTIFY:
215	rc = pSession->i_dispatchToObject(pCtxCb, pSvcCb);
216	break;
217
218	/* File stuff. */
219	case GUEST_MSG_FILE_NOTIFY:
220	rc = pSession->i_dispatchToObject(pCtxCb, pSvcCb);
221	break;
222
223	/* Session stuff. */
224	case GUEST_MSG_SESSION_NOTIFY:
225	rc = pSession->i_dispatchToThis(pCtxCb, pSvcCb);
226	break;
227
228	default:
229	rc = pSession->i_dispatchToObject(pCtxCb, pSvcCb);
230	break;
231	}
232	}
233	}
234	else
235	rc = VERR_INVALID_SESSION_ID;
236
237	LogFlowFuncLeaveRC(rc);
238	return rc;
239	}
240
241	/**
242	* Creates a new guest session.
243	* This will invoke VBoxService running on the guest creating a new (dedicated) guest session
244	* On older Guest Additions this call has no effect on the guest, and only the credentials will be
245	* used for starting/impersonating guest processes.
246	*
247	* @returns VBox status code.
248	* @param ssInfo Guest session startup information.
249	* @param guestCreds Guest OS (user) credentials to use on the guest for creating the session.
250	* The specified user must be able to logon to the guest and able to start new processes.
251	* @param pGuestSession Where to store the created guest session on success.
252	*
253	* @note Takes the write lock.
254	*/
255	int Guest::i_sessionCreate(const GuestSessionStartupInfo &ssInfo,
256	const GuestCredentials &guestCreds, ComObjPtr<GuestSession> &pGuestSession)
257	{
258	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
259
260	int rc = VERR_MAX_PROCS_REACHED;
261	if (mData.mGuestSessions.size() >= VBOX_GUESTCTRL_MAX_SESSIONS)
262	return rc;
263
264	try
265	{
266	/* Create a new session ID and assign it. */
267	uint32_t uNewSessionID = VBOX_GUESTCTRL_SESSION_ID_BASE;
268	uint32_t uTries = 0;
269
270	for (;;)
271	{
272	/* Is the context ID already used? */
273	if (!i_sessionExists(uNewSessionID))
274	{
275	rc = VINF_SUCCESS;
276	break;
277	}
278	uNewSessionID++;
279	if (uNewSessionID >= VBOX_GUESTCTRL_MAX_SESSIONS)
280	uNewSessionID = VBOX_GUESTCTRL_SESSION_ID_BASE;
281
282	if (++uTries == VBOX_GUESTCTRL_MAX_SESSIONS)
283	break; /* Don't try too hard. */
284	}
285	if (RT_FAILURE(rc)) throw rc;
286
287	/* Create the session object. */
288	HRESULT hr = pGuestSession.createObject();
289	if (FAILED(hr)) throw VERR_COM_UNEXPECTED;
290
291	/** @todo Use an overloaded copy operator. Later. */
292	GuestSessionStartupInfo startupInfo;
293	startupInfo.mID = uNewSessionID; /* Assign new session ID. */
294	startupInfo.mName = ssInfo.mName;
295	startupInfo.mOpenFlags = ssInfo.mOpenFlags;
296	startupInfo.mOpenTimeoutMS = ssInfo.mOpenTimeoutMS;
297
298	GuestCredentials guestCredentials;
299	if (!guestCreds.mUser.isEmpty())
300	{
301	/** @todo Use an overloaded copy operator. Later. */
302	guestCredentials.mUser = guestCreds.mUser;
303	guestCredentials.mPassword = guestCreds.mPassword;
304	guestCredentials.mDomain = guestCreds.mDomain;
305	}
306	else
307	{
308	/* Internal (annonymous) session. */
309	startupInfo.mIsInternal = true;
310	}
311
312	rc = pGuestSession->init(this, startupInfo, guestCredentials);
313	if (RT_FAILURE(rc)) throw rc;
314
315	/*
316	* Add session object to our session map. This is necessary
317	* before calling openSession because the guest calls back
318	* with the creation result of this session.
319	*/
320	mData.mGuestSessions[uNewSessionID] = pGuestSession;
321
322	alock.release(); /* Release lock before firing off event. */
323
324	::FireGuestSessionRegisteredEvent(mEventSource, pGuestSession, true /* Registered */);
325	}
326	catch (int rc2)
327	{
328	rc = rc2;
329	}
330
331	LogFlowFuncLeaveRC(rc);
332	return rc;
333	}
334
335	/**
336	* Destroys a given guest session and removes it from the internal list.
337	*
338	* @returns VBox status code.
339	* @param uSessionID ID of the guest control session to destroy.
340	*
341	* @note Takes the write lock.
342	*/
343	int Guest::i_sessionDestroy(uint32_t uSessionID)
344	{
345	LogFlowThisFuncEnter();
346
347	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
348
349	int rc = VERR_NOT_FOUND;
350
351	LogFlowThisFunc(("Destroying session (ID=%RU32) ...\n", uSessionID));
352
353	GuestSessions::iterator itSessions = mData.mGuestSessions.find(uSessionID);
354	if (itSessions == mData.mGuestSessions.end())
355	return VERR_NOT_FOUND;
356
357	/* Make sure to consume the pointer before the one of the
358	* iterator gets released. */
359	ComObjPtr<GuestSession> pSession = itSessions->second;
360
361	LogFlowThisFunc(("Removing session %RU32 (now total %ld sessions)\n",
362	uSessionID, mData.mGuestSessions.size() ? mData.mGuestSessions.size() - 1 : 0));
363
364	rc = pSession->i_onRemove();
365	mData.mGuestSessions.erase(itSessions);
366
367	alock.release(); /* Release lock before firing off event. */
368
369	::FireGuestSessionRegisteredEvent(mEventSource, pSession, false /* Unregistered */);
370	pSession.setNull();
371
372	LogFlowFuncLeaveRC(rc);
373	return rc;
374	}
375
376	/**
377	* Returns whether a guest control session with a specific ID exists or not.
378	*
379	* @returns Returns \c true if the session exists, \c false if not.
380	* @param uSessionID ID to check for.
381	*
382	* @note No locking done, as inline function!
383	*/
384	inline bool Guest::i_sessionExists(uint32_t uSessionID)
385	{
386	GuestSessions::const_iterator itSessions = mData.mGuestSessions.find(uSessionID);
387	return (itSessions == mData.mGuestSessions.end()) ? false : true;
388	}
389
390	#endif /* VBOX_WITH_GUEST_CONTROL */
391
392
393	// implementation of public methods
394	/////////////////////////////////////////////////////////////////////////////
395	HRESULT Guest::createSession(const com::Utf8Str &aUser, const com::Utf8Str &aPassword, const com::Utf8Str &aDomain,
396	const com::Utf8Str &aSessionName, ComPtr<IGuestSession> &aGuestSession)
397
398	{
399	#ifndef VBOX_WITH_GUEST_CONTROL
400	ReturnComNotImplemented();
401	#else /* VBOX_WITH_GUEST_CONTROL */
402
403	AutoCaller autoCaller(this);
404	if (FAILED(autoCaller.rc())) return autoCaller.rc();
405
406	/* Do not allow anonymous sessions (with system rights) with public API. */
407	if (RT_UNLIKELY(!aUser.length()))
408	return setError(E_INVALIDARG, tr("No user name specified"));
409
410	LogFlowFuncEnter();
411
412	GuestSessionStartupInfo startupInfo;
413	startupInfo.mName = aSessionName;
414
415	GuestCredentials guestCreds;
416	guestCreds.mUser = aUser;
417	guestCreds.mPassword = aPassword;
418	guestCreds.mDomain = aDomain;
419
420	ComObjPtr<GuestSession> pSession;
421	int vrc = i_sessionCreate(startupInfo, guestCreds, pSession);
422	if (RT_SUCCESS(vrc))
423	{
424	/* Return guest session to the caller. */
425	HRESULT hr2 = pSession.queryInterfaceTo(aGuestSession.asOutParam());
426	if (FAILED(hr2))
427	vrc = VERR_COM_OBJECT_NOT_FOUND;
428	}
429
430	if (RT_SUCCESS(vrc))
431	/* Start (fork) the session asynchronously
432	* on the guest. */
433	vrc = pSession->i_startSessionAsync();
434
435	HRESULT hr = S_OK;
436
437	if (RT_FAILURE(vrc))
438	{
439	switch (vrc)
440	{
441	case VERR_MAX_PROCS_REACHED:
442	hr = setErrorBoth(VBOX_E_MAXIMUM_REACHED, vrc, tr("Maximum number of concurrent guest sessions (%d) reached"),
443	VBOX_GUESTCTRL_MAX_SESSIONS);
444	break;
445
446	/** @todo Add more errors here. */
447
448	default:
449	hr = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Could not create guest session: %Rrc"), vrc);
450	break;
451	}
452	}
453
454	LogFlowThisFunc(("Returning rc=%Rhrc\n", hr));
455	return hr;
456	#endif /* VBOX_WITH_GUEST_CONTROL */
457	}
458
459	HRESULT Guest::findSession(const com::Utf8Str &aSessionName, std::vector<ComPtr<IGuestSession> > &aSessions)
460	{
461	#ifndef VBOX_WITH_GUEST_CONTROL
462	ReturnComNotImplemented();
463	#else /* VBOX_WITH_GUEST_CONTROL */
464
465	LogFlowFuncEnter();
466
467	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
468
469	Utf8Str strName(aSessionName);
470	std::list < ComObjPtr<GuestSession> > listSessions;
471
472	GuestSessions::const_iterator itSessions = mData.mGuestSessions.begin();
473	while (itSessions != mData.mGuestSessions.end())
474	{
475	if (strName.contains(itSessions->second->i_getName())) /** @todo Use a (simple) pattern match (IPRT?). */
476	listSessions.push_back(itSessions->second);
477	++itSessions;
478	}
479
480	LogFlowFunc(("Sessions with \"%s\" = %RU32\n",
481	aSessionName.c_str(), listSessions.size()));
482
483	aSessions.resize(listSessions.size());
484	if (!listSessions.empty())
485	{
486	size_t i = 0;
487	for (std::list < ComObjPtr<GuestSession> >::const_iterator it = listSessions.begin(); it != listSessions.end(); ++it, ++i)
488	(*it).queryInterfaceTo(aSessions[i].asOutParam());
489
490	return S_OK;
491
492	}
493
494	return setErrorNoLog(VBOX_E_OBJECT_NOT_FOUND,
495	tr("Could not find sessions with name '%s'"),
496	aSessionName.c_str());
497	#endif /* VBOX_WITH_GUEST_CONTROL */
498	}
499
500	HRESULT Guest::shutdown(const std::vector<GuestShutdownFlag_T> &aFlags)
501	{
502	#ifndef VBOX_WITH_GUEST_CONTROL
503	ReturnComNotImplemented();
504	#else /* VBOX_WITH_GUEST_CONTROL */
505
506	/* Validate flags. */
507	uint32_t fFlags = GuestShutdownFlag_None;
508	if (aFlags.size())
509	for (size_t i = 0; i < aFlags.size(); ++i)
510	fFlags \|= aFlags[i];
511
512	const uint32_t fValidFlags = GuestShutdownFlag_None
513	\| GuestShutdownFlag_PowerOff \| GuestShutdownFlag_Reboot \| GuestShutdownFlag_Force;
514	if (fFlags & ~fValidFlags)
515	return setError(E_INVALIDARG,tr("Unknown flags: flags value %#x, invalid: %#x"), fFlags, fFlags & ~fValidFlags);
516
517	if ( (fFlags & GuestShutdownFlag_PowerOff)
518	&& (fFlags & GuestShutdownFlag_Reboot))
519	return setError(E_INVALIDARG, tr("Invalid combination of flags (%#x)"), fFlags);
520
521	Utf8Str strAction = (fFlags & GuestShutdownFlag_Reboot) ? tr("Rebooting") : tr("Shutting down");
522
523	/*
524	* Create an anonymous session. This is required to run shutting down / rebooting
525	* the guest with administrative rights.
526	*/
527	GuestSessionStartupInfo startupInfo;
528	startupInfo.mName = (fFlags & GuestShutdownFlag_Reboot) ? tr("Rebooting guest") : tr("Shutting down guest");
529
530	GuestCredentials guestCreds;
531
532	HRESULT hrc = S_OK;
533
534	ComObjPtr<GuestSession> pSession;
535	int vrc = i_sessionCreate(startupInfo, guestCreds, pSession);
536	if (RT_SUCCESS(vrc))
537	{
538	Assert(!pSession.isNull());
539
540	int rcGuest = VERR_GSTCTL_GUEST_ERROR;
541	vrc = pSession->i_startSession(&rcGuest);
542	if (RT_SUCCESS(vrc))
543	{
544	vrc = pSession->i_shutdown(fFlags, &rcGuest);
545	if (RT_FAILURE(vrc))
546	{
547	switch (vrc)
548	{
549	case VERR_NOT_SUPPORTED:
550	hrc = setErrorBoth(VBOX_E_NOT_SUPPORTED, vrc,
551	tr("%s not supported by installed Guest Additions"), strAction.c_str());
552	break;
553
554	default:
555	{
556	if (vrc == VERR_GSTCTL_GUEST_ERROR)
557	vrc = rcGuest;
558	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Error %s guest: %Rrc"), strAction.c_str(), vrc);
559	break;
560	}
561	}
562	}
563	}
564	else
565	{
566	if (vrc == VERR_GSTCTL_GUEST_ERROR)
567	vrc = rcGuest;
568	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Could not open guest session: %Rrc"), vrc);
569	}
570	}
571	else
572	{
573	switch (vrc)
574	{
575	case VERR_MAX_PROCS_REACHED:
576	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Maximum number of concurrent guest sessions (%d) reached"),
577	VBOX_GUESTCTRL_MAX_SESSIONS);
578	break;
579
580	/** @todo Add more errors here. */
581
582	default:
583	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Could not create guest session: %Rrc"), vrc);
584	break;
585	}
586	}
587
588	LogFlowFunc(("Returning hrc=%Rhrc\n", hrc));
589	return hrc;
590	#endif /* VBOX_WITH_GUEST_CONTROL */
591	}
592
593	HRESULT Guest::updateGuestAdditions(const com::Utf8Str &aSource, const std::vector<com::Utf8Str> &aArguments,
594	const std::vector<AdditionsUpdateFlag_T> &aFlags, ComPtr<IProgress> &aProgress)
595	{
596	#ifndef VBOX_WITH_GUEST_CONTROL
597	ReturnComNotImplemented();
598	#else /* VBOX_WITH_GUEST_CONTROL */
599
600	/* Validate flags. */
601	uint32_t fFlags = AdditionsUpdateFlag_None;
602	if (aFlags.size())
603	for (size_t i = 0; i < aFlags.size(); ++i)
604	fFlags \|= aFlags[i];
605
606	if (fFlags && !(fFlags & AdditionsUpdateFlag_WaitForUpdateStartOnly))
607	return setError(E_INVALIDARG, tr("Unknown flags (%#x)"), fFlags);
608
609
610	/* Copy arguments into aArgs: */
611	ProcessArguments aArgs;
612	try
613	{
614	aArgs.resize(0);
615	for (size_t i = 0; i < aArguments.size(); ++i)
616	aArgs.push_back(aArguments[i]);
617	}
618	catch (std::bad_alloc &)
619	{
620	return E_OUTOFMEMORY;
621	}
622
623
624	/*
625	* Create an anonymous session. This is required to run the Guest Additions
626	* update process with administrative rights.
627	*/
628	GuestSessionStartupInfo startupInfo;
629	startupInfo.mName = "Updating Guest Additions";
630
631	GuestCredentials guestCreds;
632
633	HRESULT hrc;
634	ComObjPtr<GuestSession> pSession;
635	int vrc = i_sessionCreate(startupInfo, guestCreds, pSession);
636	if (RT_SUCCESS(vrc))
637	{
638	Assert(!pSession.isNull());
639
640	int rcGuest = VERR_GSTCTL_GUEST_ERROR;
641	vrc = pSession->i_startSession(&rcGuest);
642	if (RT_SUCCESS(vrc))
643	{
644	/*
645	* Create the update task.
646	*/
647	GuestSessionTaskUpdateAdditions *pTask = NULL;
648	try
649	{
650	pTask = new GuestSessionTaskUpdateAdditions(pSession /* GuestSession */, aSource, aArgs, fFlags);
651	hrc = S_OK;
652	}
653	catch (std::bad_alloc &)
654	{
655	hrc = setError(E_OUTOFMEMORY, tr("Failed to create SessionTaskUpdateAdditions object"));
656	}
657	if (SUCCEEDED(hrc))
658	{
659	try
660	{
661	hrc = pTask->Init(Utf8StrFmt(tr("Updating Guest Additions")));
662	}
663	catch (std::bad_alloc &)
664	{
665	hrc = E_OUTOFMEMORY;
666	}
667	if (SUCCEEDED(hrc))
668	{
669	ComPtr<Progress> ptrProgress = pTask->GetProgressObject();
670
671	/*
672	* Kick off the thread. Note! consumes pTask!
673	*/
674	hrc = pTask->createThreadWithType(RTTHREADTYPE_MAIN_HEAVY_WORKER);
675	pTask = NULL;
676	if (SUCCEEDED(hrc))
677	hrc = ptrProgress.queryInterfaceTo(aProgress.asOutParam());
678	else
679	hrc = setError(hrc, tr("Starting thread for updating Guest Additions on the guest failed"));
680	}
681	else
682	{
683	hrc = setError(hrc, tr("Failed to initialize SessionTaskUpdateAdditions object"));
684	delete pTask;
685	}
686	}
687	}
688	else
689	{
690	if (vrc == VERR_GSTCTL_GUEST_ERROR)
691	vrc = rcGuest;
692	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Could not open guest session: %Rrc"), vrc);
693	}
694	}
695	else
696	{
697	switch (vrc)
698	{
699	case VERR_MAX_PROCS_REACHED:
700	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Maximum number of concurrent guest sessions (%d) reached"),
701	VBOX_GUESTCTRL_MAX_SESSIONS);
702	break;
703
704	/** @todo Add more errors here. */
705
706	default:
707	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Could not create guest session: %Rrc"), vrc);
708	break;
709	}
710	}
711
712	LogFlowFunc(("Returning hrc=%Rhrc\n", hrc));
713	return hrc;
714	#endif /* VBOX_WITH_GUEST_CONTROL */
715	}
716

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

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

Download in other formats: