GuestImpl.cpp@ 34900

Last change on this file since 34900 was 34891, checked in by vboxsync, 14 years ago
Build fix.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 118.1 KB

Line
1	/* $Id: GuestImpl.cpp 34891 2010-12-09 14:28:15Z vboxsync $ */
2
3	/** @file
4	*
5	* VirtualBox COM class implementation
6	*/
7
8	/*
9	* Copyright (C) 2006-2010 Oracle Corporation
10	*
11	* This file is part of VirtualBox Open Source Edition (OSE), as
12	* available from http://www.virtualbox.org. This file is free software;
13	* you can redistribute it and/or modify it under the terms of the GNU
14	* General Public License (GPL) as published by the Free Software
15	* Foundation, in version 2 as it comes in the "COPYING" file of the
16	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18	*/
19
20	#include "GuestImpl.h"
21
22	#include "Global.h"
23	#include "ConsoleImpl.h"
24	#include "ProgressImpl.h"
25	#include "VMMDev.h"
26
27	#include "AutoCaller.h"
28	#include "Logging.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/pgm.h>
42
43	#include <memory>
44
45	// defines
46	/////////////////////////////////////////////////////////////////////////////
47
48	// constructor / destructor
49	/////////////////////////////////////////////////////////////////////////////
50
51	DEFINE_EMPTY_CTOR_DTOR (Guest)
52
53	struct Guest::TaskGuest
54	{
55	enum TaskType
56	{
57	/** Copies a file to the guest. */
58	CopyFile = 50,
59
60	/** Update Guest Additions by directly copying the required installer
61	* off the .ISO file, transfer it to the guest and execute the installer
62	* with system privileges. */
63	UpdateGuestAdditions = 100
64	};
65
66	TaskGuest(TaskType aTaskType, Guest aThat, Progress aProgress)
67	: taskType(aTaskType),
68	pGuest(aThat),
69	progress(aProgress),
70	rc(S_OK)
71	{}
72	~TaskGuest() {}
73
74	int startThread();
75	static int taskThread(RTTHREAD aThread, void *pvUser);
76	static int uploadProgress(unsigned uPercent, void *pvUser);
77
78	static HRESULT setProgressErrorInfo(HRESULT hr, ComObjPtr<Progress> pProgress, const char * pszText, ...);
79	static HRESULT setProgressErrorInfo(HRESULT hr, ComObjPtr<Progress> pProgress, ComObjPtr<Guest> pGuest);
80
81	TaskType taskType;
82	Guest *pGuest;
83	ComObjPtr<Progress> progress;
84	HRESULT rc;
85
86	/* Task data. */
87	Utf8Str strSource;
88	Utf8Str strDest;
89	Utf8Str strUserName;
90	Utf8Str strPassword;
91	ULONG uFlags;
92	};
93
94	int Guest::TaskGuest::startThread()
95	{
96	int vrc = RTThreadCreate(NULL, Guest::TaskGuest::taskThread, this,
97	0, RTTHREADTYPE_MAIN_HEAVY_WORKER, 0,
98	"Guest::Task");
99
100	if (RT_FAILURE(vrc))
101	return Guest::setErrorStatic(E_FAIL, Utf8StrFmt("Could not create taskThreadGuest (%Rrc)\n", vrc));
102
103	return vrc;
104	}
105
106	/* static */
107	DECLCALLBACK(int) Guest::TaskGuest::taskThread(RTTHREAD /* aThread /, void pvUser)
108	{
109	std::auto_ptr<TaskGuest> task(static_cast<TaskGuest*>(pvUser));
110	AssertReturn(task.get(), VERR_GENERAL_FAILURE);
111
112	Guest *pGuest = task->pGuest;
113
114	LogFlowFuncEnter();
115	LogFlowFunc(("Guest %p\n", pGuest));
116
117	HRESULT rc = S_OK;
118
119	switch (task->taskType)
120	{
121	#ifdef VBOX_WITH_GUEST_CONTROL
122	case TaskGuest::CopyFile:
123	{
124	rc = pGuest->taskCopyFile(task.get());
125	break;
126	}
127	case TaskGuest::UpdateGuestAdditions:
128	{
129	rc = pGuest->taskUpdateGuestAdditions(task.get());
130	break;
131	}
132	#endif
133	default:
134	AssertMsgFailed(("Invalid task type %u specified!\n", task->taskType));
135	break;
136	}
137
138	LogFlowFunc(("rc=%Rhrc\n", rc));
139	LogFlowFuncLeave();
140
141	return VINF_SUCCESS;
142	}
143
144	/* static */
145	int Guest::TaskGuest::uploadProgress(unsigned uPercent, void *pvUser)
146	{
147	Guest::TaskGuest pTask = (Guest::TaskGuest**)pvUser;
148
149	if (pTask &&
150	!pTask->progress.isNull())
151	{
152	BOOL fCanceled;
153	pTask->progress->COMGETTER(Canceled)(&fCanceled);
154	if (fCanceled)
155	return -1;
156	pTask->progress->SetCurrentOperationProgress(uPercent);
157	}
158	return VINF_SUCCESS;
159	}
160
161	/* static */
162	HRESULT Guest::TaskGuest::setProgressErrorInfo(HRESULT hr, ComObjPtr<Progress> pProgress, const char *pszText, ...)
163	{
164	BOOL fCanceled;
165	BOOL fCompleted;
166	if ( SUCCEEDED(pProgress->COMGETTER(Canceled(&fCanceled)))
167	&& !fCanceled
168	&& SUCCEEDED(pProgress->COMGETTER(Completed(&fCompleted)))
169	&& !fCompleted)
170	{
171	va_list va;
172	va_start(va, pszText);
173	HRESULT hr2 = pProgress->notifyCompleteV(hr,
174	COM_IIDOF(IGuest),
175	Guest::getStaticComponentName(),
176	pszText,
177	va);
178	va_end(va);
179	if (hr2 == S_OK) /* If unable to retrieve error, return input error. */
180	hr2 = hr;
181	return hr2;
182	}
183	return S_OK;
184	}
185
186	/* static */
187	HRESULT Guest::TaskGuest::setProgressErrorInfo(HRESULT hr, ComObjPtr<Progress> pProgress, ComObjPtr<Guest> pGuest)
188	{
189	return setProgressErrorInfo(hr, pProgress,
190	Utf8Str(com::ErrorInfo((IGuest*)pGuest, COM_IIDOF(IGuest)).getText()).c_str());
191	}
192
193	#ifdef VBOX_WITH_GUEST_CONTROL
194	HRESULT Guest::taskCopyFile(TaskGuest *aTask)
195	{
196	LogFlowFuncEnter();
197
198	AutoCaller autoCaller(this);
199	if (FAILED(autoCaller.rc())) return autoCaller.rc();
200
201	/*
202	* Do not take a write lock here since we don't (and won't)
203	* touch any class-specific data (of IGuest) here - only the member functions
204	* which get called here can do that.
205	*/
206
207	HRESULT rc = S_OK;
208
209	try
210	{
211	Guest *pGuest = aTask->pGuest;
212	AssertPtr(pGuest);
213
214	/* Does our source file exist? */
215	if (!RTFileExists(aTask->strSource.c_str()))
216	{
217	/* Since this task runs in another thread than the main Guest object
218	* we cannot rely on notifyComplete's internal lookup - so do this ourselves. */
219	rc = VBOX_E_IPRT_ERROR;
220	aTask->progress->notifyComplete(rc,
221	COM_IIDOF(IGuest),
222	Guest::getStaticComponentName(),
223	Guest::tr("Source file \"%s\" does not exist"), aTask->strSource.c_str());
224	}
225	else
226	{
227	RTFILE fileSource;
228	int vrc = RTFileOpen(&fileSource, aTask->strSource.c_str(),
229	RTFILE_O_OPEN \| RTFILE_O_READ \| RTFILE_O_DENY_WRITE);
230	if (RT_FAILURE(vrc))
231	{
232	rc = TaskGuest::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->progress,
233	Guest::tr("Could not open source file \"%s\" for reading (%Rrc)"),
234	aTask->strSource.c_str(), vrc);
235	}
236	else
237	{
238	uint64_t cbSize;
239	vrc = RTFileGetSize(fileSource, &cbSize);
240	if (RT_FAILURE(vrc))
241	{
242	rc = TaskGuest::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->progress,
243	Guest::tr("Could not query file size of \"%s\" (%Rrc)"),
244	aTask->strSource.c_str(), vrc);
245	}
246	else
247	{
248	com::SafeArray<IN_BSTR> args;
249	com::SafeArray<IN_BSTR> env;
250
251	/*
252	* Prepare tool command line.
253	*/
254	char szOutput[RTPATH_MAX];
255	if (RTStrPrintf(szOutput, sizeof(szOutput), "--output=%s", aTask->strDest.c_str()) <= sizeof(szOutput) - 1)
256	{
257	/*
258	* Normalize path slashes, based on the detected guest.
259	*/
260	Utf8Str osType = mData.mOSTypeId;
261	if ( osType.contains("Microsoft", Utf8Str::CaseInsensitive)
262	\|\| osType.contains("Windows", Utf8Str::CaseInsensitive))
263	{
264	/* We have a Windows guest. */
265	RTPathChangeToDosSlashes(szOutput, true /* Force conversion. */);
266	}
267	else /* ... or something which isn't from Redmond ... */
268	{
269	RTPathChangeToUnixSlashes(szOutput, true /* Force conversion. */);
270	}
271
272	args.push_back(Bstr(VBOXSERVICE_TOOL_CAT).raw()); /* The actual (internal) tool to use (as argv[0]). */
273	args.push_back(Bstr(szOutput).raw()); /* We want to write a file ... */
274	}
275	else
276	{
277	rc = TaskGuest::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->progress,
278	Guest::tr("Error preparing command line"));
279	}
280
281	ComPtr<IProgress> execProgress;
282	ULONG uPID;
283	if (SUCCEEDED(rc))
284	{
285	LogRel(("Copying file \"%s\" to guest \"%s\" (%u bytes) ...\n",
286	aTask->strSource.c_str(), aTask->strDest.c_str(), cbSize));
287	/*
288	* Okay, since we gathered all stuff we need until now to start the
289	* actual copying, start the guest part now.
290	*/
291	rc = pGuest->ExecuteProcess(Bstr(VBOXSERVICE_TOOL_CAT).raw(),
292	ExecuteProcessFlag_Hidden
293	\| ExecuteProcessFlag_WaitForProcessStartOnly,
294	ComSafeArrayAsInParam(args),
295	ComSafeArrayAsInParam(env),
296	Bstr(aTask->strUserName).raw(),
297	Bstr(aTask->strPassword).raw(),
298	5 * 1000 /* Wait 5s for getting the process started. */,
299	&uPID, execProgress.asOutParam());
300	if (FAILED(rc))
301	rc = TaskGuest::setProgressErrorInfo(rc, aTask->progress, pGuest);
302	}
303
304	if (SUCCEEDED(rc))
305	{
306	BOOL fCompleted = FALSE;
307	BOOL fCanceled = FALSE;
308
309	size_t cbToRead = cbSize;
310	size_t cbTransfered = 0;
311	size_t cbRead;
312	SafeArray<BYTE> aInputData(_1M);
313	while ( SUCCEEDED(execProgress->COMGETTER(Completed(&fCompleted)))
314	&& !fCompleted)
315	{
316	vrc = RTFileRead(fileSource, (uint8_t*)aInputData.raw(), RT_MIN(cbToRead, _1M), &cbRead);
317	/*
318	* Some other error occured? There might be a chance that RTFileRead
319	* could not resolve/map the native error code to an IPRT code, so just
320	* print a generic error.
321	*/
322	if (RT_FAILURE(vrc))
323	{
324	rc = TaskGuest::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->progress,
325	Guest::tr("Could not read from file \"%s\" (%Rrc)"),
326	aTask->strSource.c_str(), vrc);
327	break;
328	}
329
330	/* Resize buffer to reflect amount we just have read. */
331	if (cbRead > 0)
332	aInputData.resize(cbRead);
333
334	ULONG uFlags = ProcessInputFlag_None;
335	/* Did we reach the end of the content we want to transfer (last chunk)? */
336	if ( (cbRead < _1M)
337	/* ... or does the user want to cancel? */
338	\|\| ( SUCCEEDED(aTask->progress->COMGETTER(Canceled(&fCanceled)))
339	&& fCanceled)
340	)
341	{
342	uFlags \|= ProcessInputFlag_EndOfFile;
343	}
344
345	/* Transfer the current chunk ... */
346	ULONG uBytesWritten;
347	rc = pGuest->SetProcessInput(uPID, uFlags,
348	ComSafeArrayAsInParam(aInputData), &uBytesWritten);
349	if (FAILED(rc))
350	{
351	rc = TaskGuest::setProgressErrorInfo(rc, aTask->progress, pGuest);
352	break;
353	}
354
355	Assert(cbRead <= cbToRead);
356	cbToRead -= cbRead;
357	Assert(cbToRead >= 0);
358
359	cbTransfered += uBytesWritten;
360	Assert(cbTransfered <= cbSize);
361	aTask->progress->SetCurrentOperationProgress(cbTransfered / (cbSize / 100));
362
363	/* End of file reached? */
364	if (cbToRead == 0)
365	break;
366
367	/* Progress canceled by Main API? */
368	if ( SUCCEEDED(execProgress->COMGETTER(Canceled(&fCanceled)))
369	&& fCanceled)
370	{
371	rc = TaskGuest::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->progress,
372	Guest::tr("Copy operation of file \"%s\" was canceled on guest side"),
373	aTask->strSource.c_str());
374	break;
375	}
376	}
377
378	if (SUCCEEDED(rc))
379	aTask->progress->notifyComplete(S_OK);
380	}
381	}
382	RTFileClose(fileSource);
383	}
384	}
385	}
386	catch (HRESULT aRC)
387	{
388	rc = aRC;
389	}
390
391	/* Clean up */
392	aTask->rc = rc;
393
394	LogFlowFunc(("rc=%Rhrc\n", rc));
395	LogFlowFuncLeave();
396
397	return VINF_SUCCESS;
398	}
399
400	HRESULT Guest::taskUpdateGuestAdditions(TaskGuest *aTask)
401	{
402	LogFlowFuncEnter();
403
404	AutoCaller autoCaller(this);
405	if (FAILED(autoCaller.rc())) return autoCaller.rc();
406
407	/*
408	* Do not take a write lock here since we don't (and won't)
409	* touch any class-specific data (of IGuest) here - only the member functions
410	* which get called here can do that.
411	*/
412
413	HRESULT rc = S_OK;
414	BOOL fCompleted;
415	BOOL fCanceled;
416
417	try
418	{
419	Guest *pGuest = aTask->pGuest;
420	AssertPtr(pGuest);
421
422	aTask->progress->SetCurrentOperationProgress(10);
423
424	/*
425	* Determine guest OS type and the required installer image.
426	* At the moment only Windows guests are supported.
427	*/
428	Utf8Str installerImage;
429	Bstr osTypeId;
430	if ( SUCCEEDED(pGuest->COMGETTER(OSTypeId(osTypeId.asOutParam())))
431	&& !osTypeId.isEmpty())
432	{
433	Utf8Str osTypeIdUtf8(osTypeId); /* Needed for .contains(). */
434	if ( osTypeIdUtf8.contains("Microsoft", Utf8Str::CaseInsensitive)
435	\|\| osTypeIdUtf8.contains("Windows", Utf8Str::CaseInsensitive))
436	{
437	if (osTypeIdUtf8.contains("64", Utf8Str::CaseInsensitive))
438	installerImage = "VBOXWINDOWSADDITIONS_AMD64.EXE";
439	else
440	installerImage = "VBOXWINDOWSADDITIONS_X86.EXE";
441	/* Since the installers are located in the root directory,
442	* no further path processing needs to be done (yet). */
443	}
444	else /* Everything else is not supported (yet). */
445	throw TaskGuest::setProgressErrorInfo(VBOX_E_NOT_SUPPORTED, aTask->progress,
446	Guest::tr("Detected guest OS (%s) does not support automatic Guest Additions updating, please update manually"),
447	osTypeIdUtf8.c_str());
448	}
449	else
450	throw TaskGuest::setProgressErrorInfo(VBOX_E_NOT_SUPPORTED, aTask->progress,
451	Guest::tr("Could not detected guest OS type/version, please update manually"));
452	Assert(!installerImage.isEmpty());
453
454	/*
455	* Try to open the .ISO file and locate the specified installer.
456	*/
457	RTISOFSFILE iso;
458	int vrc = RTIsoFsOpen(&iso, aTask->strSource.c_str());
459	if (RT_FAILURE(vrc))
460	{
461	rc = TaskGuest::setProgressErrorInfo(VBOX_E_FILE_ERROR, aTask->progress,
462	Guest::tr("Invalid installation medium (%s) detected"),
463	aTask->strSource.c_str());
464	}
465	else
466	{
467	uint32_t cbOffset;
468	size_t cbLength;
469	vrc = RTIsoFsGetFileInfo(&iso, installerImage.c_str(), &cbOffset, &cbLength);
470	if ( RT_SUCCESS(vrc)
471	&& cbOffset
472	&& cbLength)
473	{
474	vrc = RTFileSeek(iso.file, cbOffset, RTFILE_SEEK_BEGIN, NULL);
475	if (RT_FAILURE(vrc))
476	rc = TaskGuest::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->progress,
477	Guest::tr("Could not seek to setup file on installation medium (%Rrc)"), vrc);
478	}
479	else
480	{
481	switch (vrc)
482	{
483	case VERR_FILE_NOT_FOUND:
484	rc = TaskGuest::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->progress,
485	Guest::tr("Setup file was not found on installation medium"));
486	break;
487
488	default:
489	rc = TaskGuest::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->progress,
490	Guest::tr("An unknown error occured while retrieving information of setup file (%Rrc)"), vrc);
491	break;
492	}
493	}
494
495	/* Specify the ouput path on the guest side. */
496	Utf8Str strInstallerPath = "%TEMP%\\VBoxWindowsAdditions.exe";
497
498	if (RT_SUCCESS(vrc))
499	{
500	/* Okay, we're ready to start our copy routine on the guest! */
501	LogRel(("Automatic update of Guest Additions started\n"));
502	aTask->progress->SetCurrentOperationProgress(15);
503
504	/* Prepare command line args. */
505	com::SafeArray<IN_BSTR> args;
506	com::SafeArray<IN_BSTR> env;
507
508	args.push_back(Bstr(VBOXSERVICE_TOOL_CAT).raw()); /* The actual (internal) tool to use (as argv[0]). */
509	args.push_back(Bstr("--output").raw()); /* We want to write a file ... */
510	args.push_back(Bstr(strInstallerPath.c_str()).raw()); /* ... with this path. */
511
512	if (SUCCEEDED(rc))
513	{
514	ComPtr<IProgress> progressCat;
515	ULONG uPID;
516
517	/*
518	* Start built-in "vbox_cat" tool (inside VBoxService) to
519	* copy over/pipe the data into a file on the guest (with
520	* system rights, no username/password specified).
521	*/
522	rc = pGuest->executeProcessInternal(Bstr(VBOXSERVICE_TOOL_CAT).raw(),
523	ExecuteProcessFlag_Hidden
524	\| ExecuteProcessFlag_WaitForProcessStartOnly,
525	ComSafeArrayAsInParam(args),
526	ComSafeArrayAsInParam(env),
527	Bstr("").raw() /* Username. */,
528	Bstr("").raw() /* Password */,
529	5 * 1000 /* Wait 5s for getting the process started. */,
530	&uPID, progressCat.asOutParam(), &vrc);
531	if (FAILED(rc))
532	{
533	/* Errors which return VBOX_E_NOT_SUPPORTED can be safely skipped by the caller
534	* to silently fall back to "normal" (old) .ISO mounting. */
535
536	/* Due to a very limited COM error range we use vrc for a more detailed error
537	* lookup to figure out what went wrong. */
538	switch (vrc)
539	{
540	/* Guest execution service is not (yet) ready. This basically means that either VBoxService
541	* is not running (yet) or that the Guest Additions are too old (because VBoxService does not
542	* support the guest execution feature in this version). */
543	case VERR_NOT_FOUND:
544	rc = TaskGuest::setProgressErrorInfo(VBOX_E_NOT_SUPPORTED, aTask->progress,
545	Guest::tr("Guest Additions seem not to be installed or are not ready to update yet"));
546	break;
547
548	/* Getting back a VERR_INVALID_PARAMETER indicates that the installed Guest Additions are supporting the guest
549	* execution but not the built-in "vbox_cat" tool of VBoxService (< 4.0). */
550	case VERR_INVALID_PARAMETER:
551	rc = TaskGuest::setProgressErrorInfo(VBOX_E_NOT_SUPPORTED, aTask->progress,
552	Guest::tr("Installed Guest Additions do not support automatic updating"));
553	break;
554
555	default:
556	rc = TaskGuest::setProgressErrorInfo(E_FAIL, aTask->progress,
557	Guest::tr("Error copying Guest Additions setup file to guest path \"%s\" (%Rrc)"),
558	strInstallerPath.c_str(), vrc);
559	break;
560	}
561	}
562	else
563	{
564	LogRel(("Copying Guest Additions installer to guest ...\n"));
565	aTask->progress->SetCurrentOperationProgress(20);
566
567	/* Wait for process to exit ... */
568	SafeArray<BYTE> aInputData(_1M);
569	while ( SUCCEEDED(progressCat->COMGETTER(Completed(&fCompleted)))
570	&& !fCompleted)
571	{
572	size_t cbRead;
573	/* cbLength contains remaining bytes of our installer file
574	* opened above to read. */
575	size_t cbToRead = RT_MIN(cbLength, _1M);
576	if (cbToRead)
577	{
578	vrc = RTFileRead(iso.file, (uint8_t*)aInputData.raw(), cbToRead, &cbRead);
579	if ( cbRead
580	&& RT_SUCCESS(vrc))
581	{
582	/* Resize buffer to reflect amount we just have read. */
583	if (cbRead > 0)
584	aInputData.resize(cbRead);
585
586	/* Did we reach the end of the content we want to transfer (last chunk)? */
587	ULONG uFlags = ProcessInputFlag_None;
588	if ( (cbRead < _1M)
589	/* ... or does the user want to cancel? */
590	\|\| ( SUCCEEDED(aTask->progress->COMGETTER(Canceled(&fCanceled)))
591	&& fCanceled)
592	)
593	{
594	uFlags \|= ProcessInputFlag_EndOfFile;
595	}
596
597	/* Transfer the current chunk ... */
598	#ifdef DEBUG_andy
599	LogRel(("Copying Guest Additions (%u bytes left) ...\n", cbLength));
600	#endif
601	ULONG uBytesWritten;
602	rc = pGuest->SetProcessInput(uPID, uFlags,
603	ComSafeArrayAsInParam(aInputData), &uBytesWritten);
604	if (FAILED(rc))
605	{
606	rc = TaskGuest::setProgressErrorInfo(rc, aTask->progress, pGuest);
607	break;
608	}
609
610	/* If task was canceled above also cancel the process execution. */
611	if (fCanceled)
612	progressCat->Cancel();
613
614	#ifdef DEBUG_andy
615	LogRel(("Copying Guest Additions (%u bytes written) ...\n", uBytesWritten));
616	#endif
617	Assert(cbLength >= uBytesWritten);
618	cbLength -= uBytesWritten;
619	}
620	}
621
622	/* Internal progress canceled? */
623	if ( SUCCEEDED(progressCat->COMGETTER(Canceled(&fCanceled)))
624	&& fCanceled)
625	{
626	aTask->progress->Cancel();
627	break;
628	}
629	}
630	}
631	}
632	}
633	RTIsoFsClose(&iso);
634
635	if ( SUCCEEDED(rc)
636	&& ( SUCCEEDED(aTask->progress->COMGETTER(Canceled(&fCanceled)))
637	&& !fCanceled
638	)
639	)
640	{
641	/*
642	* Installer was transferred successfully, so let's start it
643	* (with system rights).
644	*/
645	LogRel(("Preparing to execute Guest Additions update ...\n"));
646	aTask->progress->SetCurrentOperationProgress(66);
647
648	/* Prepare command line args for installer. */
649	com::SafeArray<IN_BSTR> installerArgs;
650	com::SafeArray<IN_BSTR> installerEnv;
651
652	/** @todo Only Windows! */
653	installerArgs.push_back(Bstr(strInstallerPath).raw()); /* The actual (internal) installer image (as argv[0]). */
654	/* Note that starting at Windows Vista the lovely session 0 separation applies:
655	* This means that if we run an application with the profile/security context
656	* of VBoxService (system rights!) we're not able to show any UI. */
657	installerArgs.push_back(Bstr("/S").raw()); /* We want to install in silent mode. */
658	installerArgs.push_back(Bstr("/l").raw()); /* ... and logging enabled. */
659	/* Don't quit VBoxService during upgrade because it still is used for this
660	* piece of code we're in right now (that is, here!) ... */
661	installerArgs.push_back(Bstr("/no_vboxservice_exit").raw());
662	/* Tell the installer to report its current installation status
663	* using a running VBoxTray instance via balloon messages in the
664	* Windows taskbar. */
665	installerArgs.push_back(Bstr("/post_installstatus").raw());
666
667	/*
668	* Start the just copied over installer with system rights
669	* in silent mode on the guest. Don't use the hidden flag since there
670	* may be pop ups the user has to process.
671	*/
672	ComPtr<IProgress> progressInstaller;
673	ULONG uPID;
674	rc = pGuest->executeProcessInternal(Bstr(strInstallerPath).raw(),
675	ExecuteProcessFlag_WaitForProcessStartOnly,
676	ComSafeArrayAsInParam(installerArgs),
677	ComSafeArrayAsInParam(installerEnv),
678	Bstr("").raw() /* Username */,
679	Bstr("").raw() /* Password */,
680	5 * 1000 /* Wait 5s for getting the process started */,
681	&uPID, progressInstaller.asOutParam(), &vrc);
682	if (SUCCEEDED(rc))
683	{
684	/* If the caller does not want to wait for out guest update process to end,
685	* complete the progress object now so that the caller can do other work. */
686	if (aTask->uFlags & AdditionsUpdateFlag_WaitForUpdateStartOnly)
687	aTask->progress->notifyComplete(S_OK);
688	else
689	aTask->progress->SetCurrentOperationProgress(70);
690
691	LogRel(("Guest Additions update is running ...\n"));
692	while ( SUCCEEDED(progressInstaller->COMGETTER(Completed(&fCompleted)))
693	&& !fCompleted)
694	{
695	if ( SUCCEEDED(aTask->progress->COMGETTER(Canceled(&fCanceled)))
696	&& fCanceled)
697	{
698	progressInstaller->Cancel();
699	break;
700	}
701	/* Progress canceled by Main API? */
702	if ( SUCCEEDED(progressInstaller->COMGETTER(Canceled(&fCanceled)))
703	&& fCanceled)
704	{
705	break;
706	}
707	RTThreadSleep(1);
708	}
709
710	ULONG uRetStatus, uRetExitCode, uRetFlags;
711	rc = pGuest->GetProcessStatus(uPID, &uRetExitCode, &uRetFlags, &uRetStatus);
712	if (SUCCEEDED(rc))
713	{
714	if (fCompleted)
715	{
716	if (uRetExitCode == 0)
717	{
718	LogRel(("Guest Additions update successful!\n"));
719	if ( SUCCEEDED(aTask->progress->COMGETTER(Completed(&fCompleted)))
720	&& !fCompleted)
721	aTask->progress->notifyComplete(S_OK);
722	}
723	else
724	{
725	rc = TaskGuest::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->progress,
726	Guest::tr("Guest Additions update failed with exit code=%u (status=%u, flags=%u)"),
727	uRetExitCode, uRetStatus, uRetFlags);
728	}
729	}
730	else if ( SUCCEEDED(progressInstaller->COMGETTER(Canceled(&fCanceled)))
731	&& fCanceled)
732	{
733	rc = TaskGuest::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->progress,
734	Guest::tr("Guest Additions update was canceled by the guest with exit code=%u (status=%u, flags=%u)"),
735	uRetExitCode, uRetStatus, uRetFlags);
736	}
737	else
738	{
739	/* Guest Additions update was canceled by the user. */
740	}
741	}
742	else
743	rc = TaskGuest::setProgressErrorInfo(rc, aTask->progress, pGuest);
744	}
745	else
746	rc = TaskGuest::setProgressErrorInfo(rc, aTask->progress, pGuest);
747	}
748	}
749	}
750	catch (HRESULT aRC)
751	{
752	rc = aRC;
753	}
754
755	/* Clean up */
756	aTask->rc = rc;
757
758	LogFlowFunc(("rc=%Rhrc\n", rc));
759	LogFlowFuncLeave();
760
761	return VINF_SUCCESS;
762	}
763	#endif
764
765	HRESULT Guest::FinalConstruct()
766	{
767	return S_OK;
768	}
769
770	void Guest::FinalRelease()
771	{
772	uninit ();
773	}
774
775	// public methods only for internal purposes
776	/////////////////////////////////////////////////////////////////////////////
777
778	/**
779	* Initializes the guest object.
780	*/
781	HRESULT Guest::init(Console *aParent)
782	{
783	LogFlowThisFunc(("aParent=%p\n", aParent));
784
785	ComAssertRet(aParent, E_INVALIDARG);
786
787	/* Enclose the state transition NotReady->InInit->Ready */
788	AutoInitSpan autoInitSpan(this);
789	AssertReturn(autoInitSpan.isOk(), E_FAIL);
790
791	unconst(mParent) = aParent;
792
793	/* Confirm a successful initialization when it's the case */
794	autoInitSpan.setSucceeded();
795
796	ULONG aMemoryBalloonSize;
797	HRESULT ret = mParent->machine()->COMGETTER(MemoryBalloonSize)(&aMemoryBalloonSize);
798	if (ret == S_OK)
799	mMemoryBalloonSize = aMemoryBalloonSize;
800	else
801	mMemoryBalloonSize = 0; /* Default is no ballooning */
802
803	BOOL fPageFusionEnabled;
804	ret = mParent->machine()->COMGETTER(PageFusionEnabled)(&fPageFusionEnabled);
805	if (ret == S_OK)
806	mfPageFusionEnabled = fPageFusionEnabled;
807	else
808	mfPageFusionEnabled = false; /* Default is no page fusion*/
809
810	mStatUpdateInterval = 0; /* Default is not to report guest statistics at all */
811
812	/* Clear statistics. */
813	for (unsigned i = 0 ; i < GUESTSTATTYPE_MAX; i++)
814	mCurrentGuestStat[i] = 0;
815
816	#ifdef VBOX_WITH_GUEST_CONTROL
817	/* Init the context ID counter at 1000. */
818	mNextContextID = 1000;
819	#endif
820
821	return S_OK;
822	}
823
824	/**
825	* Uninitializes the instance and sets the ready flag to FALSE.
826	* Called either from FinalRelease() or by the parent when it gets destroyed.
827	*/
828	void Guest::uninit()
829	{
830	LogFlowThisFunc(("\n"));
831
832	#ifdef VBOX_WITH_GUEST_CONTROL
833	/* Scope write lock as much as possible. */
834	{
835	/*
836	* Cleanup must be done before AutoUninitSpan to cancel all
837	* all outstanding waits in API functions (which hold AutoCaller
838	* ref counts).
839	*/
840	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
841
842	/* Clean up callback data. */
843	CallbackMapIter it;
844	for (it = mCallbackMap.begin(); it != mCallbackMap.end(); it++)
845	destroyCtrlCallbackContext(it);
846
847	/* Clear process map. */
848	mGuestProcessMap.clear();
849	}
850	#endif
851
852	/* Enclose the state transition Ready->InUninit->NotReady */
853	AutoUninitSpan autoUninitSpan(this);
854	if (autoUninitSpan.uninitDone())
855	return;
856
857	unconst(mParent) = NULL;
858	}
859
860	// IGuest properties
861	/////////////////////////////////////////////////////////////////////////////
862
863	STDMETHODIMP Guest::COMGETTER(OSTypeId) (BSTR *aOSTypeId)
864	{
865	CheckComArgOutPointerValid(aOSTypeId);
866
867	AutoCaller autoCaller(this);
868	if (FAILED(autoCaller.rc())) return autoCaller.rc();
869
870	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
871
872	/* Redirect the call to IMachine if no additions are installed. */
873	if (mData.mAdditionsVersion.isEmpty())
874	return mParent->machine()->COMGETTER(OSTypeId)(aOSTypeId);
875
876	mData.mOSTypeId.cloneTo(aOSTypeId);
877
878	return S_OK;
879	}
880
881	STDMETHODIMP Guest::COMGETTER(AdditionsRunLevel) (AdditionsRunLevelType_T *aRunLevel)
882	{
883	AutoCaller autoCaller(this);
884	if (FAILED(autoCaller.rc())) return autoCaller.rc();
885
886	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
887
888	*aRunLevel = mData.mAdditionsRunLevel;
889
890	return S_OK;
891	}
892
893	STDMETHODIMP Guest::COMGETTER(AdditionsVersion) (BSTR *aAdditionsVersion)
894	{
895	CheckComArgOutPointerValid(aAdditionsVersion);
896
897	AutoCaller autoCaller(this);
898	if (FAILED(autoCaller.rc())) return autoCaller.rc();
899
900	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
901
902	HRESULT hr = S_OK;
903	if ( mData.mAdditionsVersion.isEmpty()
904	/* Only try alternative way if GA are active! */
905	&& mData.mAdditionsRunLevel > AdditionsRunLevelType_None)
906	{
907	/*
908	* If we got back an empty string from GetAdditionsVersion() we either
909	* really don't have the Guest Additions version yet or the guest is running
910	* older Guest Additions (< 3.2.0) which don't provide VMMDevReq_ReportGuestInfo2,
911	* so get the version + revision from the (hopefully) provided guest properties
912	* instead.
913	*/
914	Bstr addVersion;
915	LONG64 u64Timestamp;
916	Bstr flags;
917	hr = mParent->machine()->GetGuestProperty(Bstr("/VirtualBox/GuestAdd/Version").raw(),
918	addVersion.asOutParam(), &u64Timestamp, flags.asOutParam());
919	if (hr == S_OK)
920	{
921	Bstr addRevision;
922	hr = mParent->machine()->GetGuestProperty(Bstr("/VirtualBox/GuestAdd/Revision").raw(),
923	addRevision.asOutParam(), &u64Timestamp, flags.asOutParam());
924	if ( hr == S_OK
925	&& !addVersion.isEmpty()
926	&& !addRevision.isEmpty())
927	{
928	/* Some Guest Additions versions had interchanged version + revision values,
929	* so check if the version value at least has a dot to identify it and change
930	* both values to reflect the right content. */
931	if (!Utf8Str(addVersion).contains("."))
932	{
933	Bstr addTemp = addVersion;
934	addVersion = addRevision;
935	addRevision = addTemp;
936	}
937
938	Bstr additionsVersion = BstrFmt("%ls r%ls",
939	addVersion.raw(), addRevision.raw());
940	additionsVersion.cloneTo(aAdditionsVersion);
941	}
942	/** @todo r=bird: else: Should not return failure! */
943	}
944	else
945	{
946	/* If getting the version + revision above fails or they simply aren't there
947	* because of really old Guest Additions we only can report the interface
948	* version to at least have something. */
949	mData.mInterfaceVersion.cloneTo(aAdditionsVersion);
950	/** @todo r=bird: hr is still indicating failure! */
951	}
952	}
953	else
954	mData.mAdditionsVersion.cloneTo(aAdditionsVersion);
955
956	return hr;
957	}
958
959	STDMETHODIMP Guest::COMGETTER(SupportsSeamless) (BOOL *aSupportsSeamless)
960	{
961	CheckComArgOutPointerValid(aSupportsSeamless);
962
963	AutoCaller autoCaller(this);
964	if (FAILED(autoCaller.rc())) return autoCaller.rc();
965
966	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
967
968	*aSupportsSeamless = mData.mSupportsSeamless;
969
970	return S_OK;
971	}
972
973	STDMETHODIMP Guest::COMGETTER(SupportsGraphics) (BOOL *aSupportsGraphics)
974	{
975	CheckComArgOutPointerValid(aSupportsGraphics);
976
977	AutoCaller autoCaller(this);
978	if (FAILED(autoCaller.rc())) return autoCaller.rc();
979
980	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
981
982	*aSupportsGraphics = mData.mSupportsGraphics;
983
984	return S_OK;
985	}
986
987	BOOL Guest::isPageFusionEnabled()
988	{
989	AutoCaller autoCaller(this);
990	if (FAILED(autoCaller.rc())) return false;
991
992	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
993
994	return mfPageFusionEnabled;
995	}
996
997	STDMETHODIMP Guest::COMGETTER(MemoryBalloonSize) (ULONG *aMemoryBalloonSize)
998	{
999	CheckComArgOutPointerValid(aMemoryBalloonSize);
1000
1001	AutoCaller autoCaller(this);
1002	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1003
1004	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1005
1006	*aMemoryBalloonSize = mMemoryBalloonSize;
1007
1008	return S_OK;
1009	}
1010
1011	STDMETHODIMP Guest::COMSETTER(MemoryBalloonSize) (ULONG aMemoryBalloonSize)
1012	{
1013	AutoCaller autoCaller(this);
1014	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1015
1016	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1017
1018	/* We must be 100% sure that IMachine::COMSETTER(MemoryBalloonSize)
1019	* does not call us back in any way! */
1020	HRESULT ret = mParent->machine()->COMSETTER(MemoryBalloonSize)(aMemoryBalloonSize);
1021	if (ret == S_OK)
1022	{
1023	mMemoryBalloonSize = aMemoryBalloonSize;
1024	/* forward the information to the VMM device */
1025	VMMDev *pVMMDev = mParent->getVMMDev();
1026	/* MUST release all locks before calling VMM device as its critsect
1027	* has higher lock order than anything in Main. */
1028	alock.release();
1029	if (pVMMDev)
1030	{
1031	PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
1032	if (pVMMDevPort)
1033	pVMMDevPort->pfnSetMemoryBalloon(pVMMDevPort, aMemoryBalloonSize);
1034	}
1035	}
1036
1037	return ret;
1038	}
1039
1040	STDMETHODIMP Guest::COMGETTER(StatisticsUpdateInterval)(ULONG *aUpdateInterval)
1041	{
1042	CheckComArgOutPointerValid(aUpdateInterval);
1043
1044	AutoCaller autoCaller(this);
1045	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1046
1047	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1048
1049	*aUpdateInterval = mStatUpdateInterval;
1050	return S_OK;
1051	}
1052
1053	STDMETHODIMP Guest::COMSETTER(StatisticsUpdateInterval)(ULONG aUpdateInterval)
1054	{
1055	AutoCaller autoCaller(this);
1056	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1057
1058	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1059
1060	mStatUpdateInterval = aUpdateInterval;
1061	/* forward the information to the VMM device */
1062	VMMDev *pVMMDev = mParent->getVMMDev();
1063	/* MUST release all locks before calling VMM device as its critsect
1064	* has higher lock order than anything in Main. */
1065	alock.release();
1066	if (pVMMDev)
1067	{
1068	PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
1069	if (pVMMDevPort)
1070	pVMMDevPort->pfnSetStatisticsInterval(pVMMDevPort, aUpdateInterval);
1071	}
1072
1073	return S_OK;
1074	}
1075
1076	STDMETHODIMP Guest::InternalGetStatistics(ULONG aCpuUser, ULONG aCpuKernel, ULONG *aCpuIdle,
1077	ULONG aMemTotal, ULONG aMemFree, ULONG aMemBalloon, ULONG aMemShared,
1078	ULONG aMemCache, ULONG aPageTotal,
1079	ULONG aMemAllocTotal, ULONG aMemFreeTotal, ULONG aMemBalloonTotal, ULONG aMemSharedTotal)
1080	{
1081	CheckComArgOutPointerValid(aCpuUser);
1082	CheckComArgOutPointerValid(aCpuKernel);
1083	CheckComArgOutPointerValid(aCpuIdle);
1084	CheckComArgOutPointerValid(aMemTotal);
1085	CheckComArgOutPointerValid(aMemFree);
1086	CheckComArgOutPointerValid(aMemBalloon);
1087	CheckComArgOutPointerValid(aMemShared);
1088	CheckComArgOutPointerValid(aMemCache);
1089	CheckComArgOutPointerValid(aPageTotal);
1090	CheckComArgOutPointerValid(aMemAllocTotal);
1091	CheckComArgOutPointerValid(aMemFreeTotal);
1092	CheckComArgOutPointerValid(aMemBalloonTotal);
1093	CheckComArgOutPointerValid(aMemSharedTotal);
1094
1095	AutoCaller autoCaller(this);
1096	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1097
1098	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1099
1100	*aCpuUser = mCurrentGuestStat[GUESTSTATTYPE_CPUUSER];
1101	*aCpuKernel = mCurrentGuestStat[GUESTSTATTYPE_CPUKERNEL];
1102	*aCpuIdle = mCurrentGuestStat[GUESTSTATTYPE_CPUIDLE];
1103	aMemTotal = mCurrentGuestStat[GUESTSTATTYPE_MEMTOTAL] (_4K/_1K); /* page (4K) -> 1KB units */
1104	aMemFree = mCurrentGuestStat[GUESTSTATTYPE_MEMFREE] (_4K/_1K); /* page (4K) -> 1KB units */
1105	aMemBalloon = mCurrentGuestStat[GUESTSTATTYPE_MEMBALLOON] (_4K/_1K); /* page (4K) -> 1KB units */
1106	aMemCache = mCurrentGuestStat[GUESTSTATTYPE_MEMCACHE] (_4K/_1K); /* page (4K) -> 1KB units */
1107	aPageTotal = mCurrentGuestStat[GUESTSTATTYPE_PAGETOTAL] (_4K/_1K); /* page (4K) -> 1KB units */
1108
1109	/* MUST release all locks before calling any PGM statistics queries,
1110	* as they are executed by EMT and that might deadlock us by VMM device
1111	* activity which waits for the Guest object lock. */
1112	alock.release();
1113	Console::SafeVMPtr pVM (mParent);
1114	if (pVM.isOk())
1115	{
1116	uint64_t uFreeTotal, uAllocTotal, uBalloonedTotal, uSharedTotal;
1117	*aMemFreeTotal = 0;
1118	int rc = PGMR3QueryVMMMemoryStats(pVM.raw(), &uAllocTotal, &uFreeTotal, &uBalloonedTotal, &uSharedTotal);
1119	AssertRC(rc);
1120	if (rc == VINF_SUCCESS)
1121	{
1122	aMemAllocTotal = (ULONG)(uAllocTotal / _1K); / bytes -> KB */
1123	*aMemFreeTotal = (ULONG)(uFreeTotal / _1K);
1124	*aMemBalloonTotal = (ULONG)(uBalloonedTotal / _1K);
1125	*aMemSharedTotal = (ULONG)(uSharedTotal / _1K);
1126	}
1127
1128	/* Query the missing per-VM memory statistics. */
1129	*aMemShared = 0;
1130	uint64_t uTotalMem, uPrivateMem, uSharedMem, uZeroMem;
1131	rc = PGMR3QueryMemoryStats(pVM.raw(), &uTotalMem, &uPrivateMem, &uSharedMem, &uZeroMem);
1132	if (rc == VINF_SUCCESS)
1133	{
1134	*aMemShared = (ULONG)(uSharedMem / _1K);
1135	}
1136	}
1137	else
1138	{
1139	*aMemFreeTotal = 0;
1140	*aMemShared = 0;
1141	}
1142
1143	return S_OK;
1144	}
1145
1146	HRESULT Guest::setStatistic(ULONG aCpuId, GUESTSTATTYPE enmType, ULONG aVal)
1147	{
1148	AutoCaller autoCaller(this);
1149	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1150
1151	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1152
1153	if (enmType >= GUESTSTATTYPE_MAX)
1154	return E_INVALIDARG;
1155
1156	mCurrentGuestStat[enmType] = aVal;
1157	return S_OK;
1158	}
1159
1160	STDMETHODIMP Guest::GetAdditionsStatus(AdditionsRunLevelType_T aLevel, BOOL *aActive)
1161	{
1162	AutoCaller autoCaller(this);
1163	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1164
1165	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1166
1167	HRESULT rc = S_OK;
1168	switch (aLevel)
1169	{
1170	case AdditionsRunLevelType_System:
1171	*aActive = (mData.mAdditionsRunLevel > AdditionsRunLevelType_None);
1172	break;
1173
1174	case AdditionsRunLevelType_Userland:
1175	*aActive = (mData.mAdditionsRunLevel >= AdditionsRunLevelType_Userland);
1176	break;
1177
1178	case AdditionsRunLevelType_Desktop:
1179	*aActive = (mData.mAdditionsRunLevel >= AdditionsRunLevelType_Desktop);
1180	break;
1181
1182	default:
1183	rc = setError(VBOX_E_NOT_SUPPORTED,
1184	tr("Invalid status level defined: %u"), aLevel);
1185	break;
1186	}
1187
1188	return rc;
1189	}
1190
1191	STDMETHODIMP Guest::SetCredentials(IN_BSTR aUserName, IN_BSTR aPassword,
1192	IN_BSTR aDomain, BOOL aAllowInteractiveLogon)
1193	{
1194	AutoCaller autoCaller(this);
1195	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1196
1197	/* forward the information to the VMM device */
1198	VMMDev *pVMMDev = mParent->getVMMDev();
1199	if (pVMMDev)
1200	{
1201	PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
1202	if (pVMMDevPort)
1203	{
1204	uint32_t u32Flags = VMMDEV_SETCREDENTIALS_GUESTLOGON;
1205	if (!aAllowInteractiveLogon)
1206	u32Flags = VMMDEV_SETCREDENTIALS_NOLOCALLOGON;
1207
1208	pVMMDevPort->pfnSetCredentials(pVMMDevPort,
1209	Utf8Str(aUserName).c_str(),
1210	Utf8Str(aPassword).c_str(),
1211	Utf8Str(aDomain).c_str(),
1212	u32Flags);
1213	return S_OK;
1214	}
1215	}
1216
1217	return setError(VBOX_E_VM_ERROR,
1218	tr("VMM device is not available (is the VM running?)"));
1219	}
1220
1221	#ifdef VBOX_WITH_GUEST_CONTROL
1222	/**
1223	* Appends environment variables to the environment block.
1224	*
1225	* Each var=value pair is separated by the null character ('\\0'). The whole
1226	* block will be stored in one blob and disassembled on the guest side later to
1227	* fit into the HGCM param structure.
1228	*
1229	* @returns VBox status code.
1230	*
1231	* @param pszEnvVar The environment variable=value to append to the
1232	* environment block.
1233	* @param ppvList This is actually a pointer to a char pointer
1234	* variable which keeps track of the environment block
1235	* that we're constructing.
1236	* @param pcbList Pointer to the variable holding the current size of
1237	* the environment block. (List is a misnomer, go
1238	* ahead a be confused.)
1239	* @param pcEnvVars Pointer to the variable holding count of variables
1240	* stored in the environment block.
1241	*/
1242	int Guest::prepareExecuteEnv(const char pszEnv, void ppvList, uint32_t pcbList, uint32_t *pcEnvVars)
1243	{
1244	int rc = VINF_SUCCESS;
1245	uint32_t cchEnv = strlen(pszEnv); Assert(cchEnv >= 2);
1246	if (*ppvList)
1247	{
1248	uint32_t cbNewLen = pcbList + cchEnv + 1; / Include zero termination. */
1249	char pvTmp = (char )RTMemRealloc(*ppvList, cbNewLen);
1250	if (pvTmp == NULL)
1251	rc = VERR_NO_MEMORY;
1252	else
1253	{
1254	memcpy(pvTmp + *pcbList, pszEnv, cchEnv);
1255	pvTmp[cbNewLen - 1] = '\0'; /* Add zero termination. */
1256	ppvList = (void *)pvTmp;
1257	}
1258	}
1259	else
1260	{
1261	char *pszTmp;
1262	if (RTStrAPrintf(&pszTmp, "%s", pszEnv) >= 0)
1263	{
1264	ppvList = (void *)pszTmp;
1265	/* Reset counters. */
1266	*pcEnvVars = 0;
1267	*pcbList = 0;
1268	}
1269	}
1270	if (RT_SUCCESS(rc))
1271	{
1272	pcbList += cchEnv + 1; / Include zero termination. */
1273	pcEnvVars += 1; / Increase env variable count. */
1274	}
1275	return rc;
1276	}
1277
1278	/**
1279	* Static callback function for receiving updates on guest control commands
1280	* from the guest. Acts as a dispatcher for the actual class instance.
1281	*
1282	* @returns VBox status code.
1283	*
1284	* @todo
1285	*
1286	*/
1287	DECLCALLBACK(int) Guest::doGuestCtrlNotification(void *pvExtension,
1288	uint32_t u32Function,
1289	void *pvParms,
1290	uint32_t cbParms)
1291	{
1292	using namespace guestControl;
1293
1294	/*
1295	* No locking, as this is purely a notification which does not make any
1296	* changes to the object state.
1297	*/
1298	#ifdef DEBUG_andy
1299	LogFlowFunc(("pvExtension = %p, u32Function = %d, pvParms = %p, cbParms = %d\n",
1300	pvExtension, u32Function, pvParms, cbParms));
1301	#endif
1302	ComObjPtr<Guest> pGuest = reinterpret_cast<Guest *>(pvExtension);
1303
1304	int rc = VINF_SUCCESS;
1305	switch (u32Function)
1306	{
1307	case GUEST_DISCONNECTED:
1308	{
1309	//LogFlowFunc(("GUEST_DISCONNECTED\n"));
1310
1311	PCALLBACKDATACLIENTDISCONNECTED pCBData = reinterpret_cast<PCALLBACKDATACLIENTDISCONNECTED>(pvParms);
1312	AssertPtr(pCBData);
1313	AssertReturn(sizeof(CALLBACKDATACLIENTDISCONNECTED) == cbParms, VERR_INVALID_PARAMETER);
1314	AssertReturn(CALLBACKDATAMAGICCLIENTDISCONNECTED == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
1315
1316	rc = pGuest->notifyCtrlClientDisconnected(u32Function, pCBData);
1317	break;
1318	}
1319
1320	case GUEST_EXEC_SEND_STATUS:
1321	{
1322	//LogFlowFunc(("GUEST_EXEC_SEND_STATUS\n"));
1323
1324	PCALLBACKDATAEXECSTATUS pCBData = reinterpret_cast<PCALLBACKDATAEXECSTATUS>(pvParms);
1325	AssertPtr(pCBData);
1326	AssertReturn(sizeof(CALLBACKDATAEXECSTATUS) == cbParms, VERR_INVALID_PARAMETER);
1327	AssertReturn(CALLBACKDATAMAGICEXECSTATUS == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
1328
1329	rc = pGuest->notifyCtrlExecStatus(u32Function, pCBData);
1330	break;
1331	}
1332
1333	case GUEST_EXEC_SEND_OUTPUT:
1334	{
1335	//LogFlowFunc(("GUEST_EXEC_SEND_OUTPUT\n"));
1336
1337	PCALLBACKDATAEXECOUT pCBData = reinterpret_cast<PCALLBACKDATAEXECOUT>(pvParms);
1338	AssertPtr(pCBData);
1339	AssertReturn(sizeof(CALLBACKDATAEXECOUT) == cbParms, VERR_INVALID_PARAMETER);
1340	AssertReturn(CALLBACKDATAMAGICEXECOUT == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
1341
1342	rc = pGuest->notifyCtrlExecOut(u32Function, pCBData);
1343	break;
1344	}
1345
1346	case GUEST_EXEC_SEND_INPUT_STATUS:
1347	{
1348	//LogFlowFunc(("GUEST_EXEC_SEND_INPUT_STATUS\n"));
1349
1350	PCALLBACKDATAEXECINSTATUS pCBData = reinterpret_cast<PCALLBACKDATAEXECINSTATUS>(pvParms);
1351	AssertPtr(pCBData);
1352	AssertReturn(sizeof(CALLBACKDATAEXECINSTATUS) == cbParms, VERR_INVALID_PARAMETER);
1353	AssertReturn(CALLBACKDATAMAGICEXECINSTATUS == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
1354
1355	rc = pGuest->notifyCtrlExecInStatus(u32Function, pCBData);
1356	break;
1357	}
1358
1359	default:
1360	AssertMsgFailed(("Unknown guest control notification received, u32Function=%u\n", u32Function));
1361	rc = VERR_INVALID_PARAMETER;
1362	break;
1363	}
1364	return rc;
1365	}
1366
1367	/* Function for handling the execution start/termination notification. */
1368	int Guest::notifyCtrlExecStatus(uint32_t u32Function,
1369	PCALLBACKDATAEXECSTATUS pData)
1370	{
1371	int vrc = VINF_SUCCESS;
1372
1373	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1374
1375	AssertPtr(pData);
1376	CallbackMapIter it = getCtrlCallbackContextByID(pData->hdr.u32ContextID);
1377
1378	/* Callback can be called several times. */
1379	if (it != mCallbackMap.end())
1380	{
1381	PCALLBACKDATAEXECSTATUS pCBData = (PCALLBACKDATAEXECSTATUS)it->second.pvData;
1382	AssertPtr(pCBData);
1383
1384	pCBData->u32PID = pData->u32PID;
1385	pCBData->u32Status = pData->u32Status;
1386	pCBData->u32Flags = pData->u32Flags;
1387	/** @todo Copy void* buffer contents! */
1388
1389	Utf8Str errMsg;
1390
1391	/* Was progress canceled before? */
1392	BOOL fCanceled;
1393	ComAssert(!it->second.pProgress.isNull());
1394	if ( SUCCEEDED(it->second.pProgress->COMGETTER(Canceled)(&fCanceled))
1395	&& !fCanceled)
1396	{
1397	/* Do progress handling. */
1398	HRESULT hr;
1399	switch (pData->u32Status)
1400	{
1401	case PROC_STS_STARTED:
1402	LogRel(("Guest process (PID %u) started\n", pCBData->u32PID)); /** @todo Add process name */
1403	hr = it->second.pProgress->SetNextOperation(Bstr(tr("Waiting for process to exit ...")).raw(), 1 /* Weight */);
1404	AssertComRC(hr);
1405	break;
1406
1407	case PROC_STS_TEN: /* Terminated normally. */
1408	LogRel(("Guest process (PID %u) exited normally\n", pCBData->u32PID)); /** @todo Add process name */
1409	if (!it->second.pProgress->getCompleted())
1410	{
1411	hr = it->second.pProgress->notifyComplete(S_OK);
1412	AssertComRC(hr);
1413
1414	LogFlowFunc(("Process (CID=%u, status=%u) terminated successfully\n",
1415	pData->hdr.u32ContextID, pData->u32Status));
1416	}
1417	break;
1418
1419	case PROC_STS_TEA: /* Terminated abnormally. */
1420	LogRel(("Guest process (PID %u) terminated abnormally with exit code = %u\n",
1421	pCBData->u32PID, pCBData->u32Flags)); /** @todo Add process name */
1422	errMsg = Utf8StrFmt(Guest::tr("Process terminated abnormally with status '%u'"),
1423	pCBData->u32Flags);
1424	break;
1425
1426	case PROC_STS_TES: /* Terminated through signal. */
1427	LogRel(("Guest process (PID %u) terminated through signal with exit code = %u\n",
1428	pCBData->u32PID, pCBData->u32Flags)); /** @todo Add process name */
1429	errMsg = Utf8StrFmt(Guest::tr("Process terminated via signal with status '%u'"),
1430	pCBData->u32Flags);
1431	break;
1432
1433	case PROC_STS_TOK:
1434	LogRel(("Guest process (PID %u) timed out and was killed\n", pCBData->u32PID)); /** @todo Add process name */
1435	errMsg = Utf8StrFmt(Guest::tr("Process timed out and was killed"));
1436	break;
1437
1438	case PROC_STS_TOA:
1439	LogRel(("Guest process (PID %u) timed out and could not be killed\n", pCBData->u32PID)); /** @todo Add process name */
1440	errMsg = Utf8StrFmt(Guest::tr("Process timed out and could not be killed"));
1441	break;
1442
1443	case PROC_STS_DWN:
1444	LogRel(("Guest process (PID %u) killed because system is shutting down\n", pCBData->u32PID)); /** @todo Add process name */
1445	/*
1446	* If u32Flags has ExecuteProcessFlag_IgnoreOrphanedProcesses set, we don't report an error to
1447	* our progress object. This is helpful for waiters which rely on the success of our progress object
1448	* even if the executed process was killed because the system/VBoxService is shutting down.
1449	*
1450	* In this case u32Flags contains the actual execution flags reached in via Guest::ExecuteProcess().
1451	*/
1452	if (pData->u32Flags & ExecuteProcessFlag_IgnoreOrphanedProcesses)
1453	{
1454	if (!it->second.pProgress->getCompleted())
1455	{
1456	hr = it->second.pProgress->notifyComplete(S_OK);
1457	AssertComRC(hr);
1458	}
1459	}
1460	else
1461	{
1462	errMsg = Utf8StrFmt(Guest::tr("Process killed because system is shutting down"));
1463	}
1464	break;
1465
1466	case PROC_STS_ERROR:
1467	LogRel(("Guest process (PID %u) could not be started because of rc=%Rrc\n",
1468	pCBData->u32PID, pCBData->u32Flags)); /** @todo Add process name */
1469	errMsg = Utf8StrFmt(Guest::tr("Process execution failed with rc=%Rrc"), pCBData->u32Flags);
1470	break;
1471
1472	default:
1473	vrc = VERR_INVALID_PARAMETER;
1474	break;
1475	}
1476
1477	/* Handle process map. */
1478	/** @todo What happens on/deal with PID reuse? */
1479	/** @todo How to deal with multiple updates at once? */
1480	if (pCBData->u32PID > 0)
1481	{
1482	GuestProcessMapIter it_proc = getProcessByPID(pCBData->u32PID);
1483	if (it_proc == mGuestProcessMap.end())
1484	{
1485	/* Not found, add to map. */
1486	GuestProcess newProcess;
1487	newProcess.mStatus = pCBData->u32Status;
1488	newProcess.mExitCode = pCBData->u32Flags; /* Contains exit code. */
1489	newProcess.mFlags = 0;
1490
1491	mGuestProcessMap[pCBData->u32PID] = newProcess;
1492	}
1493	else /* Update map. */
1494	{
1495	it_proc->second.mStatus = pCBData->u32Status;
1496	it_proc->second.mExitCode = pCBData->u32Flags; /* Contains exit code. */
1497	it_proc->second.mFlags = 0;
1498	}
1499	}
1500	}
1501	else
1502	errMsg = Utf8StrFmt(Guest::tr("Process execution canceled"));
1503
1504	if (!it->second.pProgress->getCompleted())
1505	{
1506	if ( errMsg.length()
1507	\|\| fCanceled) /* If canceled we have to report E_FAIL! */
1508	{
1509	/* Destroy all callbacks which are still waiting on something
1510	* which is related to the current PID. */
1511	CallbackMapIter it2;
1512	for (it2 = mCallbackMap.begin(); it2 != mCallbackMap.end(); it2++)
1513	{
1514	switch (it2->second.mType)
1515	{
1516	case VBOXGUESTCTRLCALLBACKTYPE_EXEC_START:
1517	break;
1518
1519	/* When waiting for process output while the process is destroyed,
1520	* make sure we also destroy the actual waiting operation (internal progress object)
1521	* in order to not block the caller. */
1522	case VBOXGUESTCTRLCALLBACKTYPE_EXEC_OUTPUT:
1523	{
1524	PCALLBACKDATAEXECOUT pItData = (CALLBACKDATAEXECOUT*)it2->second.pvData;
1525	AssertPtr(pItData);
1526	if (pItData->u32PID == pCBData->u32PID)
1527	destroyCtrlCallbackContext(it2);
1528	break;
1529	}
1530
1531	default:
1532	AssertMsgFailed(("Unknown callback type %d\n", it2->second.mType));
1533	break;
1534	}
1535	}
1536
1537	HRESULT hr2 = it->second.pProgress->notifyComplete(VBOX_E_IPRT_ERROR,
1538	COM_IIDOF(IGuest),
1539	Guest::getStaticComponentName(),
1540	"%s", errMsg.c_str());
1541	AssertComRC(hr2);
1542	LogFlowFunc(("Process (CID=%u, status=%u) reported error: %s\n",
1543	pData->hdr.u32ContextID, pData->u32Status, errMsg.c_str()));
1544	}
1545	}
1546	}
1547	else
1548	LogFlowFunc(("Unexpected callback (magic=%u, CID=%u) arrived\n", pData->hdr.u32Magic, pData->hdr.u32ContextID));
1549	LogFlowFunc(("Returned with rc=%Rrc\n", vrc));
1550	return vrc;
1551	}
1552
1553	/* Function for handling the execution output notification. */
1554	int Guest::notifyCtrlExecOut(uint32_t u32Function,
1555	PCALLBACKDATAEXECOUT pData)
1556	{
1557	int rc = VINF_SUCCESS;
1558
1559	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1560
1561	AssertPtr(pData);
1562	CallbackMapIter it = getCtrlCallbackContextByID(pData->hdr.u32ContextID);
1563	if (it != mCallbackMap.end())
1564	{
1565	PCALLBACKDATAEXECOUT pCBData = (PCALLBACKDATAEXECOUT)it->second.pvData;
1566	AssertPtr(pCBData);
1567
1568	pCBData->u32PID = pData->u32PID;
1569	pCBData->u32HandleId = pData->u32HandleId;
1570	pCBData->u32Flags = pData->u32Flags;
1571
1572	/* Make sure we really got something! */
1573	if ( pData->cbData
1574	&& pData->pvData)
1575	{
1576	/* Allocate data buffer and copy it */
1577	pCBData->pvData = RTMemAlloc(pData->cbData);
1578	pCBData->cbData = pData->cbData;
1579
1580	AssertReturn(pCBData->pvData, VERR_NO_MEMORY);
1581	memcpy(pCBData->pvData, pData->pvData, pData->cbData);
1582	}
1583	else
1584	{
1585	pCBData->pvData = NULL;
1586	pCBData->cbData = 0;
1587	}
1588
1589	/* Was progress canceled before? */
1590	BOOL fCanceled;
1591	ComAssert(!it->second.pProgress.isNull());
1592	if (SUCCEEDED(it->second.pProgress->COMGETTER(Canceled)(&fCanceled)) && fCanceled)
1593	{
1594	it->second.pProgress->notifyComplete(VBOX_E_IPRT_ERROR,
1595	COM_IIDOF(IGuest),
1596	Guest::getStaticComponentName(),
1597	Guest::tr("The output operation was canceled"));
1598	}
1599	else
1600	{
1601	BOOL fCompleted;
1602	if ( SUCCEEDED(it->second.pProgress->COMGETTER(Completed)(&fCompleted))
1603	&& !fCompleted)
1604	{
1605	/* If we previously got completed notification, don't trigger again. */
1606	it->second.pProgress->notifyComplete(S_OK);
1607	}
1608	}
1609	}
1610	else
1611	LogFlowFunc(("Unexpected callback (magic=%u, CID=%u) arrived\n", pData->hdr.u32Magic, pData->hdr.u32ContextID));
1612	return rc;
1613	}
1614
1615	/* Function for handling the execution input status notification. */
1616	int Guest::notifyCtrlExecInStatus(uint32_t u32Function,
1617	PCALLBACKDATAEXECINSTATUS pData)
1618	{
1619	int rc = VINF_SUCCESS;
1620
1621	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1622
1623	AssertPtr(pData);
1624	CallbackMapIter it = getCtrlCallbackContextByID(pData->hdr.u32ContextID);
1625	if (it != mCallbackMap.end())
1626	{
1627	PCALLBACKDATAEXECINSTATUS pCBData = (PCALLBACKDATAEXECINSTATUS)it->second.pvData;
1628	AssertPtr(pCBData);
1629
1630	/* Save bytes processed. */
1631	pCBData->cbProcessed = pData->cbProcessed;
1632
1633	/* Was progress canceled before? */
1634	BOOL fCanceled;
1635	ComAssert(!it->second.pProgress.isNull());
1636	if (SUCCEEDED(it->second.pProgress->COMGETTER(Canceled)(&fCanceled)) && fCanceled)
1637	{
1638	it->second.pProgress->notifyComplete(VBOX_E_IPRT_ERROR,
1639	COM_IIDOF(IGuest),
1640	Guest::getStaticComponentName(),
1641	Guest::tr("The input operation was canceled"));
1642	}
1643	else
1644	{
1645	BOOL fCompleted;
1646	if ( SUCCEEDED(it->second.pProgress->COMGETTER(Completed)(&fCompleted))
1647	&& !fCompleted)
1648	{
1649	/* If we previously got completed notification, don't trigger again. */
1650	it->second.pProgress->notifyComplete(S_OK);
1651	}
1652	}
1653	}
1654	else
1655	LogFlowFunc(("Unexpected callback (magic=%u, CID=%u) arrived\n", pData->hdr.u32Magic, pData->hdr.u32ContextID));
1656	return rc;
1657	}
1658
1659	int Guest::notifyCtrlClientDisconnected(uint32_t u32Function,
1660	PCALLBACKDATACLIENTDISCONNECTED pData)
1661	{
1662	int rc = VINF_SUCCESS;
1663
1664	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1665	CallbackMapIter it = getCtrlCallbackContextByID(pData->hdr.u32ContextID);
1666	if (it != mCallbackMap.end())
1667	{
1668	LogFlowFunc(("Client with CID=%u disconnected\n", it->first));
1669	destroyCtrlCallbackContext(it);
1670	}
1671	return rc;
1672	}
1673
1674	Guest::CallbackMapIter Guest::getCtrlCallbackContextByID(uint32_t u32ContextID)
1675	{
1676	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1677	return mCallbackMap.find(u32ContextID);
1678	}
1679
1680	Guest::GuestProcessMapIter Guest::getProcessByPID(uint32_t u32PID)
1681	{
1682	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1683	return mGuestProcessMap.find(u32PID);
1684	}
1685
1686	/* No locking here; */
1687	void Guest::destroyCtrlCallbackContext(Guest::CallbackMapIter it)
1688	{
1689	LogFlowFunc(("Destroying callback with CID=%u ...\n", it->first));
1690
1691	if (it->second.pvData)
1692	{
1693	RTMemFree(it->second.pvData);
1694	it->second.pvData = NULL;
1695	it->second.cbData = 0;
1696	}
1697
1698	/* Notify outstanding waits for progress ... */
1699	if ( it->second.pProgress
1700	&& !it->second.pProgress.isNull())
1701	{
1702	LogFlowFunc(("Handling progress for CID=%u ...\n", it->first));
1703
1704	/*
1705	* Assume we didn't complete to make sure we clean up even if the
1706	* following call fails.
1707	*/
1708	BOOL fCompleted = FALSE;
1709	it->second.pProgress->COMGETTER(Completed)(&fCompleted);
1710	if (!fCompleted)
1711	{
1712	LogFlowFunc(("Progress of CID=%u not completed, cancelling ...\n", it->first));
1713
1714	/* Only cancel if not canceled before! */
1715	BOOL fCanceled;
1716	if (SUCCEEDED(it->second.pProgress->COMGETTER(Canceled)(&fCanceled)) && !fCanceled)
1717	it->second.pProgress->Cancel();
1718
1719	/*
1720	* To get waitForCompletion completed (unblocked) we have to notify it if necessary (only
1721	* cancel won't work!). This could happen if the client thread (e.g. VBoxService, thread of a spawned process)
1722	* is disconnecting without having the chance to sending a status message before, so we
1723	* have to abort here to make sure the host never hangs/gets stuck while waiting for the
1724	* progress object to become signalled.
1725	*/
1726	it->second.pProgress->notifyComplete(VBOX_E_IPRT_ERROR,
1727	COM_IIDOF(IGuest),
1728	Guest::getStaticComponentName(),
1729	Guest::tr("The operation was canceled because client is shutting down"));
1730	}
1731	/*
1732	* Do not NULL pProgress here, because waiting function like executeProcess()
1733	* will still rely on this object for checking whether they have to give up!
1734	*/
1735	}
1736	}
1737
1738	/* Adds a callback with a user provided data block and an optional progress object
1739	* to the callback map. A callback is identified by a unique context ID which is used
1740	* to identify a callback from the guest side. */
1741	uint32_t Guest::addCtrlCallbackContext(eVBoxGuestCtrlCallbackType enmType, void pvData, uint32_t cbData, Progress pProgress)
1742	{
1743	AssertPtr(pProgress);
1744
1745	/** @todo Put this stuff into a constructor! */
1746	CallbackContext context;
1747	context.mType = enmType;
1748	context.pvData = pvData;
1749	context.cbData = cbData;
1750	context.pProgress = pProgress;
1751
1752	/* Create a new context ID and assign it. */
1753	CallbackMapIter it;
1754	uint32_t uNewContext = 0;
1755	do
1756	{
1757	/* Create a new context ID ... */
1758	uNewContext = ASMAtomicIncU32(&mNextContextID);
1759	if (uNewContext == UINT32_MAX)
1760	ASMAtomicUoWriteU32(&mNextContextID, 1000);
1761	/* Is the context ID already used? */
1762	it = getCtrlCallbackContextByID(uNewContext);
1763	} while(it != mCallbackMap.end());
1764
1765	uint32_t nCallbacks = 0;
1766	if ( it == mCallbackMap.end()
1767	&& uNewContext > 0)
1768	{
1769	/* We apparently got an unused context ID, let's use it! */
1770	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1771	mCallbackMap[uNewContext] = context;
1772	nCallbacks = mCallbackMap.size();
1773	}
1774	else
1775	{
1776	/* Should never happen ... */
1777	{
1778	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1779	nCallbacks = mCallbackMap.size();
1780	}
1781	AssertReleaseMsg(uNewContext, ("No free context ID found! uNewContext=%u, nCallbacks=%u", uNewContext, nCallbacks));
1782	}
1783
1784	#if 0
1785	if (nCallbacks > 256) /* Don't let the container size get too big! */
1786	{
1787	Guest::CallbackListIter it = mCallbackList.begin();
1788	destroyCtrlCallbackContext(it);
1789	{
1790	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1791	mCallbackList.erase(it);
1792	}
1793	}
1794	#endif
1795	return uNewContext;
1796	}
1797	#endif /* VBOX_WITH_GUEST_CONTROL */
1798
1799	STDMETHODIMP Guest::ExecuteProcess(IN_BSTR aCommand, ULONG aFlags,
1800	ComSafeArrayIn(IN_BSTR, aArguments), ComSafeArrayIn(IN_BSTR, aEnvironment),
1801	IN_BSTR aUserName, IN_BSTR aPassword,
1802	ULONG aTimeoutMS, ULONG aPID, IProgress *aProgress)
1803	{
1804	/** @todo r=bird: Eventually we should clean up all the timeout parameters
1805	* in the API and have the same way of specifying infinite waits! */
1806	#ifndef VBOX_WITH_GUEST_CONTROL
1807	ReturnComNotImplemented();
1808	#else /* VBOX_WITH_GUEST_CONTROL */
1809	using namespace guestControl;
1810
1811	CheckComArgStrNotEmptyOrNull(aCommand);
1812	CheckComArgOutPointerValid(aPID);
1813	CheckComArgOutPointerValid(aProgress);
1814
1815	/* Do not allow anonymous executions (with system rights). */
1816	if (RT_UNLIKELY((aUserName) == NULL \|\| *(aUserName) == '\0'))
1817	return setError(E_INVALIDARG, tr("No user name specified"));
1818
1819	LogRel(("Executing guest process \"%s\" as user \"%s\" ...\n",
1820	Utf8Str(aCommand).c_str(), Utf8Str(aUserName).c_str()));
1821
1822	return executeProcessInternal(aCommand, aFlags, ComSafeArrayInArg(aArguments),
1823	ComSafeArrayInArg(aEnvironment),
1824	aUserName, aPassword, aTimeoutMS, aPID, aProgress, NULL /* rc */);
1825	#endif
1826	}
1827
1828	HRESULT Guest::executeProcessInternal(IN_BSTR aCommand, ULONG aFlags,
1829	ComSafeArrayIn(IN_BSTR, aArguments), ComSafeArrayIn(IN_BSTR, aEnvironment),
1830	IN_BSTR aUserName, IN_BSTR aPassword,
1831	ULONG aTimeoutMS, ULONG aPID, IProgress aProgress, int pRC)
1832	{
1833	/** @todo r=bird: Eventually we should clean up all the timeout parameters
1834	* in the API and have the same way of specifying infinite waits! */
1835	#ifndef VBOX_WITH_GUEST_CONTROL
1836	ReturnComNotImplemented();
1837	#else /* VBOX_WITH_GUEST_CONTROL */
1838	using namespace guestControl;
1839
1840	AutoCaller autoCaller(this);
1841	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1842
1843	/* Validate flags. */
1844	if (aFlags != ExecuteProcessFlag_None)
1845	{
1846	if ( !(aFlags & ExecuteProcessFlag_IgnoreOrphanedProcesses)
1847	&& !(aFlags & ExecuteProcessFlag_WaitForProcessStartOnly)
1848	&& !(aFlags & ExecuteProcessFlag_Hidden))
1849	{
1850	if (pRC)
1851	*pRC = VERR_INVALID_PARAMETER;
1852	return setError(E_INVALIDARG, tr("Unknown flags (%#x)"), aFlags);
1853	}
1854	}
1855
1856	HRESULT rc = S_OK;
1857
1858	try
1859	{
1860	/*
1861	* Create progress object. Note that this is a multi operation
1862	* object to perform the following steps:
1863	* - Operation 1 (0): Create/start process.
1864	* - Operation 2 (1): Wait for process to exit.
1865	* If this progress completed successfully (S_OK), the process
1866	* started and exited normally. In any other case an error/exception
1867	* occurred.
1868	*/
1869	ComObjPtr <Progress> progress;
1870	rc = progress.createObject();
1871	if (SUCCEEDED(rc))
1872	{
1873	rc = progress->init(static_cast<IGuest*>(this),
1874	Bstr(tr("Executing process")).raw(),
1875	TRUE,
1876	2, /* Number of operations. */
1877	Bstr(tr("Starting process ...")).raw()); /* Description of first stage. */
1878	}
1879	ComAssertComRC(rc);
1880
1881	/*
1882	* Prepare process execution.
1883	*/
1884	int vrc = VINF_SUCCESS;
1885	Utf8Str Utf8Command(aCommand);
1886
1887	/* Adjust timeout. If set to 0, we define
1888	* an infinite timeout. */
1889	if (aTimeoutMS == 0)
1890	aTimeoutMS = UINT32_MAX;
1891
1892	/* Prepare arguments. */
1893	char **papszArgv = NULL;
1894	uint32_t uNumArgs = 0;
1895	if (aArguments > 0)
1896	{
1897	com::SafeArray<IN_BSTR> args(ComSafeArrayInArg(aArguments));
1898	uNumArgs = args.size();
1899	papszArgv = (char*)RTMemAlloc(sizeof(char) * (uNumArgs + 1));
1900	AssertReturn(papszArgv, E_OUTOFMEMORY);
1901	for (unsigned i = 0; RT_SUCCESS(vrc) && i < uNumArgs; i++)
1902	vrc = RTUtf16ToUtf8(args[i], &papszArgv[i]);
1903	papszArgv[uNumArgs] = NULL;
1904	}
1905
1906	Utf8Str Utf8UserName(aUserName);
1907	Utf8Str Utf8Password(aPassword);
1908	if (RT_SUCCESS(vrc))
1909	{
1910	uint32_t uContextID = 0;
1911
1912	char *pszArgs = NULL;
1913	if (uNumArgs > 0)
1914	vrc = RTGetOptArgvToString(&pszArgs, papszArgv, 0);
1915	if (RT_SUCCESS(vrc))
1916	{
1917	uint32_t cbArgs = pszArgs ? strlen(pszArgs) + 1 : 0; /* Include terminating zero. */
1918
1919	/* Prepare environment. */
1920	void *pvEnv = NULL;
1921	uint32_t uNumEnv = 0;
1922	uint32_t cbEnv = 0;
1923	if (aEnvironment > 0)
1924	{
1925	com::SafeArray<IN_BSTR> env(ComSafeArrayInArg(aEnvironment));
1926
1927	for (unsigned i = 0; i < env.size(); i++)
1928	{
1929	vrc = prepareExecuteEnv(Utf8Str(env[i]).c_str(), &pvEnv, &cbEnv, &uNumEnv);
1930	if (RT_FAILURE(vrc))
1931	break;
1932	}
1933	}
1934
1935	if (RT_SUCCESS(vrc))
1936	{
1937	PCALLBACKDATAEXECSTATUS pData = (PCALLBACKDATAEXECSTATUS)RTMemAlloc(sizeof(CALLBACKDATAEXECSTATUS));
1938	AssertReturn(pData, VBOX_E_IPRT_ERROR);
1939	RT_ZERO(*pData);
1940	uContextID = addCtrlCallbackContext(VBOXGUESTCTRLCALLBACKTYPE_EXEC_START,
1941	pData, sizeof(CALLBACKDATAEXECSTATUS), progress);
1942	Assert(uContextID > 0);
1943
1944	VBOXHGCMSVCPARM paParms[15];
1945	int i = 0;
1946	paParms[i++].setUInt32(uContextID);
1947	paParms[i++].setPointer((void*)Utf8Command.c_str(), (uint32_t)Utf8Command.length() + 1);
1948	paParms[i++].setUInt32(aFlags);
1949	paParms[i++].setUInt32(uNumArgs);
1950	paParms[i++].setPointer((void*)pszArgs, cbArgs);
1951	paParms[i++].setUInt32(uNumEnv);
1952	paParms[i++].setUInt32(cbEnv);
1953	paParms[i++].setPointer((void*)pvEnv, cbEnv);
1954	paParms[i++].setPointer((void*)Utf8UserName.c_str(), (uint32_t)Utf8UserName.length() + 1);
1955	paParms[i++].setPointer((void*)Utf8Password.c_str(), (uint32_t)Utf8Password.length() + 1);
1956
1957	/*
1958	* If the WaitForProcessStartOnly flag is set, we only want to define and wait for a timeout
1959	* until the process was started - the process itself then gets an infinite timeout for execution.
1960	* This is handy when we want to start a process inside a worker thread within a certain timeout
1961	* but let the started process perform lengthly operations then.
1962	*/
1963	if (aFlags & ExecuteProcessFlag_WaitForProcessStartOnly)
1964	paParms[i++].setUInt32(UINT32_MAX /* Infinite timeout */);
1965	else
1966	paParms[i++].setUInt32(aTimeoutMS);
1967
1968	VMMDev *vmmDev;
1969	{
1970	/* Make sure mParent is valid, so set the read lock while using.
1971	* Do not keep this lock while doing the actual call, because in the meanwhile
1972	* another thread could request a write lock which would be a bad idea ... */
1973	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1974
1975	/* Forward the information to the VMM device. */
1976	AssertPtr(mParent);
1977	vmmDev = mParent->getVMMDev();
1978	}
1979
1980	if (vmmDev)
1981	{
1982	LogFlowFunc(("hgcmHostCall numParms=%d\n", i));
1983	vrc = vmmDev->hgcmHostCall("VBoxGuestControlSvc", HOST_EXEC_CMD,
1984	i, paParms);
1985	}
1986	else
1987	vrc = VERR_INVALID_VM_HANDLE;
1988	RTMemFree(pvEnv);
1989	}
1990	RTStrFree(pszArgs);
1991	}
1992	if (RT_SUCCESS(vrc))
1993	{
1994	LogFlowFunc(("Waiting for HGCM callback (timeout=%ldms) ...\n", aTimeoutMS));
1995
1996	/*
1997	* Wait for the HGCM low level callback until the process
1998	* has been started (or something went wrong). This is necessary to
1999	* get the PID.
2000	*/
2001	CallbackMapIter it = getCtrlCallbackContextByID(uContextID);
2002	BOOL fCanceled = FALSE;
2003	if (it != mCallbackMap.end())
2004	{
2005	ComAssert(!it->second.pProgress.isNull());
2006
2007	/*
2008	* Wait for the first stage (=0) to complete (that is starting the process).
2009	*/
2010	PCALLBACKDATAEXECSTATUS pData = NULL;
2011	rc = it->second.pProgress->WaitForOperationCompletion(0, aTimeoutMS);
2012	if (SUCCEEDED(rc))
2013	{
2014	/* Was the operation canceled by one of the parties? */
2015	rc = it->second.pProgress->COMGETTER(Canceled)(&fCanceled);
2016	if (FAILED(rc)) throw rc;
2017
2018	if (!fCanceled)
2019	{
2020	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2021
2022	pData = (PCALLBACKDATAEXECSTATUS)it->second.pvData;
2023	Assert(it->second.cbData == sizeof(CALLBACKDATAEXECSTATUS));
2024	AssertPtr(pData);
2025
2026	/* Did we get some status? */
2027	switch (pData->u32Status)
2028	{
2029	case PROC_STS_STARTED:
2030	/* Process is (still) running; get PID. */
2031	*aPID = pData->u32PID;
2032	break;
2033
2034	/* In any other case the process either already
2035	* terminated or something else went wrong, so no PID ... */
2036	case PROC_STS_TEN: /* Terminated normally. */
2037	case PROC_STS_TEA: /* Terminated abnormally. */
2038	case PROC_STS_TES: /* Terminated through signal. */
2039	case PROC_STS_TOK:
2040	case PROC_STS_TOA:
2041	case PROC_STS_DWN:
2042	/*
2043	* Process (already) ended, but we want to get the
2044	* PID anyway to retrieve the output in a later call.
2045	*/
2046	*aPID = pData->u32PID;
2047	break;
2048
2049	case PROC_STS_ERROR:
2050	vrc = pData->u32Flags; /* u32Flags member contains IPRT error code. */
2051	break;
2052
2053	case PROC_STS_UNDEFINED:
2054	vrc = VERR_TIMEOUT; /* Operation did not complete within time. */
2055	break;
2056
2057	default:
2058	vrc = VERR_INVALID_PARAMETER; /* Unknown status, should never happen! */
2059	break;
2060	}
2061	}
2062	else /* Operation was canceled. */
2063	vrc = VERR_CANCELLED;
2064	}
2065	else /* Operation did not complete within time. */
2066	vrc = VERR_TIMEOUT;
2067
2068	/*
2069	* Do not remove the callback yet - we might wait with the IProgress object on something
2070	* else (like end of process) ...
2071	*/
2072	if (RT_FAILURE(vrc))
2073	{
2074	if (vrc == VERR_FILE_NOT_FOUND) /* This is the most likely error. */
2075	rc = setErrorNoLog(VBOX_E_IPRT_ERROR,
2076	tr("The file '%s' was not found on guest"), Utf8Command.c_str());
2077	else if (vrc == VERR_PATH_NOT_FOUND)
2078	rc = setErrorNoLog(VBOX_E_IPRT_ERROR,
2079	tr("The path to file '%s' was not found on guest"), Utf8Command.c_str());
2080	else if (vrc == VERR_BAD_EXE_FORMAT)
2081	rc = setErrorNoLog(VBOX_E_IPRT_ERROR,
2082	tr("The file '%s' is not an executable format on guest"), Utf8Command.c_str());
2083	else if (vrc == VERR_AUTHENTICATION_FAILURE)
2084	rc = setErrorNoLog(VBOX_E_IPRT_ERROR,
2085	tr("The specified user '%s' was not able to logon on guest"), Utf8UserName.c_str());
2086	else if (vrc == VERR_TIMEOUT)
2087	rc = setErrorNoLog(VBOX_E_IPRT_ERROR,
2088	tr("The guest did not respond within time (%ums)"), aTimeoutMS);
2089	else if (vrc == VERR_CANCELLED)
2090	rc = setErrorNoLog(VBOX_E_IPRT_ERROR,
2091	tr("The execution operation was canceled"));
2092	else if (vrc == VERR_PERMISSION_DENIED)
2093	rc = setErrorNoLog(VBOX_E_IPRT_ERROR,
2094	tr("Invalid user/password credentials"));
2095	else
2096	{
2097	if (pData && pData->u32Status == PROC_STS_ERROR)
2098	rc = setErrorNoLog(VBOX_E_IPRT_ERROR,
2099	tr("Process could not be started: %Rrc"), pData->u32Flags);
2100	else
2101	rc = setErrorNoLog(E_UNEXPECTED,
2102	tr("The service call failed with error %Rrc"), vrc);
2103	}
2104	}
2105	else /* Execution went fine. */
2106	{
2107	/* Return the progress to the caller. */
2108	progress.queryInterfaceTo(aProgress);
2109	}
2110	}
2111	else /* Callback context not found; should never happen! */
2112	AssertMsg(it != mCallbackMap.end(), ("Callback context with ID %u not found!", uContextID));
2113	}
2114	else /* HGCM related error codes .*/
2115	{
2116	if (vrc == VERR_INVALID_VM_HANDLE)
2117	rc = setErrorNoLog(VBOX_E_VM_ERROR,
2118	tr("VMM device is not available (is the VM running?)"));
2119	else if (vrc == VERR_NOT_FOUND)
2120	rc = setErrorNoLog(VBOX_E_IPRT_ERROR,
2121	tr("The guest execution service is not ready"));
2122	else if (vrc == VERR_HGCM_SERVICE_NOT_FOUND)
2123	rc = setErrorNoLog(VBOX_E_IPRT_ERROR,
2124	tr("The guest execution service is not available"));
2125	else /* HGCM call went wrong. */
2126	rc = setErrorNoLog(E_UNEXPECTED,
2127	tr("The HGCM call failed with error %Rrc"), vrc);
2128	}
2129
2130	for (unsigned i = 0; i < uNumArgs; i++)
2131	RTMemFree(papszArgv[i]);
2132	RTMemFree(papszArgv);
2133	}
2134
2135	if (RT_FAILURE(vrc))
2136	{
2137	if (!pRC) /* Skip logging internal calls. */
2138	LogRel(("Executing guest process \"%s\" as user \"%s\" failed with %Rrc\n",
2139	Utf8Command.c_str(), Utf8UserName.c_str(), vrc));
2140	}
2141
2142	if (pRC)
2143	*pRC = vrc;
2144	}
2145	catch (std::bad_alloc &)
2146	{
2147	rc = E_OUTOFMEMORY;
2148	}
2149	return rc;
2150	#endif /* VBOX_WITH_GUEST_CONTROL */
2151	}
2152
2153	STDMETHODIMP Guest::SetProcessInput(ULONG aPID, ULONG aFlags, ComSafeArrayIn(BYTE, aData), ULONG *aBytesWritten)
2154	{
2155	#ifndef VBOX_WITH_GUEST_CONTROL
2156	ReturnComNotImplemented();
2157	#else /* VBOX_WITH_GUEST_CONTROL */
2158	using namespace guestControl;
2159
2160	CheckComArgExpr(aPID, aPID > 0);
2161	CheckComArgOutPointerValid(aBytesWritten);
2162
2163	/* Validate flags. */
2164	if (aFlags)
2165	{
2166	if (!(aFlags & ProcessInputFlag_EndOfFile))
2167	return setError(E_INVALIDARG, tr("Unknown flags (%#x)"), aFlags);
2168	}
2169
2170	AutoCaller autoCaller(this);
2171	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2172
2173	HRESULT rc = S_OK;
2174
2175	try
2176	{
2177	/* Init. */
2178	*aBytesWritten = 0;
2179
2180	/* Search for existing PID. */
2181	GuestProcessMapIterConst itProc = getProcessByPID(aPID);
2182	if (itProc != mGuestProcessMap.end())
2183	{
2184	/* PID exists; check if process is still running. */
2185	if (itProc->second.mStatus != PROC_STS_STARTED)
2186	{
2187	rc = setError(VBOX_E_IPRT_ERROR,
2188	tr("Process (PID %u) does not run anymore! Status: %ld, Flags: %u, Exit Code: %u"),
2189	aPID, itProc->second.mStatus, itProc->second.mFlags, itProc->second.mExitCode);
2190	}
2191	}
2192	else
2193	rc = setError(VBOX_E_IPRT_ERROR,
2194	tr("Process (PID %u) not found!"), aPID);
2195
2196	if (SUCCEEDED(rc))
2197	{
2198	/*
2199	* Create progress object.
2200	* This progress object, compared to the one in executeProgress() above
2201	* is only local and is used to determine whether the operation finished
2202	* or got canceled.
2203	*/
2204	ComObjPtr <Progress> progress;
2205	rc = progress.createObject();
2206	if (SUCCEEDED(rc))
2207	{
2208	rc = progress->init(static_cast<IGuest*>(this),
2209	Bstr(tr("Setting input for process")).raw(),
2210	TRUE /* Cancelable */);
2211	}
2212	if (FAILED(rc)) return rc;
2213
2214	PCALLBACKDATAEXECINSTATUS pData = (PCALLBACKDATAEXECINSTATUS)RTMemAlloc(sizeof(CALLBACKDATAEXECINSTATUS));
2215	AssertReturn(pData, VBOX_E_IPRT_ERROR);
2216	RT_ZERO(*pData);
2217	/* Save PID + output flags for later use. */
2218	pData->u32PID = aPID;
2219	pData->u32Flags = aFlags;
2220	/* Add job to callback contexts. */
2221	uint32_t uContextID = addCtrlCallbackContext(VBOXGUESTCTRLCALLBACKTYPE_EXEC_INPUT_STATUS,
2222	pData, sizeof(CALLBACKDATAEXECINSTATUS), progress);
2223	Assert(uContextID > 0);
2224
2225	com::SafeArray<BYTE> sfaData(ComSafeArrayInArg(aData));
2226	uint32_t cbSize = sfaData.size();
2227
2228	VBOXHGCMSVCPARM paParms[6];
2229	int i = 0;
2230	paParms[i++].setUInt32(uContextID);
2231	paParms[i++].setUInt32(aPID);
2232	paParms[i++].setUInt32(aFlags);
2233	paParms[i++].setPointer(sfaData.raw(), cbSize);
2234	paParms[i++].setUInt32(cbSize);
2235
2236	int vrc = VINF_SUCCESS;
2237
2238	{
2239	VMMDev *vmmDev;
2240	{
2241	/* Make sure mParent is valid, so set the read lock while using.
2242	* Do not keep this lock while doing the actual call, because in the meanwhile
2243	* another thread could request a write lock which would be a bad idea ... */
2244	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2245
2246	/* Forward the information to the VMM device. */
2247	AssertPtr(mParent);
2248	vmmDev = mParent->getVMMDev();
2249	}
2250
2251	if (vmmDev)
2252	{
2253	LogFlowFunc(("hgcmHostCall numParms=%d\n", i));
2254	vrc = vmmDev->hgcmHostCall("VBoxGuestControlSvc", HOST_EXEC_SET_INPUT,
2255	i, paParms);
2256	}
2257	}
2258
2259	if (RT_SUCCESS(vrc))
2260	{
2261	LogFlowFunc(("Waiting for HGCM callback ...\n"));
2262
2263	/*
2264	* Wait for the HGCM low level callback until the process
2265	* has been started (or something went wrong). This is necessary to
2266	* get the PID.
2267	*/
2268	CallbackMapIter it = getCtrlCallbackContextByID(uContextID);
2269	BOOL fCanceled = FALSE;
2270	if (it != mCallbackMap.end())
2271	{
2272	ComAssert(!it->second.pProgress.isNull());
2273
2274	/* Wait until operation completed. */
2275	rc = it->second.pProgress->WaitForCompletion(UINT32_MAX /* Wait forever */);
2276	if (FAILED(rc)) throw rc;
2277
2278	/* Was the operation canceled by one of the parties? */
2279	rc = it->second.pProgress->COMGETTER(Canceled)(&fCanceled);
2280	if (FAILED(rc)) throw rc;
2281
2282	if (!fCanceled)
2283	{
2284	BOOL fCompleted;
2285	if ( SUCCEEDED(it->second.pProgress->COMGETTER(Completed)(&fCompleted))
2286	&& fCompleted)
2287	{
2288	PCALLBACKDATAEXECINSTATUS pStatusData = (PCALLBACKDATAEXECINSTATUS)it->second.pvData;
2289	Assert(it->second.cbData == sizeof(CALLBACKDATAEXECINSTATUS));
2290	AssertPtr(pStatusData);
2291
2292	*aBytesWritten = pStatusData->cbProcessed;
2293	}
2294	}
2295	else /* Operation was canceled. */
2296	vrc = VERR_CANCELLED;
2297
2298	if (RT_FAILURE(vrc))
2299	{
2300	if (vrc == VERR_CANCELLED)
2301	{
2302	rc = setError(VBOX_E_IPRT_ERROR,
2303	tr("The input operation was canceled"));
2304	}
2305	else
2306	{
2307	rc = setError(E_UNEXPECTED,
2308	tr("The service call failed with error %Rrc"), vrc);
2309	}
2310	}
2311
2312	{
2313	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2314	/*
2315	* Destroy locally used progress object.
2316	*/
2317	destroyCtrlCallbackContext(it);
2318	}
2319
2320	/* Remove callback context (not used anymore). */
2321	mCallbackMap.erase(it);
2322	}
2323	else /* PID lookup failed. */
2324	rc = setError(VBOX_E_IPRT_ERROR,
2325	tr("Process (PID %u) not found!"), aPID);
2326	}
2327	else /* HGCM operation failed. */
2328	rc = setError(E_UNEXPECTED,
2329	tr("The HGCM call failed with error %Rrc"), vrc);
2330
2331	/* Cleanup. */
2332	progress->uninit();
2333	progress.setNull();
2334	}
2335	}
2336	catch (std::bad_alloc &)
2337	{
2338	rc = E_OUTOFMEMORY;
2339	}
2340	return rc;
2341	#endif
2342	}
2343
2344	STDMETHODIMP Guest::GetProcessOutput(ULONG aPID, ULONG aFlags, ULONG aTimeoutMS, LONG64 aSize, ComSafeArrayOut(BYTE, aData))
2345	{
2346	/** @todo r=bird: Eventually we should clean up all the timeout parameters
2347	* in the API and have the same way of specifying infinite waits! */
2348	#ifndef VBOX_WITH_GUEST_CONTROL
2349	ReturnComNotImplemented();
2350	#else /* VBOX_WITH_GUEST_CONTROL */
2351	using namespace guestControl;
2352
2353	CheckComArgExpr(aPID, aPID > 0);
2354	if (aSize < 0)
2355	return setError(E_INVALIDARG, tr("The size argument (%lld) is negative"), aSize);
2356	if (aFlags != 0) /* Flags are not supported at the moment. */
2357	return setError(E_INVALIDARG, tr("Unknown flags (%#x)"), aFlags);
2358
2359	AutoCaller autoCaller(this);
2360	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2361
2362	HRESULT rc = S_OK;
2363
2364	try
2365	{
2366	/*
2367	* Create progress object.
2368	* This progress object, compared to the one in executeProgress() above
2369	* is only local and is used to determine whether the operation finished
2370	* or got canceled.
2371	*/
2372	ComObjPtr <Progress> progress;
2373	rc = progress.createObject();
2374	if (SUCCEEDED(rc))
2375	{
2376	rc = progress->init(static_cast<IGuest*>(this),
2377	Bstr(tr("Getting output of process")).raw(),
2378	TRUE);
2379	}
2380	if (FAILED(rc)) return rc;
2381
2382	/* Adjust timeout */
2383	if (aTimeoutMS == 0)
2384	aTimeoutMS = UINT32_MAX;
2385
2386	/* Search for existing PID. */
2387	PCALLBACKDATAEXECOUT pData = (CALLBACKDATAEXECOUT*)RTMemAlloc(sizeof(CALLBACKDATAEXECOUT));
2388	AssertReturn(pData, VBOX_E_IPRT_ERROR);
2389	RT_ZERO(*pData);
2390	/* Save PID + output flags for later use. */
2391	pData->u32PID = aPID;
2392	pData->u32Flags = aFlags;
2393	/* Add job to callback contexts. */
2394	uint32_t uContextID = addCtrlCallbackContext(VBOXGUESTCTRLCALLBACKTYPE_EXEC_OUTPUT,
2395	pData, sizeof(CALLBACKDATAEXECOUT), progress);
2396	Assert(uContextID > 0);
2397
2398	com::SafeArray<BYTE> outputData((size_t)aSize);
2399
2400	VBOXHGCMSVCPARM paParms[5];
2401	int i = 0;
2402	paParms[i++].setUInt32(uContextID);
2403	paParms[i++].setUInt32(aPID);
2404	paParms[i++].setUInt32(aFlags); /** @todo Should represent stdout and/or stderr. */
2405
2406	int vrc = VINF_SUCCESS;
2407
2408	{
2409	VMMDev *vmmDev;
2410	{
2411	/* Make sure mParent is valid, so set the read lock while using.
2412	* Do not keep this lock while doing the actual call, because in the meanwhile
2413	* another thread could request a write lock which would be a bad idea ... */
2414	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2415
2416	/* Forward the information to the VMM device. */
2417	AssertPtr(mParent);
2418	vmmDev = mParent->getVMMDev();
2419	}
2420
2421	if (vmmDev)
2422	{
2423	LogFlowFunc(("hgcmHostCall numParms=%d\n", i));
2424	vrc = vmmDev->hgcmHostCall("VBoxGuestControlSvc", HOST_EXEC_GET_OUTPUT,
2425	i, paParms);
2426	}
2427	}
2428
2429	if (RT_SUCCESS(vrc))
2430	{
2431	LogFlowFunc(("Waiting for HGCM callback (timeout=%ldms) ...\n", aTimeoutMS));
2432
2433	/*
2434	* Wait for the HGCM low level callback until the process
2435	* has been started (or something went wrong). This is necessary to
2436	* get the PID.
2437	*/
2438	CallbackMapIter it = getCtrlCallbackContextByID(uContextID);
2439	BOOL fCanceled = FALSE;
2440	if (it != mCallbackMap.end())
2441	{
2442	ComAssert(!it->second.pProgress.isNull());
2443
2444	/* Wait until operation completed. */
2445	rc = it->second.pProgress->WaitForCompletion(aTimeoutMS);
2446	if (FAILED(rc)) throw rc;
2447
2448	/* Was the operation canceled by one of the parties? */
2449	rc = it->second.pProgress->COMGETTER(Canceled)(&fCanceled);
2450	if (FAILED(rc)) throw rc;
2451
2452	if (!fCanceled)
2453	{
2454	BOOL fCompleted;
2455	if ( SUCCEEDED(it->second.pProgress->COMGETTER(Completed)(&fCompleted))
2456	&& fCompleted)
2457	{
2458	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2459
2460	/* Did we get some output? */
2461	pData = (PCALLBACKDATAEXECOUT)it->second.pvData;
2462	Assert(it->second.cbData == sizeof(CALLBACKDATAEXECOUT));
2463	AssertPtr(pData);
2464
2465	if (pData->cbData)
2466	{
2467	/* Do we need to resize the array? */
2468	if (pData->cbData > aSize)
2469	outputData.resize(pData->cbData);
2470
2471	/* Fill output in supplied out buffer. */
2472	memcpy(outputData.raw(), pData->pvData, pData->cbData);
2473	outputData.resize(pData->cbData); /* Shrink to fit actual buffer size. */
2474	}
2475	else
2476	vrc = VERR_NO_DATA; /* This is not an error we want to report to COM. */
2477	}
2478	else /* If callback not called within time ... well, that's a timeout! */
2479	vrc = VERR_TIMEOUT;
2480	}
2481	else /* Operation was canceled. */
2482	{
2483	vrc = VERR_CANCELLED;
2484	}
2485
2486	if (RT_FAILURE(vrc))
2487	{
2488	if (vrc == VERR_NO_DATA)
2489	{
2490	/* This is not an error we want to report to COM. */
2491	rc = S_OK;
2492	}
2493	else if (vrc == VERR_TIMEOUT)
2494	{
2495	rc = setError(VBOX_E_IPRT_ERROR,
2496	tr("The guest did not output within time (%ums)"), aTimeoutMS);
2497	}
2498	else if (vrc == VERR_CANCELLED)
2499	{
2500	rc = setError(VBOX_E_IPRT_ERROR,
2501	tr("The output operation was canceled"));
2502	}
2503	else
2504	{
2505	rc = setError(E_UNEXPECTED,
2506	tr("The service call failed with error %Rrc"), vrc);
2507	}
2508	}
2509
2510	{
2511	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2512	/*
2513	* Destroy locally used progress object.
2514	*/
2515	destroyCtrlCallbackContext(it);
2516	}
2517
2518	/* Remove callback context (not used anymore). */
2519	mCallbackMap.erase(it);
2520	}
2521	else /* PID lookup failed. */
2522	rc = setError(VBOX_E_IPRT_ERROR,
2523	tr("Process (PID %u) not found!"), aPID);
2524	}
2525	else /* HGCM operation failed. */
2526	rc = setError(E_UNEXPECTED,
2527	tr("The HGCM call failed with error %Rrc"), vrc);
2528
2529	/* Cleanup. */
2530	progress->uninit();
2531	progress.setNull();
2532
2533	/* If something failed (or there simply was no data, indicated by VERR_NO_DATA,
2534	* we return an empty array so that the frontend knows when to give up. */
2535	if (RT_FAILURE(vrc) \|\| FAILED(rc))
2536	outputData.resize(0);
2537	outputData.detachTo(ComSafeArrayOutArg(aData));
2538	}
2539	catch (std::bad_alloc &)
2540	{
2541	rc = E_OUTOFMEMORY;
2542	}
2543	return rc;
2544	#endif
2545	}
2546
2547	STDMETHODIMP Guest::GetProcessStatus(ULONG aPID, ULONG aExitCode, ULONG aFlags, ULONG *aStatus)
2548	{
2549	#ifndef VBOX_WITH_GUEST_CONTROL
2550	ReturnComNotImplemented();
2551	#else /* VBOX_WITH_GUEST_CONTROL */
2552	using namespace guestControl;
2553
2554	AutoCaller autoCaller(this);
2555	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2556
2557	HRESULT rc = S_OK;
2558
2559	try
2560	{
2561	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2562
2563	GuestProcessMapIterConst it = getProcessByPID(aPID);
2564	if (it != mGuestProcessMap.end())
2565	{
2566	*aExitCode = it->second.mExitCode;
2567	*aFlags = it->second.mFlags;
2568	*aStatus = it->second.mStatus;
2569	}
2570	else
2571	rc = setError(VBOX_E_IPRT_ERROR,
2572	tr("Process (PID %u) not found!"), aPID);
2573	}
2574	catch (std::bad_alloc &)
2575	{
2576	rc = E_OUTOFMEMORY;
2577	}
2578	return rc;
2579	#endif
2580	}
2581
2582	STDMETHODIMP Guest::CopyToGuest(IN_BSTR aSource, IN_BSTR aDest,
2583	IN_BSTR aUserName, IN_BSTR aPassword,
2584	ULONG aFlags, IProgress **aProgress)
2585	{
2586	#ifndef VBOX_WITH_GUEST_CONTROL
2587	ReturnComNotImplemented();
2588	#else /* VBOX_WITH_GUEST_CONTROL */
2589	CheckComArgStrNotEmptyOrNull(aSource);
2590	CheckComArgStrNotEmptyOrNull(aDest);
2591	CheckComArgStrNotEmptyOrNull(aUserName);
2592	CheckComArgStrNotEmptyOrNull(aPassword);
2593	CheckComArgOutPointerValid(aProgress);
2594
2595	AutoCaller autoCaller(this);
2596	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2597
2598	/* Validate flags. */
2599	if (aFlags != CopyFileFlag_None)
2600	{
2601	if ( !(aFlags & CopyFileFlag_Recursive)
2602	&& !(aFlags & CopyFileFlag_Update)
2603	&& !(aFlags & CopyFileFlag_FollowLinks))
2604	{
2605	return setError(E_INVALIDARG, tr("Unknown flags (%#x)"), aFlags);
2606	}
2607	}
2608
2609	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2610
2611	HRESULT rc = S_OK;
2612
2613	ComObjPtr<Progress> progress;
2614	try
2615	{
2616	/* Create the progress object. */
2617	progress.createObject();
2618
2619	rc = progress->init(static_cast<IGuest*>(this),
2620	Bstr(tr("Copying file")).raw(),
2621	TRUE /* aCancelable */);
2622	if (FAILED(rc)) throw rc;
2623
2624	/* Initialize our worker task. */
2625	TaskGuest *pTask = new TaskGuest(TaskGuest::CopyFile, this, progress);
2626	AssertPtr(pTask);
2627	std::auto_ptr<TaskGuest> task(pTask);
2628
2629	/* Assign data - aSource is the source file on the host,
2630	* aDest reflects the full path on the guest. */
2631	task->strSource = (Utf8Str(aSource));
2632	task->strDest = (Utf8Str(aDest));
2633	task->strUserName = (Utf8Str(aUserName));
2634	task->strPassword = (Utf8Str(aPassword));
2635	task->uFlags = aFlags;
2636
2637	rc = task->startThread();
2638	if (FAILED(rc)) throw rc;
2639
2640	/* Don't destruct on success. */
2641	task.release();
2642	}
2643	catch (HRESULT aRC)
2644	{
2645	rc = aRC;
2646	}
2647
2648	if (SUCCEEDED(rc))
2649	{
2650	/* Return progress to the caller. */
2651	progress.queryInterfaceTo(aProgress);
2652	}
2653	return rc;
2654	#endif /* VBOX_WITH_GUEST_CONTROL */
2655	}
2656
2657	STDMETHODIMP Guest::CreateDirectory(IN_BSTR aDirectory,
2658	IN_BSTR aUserName, IN_BSTR aPassword,
2659	ULONG aMode, ULONG aFlags,
2660	IProgress **aProgress)
2661	{
2662	#ifndef VBOX_WITH_GUEST_CONTROL
2663	ReturnComNotImplemented();
2664	#else /* VBOX_WITH_GUEST_CONTROL */
2665	using namespace guestControl;
2666
2667	CheckComArgStrNotEmptyOrNull(aDirectory);
2668
2669	/* Do not allow anonymous executions (with system rights). */
2670	if (RT_UNLIKELY((aUserName) == NULL \|\| *(aUserName) == '\0'))
2671	return setError(E_INVALIDARG, tr("No user name specified"));
2672
2673	LogRel(("Creating guest directory \"%s\" as user \"%s\" ...\n",
2674	Utf8Str(aDirectory).c_str(), Utf8Str(aUserName).c_str()));
2675
2676	return createDirectoryInternal(aDirectory,
2677	aUserName, aPassword,
2678	aMode, aFlags, aProgress, NULL /* rc */);
2679	#endif
2680	}
2681
2682	HRESULT Guest::createDirectoryInternal(IN_BSTR aDirectory,
2683	IN_BSTR aUserName, IN_BSTR aPassword,
2684	ULONG aMode, ULONG aFlags,
2685	IProgress *aProgress, int pRC)
2686	{
2687	#ifndef VBOX_WITH_GUEST_CONTROL
2688	ReturnComNotImplemented();
2689	#else /* VBOX_WITH_GUEST_CONTROL */
2690	using namespace guestControl;
2691
2692	CheckComArgStrNotEmptyOrNull(aDirectory);
2693	CheckComArgOutPointerValid(aProgress);
2694
2695	AutoCaller autoCaller(this);
2696	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2697
2698	/* Validate flags. */
2699	if (aFlags != CreateDirectoryFlag_None)
2700	{
2701	if (!(aFlags & CreateDirectoryFlag_Parents))
2702	{
2703	return setError(E_INVALIDARG, tr("Unknown flags (%#x)"), aFlags);
2704	}
2705	}
2706
2707	/**
2708	* @todo We return a progress object because we maybe later want to
2709	* process more than one directory (or somewhat lengthly operations)
2710	* that require having a progress object provided to the caller.
2711	*/
2712
2713	HRESULT rc = S_OK;
2714	try
2715	{
2716	Utf8Str Utf8Directory(aDirectory);
2717	Utf8Str Utf8UserName(aUserName);
2718	Utf8Str Utf8Password(aPassword);
2719
2720	com::SafeArray<IN_BSTR> args;
2721	com::SafeArray<IN_BSTR> env;
2722
2723	/*
2724	* Prepare tool command line.
2725	*/
2726	args.push_back(Bstr(VBOXSERVICE_TOOL_MKDIR).raw()); /* The actual (internal) tool to use (as argv[0]). */
2727	if (aFlags & CreateDirectoryFlag_Parents)
2728	args.push_back(Bstr("--parents").raw()); /* We also want to create the parent directories. */
2729	if (aMode > 0)
2730	{
2731	args.push_back(Bstr("--mode").raw()); /* Set the creation mode. */
2732
2733	char szMode[16];
2734	RTStrPrintf(szMode, sizeof(szMode), "%o", aMode);
2735	args.push_back(Bstr(szMode).raw());
2736	}
2737	args.push_back(Bstr(Utf8Directory).raw()); /* The directory we want to create. */
2738
2739	/*
2740	* Execute guest process.
2741	*/
2742	ComPtr<IProgress> progressExec;
2743	ULONG uPID;
2744	if (SUCCEEDED(rc))
2745	{
2746	rc = ExecuteProcess(Bstr(VBOXSERVICE_TOOL_MKDIR).raw(),
2747	ExecuteProcessFlag_Hidden,
2748	ComSafeArrayAsInParam(args),
2749	ComSafeArrayAsInParam(env),
2750	Bstr(Utf8UserName).raw(),
2751	Bstr(Utf8Password).raw(),
2752	5 * 1000 /* Wait 5s for getting the process started. */,
2753	&uPID, progressExec.asOutParam());
2754	}
2755
2756	if (SUCCEEDED(rc))
2757	{
2758	/* Wait for process to exit ... */
2759	BOOL fCompleted = FALSE;
2760	BOOL fCanceled = FALSE;
2761
2762	while ( SUCCEEDED(progressExec->COMGETTER(Completed(&fCompleted)))
2763	&& !fCompleted)
2764	{
2765	/* Progress canceled by Main API? */
2766	if ( SUCCEEDED(progressExec->COMGETTER(Canceled(&fCanceled)))
2767	&& fCanceled)
2768	{
2769	break;
2770	}
2771	}
2772
2773	ComObjPtr<Progress> progressCreate;
2774	rc = progressCreate.createObject();
2775	if (SUCCEEDED(rc))
2776	{
2777	rc = progressCreate->init(static_cast<IGuest*>(this),
2778	Bstr(tr("Creating directory")).raw(),
2779	TRUE);
2780	}
2781	if (FAILED(rc)) return rc;
2782
2783	if (fCompleted)
2784	{
2785	ULONG uRetStatus, uRetExitCode, uRetFlags;
2786	if (SUCCEEDED(rc))
2787	{
2788	rc = GetProcessStatus(uPID, &uRetExitCode, &uRetFlags, &uRetStatus);
2789	if (SUCCEEDED(rc) && uRetExitCode != 0)
2790	{
2791	rc = setError(VBOX_E_IPRT_ERROR,
2792	tr("Error while creating directory"));
2793	}
2794	}
2795	}
2796	else if (fCanceled)
2797	rc = setError(VBOX_E_IPRT_ERROR,
2798	tr("Directory creation was aborted"));
2799	else
2800	AssertReleaseMsgFailed(("Directory creation neither completed nor canceled!?"));
2801
2802	if (SUCCEEDED(rc))
2803	progressCreate->notifyComplete(S_OK);
2804	else
2805	progressCreate->notifyComplete(VBOX_E_IPRT_ERROR,
2806	COM_IIDOF(IGuest),
2807	Guest::getStaticComponentName(),
2808	Guest::tr("Error while executing creation command"));
2809
2810	/* Return the progress to the caller. */
2811	progressCreate.queryInterfaceTo(aProgress);
2812	}
2813	}
2814	catch (std::bad_alloc &)
2815	{
2816	rc = E_OUTOFMEMORY;
2817	}
2818	return rc;
2819	#endif /* VBOX_WITH_GUEST_CONTROL */
2820	}
2821
2822	STDMETHODIMP Guest::UpdateGuestAdditions(IN_BSTR aSource, ULONG aFlags, IProgress **aProgress)
2823	{
2824	#ifndef VBOX_WITH_GUEST_CONTROL
2825	ReturnComNotImplemented();
2826	#else /* VBOX_WITH_GUEST_CONTROL */
2827	CheckComArgStrNotEmptyOrNull(aSource);
2828	CheckComArgOutPointerValid(aProgress);
2829
2830	AutoCaller autoCaller(this);
2831	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2832
2833	/* Validate flags. */
2834	if (aFlags)
2835	{
2836	if (!(aFlags & AdditionsUpdateFlag_WaitForUpdateStartOnly))
2837	return setError(E_INVALIDARG, tr("Unknown flags (%#x)"), aFlags);
2838	}
2839
2840	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2841
2842	HRESULT rc = S_OK;
2843
2844	ComObjPtr<Progress> progress;
2845	try
2846	{
2847	/* Create the progress object. */
2848	progress.createObject();
2849
2850	rc = progress->init(static_cast<IGuest*>(this),
2851	Bstr(tr("Updating Guest Additions")).raw(),
2852	TRUE /* aCancelable */);
2853	if (FAILED(rc)) throw rc;
2854
2855	/* Initialize our worker task. */
2856	TaskGuest *pTask = new TaskGuest(TaskGuest::UpdateGuestAdditions, this, progress);
2857	AssertPtr(pTask);
2858	std::auto_ptr<TaskGuest> task(pTask);
2859
2860	/* Assign data - in that case aSource is the full path
2861	* to the Guest Additions .ISO we want to mount. */
2862	task->strSource = (Utf8Str(aSource));
2863	task->uFlags = aFlags;
2864
2865	rc = task->startThread();
2866	if (FAILED(rc)) throw rc;
2867
2868	/* Don't destruct on success. */
2869	task.release();
2870	}
2871	catch (HRESULT aRC)
2872	{
2873	rc = aRC;
2874	}
2875
2876	if (SUCCEEDED(rc))
2877	{
2878	/* Return progress to the caller. */
2879	progress.queryInterfaceTo(aProgress);
2880	}
2881	return rc;
2882	#endif /* VBOX_WITH_GUEST_CONTROL */
2883	}
2884
2885	// public methods only for internal purposes
2886	/////////////////////////////////////////////////////////////////////////////
2887
2888	/**
2889	* Sets the general Guest Additions information like
2890	* API (interface) version and OS type. Gets called by
2891	* vmmdevUpdateGuestInfo.
2892	*
2893	* @param aInterfaceVersion
2894	* @param aOsType
2895	*/
2896	void Guest::setAdditionsInfo(Bstr aInterfaceVersion, VBOXOSTYPE aOsType)
2897	{
2898	AutoCaller autoCaller(this);
2899	AssertComRCReturnVoid(autoCaller.rc());
2900
2901	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2902
2903	/*
2904	* Note: The Guest Additions API (interface) version is deprecated
2905	* and will not be used anymore! We might need it to at least report
2906	* something as version number if really ancient Guest Additions are
2907	* installed (without the guest version + revision properties having set).
2908	*/
2909	mData.mInterfaceVersion = aInterfaceVersion;
2910
2911	/*
2912	* Older Additions rely on the Additions API version whether they
2913	* are assumed to be active or not. Since newer Additions do report
2914	* the Additions version before calling this function (by calling
2915	* VMMDevReportGuestInfo2, VMMDevReportGuestStatus, VMMDevReportGuestInfo,
2916	* in that order) we can tell apart old and new Additions here. Old
2917	* Additions never would set VMMDevReportGuestInfo2 (which set mData.mAdditionsVersion)
2918	* so they just rely on the aInterfaceVersion string (which gets set by
2919	* VMMDevReportGuestInfo).
2920	*
2921	* So only mark the Additions as being active (run level = system) when we
2922	* don't have the Additions version set.
2923	*/
2924	if (mData.mAdditionsVersion.isEmpty())
2925	{
2926	if (aInterfaceVersion.isEmpty())
2927	mData.mAdditionsRunLevel = AdditionsRunLevelType_None;
2928	else
2929	mData.mAdditionsRunLevel = AdditionsRunLevelType_System;
2930	}
2931
2932	/*
2933	* Older Additions didn't have this finer grained capability bit,
2934	* so enable it by default. Newer Additions will not enable this here
2935	* and use the setSupportedFeatures function instead.
2936	*/
2937	mData.mSupportsGraphics = mData.mAdditionsRunLevel > AdditionsRunLevelType_None;
2938
2939	/*
2940	* Note! There is a race going on between setting mAdditionsRunLevel and
2941	* mSupportsGraphics here and disabling/enabling it later according to
2942	* its real status when using new(er) Guest Additions.
2943	*/
2944	mData.mOSTypeId = Global::OSTypeId (aOsType);
2945	}
2946
2947	/**
2948	* Sets the Guest Additions version information details.
2949	* Gets called by vmmdevUpdateGuestInfo2.
2950	*
2951	* @param aAdditionsVersion
2952	* @param aVersionName
2953	*/
2954	void Guest::setAdditionsInfo2(Bstr aAdditionsVersion, Bstr aVersionName, Bstr aRevision)
2955	{
2956	AutoCaller autoCaller(this);
2957	AssertComRCReturnVoid(autoCaller.rc());
2958
2959	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2960
2961	if (!aVersionName.isEmpty())
2962	/*
2963	* aVersionName could be "x.y.z_BETA1_FOOBAR", so append revision manually to
2964	* become "x.y.z_BETA1_FOOBAR r12345".
2965	*/
2966	mData.mAdditionsVersion = BstrFmt("%ls r%ls", aVersionName.raw(), aRevision.raw());
2967	else /* aAdditionsVersion is in x.y.zr12345 format. */
2968	mData.mAdditionsVersion = aAdditionsVersion;
2969	}
2970
2971	/**
2972	* Sets the status of a certain Guest Additions facility.
2973	* Gets called by vmmdevUpdateGuestStatus.
2974	*
2975	* @param Facility
2976	* @param Status
2977	* @param ulFlags
2978	*/
2979	void Guest::setAdditionsStatus(VBoxGuestStatusFacility Facility, VBoxGuestStatusCurrent Status, ULONG ulFlags)
2980	{
2981	AutoCaller autoCaller(this);
2982	AssertComRCReturnVoid(autoCaller.rc());
2983
2984	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2985
2986	uint32_t uCurFacility = Facility + (Status == VBoxGuestStatusCurrent_Active ? 0 : -1);
2987
2988	/* First check for disabled status. */
2989	if ( Facility < VBoxGuestStatusFacility_VBoxGuestDriver
2990	\|\| ( Facility == VBoxGuestStatusFacility_All
2991	&& ( Status == VBoxGuestStatusCurrent_Inactive
2992	\|\| Status == VBoxGuestStatusCurrent_Disabled
2993	)
2994	)
2995	)
2996	{
2997	mData.mAdditionsRunLevel = AdditionsRunLevelType_None;
2998	}
2999	else if (uCurFacility >= VBoxGuestStatusFacility_VBoxTray)
3000	{
3001	mData.mAdditionsRunLevel = AdditionsRunLevelType_Desktop;
3002	}
3003	else if (uCurFacility >= VBoxGuestStatusFacility_VBoxService)
3004	{
3005	mData.mAdditionsRunLevel = AdditionsRunLevelType_Userland;
3006	}
3007	else if (uCurFacility >= VBoxGuestStatusFacility_VBoxGuestDriver)
3008	{
3009	mData.mAdditionsRunLevel = AdditionsRunLevelType_System;
3010	}
3011	else /* Should never happen! */
3012	AssertMsgFailed(("Invalid facility status/run level detected! uCurFacility=%ld\n", uCurFacility));
3013	}
3014
3015	/**
3016	* Sets the supported features (and whether they are active or not).
3017	*
3018	* @param fCaps Guest capability bit mask (VMMDEV_GUEST_SUPPORTS_XXX).
3019	* @param fActive No idea what this is supposed to be, it's always 0 and
3020	* not references by this method.
3021	*/
3022	void Guest::setSupportedFeatures(uint32_t fCaps, uint32_t fActive)
3023	{
3024	AutoCaller autoCaller(this);
3025	AssertComRCReturnVoid(autoCaller.rc());
3026
3027	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3028
3029	mData.mSupportsSeamless = (fCaps & VMMDEV_GUEST_SUPPORTS_SEAMLESS);
3030	/** @todo Add VMMDEV_GUEST_SUPPORTS_GUEST_HOST_WINDOW_MAPPING */
3031	mData.mSupportsGraphics = (fCaps & VMMDEV_GUEST_SUPPORTS_GRAPHICS);
3032	}
3033	/* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

source: vbox/trunk/src/VBox/Main/GuestImpl.cpp@ 34900

Download in other formats: