GuestCtrlImpl.cpp@ 49349

Last change on this file since 49349 was 49349, checked in by vboxsync, 11 years ago

Guest Control:

Implemented IGuestSession::DirectoryRemove, IGuestSession::DirectoryRemoveRecursive, IGuestSession::DirectoryRename + IGuestSession::FileRename.
Added appropriate commands to VBoxManage (basic support for now).
Implemented support for proper guest session process termination via SCM.
Implemented support for internal anonymous wait events which are not relying on the public API's VBoxEventType_T.
Various bugfixes.

Property svn:eol-style set to native
Property svn:keywords set to Author Date Id Revision

File size: 18.5 KB

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

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

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

Download in other formats: