GuestCtrlImpl.cpp@ 105978

Last change on this file since 105978 was 102533, checked in by vboxsync, 12 months ago
Main/Guest Control: Fixed a shutdown race when uninitializing guest sessions via IGuestSession::Close(): There we need to check if its parent object (IGuest) still is around and in a working shape, and if not, do the cleanup stuff ourselves. Renamed Guest::i_sessionDestroy() -> Guest::i_sessionRemove() to make its function more clear. This race seemed to happen in combination with FE/Qt's guest file manager every now and then. bugref:9135
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 25.1 KB

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

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

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

Download in other formats: