VirtualBox

About
Screenshots
Downloads
Documentation
End-user docs
Technical docs
Contribute
Community

Browse Source

Context Navigation

source: vbox/trunk/src/VBox/Main/src-client/GuestSessionImplTasks.cpp@ 86506

Last change on this file since 86506 was 84975, checked in by vboxsync, 4 years ago
Guest Control/GuestSessionImplTasks: Logging nits.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 103.8 KB

Line
1	/* $Id: GuestSessionImplTasks.cpp 84975 2020-06-26 15:39:06Z vboxsync $ */
2	/** @file
3	* VirtualBox Main - Guest session tasks.
4	*/
5
6	/*
7	* Copyright (C) 2012-2020 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#define LOG_GROUP LOG_GROUP_MAIN_GUESTSESSION
23	#include "LoggingNew.h"
24
25	#include "GuestImpl.h"
26	#ifndef VBOX_WITH_GUEST_CONTROL
27	# error "VBOX_WITH_GUEST_CONTROL must defined in this file"
28	#endif
29	#include "GuestSessionImpl.h"
30	#include "GuestSessionImplTasks.h"
31	#include "GuestCtrlImplPrivate.h"
32
33	#include "Global.h"
34	#include "AutoCaller.h"
35	#include "ConsoleImpl.h"
36	#include "ProgressImpl.h"
37
38	#include <memory> /* For auto_ptr. */
39
40	#include <iprt/env.h>
41	#include <iprt/file.h> /* For CopyTo/From. */
42	#include <iprt/dir.h>
43	#include <iprt/path.h>
44	#include <iprt/fsvfs.h>
45
46
47	/*********************************************************************************************************************************
48	* Defines *
49	*********************************************************************************************************************************/
50
51	/**
52	* (Guest Additions) ISO file flags.
53	* Needed for handling Guest Additions updates.
54	*/
55	#define ISOFILE_FLAG_NONE 0
56	/** Copy over the file from host to the
57	* guest. */
58	#define ISOFILE_FLAG_COPY_FROM_ISO RT_BIT(0)
59	/** Execute file on the guest after it has
60	* been successfully transfered. */
61	#define ISOFILE_FLAG_EXECUTE RT_BIT(7)
62	/** File is optional, does not have to be
63	* existent on the .ISO. */
64	#define ISOFILE_FLAG_OPTIONAL RT_BIT(8)
65
66
67	// session task classes
68	/////////////////////////////////////////////////////////////////////////////
69
70	GuestSessionTask::GuestSessionTask(GuestSession *pSession)
71	: ThreadTask("GenericGuestSessionTask")
72	{
73	mSession = pSession;
74
75	switch (mSession->i_getPathStyle())
76	{
77	case PathStyle_DOS:
78	mfPathStyle = RTPATH_STR_F_STYLE_DOS;
79	mPathStyle = "\\";
80	break;
81
82	default:
83	mfPathStyle = RTPATH_STR_F_STYLE_UNIX;
84	mPathStyle = "/";
85	break;
86	}
87	}
88
89	GuestSessionTask::~GuestSessionTask(void)
90	{
91	}
92
93	int GuestSessionTask::createAndSetProgressObject(ULONG cOperations /* = 1 */)
94	{
95	LogFlowThisFunc(("cOperations=%ld\n", cOperations));
96
97	/* Create the progress object. */
98	ComObjPtr<Progress> pProgress;
99	HRESULT hr = pProgress.createObject();
100	if (FAILED(hr))
101	return VERR_COM_UNEXPECTED;
102
103	hr = pProgress->init(static_cast<IGuestSession*>(mSession),
104	Bstr(mDesc).raw(),
105	TRUE /* aCancelable */, cOperations, Bstr(mDesc).raw());
106	if (FAILED(hr))
107	return VERR_COM_UNEXPECTED;
108
109	mProgress = pProgress;
110
111	LogFlowFuncLeave();
112	return VINF_SUCCESS;
113	}
114
115	#if 0 /* unsed */
116	/** @note The task object is owned by the thread after this returns, regardless of the result. */
117	int GuestSessionTask::RunAsync(const Utf8Str &strDesc, ComObjPtr<Progress> &pProgress)
118	{
119	LogFlowThisFunc(("strDesc=%s\n", strDesc.c_str()));
120
121	mDesc = strDesc;
122	mProgress = pProgress;
123	HRESULT hrc = createThreadWithType(RTTHREADTYPE_MAIN_HEAVY_WORKER);
124
125	LogFlowThisFunc(("Returning hrc=%Rhrc\n", hrc));
126	return Global::vboxStatusCodeToCOM(hrc);
127	}
128	#endif
129
130	int GuestSessionTask::getGuestProperty(const ComObjPtr<Guest> &pGuest,
131	const Utf8Str &strPath, Utf8Str &strValue)
132	{
133	ComObjPtr<Console> pConsole = pGuest->i_getConsole();
134	const ComPtr<IMachine> pMachine = pConsole->i_machine();
135
136	Assert(!pMachine.isNull());
137	Bstr strTemp, strFlags;
138	LONG64 i64Timestamp;
139	HRESULT hr = pMachine->GetGuestProperty(Bstr(strPath).raw(),
140	strTemp.asOutParam(),
141	&i64Timestamp, strFlags.asOutParam());
142	if (SUCCEEDED(hr))
143	{
144	strValue = strTemp;
145	return VINF_SUCCESS;
146	}
147	return VERR_NOT_FOUND;
148	}
149
150	int GuestSessionTask::setProgress(ULONG uPercent)
151	{
152	if (mProgress.isNull()) /* Progress is optional. */
153	return VINF_SUCCESS;
154
155	BOOL fCanceled;
156	if ( SUCCEEDED(mProgress->COMGETTER(Canceled(&fCanceled)))
157	&& fCanceled)
158	return VERR_CANCELLED;
159	BOOL fCompleted;
160	if ( SUCCEEDED(mProgress->COMGETTER(Completed(&fCompleted)))
161	&& fCompleted)
162	{
163	AssertMsgFailed(("Setting value of an already completed progress\n"));
164	return VINF_SUCCESS;
165	}
166	HRESULT hr = mProgress->SetCurrentOperationProgress(uPercent);
167	if (FAILED(hr))
168	return VERR_COM_UNEXPECTED;
169
170	return VINF_SUCCESS;
171	}
172
173	int GuestSessionTask::setProgressSuccess(void)
174	{
175	if (mProgress.isNull()) /* Progress is optional. */
176	return VINF_SUCCESS;
177
178	BOOL fCompleted;
179	if ( SUCCEEDED(mProgress->COMGETTER(Completed(&fCompleted)))
180	&& !fCompleted)
181	{
182	#ifdef VBOX_STRICT
183	ULONG uCurOp; mProgress->COMGETTER(Operation(&uCurOp));
184	ULONG cOps; mProgress->COMGETTER(OperationCount(&cOps));
185	AssertMsg(uCurOp + 1 /* Zero-based */ == cOps, ("Not all operations done yet (%u/%u)\n", uCurOp + 1, cOps));
186	#endif
187	HRESULT hr = mProgress->i_notifyComplete(S_OK);
188	if (FAILED(hr))
189	return VERR_COM_UNEXPECTED; /** @todo Find a better rc. */
190	}
191
192	return VINF_SUCCESS;
193	}
194
195	/**
196	* Sets the task's progress object to an error using a string message.
197	*
198	* @returns Returns \a hr for covenience.
199	* @param hr Progress operation result to set.
200	* @param strMsg Message to set.
201	*/
202	HRESULT GuestSessionTask::setProgressErrorMsg(HRESULT hr, const Utf8Str &strMsg)
203	{
204	LogFlowFunc(("hr=%Rhrc, strMsg=%s\n", hr, strMsg.c_str()));
205
206	if (mProgress.isNull()) /* Progress is optional. */
207	return hr; /* Return original rc. */
208
209	BOOL fCanceled;
210	BOOL fCompleted;
211	if ( SUCCEEDED(mProgress->COMGETTER(Canceled(&fCanceled)))
212	&& !fCanceled
213	&& SUCCEEDED(mProgress->COMGETTER(Completed(&fCompleted)))
214	&& !fCompleted)
215	{
216	HRESULT hr2 = mProgress->i_notifyComplete(hr,
217	COM_IIDOF(IGuestSession),
218	GuestSession::getStaticComponentName(),
219	/* Make sure to hand-in the message via format string to avoid problems
220	* with (file) paths which e.g. contain "%s" and friends. Can happen with
221	* randomly generated Validation Kit stuff. */
222	"%s", strMsg.c_str());
223	if (FAILED(hr2))
224	return hr2;
225	}
226	return hr; /* Return original rc. */
227	}
228
229	/**
230	* Sets the task's progress object to an error using a string message and a guest error info object.
231	*
232	* @returns Returns \a hr for covenience.
233	* @param hr Progress operation result to set.
234	* @param strMsg Message to set.
235	* @param guestErrorInfo Guest error info to use.
236	*/
237	HRESULT GuestSessionTask::setProgressErrorMsg(HRESULT hr, const Utf8Str &strMsg, const GuestErrorInfo &guestErrorInfo)
238	{
239	return setProgressErrorMsg(hr, strMsg + Utf8Str(": ") + GuestBase::getErrorAsString(guestErrorInfo));
240	}
241
242	/**
243	* Creates a directory on the guest.
244	*
245	* @return VBox status code.
246	* VINF_ALREADY_EXISTS if directory on the guest already exists (\a fCanExist is \c true).
247	* VWRN_ALREADY_EXISTS if directory on the guest already exists but must not exist (\a fCanExist is \c false).
248	* @param strPath Absolute path to directory on the guest (guest style path) to create.
249	* @param enmDirectoryCreateFlags Directory creation flags.
250	* @param fMode Directory mode to use for creation.
251	* @param fFollowSymlinks Whether to follow symlinks on the guest or not.
252	* @param fCanExist Whether the directory to create is allowed to exist already.
253	*/
254	int GuestSessionTask::directoryCreateOnGuest(const com::Utf8Str &strPath,
255	DirectoryCreateFlag_T enmDirectoryCreateFlags, uint32_t fMode,
256	bool fFollowSymlinks, bool fCanExist)
257	{
258	LogFlowFunc(("strPath=%s, enmDirectoryCreateFlags=0x%x, fMode=%RU32, fFollowSymlinks=%RTbool, fCanExist=%RTbool\n",
259	strPath.c_str(), enmDirectoryCreateFlags, fMode, fFollowSymlinks, fCanExist));
260
261	GuestFsObjData objData;
262	int rcGuest = VERR_IPE_UNINITIALIZED_STATUS;
263	int rc = mSession->i_directoryQueryInfo(strPath, fFollowSymlinks, objData, &rcGuest);
264	if (RT_SUCCESS(rc))
265	{
266	if (!fCanExist)
267	{
268	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
269	Utf8StrFmt(GuestSession::tr("Guest directory \"%s\" already exists"), strPath.c_str()));
270	rc = VERR_ALREADY_EXISTS;
271	}
272	else
273	rc = VWRN_ALREADY_EXISTS;
274	}
275	else
276	{
277	switch (rc)
278	{
279	case VERR_GSTCTL_GUEST_ERROR:
280	{
281	switch (rcGuest)
282	{
283	case VERR_FILE_NOT_FOUND:
284	RT_FALL_THROUGH();
285	case VERR_PATH_NOT_FOUND:
286	rc = mSession->i_directoryCreate(strPath.c_str(), fMode, enmDirectoryCreateFlags, &rcGuest);
287	break;
288	default:
289	break;
290	}
291
292	if (RT_FAILURE(rc))
293	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
294	Utf8StrFmt(GuestSession::tr("Guest error creating directory \"%s\" on the guest: %Rrc"),
295	strPath.c_str(), rcGuest));
296	break;
297	}
298
299	default:
300	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
301	Utf8StrFmt(GuestSession::tr("Host error creating directory \"%s\" on the guest: %Rrc"),
302	strPath.c_str(), rc));
303	break;
304	}
305	}
306
307	LogFlowFuncLeaveRC(rc);
308	return rc;
309	}
310
311	/**
312	* Creates a directory on the host.
313	*
314	* @return VBox status code. VERR_ALREADY_EXISTS if directory on the guest already exists.
315	* @param strPath Absolute path to directory on the host (host style path) to create.
316	* @param fCreate Directory creation flags.
317	* @param fMode Directory mode to use for creation.
318	* @param fCanExist Whether the directory to create is allowed to exist already.
319	*/
320	int GuestSessionTask::directoryCreateOnHost(const com::Utf8Str &strPath, uint32_t fCreate, uint32_t fMode, bool fCanExist)
321	{
322	LogFlowFunc(("strPath=%s, fCreate=0x%x, fMode=%RU32, fCanExist=%RTbool\n", strPath.c_str(), fCreate, fMode, fCanExist));
323
324	int rc = RTDirCreate(strPath.c_str(), fMode, fCreate);
325	if (RT_FAILURE(rc))
326	{
327	if (rc == VERR_ALREADY_EXISTS)
328	{
329	if (!fCanExist)
330	{
331	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
332	Utf8StrFmt(GuestSession::tr("Host directory \"%s\" already exists"), strPath.c_str()));
333	}
334	else
335	rc = VINF_SUCCESS;
336	}
337	else
338	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
339	Utf8StrFmt(GuestSession::tr("Could not create host directory \"%s\": %Rrc"),
340	strPath.c_str(), rc));
341	}
342
343	LogFlowFuncLeaveRC(rc);
344	return rc;
345	}
346
347	/**
348	* Main function for copying a file from guest to the host.
349	*
350	* @return VBox status code.
351	* @param strSrcFile Full path of source file on the host to copy.
352	* @param srcFile Guest file (source) to copy to the host. Must be in opened and ready state already.
353	* @param strDstFile Full destination path and file name (guest style) to copy file to.
354	* @param phDstFile Pointer to host file handle (destination) to copy to. Must be in opened and ready state already.
355	* @param fFileCopyFlags File copy flags.
356	* @param offCopy Offset (in bytes) where to start copying the source file.
357	* @param cbSize Size (in bytes) to copy from the source file.
358	*/
359	int GuestSessionTask::fileCopyFromGuestInner(const Utf8Str &strSrcFile, ComObjPtr<GuestFile> &srcFile,
360	const Utf8Str &strDstFile, PRTFILE phDstFile,
361	FileCopyFlag_T fFileCopyFlags, uint64_t offCopy, uint64_t cbSize)
362	{
363	RT_NOREF(fFileCopyFlags);
364
365	BOOL fCanceled = FALSE;
366	uint64_t cbWrittenTotal = 0;
367	uint64_t cbToRead = cbSize;
368
369	uint32_t uTimeoutMs = 30 * 1000; /* 30s timeout. */
370
371	int rc = VINF_SUCCESS;
372
373	if (offCopy)
374	{
375	uint64_t offActual;
376	rc = srcFile->i_seekAt(offCopy, GUEST_FILE_SEEKTYPE_BEGIN, uTimeoutMs, &offActual);
377	if (RT_FAILURE(rc))
378	{
379	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
380	Utf8StrFmt(GuestSession::tr("Seeking to offset %RU64 of guest file \"%s\" failed: %Rrc"),
381	offCopy, strSrcFile.c_str(), rc));
382	return rc;
383	}
384	}
385
386	BYTE byBuf[_64K]; /** @todo Can we do better here? */
387	while (cbToRead)
388	{
389	uint32_t cbRead;
390	const uint32_t cbChunk = RT_MIN(cbToRead, sizeof(byBuf));
391	rc = srcFile->i_readData(cbChunk, uTimeoutMs, byBuf, sizeof(byBuf), &cbRead);
392	if (RT_FAILURE(rc))
393	{
394	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
395	Utf8StrFmt(GuestSession::tr("Reading %RU32 bytes @ %RU64 from guest \"%s\" failed: %Rrc"),
396	cbChunk, cbWrittenTotal, strSrcFile.c_str(), rc));
397	break;
398	}
399
400	rc = RTFileWrite(phDstFile, byBuf, cbRead, NULL / No partial writes */);
401	if (RT_FAILURE(rc))
402	{
403	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
404	Utf8StrFmt(GuestSession::tr("Writing %RU32 bytes to host file \"%s\" failed: %Rrc"),
405	cbRead, strDstFile.c_str(), rc));
406	break;
407	}
408
409	AssertBreak(cbToRead >= cbRead);
410	cbToRead -= cbRead;
411
412	/* Update total bytes written to the guest. */
413	cbWrittenTotal += cbRead;
414	AssertBreak(cbWrittenTotal <= cbSize);
415
416	/* Did the user cancel the operation above? */
417	if ( SUCCEEDED(mProgress->COMGETTER(Canceled(&fCanceled)))
418	&& fCanceled)
419	break;
420
421	rc = setProgress((ULONG)(cbWrittenTotal / ((uint64_t)cbSize / 100.0)));
422	if (RT_FAILURE(rc))
423	break;
424	}
425
426	if ( SUCCEEDED(mProgress->COMGETTER(Canceled(&fCanceled)))
427	&& fCanceled)
428	return VINF_SUCCESS;
429
430	if (RT_FAILURE(rc))
431	return rc;
432
433	/*
434	* Even if we succeeded until here make sure to check whether we really transfered
435	* everything.
436	*/
437	if ( cbSize > 0
438	&& cbWrittenTotal == 0)
439	{
440	/* If nothing was transfered but the file size was > 0 then "vbox_cat" wasn't able to write
441	* to the destination -> access denied. */
442	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
443	Utf8StrFmt(GuestSession::tr("Writing guest file \"%s\" to host file \"%s\" failed: Access denied"),
444	strSrcFile.c_str(), strDstFile.c_str()));
445	rc = VERR_ACCESS_DENIED;
446	}
447	else if (cbWrittenTotal < cbSize)
448	{
449	/* If we did not copy all let the user know. */
450	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
451	Utf8StrFmt(GuestSession::tr("Copying guest file \"%s\" to host file \"%s\" failed (%RU64/%RU64 bytes transfered)"),
452	strSrcFile.c_str(), strDstFile.c_str(), cbWrittenTotal, cbSize));
453	rc = VERR_INTERRUPTED;
454	}
455
456	LogFlowFuncLeaveRC(rc);
457	return rc;
458	}
459
460	/**
461	* Copies a file from the guest to the host.
462	*
463	* @return VBox status code. VINF_NO_CHANGE if file was skipped.
464	* @param strSrc Full path of source file on the guest to copy.
465	* @param strDst Full destination path and file name (host style) to copy file to.
466	* @param fFileCopyFlags File copy flags.
467	*/
468	int GuestSessionTask::fileCopyFromGuest(const Utf8Str &strSrc, const Utf8Str &strDst, FileCopyFlag_T fFileCopyFlags)
469	{
470	LogFlowThisFunc(("strSource=%s, strDest=%s, enmFileCopyFlags=%#x\n", strSrc.c_str(), strDst.c_str(), fFileCopyFlags));
471
472	GuestFileOpenInfo srcOpenInfo;
473	srcOpenInfo.mFilename = strSrc;
474	srcOpenInfo.mOpenAction = FileOpenAction_OpenExisting;
475	srcOpenInfo.mAccessMode = FileAccessMode_ReadOnly;
476	srcOpenInfo.mSharingMode = FileSharingMode_All; /** @todo Use _Read when implemented. */
477
478	ComObjPtr<GuestFile> srcFile;
479
480	GuestFsObjData srcObjData;
481	int rcGuest = VERR_IPE_UNINITIALIZED_STATUS;
482	int rc = mSession->i_fsQueryInfo(strSrc, TRUE /* fFollowSymlinks */, srcObjData, &rcGuest);
483	if (RT_FAILURE(rc))
484	{
485	if (rc == VERR_GSTCTL_GUEST_ERROR)
486	setProgressErrorMsg(VBOX_E_IPRT_ERROR, GuestSession::tr("Guest file lookup failed"),
487	GuestErrorInfo(GuestErrorInfo::Type_ToolStat, rcGuest, strSrc.c_str()));
488	else
489	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
490	Utf8StrFmt(GuestSession::tr("Guest file lookup for \"%s\" failed: %Rrc"), strSrc.c_str(), rc));
491	}
492	else
493	{
494	switch (srcObjData.mType)
495	{
496	case FsObjType_File:
497	break;
498
499	case FsObjType_Symlink:
500	if (!(fFileCopyFlags & FileCopyFlag_FollowLinks))
501	{
502	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
503	Utf8StrFmt(GuestSession::tr("Guest file \"%s\" is a symbolic link"),
504	strSrc.c_str()));
505	rc = VERR_IS_A_SYMLINK;
506	}
507	break;
508
509	default:
510	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
511	Utf8StrFmt(GuestSession::tr("Guest object \"%s\" is not a file (is type %#x)"),
512	strSrc.c_str(), srcObjData.mType));
513	rc = VERR_NOT_A_FILE;
514	break;
515	}
516	}
517
518	if (RT_FAILURE(rc))
519	return rc;
520
521	rc = mSession->i_fileOpen(srcOpenInfo, srcFile, &rcGuest);
522	if (RT_FAILURE(rc))
523	{
524	if (rc == VERR_GSTCTL_GUEST_ERROR)
525	setProgressErrorMsg(VBOX_E_IPRT_ERROR, GuestSession::tr("Guest file could not be opened"),
526	GuestErrorInfo(GuestErrorInfo::Type_File, rcGuest, strSrc.c_str()));
527	else
528	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
529	Utf8StrFmt(GuestSession::tr("Guest file \"%s\" could not be opened: %Rrc"), strSrc.c_str(), rc));
530	}
531
532	if (RT_FAILURE(rc))
533	return rc;
534
535	RTFSOBJINFO dstObjInfo;
536	RT_ZERO(dstObjInfo);
537
538	bool fSkip = false; /* Whether to skip handling the file. */
539
540	if (RT_SUCCESS(rc))
541	{
542	rc = RTPathQueryInfo(strDst.c_str(), &dstObjInfo, RTFSOBJATTRADD_NOTHING);
543	if (RT_SUCCESS(rc))
544	{
545	if (fFileCopyFlags & FileCopyFlag_NoReplace)
546	{
547	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
548	Utf8StrFmt(GuestSession::tr("Host file \"%s\" already exists"), strDst.c_str()));
549	rc = VERR_ALREADY_EXISTS;
550	}
551
552	if (fFileCopyFlags & FileCopyFlag_Update)
553	{
554	RTTIMESPEC srcModificationTimeTS;
555	RTTimeSpecSetSeconds(&srcModificationTimeTS, srcObjData.mModificationTime);
556	if (RTTimeSpecCompare(&srcModificationTimeTS, &dstObjInfo.ModificationTime) <= 0)
557	{
558	LogRel2(("Guest Control: Host file \"%s\" has same or newer modification date, skipping", strDst.c_str()));
559	fSkip = true;
560	}
561	}
562	}
563	else
564	{
565	if (rc != VERR_FILE_NOT_FOUND) /* Destination file does not exist (yet)? */
566	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
567	Utf8StrFmt(GuestSession::tr("Host file lookup for \"%s\" failed: %Rrc"),
568	strDst.c_str(), rc));
569	}
570	}
571
572	if (fSkip)
573	{
574	int rc2 = srcFile->i_closeFile(&rcGuest);
575	AssertRC(rc2);
576	return VINF_SUCCESS;
577	}
578
579	char *pszDstFile = NULL;
580
581	if (RT_SUCCESS(rc))
582	{
583	if (RTFS_IS_FILE(dstObjInfo.Attr.fMode))
584	{
585	if (fFileCopyFlags & FileCopyFlag_NoReplace)
586	{
587	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
588	Utf8StrFmt(GuestSession::tr("Host file \"%s\" already exists"), strDst.c_str()));
589	rc = VERR_ALREADY_EXISTS;
590	}
591	else
592	pszDstFile = RTStrDup(strDst.c_str());
593	}
594	else if (RTFS_IS_DIRECTORY(dstObjInfo.Attr.fMode))
595	{
596	/* Build the final file name with destination path (on the host). */
597	char szDstPath[RTPATH_MAX];
598	rc = RTStrCopy(szDstPath, sizeof(szDstPath), strDst.c_str());
599	if (RT_SUCCESS(rc))
600	{
601	rc = RTPathAppend(szDstPath, sizeof(szDstPath), RTPathFilenameEx(strSrc.c_str(), mfPathStyle));
602	if (RT_SUCCESS(rc))
603	pszDstFile = RTStrDup(szDstPath);
604	}
605	}
606	else if (RTFS_IS_SYMLINK(dstObjInfo.Attr.fMode))
607	{
608	if (!(fFileCopyFlags & FileCopyFlag_FollowLinks))
609	{
610	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
611	Utf8StrFmt(GuestSession::tr("Host file \"%s\" is a symbolic link"),
612	strDst.c_str()));
613	rc = VERR_IS_A_SYMLINK;
614	}
615	else
616	pszDstFile = RTStrDup(strDst.c_str());
617	}
618	else
619	{
620	LogFlowThisFunc(("Object type %RU32 not implemented yet\n", dstObjInfo.Attr.fMode));
621	rc = VERR_NOT_IMPLEMENTED;
622	}
623	}
624	else if (rc == VERR_FILE_NOT_FOUND)
625	pszDstFile = RTStrDup(strDst.c_str());
626
627	if ( RT_SUCCESS(rc)
628	\|\| rc == VERR_FILE_NOT_FOUND)
629	{
630	if (!pszDstFile)
631	{
632	setProgressErrorMsg(VBOX_E_IPRT_ERROR, Utf8StrFmt(GuestSession::tr("No memory to allocate host file path")));
633	rc = VERR_NO_MEMORY;
634	}
635	else
636	{
637	RTFILE hDstFile;
638	rc = RTFileOpen(&hDstFile, pszDstFile,
639	RTFILE_O_WRITE \| RTFILE_O_OPEN_CREATE \| RTFILE_O_DENY_WRITE); /** @todo Use the correct open modes! */
640	if (RT_SUCCESS(rc))
641	{
642	LogFlowThisFunc(("Copying '%s' to '%s' (%RI64 bytes) ...\n",
643	strSrc.c_str(), pszDstFile, srcObjData.mObjectSize));
644
645	rc = fileCopyFromGuestInner(strSrc, srcFile, pszDstFile, &hDstFile, fFileCopyFlags,
646	0 /* Offset, unused */, (uint64_t)srcObjData.mObjectSize);
647
648	int rc2 = RTFileClose(hDstFile);
649	AssertRC(rc2);
650	}
651	else
652	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
653	Utf8StrFmt(GuestSession::tr("Opening/creating host file \"%s\" failed: %Rrc"),
654	pszDstFile, rc));
655	}
656	}
657
658	RTStrFree(pszDstFile);
659
660	int rc2 = srcFile->i_closeFile(&rcGuest);
661	AssertRC(rc2);
662
663	LogFlowFuncLeaveRC(rc);
664	return rc;
665	}
666
667	/**
668	* Main function for copying a file from host to the guest.
669	*
670	* @return VBox status code.
671	* @param strSrcFile Full path of source file on the host to copy.
672	* @param hVfsFile The VFS file handle to read from.
673	* @param strDstFile Full destination path and file name (guest style) to copy file to.
674	* @param fileDst Guest file (destination) to copy to the guest. Must be in opened and ready state already.
675	* @param fFileCopyFlags File copy flags.
676	* @param offCopy Offset (in bytes) where to start copying the source file.
677	* @param cbSize Size (in bytes) to copy from the source file.
678	*/
679	int GuestSessionTask::fileCopyToGuestInner(const Utf8Str &strSrcFile, RTVFSFILE hVfsFile,
680	const Utf8Str &strDstFile, ComObjPtr<GuestFile> &fileDst,
681	FileCopyFlag_T fFileCopyFlags, uint64_t offCopy, uint64_t cbSize)
682	{
683	RT_NOREF(fFileCopyFlags);
684
685	BOOL fCanceled = FALSE;
686	uint64_t cbWrittenTotal = 0;
687	uint64_t cbToRead = cbSize;
688
689	uint32_t uTimeoutMs = 30 * 1000; /* 30s timeout. */
690
691	int rc = VINF_SUCCESS;
692
693	if (offCopy)
694	{
695	uint64_t offActual;
696	rc = RTVfsFileSeek(hVfsFile, offCopy, RTFILE_SEEK_END, &offActual);
697	if (RT_FAILURE(rc))
698	{
699	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
700	Utf8StrFmt(GuestSession::tr("Seeking to offset %RU64 of host file \"%s\" failed: %Rrc"),
701	offCopy, strSrcFile.c_str(), rc));
702	return rc;
703	}
704	}
705
706	BYTE byBuf[_64K];
707	while (cbToRead)
708	{
709	size_t cbRead;
710	const uint32_t cbChunk = RT_MIN(cbToRead, sizeof(byBuf));
711	rc = RTVfsFileRead(hVfsFile, byBuf, cbChunk, &cbRead);
712	if (RT_FAILURE(rc))
713	{
714	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
715	Utf8StrFmt(GuestSession::tr("Reading %RU32 bytes @ %RU64 from host file \"%s\" failed: %Rrc"),
716	cbChunk, cbWrittenTotal, strSrcFile.c_str(), rc));
717	break;
718	}
719
720	rc = fileDst->i_writeData(uTimeoutMs, byBuf, (uint32_t)cbRead, NULL /* No partial writes */);
721	if (RT_FAILURE(rc))
722	{
723	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
724	Utf8StrFmt(GuestSession::tr("Writing %zu bytes to guest file \"%s\" failed: %Rrc"),
725	cbRead, strDstFile.c_str(), rc));
726	break;
727	}
728
729	Assert(cbToRead >= cbRead);
730	cbToRead -= cbRead;
731
732	/* Update total bytes written to the guest. */
733	cbWrittenTotal += cbRead;
734	Assert(cbWrittenTotal <= cbSize);
735
736	/* Did the user cancel the operation above? */
737	if ( SUCCEEDED(mProgress->COMGETTER(Canceled(&fCanceled)))
738	&& fCanceled)
739	break;
740
741	rc = setProgress((ULONG)(cbWrittenTotal / ((uint64_t)cbSize / 100.0)));
742	if (RT_FAILURE(rc))
743	break;
744	}
745
746	if (RT_FAILURE(rc))
747	return rc;
748
749	/*
750	* Even if we succeeded until here make sure to check whether we really transfered
751	* everything.
752	*/
753	if ( cbSize > 0
754	&& cbWrittenTotal == 0)
755	{
756	/* If nothing was transfered but the file size was > 0 then "vbox_cat" wasn't able to write
757	* to the destination -> access denied. */
758	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
759	Utf8StrFmt(GuestSession::tr("Writing to guest file \"%s\" failed: Access denied"),
760	strDstFile.c_str()));
761	rc = VERR_ACCESS_DENIED;
762	}
763	else if (cbWrittenTotal < cbSize)
764	{
765	/* If we did not copy all let the user know. */
766	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
767	Utf8StrFmt(GuestSession::tr("Copying to guest file \"%s\" failed (%RU64/%RU64 bytes transfered)"),
768	strDstFile.c_str(), cbWrittenTotal, cbSize));
769	rc = VERR_INTERRUPTED;
770	}
771
772	LogFlowFuncLeaveRC(rc);
773	return rc;
774	}
775
776	/**
777	* Copies a file from the guest to the host.
778	*
779	* @return VBox status code. VINF_NO_CHANGE if file was skipped.
780	* @param strSrc Full path of source file on the host to copy.
781	* @param strDst Full destination path and file name (guest style) to copy file to.
782	* @param fFileCopyFlags File copy flags.
783	*/
784	int GuestSessionTask::fileCopyToGuest(const Utf8Str &strSrc, const Utf8Str &strDst, FileCopyFlag_T fFileCopyFlags)
785	{
786	LogFlowThisFunc(("strSource=%s, strDst=%s, fFileCopyFlags=0x%x\n", strSrc.c_str(), strDst.c_str(), fFileCopyFlags));
787
788	Utf8Str strDstFinal = strDst;
789
790	GuestFileOpenInfo dstOpenInfo;
791	dstOpenInfo.mFilename = strDstFinal;
792	if (fFileCopyFlags & FileCopyFlag_NoReplace)
793	dstOpenInfo.mOpenAction = FileOpenAction_CreateNew;
794	else
795	dstOpenInfo.mOpenAction = FileOpenAction_CreateOrReplace;
796	dstOpenInfo.mAccessMode = FileAccessMode_WriteOnly;
797	dstOpenInfo.mSharingMode = FileSharingMode_All; /** @todo Use _Read when implemented. */
798
799	ComObjPtr<GuestFile> dstFile;
800	int rcGuest;
801	int rc = mSession->i_fileOpen(dstOpenInfo, dstFile, &rcGuest);
802	if (RT_FAILURE(rc))
803	{
804	if (rc == VERR_GSTCTL_GUEST_ERROR)
805	setProgressErrorMsg(VBOX_E_IPRT_ERROR, GuestSession::tr("Guest file could not be opened"),
806	GuestErrorInfo(GuestErrorInfo::Type_File, rcGuest, strSrc.c_str()));
807	else
808	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
809	Utf8StrFmt(GuestSession::tr("Guest file \"%s\" could not be opened: %Rrc"), strSrc.c_str(), rc));
810	return rc;
811	}
812
813	char szSrcReal[RTPATH_MAX];
814
815	RTFSOBJINFO srcObjInfo;
816	RT_ZERO(srcObjInfo);
817
818	bool fSkip = false; /* Whether to skip handling the file. */
819
820	if (RT_SUCCESS(rc))
821	{
822	rc = RTPathReal(strSrc.c_str(), szSrcReal, sizeof(szSrcReal));
823	if (RT_FAILURE(rc))
824	{
825	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
826	Utf8StrFmt(GuestSession::tr("Host path lookup for file \"%s\" failed: %Rrc"),
827	strSrc.c_str(), rc));
828	}
829	else
830	{
831	rc = RTPathQueryInfo(szSrcReal, &srcObjInfo, RTFSOBJATTRADD_NOTHING);
832	if (RT_SUCCESS(rc))
833	{
834	if (fFileCopyFlags & FileCopyFlag_Update)
835	{
836	GuestFsObjData dstObjData;
837	rc = mSession->i_fileQueryInfo(strDstFinal, RT_BOOL(fFileCopyFlags & FileCopyFlag_FollowLinks), dstObjData,
838	&rcGuest);
839	if (RT_SUCCESS(rc))
840	{
841	RTTIMESPEC dstModificationTimeTS;
842	RTTimeSpecSetSeconds(&dstModificationTimeTS, dstObjData.mModificationTime);
843	if (RTTimeSpecCompare(&dstModificationTimeTS, &srcObjInfo.ModificationTime) <= 0)
844	{
845	LogRel2(("Guest Control: Guest file \"%s\" has same or newer modification date, skipping",
846	strDstFinal.c_str()));
847	fSkip = true;
848	}
849	}
850	else
851	{
852	if (rc == VERR_GSTCTL_GUEST_ERROR)
853	{
854	switch (rcGuest)
855	{
856	case VERR_FILE_NOT_FOUND:
857	rc = VINF_SUCCESS;
858	break;
859
860	default:
861	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
862	Utf8StrFmt(GuestSession::tr("Guest error while determining object data for guest file \"%s\": %Rrc"),
863	strDstFinal.c_str(), rcGuest));
864	break;
865	}
866	}
867	else
868	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
869	Utf8StrFmt(GuestSession::tr("Host error while determining object data for guest file \"%s\": %Rrc"),
870	strDstFinal.c_str(), rc));
871	}
872	}
873	}
874	else
875	{
876	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
877	Utf8StrFmt(GuestSession::tr("Host file lookup for \"%s\" failed: %Rrc"),
878	szSrcReal, rc));
879	}
880	}
881	}
882
883	if (fSkip)
884	{
885	int rc2 = dstFile->i_closeFile(&rcGuest);
886	AssertRC(rc2);
887	return VINF_SUCCESS;
888	}
889
890	if (RT_SUCCESS(rc))
891	{
892	RTVFSFILE hSrcFile;
893	rc = RTVfsFileOpenNormal(szSrcReal, RTFILE_O_OPEN \| RTFILE_O_READ \| RTFILE_O_DENY_WRITE, &hSrcFile);
894	if (RT_SUCCESS(rc))
895	{
896	LogFlowThisFunc(("Copying '%s' to '%s' (%RI64 bytes) ...\n",
897	szSrcReal, strDstFinal.c_str(), srcObjInfo.cbObject));
898
899	rc = fileCopyToGuestInner(szSrcReal, hSrcFile, strDstFinal, dstFile,
900	fFileCopyFlags, 0 /* Offset, unused */, srcObjInfo.cbObject);
901
902	int rc2 = RTVfsFileRelease(hSrcFile);
903	AssertRC(rc2);
904	}
905	else
906	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
907	Utf8StrFmt(GuestSession::tr("Opening host file \"%s\" failed: %Rrc"),
908	szSrcReal, rc));
909	}
910
911	int rc2 = dstFile->i_closeFile(&rcGuest);
912	AssertRC(rc2);
913
914	LogFlowFuncLeaveRC(rc);
915	return rc;
916	}
917
918	/**
919	* Adds a guest file system entry to a given list.
920	*
921	* @return VBox status code.
922	* @param strFile Path to file system entry to add.
923	* @param fsObjData Guest file system information of entry to add.
924	*/
925	int FsList::AddEntryFromGuest(const Utf8Str &strFile, const GuestFsObjData &fsObjData)
926	{
927	LogFlowFunc(("Adding '%s'\n", strFile.c_str()));
928
929	FsEntry *pEntry = NULL;
930	try
931	{
932	pEntry = new FsEntry();
933	pEntry->fMode = fsObjData.GetFileMode();
934	pEntry->strPath = strFile;
935
936	mVecEntries.push_back(pEntry);
937	}
938	catch (std::bad_alloc &)
939	{
940	if (pEntry)
941	delete pEntry;
942	return VERR_NO_MEMORY;
943	}
944
945	return VINF_SUCCESS;
946	}
947
948	/**
949	* Adds a host file system entry to a given list.
950	*
951	* @return VBox status code.
952	* @param strFile Path to file system entry to add.
953	* @param pcObjInfo File system information of entry to add.
954	*/
955	int FsList::AddEntryFromHost(const Utf8Str &strFile, PCRTFSOBJINFO pcObjInfo)
956	{
957	LogFlowFunc(("Adding '%s'\n", strFile.c_str()));
958
959	FsEntry *pEntry = NULL;
960	try
961	{
962	pEntry = new FsEntry();
963	pEntry->fMode = pcObjInfo->Attr.fMode & RTFS_TYPE_MASK;
964	pEntry->strPath = strFile;
965
966	mVecEntries.push_back(pEntry);
967	}
968	catch (std::bad_alloc &)
969	{
970	if (pEntry)
971	delete pEntry;
972	return VERR_NO_MEMORY;
973	}
974
975	return VINF_SUCCESS;
976	}
977
978	FsList::FsList(const GuestSessionTask &Task)
979	: mTask(Task)
980	{
981	}
982
983	FsList::~FsList()
984	{
985	Destroy();
986	}
987
988	/**
989	* Initializes a file list.
990	*
991	* @return VBox status code.
992	* @param strSrcRootAbs Source root path (absolute) for this file list.
993	* @param strDstRootAbs Destination root path (absolute) for this file list.
994	* @param SourceSpec Source specification to use.
995	*/
996	int FsList::Init(const Utf8Str &strSrcRootAbs, const Utf8Str &strDstRootAbs,
997	const GuestSessionFsSourceSpec &SourceSpec)
998	{
999	mSrcRootAbs = strSrcRootAbs;
1000	mDstRootAbs = strDstRootAbs;
1001	mSourceSpec = SourceSpec;
1002
1003	/* If the source is a directory, make sure the path is properly terminated already. */
1004	if (mSourceSpec.enmType == FsObjType_Directory)
1005	{
1006	LogFlowFunc(("Directory: mSrcRootAbs=%s, mDstRootAbs=%s, fCopyFlags=%#x, fFollowSymlinks=%RTbool, fRecursive=%RTbool\n",
1007	mSrcRootAbs.c_str(), mDstRootAbs.c_str(), mSourceSpec.Type.Dir.fCopyFlags,
1008	mSourceSpec.Type.Dir.fFollowSymlinks, mSourceSpec.Type.Dir.fRecursive));
1009
1010	if ( !mSrcRootAbs.endsWith("/")
1011	&& !mSrcRootAbs.endsWith("\\"))
1012	mSrcRootAbs += "/";
1013
1014	if ( !mDstRootAbs.endsWith("/")
1015	&& !mDstRootAbs.endsWith("\\"))
1016	mDstRootAbs += "/";
1017	}
1018	else if (mSourceSpec.enmType == FsObjType_File)
1019	{
1020	LogFlowFunc(("File: mSrcRootAbs=%s, mDstRootAbs=%s, fCopyFlags=%#x\n",
1021	mSrcRootAbs.c_str(), mDstRootAbs.c_str(), mSourceSpec.Type.File.fCopyFlags));
1022	}
1023	else
1024	AssertFailedReturn(VERR_NOT_IMPLEMENTED);
1025
1026	return VINF_SUCCESS;
1027	}
1028
1029	/**
1030	* Destroys a file list.
1031	*/
1032	void FsList::Destroy(void)
1033	{
1034	LogFlowFuncEnter();
1035
1036	FsEntries::iterator itEntry = mVecEntries.begin();
1037	while (itEntry != mVecEntries.end())
1038	{
1039	FsEntry pEntry = itEntry;
1040	delete pEntry;
1041	mVecEntries.erase(itEntry);
1042	itEntry = mVecEntries.begin();
1043	}
1044
1045	Assert(mVecEntries.empty());
1046
1047	LogFlowFuncLeave();
1048	}
1049
1050	/**
1051	* Builds a guest file list from a given path (and optional filter).
1052	*
1053	* @return VBox status code.
1054	* @param strPath Directory on the guest to build list from.
1055	* @param strSubDir Current sub directory path; needed for recursion.
1056	* Set to an empty path.
1057	*/
1058	int FsList::AddDirFromGuest(const Utf8Str &strPath, const Utf8Str &strSubDir /* = "" */)
1059	{
1060	Utf8Str strPathAbs = strPath;
1061	if ( !strPathAbs.endsWith("/")
1062	&& !strPathAbs.endsWith("\\"))
1063	strPathAbs += "/";
1064
1065	Utf8Str strPathSub = strSubDir;
1066	if ( strPathSub.isNotEmpty()
1067	&& !strPathSub.endsWith("/")
1068	&& !strPathSub.endsWith("\\"))
1069	strPathSub += "/";
1070
1071	strPathAbs += strPathSub;
1072
1073	LogFlowFunc(("Entering '%s' (sub '%s')\n", strPathAbs.c_str(), strPathSub.c_str()));
1074
1075	GuestDirectoryOpenInfo dirOpenInfo;
1076	dirOpenInfo.mFilter = "";
1077	dirOpenInfo.mPath = strPathAbs;
1078	dirOpenInfo.mFlags = 0; /** @todo Handle flags? */
1079
1080	const ComObjPtr<GuestSession> &pSession = mTask.GetSession();
1081
1082	ComObjPtr <GuestDirectory> pDir;
1083	int rcGuest = VERR_IPE_UNINITIALIZED_STATUS;
1084	int rc = pSession->i_directoryOpen(dirOpenInfo, pDir, &rcGuest);
1085	if (RT_FAILURE(rc))
1086	{
1087	switch (rc)
1088	{
1089	case VERR_INVALID_PARAMETER:
1090	break;
1091
1092	case VERR_GSTCTL_GUEST_ERROR:
1093	break;
1094
1095	default:
1096	break;
1097	}
1098
1099	return rc;
1100	}
1101
1102	if (strPathSub.isNotEmpty())
1103	{
1104	GuestFsObjData fsObjData;
1105	fsObjData.mType = FsObjType_Directory;
1106
1107	rc = AddEntryFromGuest(strPathSub, fsObjData);
1108	}
1109
1110	if (RT_SUCCESS(rc))
1111	{
1112	ComObjPtr<GuestFsObjInfo> fsObjInfo;
1113	while (RT_SUCCESS(rc = pDir->i_read(fsObjInfo, &rcGuest)))
1114	{
1115	FsObjType_T enmObjType = FsObjType_Unknown; /* Shut up MSC. */
1116	HRESULT hr2 = fsObjInfo->COMGETTER(Type)(&enmObjType);
1117	AssertComRC(hr2);
1118
1119	com::Bstr bstrName;
1120	hr2 = fsObjInfo->COMGETTER(Name)(bstrName.asOutParam());
1121	AssertComRC(hr2);
1122
1123	Utf8Str strEntry = strPathSub + Utf8Str(bstrName);
1124
1125	LogFlowFunc(("Entry '%s'\n", strEntry.c_str()));
1126
1127	switch (enmObjType)
1128	{
1129	case FsObjType_Directory:
1130	{
1131	if ( bstrName.equals(".")
1132	\|\| bstrName.equals(".."))
1133	{
1134	break;
1135	}
1136
1137	if (!(mSourceSpec.Type.Dir.fRecursive))
1138	break;
1139
1140	rc = AddDirFromGuest(strPath, strEntry);
1141	break;
1142	}
1143
1144	case FsObjType_Symlink:
1145	{
1146	if (mSourceSpec.Type.Dir.fFollowSymlinks)
1147	{
1148	/** @todo Symlink handling from guest is not imlemented yet.
1149	* See IGuestSession::symlinkRead(). */
1150	LogRel2(("Guest Control: Warning: Symlink support on guest side not available, skipping \"%s\"",
1151	strEntry.c_str()));
1152	}
1153	break;
1154	}
1155
1156	case FsObjType_File:
1157	{
1158	rc = AddEntryFromGuest(strEntry, fsObjInfo->i_getData());
1159	break;
1160	}
1161
1162	default:
1163	break;
1164	}
1165	}
1166
1167	if (rc == VERR_NO_MORE_FILES) /* End of listing reached? */
1168	rc = VINF_SUCCESS;
1169	}
1170
1171	int rc2 = pDir->i_closeInternal(&rcGuest);
1172	if (RT_SUCCESS(rc))
1173	rc = rc2;
1174
1175	return rc;
1176	}
1177
1178	/**
1179	* Builds a host file list from a given path (and optional filter).
1180	*
1181	* @return VBox status code.
1182	* @param strPath Directory on the host to build list from.
1183	* @param strSubDir Current sub directory path; needed for recursion.
1184	* Set to an empty path.
1185	*/
1186	int FsList::AddDirFromHost(const Utf8Str &strPath, const Utf8Str &strSubDir)
1187	{
1188	Utf8Str strPathAbs = strPath;
1189	if ( !strPathAbs.endsWith("/")
1190	&& !strPathAbs.endsWith("\\"))
1191	strPathAbs += "/";
1192
1193	Utf8Str strPathSub = strSubDir;
1194	if ( strPathSub.isNotEmpty()
1195	&& !strPathSub.endsWith("/")
1196	&& !strPathSub.endsWith("\\"))
1197	strPathSub += "/";
1198
1199	strPathAbs += strPathSub;
1200
1201	LogFlowFunc(("Entering '%s' (sub '%s')\n", strPathAbs.c_str(), strPathSub.c_str()));
1202
1203	RTFSOBJINFO objInfo;
1204	int rc = RTPathQueryInfo(strPathAbs.c_str(), &objInfo, RTFSOBJATTRADD_NOTHING);
1205	if (RT_SUCCESS(rc))
1206	{
1207	if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode))
1208	{
1209	if (strPathSub.isNotEmpty())
1210	rc = AddEntryFromHost(strPathSub, &objInfo);
1211
1212	if (RT_SUCCESS(rc))
1213	{
1214	RTDIR hDir;
1215	rc = RTDirOpen(&hDir, strPathAbs.c_str());
1216	if (RT_SUCCESS(rc))
1217	{
1218	do
1219	{
1220	/* Retrieve the next directory entry. */
1221	RTDIRENTRYEX Entry;
1222	rc = RTDirReadEx(hDir, &Entry, NULL, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
1223	if (RT_FAILURE(rc))
1224	{
1225	if (rc == VERR_NO_MORE_FILES)
1226	rc = VINF_SUCCESS;
1227	break;
1228	}
1229
1230	Utf8Str strEntry = strPathSub + Utf8Str(Entry.szName);
1231
1232	LogFlowFunc(("Entry '%s'\n", strEntry.c_str()));
1233
1234	switch (Entry.Info.Attr.fMode & RTFS_TYPE_MASK)
1235	{
1236	case RTFS_TYPE_DIRECTORY:
1237	{
1238	/* Skip "." and ".." entries. */
1239	if (RTDirEntryExIsStdDotLink(&Entry))
1240	break;
1241
1242	if (!(mSourceSpec.Type.Dir.fRecursive))
1243	break;
1244
1245	rc = AddDirFromHost(strPath, strEntry);
1246	break;
1247	}
1248
1249	case RTFS_TYPE_FILE:
1250	{
1251	rc = AddEntryFromHost(strEntry, &Entry.Info);
1252	break;
1253	}
1254
1255	case RTFS_TYPE_SYMLINK:
1256	{
1257	if (mSourceSpec.Type.Dir.fFollowSymlinks)
1258	{
1259	Utf8Str strEntryAbs = strPathAbs + Utf8Str(Entry.szName);
1260
1261	char szPathReal[RTPATH_MAX];
1262	rc = RTPathReal(strEntryAbs.c_str(), szPathReal, sizeof(szPathReal));
1263	if (RT_SUCCESS(rc))
1264	{
1265	rc = RTPathQueryInfo(szPathReal, &objInfo, RTFSOBJATTRADD_NOTHING);
1266	if (RT_SUCCESS(rc))
1267	{
1268	LogFlowFunc(("Symlink '%s' -> '%s'\n", strEntryAbs.c_str(), szPathReal));
1269
1270	if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode))
1271	{
1272	LogFlowFunc(("Symlink to directory\n"));
1273	rc = AddDirFromHost(strPath, strEntry);
1274	}
1275	else if (RTFS_IS_FILE(objInfo.Attr.fMode))
1276	{
1277	LogFlowFunc(("Symlink to file\n"));
1278	rc = AddEntryFromHost(strEntry, &objInfo);
1279	}
1280	else
1281	rc = VERR_NOT_SUPPORTED;
1282	}
1283	else
1284	LogFlowFunc(("Unable to query symlink info for '%s', rc=%Rrc\n", szPathReal, rc));
1285	}
1286	else
1287	{
1288	LogFlowFunc(("Unable to resolve symlink for '%s', rc=%Rrc\n", strPathAbs.c_str(), rc));
1289	if (rc == VERR_FILE_NOT_FOUND) /* Broken symlink, skip. */
1290	rc = VINF_SUCCESS;
1291	}
1292	}
1293	break;
1294	}
1295
1296	default:
1297	break;
1298	}
1299
1300	} while (RT_SUCCESS(rc));
1301
1302	RTDirClose(hDir);
1303	}
1304	}
1305	}
1306	else if (RTFS_IS_FILE(objInfo.Attr.fMode))
1307	{
1308	rc = VERR_IS_A_FILE;
1309	}
1310	else if (RTFS_IS_SYMLINK(objInfo.Attr.fMode))
1311	{
1312	rc = VERR_IS_A_SYMLINK;
1313	}
1314	else
1315	rc = VERR_NOT_SUPPORTED;
1316	}
1317	else
1318	LogFlowFunc(("Unable to query '%s', rc=%Rrc\n", strPathAbs.c_str(), rc));
1319
1320	LogFlowFuncLeaveRC(rc);
1321	return rc;
1322	}
1323
1324	GuestSessionTaskOpen::GuestSessionTaskOpen(GuestSession *pSession, uint32_t uFlags, uint32_t uTimeoutMS)
1325	: GuestSessionTask(pSession)
1326	, mFlags(uFlags)
1327	, mTimeoutMS(uTimeoutMS)
1328	{
1329	m_strTaskName = "gctlSesOpen";
1330	}
1331
1332	GuestSessionTaskOpen::~GuestSessionTaskOpen(void)
1333	{
1334
1335	}
1336
1337	int GuestSessionTaskOpen::Run(void)
1338	{
1339	LogFlowThisFuncEnter();
1340
1341	AutoCaller autoCaller(mSession);
1342	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1343
1344	int vrc = mSession->i_startSession(NULL /pvrcGuest/);
1345	/* Nothing to do here anymore. */
1346
1347	LogFlowFuncLeaveRC(vrc);
1348	return vrc;
1349	}
1350
1351	GuestSessionCopyTask::GuestSessionCopyTask(GuestSession *pSession)
1352	: GuestSessionTask(pSession)
1353	{
1354	}
1355
1356	GuestSessionCopyTask::~GuestSessionCopyTask()
1357	{
1358	FsLists::iterator itList = mVecLists.begin();
1359	while (itList != mVecLists.end())
1360	{
1361	FsList pFsList = (itList);
1362	pFsList->Destroy();
1363	delete pFsList;
1364	mVecLists.erase(itList);
1365	itList = mVecLists.begin();
1366	}
1367
1368	Assert(mVecLists.empty());
1369	}
1370
1371	GuestSessionTaskCopyFrom::GuestSessionTaskCopyFrom(GuestSession *pSession, GuestSessionFsSourceSet const &vecSrc,
1372	const Utf8Str &strDest)
1373	: GuestSessionCopyTask(pSession)
1374	{
1375	m_strTaskName = "gctlCpyFrm";
1376
1377	mSources = vecSrc;
1378	mDest = strDest;
1379	}
1380
1381	GuestSessionTaskCopyFrom::~GuestSessionTaskCopyFrom(void)
1382	{
1383	}
1384
1385	HRESULT GuestSessionTaskCopyFrom::Init(const Utf8Str &strTaskDesc)
1386	{
1387	setTaskDesc(strTaskDesc);
1388
1389	/* Create the progress object. */
1390	ComObjPtr<Progress> pProgress;
1391	HRESULT hrc = pProgress.createObject();
1392	if (FAILED(hrc))
1393	return hrc;
1394
1395	mProgress = pProgress;
1396
1397	int vrc = VINF_SUCCESS;
1398
1399	ULONG cOperations = 0;
1400	Utf8Str strErrorInfo;
1401
1402	/**
1403	* Note: We need to build up the file/directory here instead of GuestSessionTaskCopyFrom::Run
1404	* because the caller expects a ready-for-operation progress object on return.
1405	* The progress object will have a variable operation count, based on the elements to
1406	* be processed.
1407	*/
1408
1409	if (mDest.isEmpty())
1410	{
1411	strErrorInfo = Utf8StrFmt(GuestSession::tr("Host destination must not be empty"));
1412	vrc = VERR_INVALID_PARAMETER;
1413	}
1414	else
1415	{
1416	GuestSessionFsSourceSet::iterator itSrc = mSources.begin();
1417	while (itSrc != mSources.end())
1418	{
1419	Utf8Str strSrc = itSrc->strSource;
1420	Utf8Str strDst = mDest;
1421
1422	bool fFollowSymlinks;
1423
1424	if (strSrc.isEmpty())
1425	{
1426	strErrorInfo = Utf8StrFmt(GuestSession::tr("Guest source entry must not be empty"));
1427	vrc = VERR_INVALID_PARAMETER;
1428	break;
1429	}
1430
1431	if (itSrc->enmType == FsObjType_Directory)
1432	{
1433	/* If the source does not end with a slash, copy over the entire directory
1434	* (and not just its contents). */
1435	/** @todo r=bird: Try get the path style stuff right and stop assuming all guest are windows guests. */
1436	if ( !strSrc.endsWith("/")
1437	&& !strSrc.endsWith("\\"))
1438	{
1439	if (!RTPATH_IS_SLASH(strDst[strDst.length() - 1]))
1440	strDst += "/";
1441
1442	strDst += Utf8Str(RTPathFilenameEx(strSrc.c_str(), mfPathStyle));
1443	}
1444
1445	fFollowSymlinks = itSrc->Type.Dir.fFollowSymlinks;
1446	}
1447	else
1448	{
1449	fFollowSymlinks = RT_BOOL(itSrc->Type.File.fCopyFlags & FileCopyFlag_FollowLinks);
1450	}
1451
1452	LogFlowFunc(("strSrc=%s, strDst=%s, fFollowSymlinks=%RTbool\n", strSrc.c_str(), strDst.c_str(), fFollowSymlinks));
1453
1454	GuestFsObjData srcObjData;
1455	int rcGuest = VERR_IPE_UNINITIALIZED_STATUS;
1456	vrc = mSession->i_fsQueryInfo(strSrc, fFollowSymlinks, srcObjData, &rcGuest);
1457	if (RT_FAILURE(vrc))
1458	{
1459	if (vrc == VERR_GSTCTL_GUEST_ERROR)
1460	strErrorInfo = GuestBase::getErrorAsString(GuestSession::tr("Guest file lookup failed"),
1461	GuestErrorInfo(GuestErrorInfo::Type_ToolStat, rcGuest, strSrc.c_str()));
1462	else
1463	strErrorInfo = Utf8StrFmt(GuestSession::tr("Guest file lookup for \"%s\" failed: %Rrc"),
1464	strSrc.c_str(), vrc);
1465	break;
1466	}
1467
1468	if (srcObjData.mType == FsObjType_Directory)
1469	{
1470	if (itSrc->enmType != FsObjType_Directory)
1471	{
1472	strErrorInfo = Utf8StrFmt(GuestSession::tr("Guest source is not a file: %s"), strSrc.c_str());
1473	vrc = VERR_NOT_A_FILE;
1474	break;
1475	}
1476	}
1477	else
1478	{
1479	if (itSrc->enmType != FsObjType_File)
1480	{
1481	strErrorInfo = Utf8StrFmt(GuestSession::tr("Guest source is not a directory: %s"), strSrc.c_str());
1482	vrc = VERR_NOT_A_DIRECTORY;
1483	break;
1484	}
1485	}
1486
1487	FsList *pFsList = NULL;
1488	try
1489	{
1490	pFsList = new FsList(*this);
1491	vrc = pFsList->Init(strSrc, strDst, *itSrc);
1492	if (RT_SUCCESS(vrc))
1493	{
1494	if (itSrc->enmType == FsObjType_Directory)
1495	vrc = pFsList->AddDirFromGuest(strSrc);
1496	else
1497	vrc = pFsList->AddEntryFromGuest(RTPathFilename(strSrc.c_str()), srcObjData);
1498	}
1499
1500	if (RT_FAILURE(vrc))
1501	{
1502	delete pFsList;
1503	strErrorInfo = Utf8StrFmt(GuestSession::tr("Error adding guest source '%s' to list: %Rrc"),
1504	strSrc.c_str(), vrc);
1505	break;
1506	}
1507
1508	mVecLists.push_back(pFsList);
1509	}
1510	catch (std::bad_alloc &)
1511	{
1512	vrc = VERR_NO_MEMORY;
1513	break;
1514	}
1515
1516	AssertPtr(pFsList);
1517	cOperations += (ULONG)pFsList->mVecEntries.size();
1518
1519	itSrc++;
1520	}
1521	}
1522
1523	if (cOperations) /* Use the first element as description (if available). */
1524	{
1525	Assert(mVecLists.size());
1526	Assert(mVecLists[0]->mVecEntries.size());
1527
1528	Utf8Str strFirstOp = mDest + mVecLists[0]->mVecEntries[0]->strPath;
1529	hrc = pProgress->init(static_cast<IGuestSession*>(mSession), Bstr(mDesc).raw(),
1530	TRUE /* aCancelable /, cOperations + 1 / Number of operations */, Bstr(strFirstOp).raw());
1531	}
1532	else /* If no operations have been defined, go with an "empty" progress object when will be used for error handling. */
1533	hrc = pProgress->init(static_cast<IGuestSession*>(mSession), Bstr(mDesc).raw(),
1534	TRUE /* aCancelable /, 1 / cOperations */, Bstr(mDesc).raw());
1535
1536	if (RT_FAILURE(vrc))
1537	{
1538	if (strErrorInfo.isEmpty())
1539	strErrorInfo = Utf8StrFmt(GuestSession::tr("Failed with %Rrc"), vrc);
1540	setProgressErrorMsg(VBOX_E_IPRT_ERROR, strErrorInfo);
1541	}
1542
1543	LogFlowFunc(("Returning %Rhrc (%Rrc)\n", hrc, vrc));
1544	return hrc;
1545	}
1546
1547	int GuestSessionTaskCopyFrom::Run(void)
1548	{
1549	LogFlowThisFuncEnter();
1550
1551	AutoCaller autoCaller(mSession);
1552	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1553
1554	int rc = VINF_SUCCESS;
1555
1556	FsLists::const_iterator itList = mVecLists.begin();
1557	while (itList != mVecLists.end())
1558	{
1559	FsList pList = itList;
1560	AssertPtr(pList);
1561
1562	const bool fCopyIntoExisting = pList->mSourceSpec.Type.Dir.fCopyFlags & DirectoryCopyFlag_CopyIntoExisting;
1563	const bool fFollowSymlinks = true; /** @todo */
1564	const uint32_t fDirMode = 0700; /** @todo Play safe by default; implement ACLs. */
1565	uint32_t fDirCreate = 0;
1566
1567	if (!fFollowSymlinks)
1568	fDirCreate \|= RTDIRCREATE_FLAGS_NO_SYMLINKS;
1569
1570	LogFlowFunc(("List: srcRootAbs=%s, dstRootAbs=%s\n", pList->mSrcRootAbs.c_str(), pList->mDstRootAbs.c_str()));
1571
1572	/* Create the root directory. */
1573	if ( pList->mSourceSpec.enmType == FsObjType_Directory
1574	&& pList->mSourceSpec.fDryRun == false)
1575	{
1576	rc = directoryCreateOnHost(pList->mDstRootAbs, fDirCreate, fDirMode, fCopyIntoExisting);
1577	if (RT_FAILURE(rc))
1578	break;
1579	}
1580
1581	FsEntries::const_iterator itEntry = pList->mVecEntries.begin();
1582	while (itEntry != pList->mVecEntries.end())
1583	{
1584	FsEntry pEntry = itEntry;
1585	AssertPtr(pEntry);
1586
1587	Utf8Str strSrcAbs = pList->mSrcRootAbs;
1588	Utf8Str strDstAbs = pList->mDstRootAbs;
1589	if (pList->mSourceSpec.enmType == FsObjType_Directory)
1590	{
1591	strSrcAbs += pEntry->strPath;
1592	strDstAbs += pEntry->strPath;
1593
1594	if (pList->mSourceSpec.enmPathStyle == PathStyle_DOS)
1595	strDstAbs.findReplace('\\', '/');
1596	}
1597
1598	mProgress->SetNextOperation(Bstr(strSrcAbs).raw(), 1);
1599
1600	switch (pEntry->fMode & RTFS_TYPE_MASK)
1601	{
1602	case RTFS_TYPE_DIRECTORY:
1603	LogFlowFunc(("Directory '%s': %s -> %s\n", pEntry->strPath.c_str(), strSrcAbs.c_str(), strDstAbs.c_str()));
1604	if (!pList->mSourceSpec.fDryRun)
1605	rc = directoryCreateOnHost(strDstAbs, fDirCreate, fDirMode, fCopyIntoExisting);
1606	break;
1607
1608	case RTFS_TYPE_FILE:
1609	LogFlowFunc(("File '%s': %s -> %s\n", pEntry->strPath.c_str(), strSrcAbs.c_str(), strDstAbs.c_str()));
1610	if (!pList->mSourceSpec.fDryRun)
1611	rc = fileCopyFromGuest(strSrcAbs, strDstAbs, FileCopyFlag_None);
1612	break;
1613
1614	default:
1615	LogFlowFunc(("Warning: Type %d for '%s' is not supported\n",
1616	pEntry->fMode & RTFS_TYPE_MASK, strSrcAbs.c_str()));
1617	break;
1618	}
1619
1620	if (RT_FAILURE(rc))
1621	break;
1622
1623	++itEntry;
1624	}
1625
1626	if (RT_FAILURE(rc))
1627	break;
1628
1629	++itList;
1630	}
1631
1632	if (RT_SUCCESS(rc))
1633	rc = setProgressSuccess();
1634
1635	LogFlowFuncLeaveRC(rc);
1636	return rc;
1637	}
1638
1639	GuestSessionTaskCopyTo::GuestSessionTaskCopyTo(GuestSession *pSession, GuestSessionFsSourceSet const &vecSrc,
1640	const Utf8Str &strDest)
1641	: GuestSessionCopyTask(pSession)
1642	{
1643	m_strTaskName = "gctlCpyTo";
1644
1645	mSources = vecSrc;
1646	mDest = strDest;
1647	}
1648
1649	GuestSessionTaskCopyTo::~GuestSessionTaskCopyTo(void)
1650	{
1651	}
1652
1653	HRESULT GuestSessionTaskCopyTo::Init(const Utf8Str &strTaskDesc)
1654	{
1655	LogFlowFuncEnter();
1656
1657	setTaskDesc(strTaskDesc);
1658
1659	/* Create the progress object. */
1660	ComObjPtr<Progress> pProgress;
1661	HRESULT hr = pProgress.createObject();
1662	if (FAILED(hr))
1663	return hr;
1664
1665	mProgress = pProgress;
1666
1667	int rc = VINF_SUCCESS;
1668
1669	ULONG cOperations = 0;
1670	Utf8Str strErrorInfo;
1671
1672	/**
1673	* Note: We need to build up the file/directory here instead of GuestSessionTaskCopyTo::Run
1674	* because the caller expects a ready-for-operation progress object on return.
1675	* The progress object will have a variable operation count, based on the elements to
1676	* be processed.
1677	*/
1678
1679	if (mDest.isEmpty())
1680	{
1681	strErrorInfo = Utf8StrFmt(GuestSession::tr("Guest destination must not be empty"));
1682	rc = VERR_INVALID_PARAMETER;
1683	}
1684	else
1685	{
1686	GuestSessionFsSourceSet::iterator itSrc = mSources.begin();
1687	while (itSrc != mSources.end())
1688	{
1689	Utf8Str strSrc = itSrc->strSource;
1690	Utf8Str strDst = mDest;
1691
1692	LogFlowFunc(("strSrc=%s, strDst=%s\n", strSrc.c_str(), strDst.c_str()));
1693
1694	if (strSrc.isEmpty())
1695	{
1696	strErrorInfo = Utf8StrFmt(GuestSession::tr("Host source entry must not be empty"));
1697	rc = VERR_INVALID_PARAMETER;
1698	break;
1699	}
1700
1701	RTFSOBJINFO srcFsObjInfo;
1702	rc = RTPathQueryInfo(strSrc.c_str(), &srcFsObjInfo, RTFSOBJATTRADD_NOTHING);
1703	if (RT_FAILURE(rc))
1704	{
1705	strErrorInfo = Utf8StrFmt(GuestSession::tr("No such host file/directory: %s"), strSrc.c_str());
1706	break;
1707	}
1708
1709	if (RTFS_IS_DIRECTORY(srcFsObjInfo.Attr.fMode))
1710	{
1711	if (itSrc->enmType != FsObjType_Directory)
1712	{
1713	strErrorInfo = Utf8StrFmt(GuestSession::tr("Host source is not a file: %s"), strSrc.c_str());
1714	rc = VERR_NOT_A_FILE;
1715	break;
1716	}
1717	}
1718	else
1719	{
1720	if (itSrc->enmType == FsObjType_Directory)
1721	{
1722	strErrorInfo = Utf8StrFmt(GuestSession::tr("Host source is not a directory: %s"), strSrc.c_str());
1723	rc = VERR_NOT_A_DIRECTORY;
1724	break;
1725	}
1726	}
1727
1728	FsList *pFsList = NULL;
1729	try
1730	{
1731	pFsList = new FsList(*this);
1732	rc = pFsList->Init(strSrc, strDst, *itSrc);
1733	if (RT_SUCCESS(rc))
1734	{
1735	if (itSrc->enmType == FsObjType_Directory)
1736	{
1737	rc = pFsList->AddDirFromHost(strSrc);
1738	}
1739	else
1740	rc = pFsList->AddEntryFromHost(RTPathFilename(strSrc.c_str()), &srcFsObjInfo);
1741	}
1742
1743	if (RT_FAILURE(rc))
1744	{
1745	delete pFsList;
1746	strErrorInfo = Utf8StrFmt(GuestSession::tr("Error adding host source '%s' to list: %Rrc"),
1747	strSrc.c_str(), rc);
1748	break;
1749	}
1750
1751	mVecLists.push_back(pFsList);
1752	}
1753	catch (std::bad_alloc &)
1754	{
1755	rc = VERR_NO_MEMORY;
1756	break;
1757	}
1758
1759	AssertPtr(pFsList);
1760	cOperations += (ULONG)pFsList->mVecEntries.size();
1761
1762	itSrc++;
1763	}
1764	}
1765
1766	if (cOperations) /* Use the first element as description (if available). */
1767	{
1768	Assert(mVecLists.size());
1769	Assert(mVecLists[0]->mVecEntries.size());
1770
1771	hr = pProgress->init(static_cast<IGuestSession*>(mSession), Bstr(mDesc).raw(),
1772	TRUE /* aCancelable /, cOperations + 1 / Number of operations */,
1773	Bstr(mDesc).raw());
1774	}
1775	else /* If no operations have been defined, go with an "empty" progress object when will be used for error handling. */
1776	hr = pProgress->init(static_cast<IGuestSession*>(mSession), Bstr(mDesc).raw(),
1777	TRUE /* aCancelable /, 1 / cOperations */, Bstr(mDesc).raw());
1778
1779	if (RT_FAILURE(rc))
1780	{
1781	if (strErrorInfo.isEmpty())
1782	strErrorInfo = Utf8StrFmt(GuestSession::tr("Failed with %Rrc"), rc);
1783	setProgressErrorMsg(VBOX_E_IPRT_ERROR, strErrorInfo);
1784	}
1785
1786	LogFlowFunc(("Returning %Rhrc (%Rrc)\n", hr, rc));
1787	return hr;
1788	}
1789
1790	int GuestSessionTaskCopyTo::Run(void)
1791	{
1792	LogFlowThisFuncEnter();
1793
1794	AutoCaller autoCaller(mSession);
1795	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1796
1797	int rc = VINF_SUCCESS;
1798
1799	FsLists::const_iterator itList = mVecLists.begin();
1800	while (itList != mVecLists.end())
1801	{
1802	FsList pList = itList;
1803	AssertPtr(pList);
1804
1805	Utf8Str strSrcRootAbs = pList->mSrcRootAbs;
1806	Utf8Str strDstRootAbs = pList->mDstRootAbs;
1807
1808	bool fCopyIntoExisting = false;
1809	bool fFollowSymlinks = false;
1810	uint32_t fDirMode = 0700; /** @todo Play safe by default; implement ACLs. */
1811
1812	GuestFsObjData dstObjData;
1813	int rcGuest;
1814	rc = mSession->i_fsQueryInfo(strDstRootAbs, pList->mSourceSpec.Type.Dir.fFollowSymlinks, dstObjData, &rcGuest);
1815	if (RT_FAILURE(rc))
1816	{
1817	if (rc == VERR_GSTCTL_GUEST_ERROR)
1818	{
1819	switch (rcGuest)
1820	{
1821	case VERR_PATH_NOT_FOUND:
1822	RT_FALL_THROUGH();
1823	case VERR_FILE_NOT_FOUND:
1824	/* We will deal with this down below. */
1825	rc = VINF_SUCCESS;
1826	break;
1827	default:
1828	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
1829	Utf8StrFmt(GuestSession::tr("Querying information on for '%s' failed: %Rrc"),
1830	strDstRootAbs.c_str(), rcGuest));
1831	break;
1832	}
1833	}
1834	else
1835	{
1836	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
1837	Utf8StrFmt(GuestSession::tr("Querying information on guest for '%s' failed: %Rrc"),
1838	strDstRootAbs.c_str(), rc));
1839	break;
1840	}
1841	}
1842
1843	LogFlowFunc(("List inital: rc=%Rrc, srcRootAbs=%s, dstRootAbs=%s\n",
1844	rc, strSrcRootAbs.c_str(), strDstRootAbs.c_str()));
1845
1846	/* Calculated file copy flags for the current source spec. */
1847	FileCopyFlag_T fFileCopyFlags = FileCopyFlag_None;
1848
1849	/* Create the root directory. */
1850	if (pList->mSourceSpec.enmType == FsObjType_Directory)
1851	{
1852	fCopyIntoExisting = RT_BOOL(pList->mSourceSpec.Type.Dir.fCopyFlags & DirectoryCopyFlag_CopyIntoExisting);
1853	fFollowSymlinks = pList->mSourceSpec.Type.Dir.fFollowSymlinks;
1854
1855	LogFlowFunc(("Directory: fDirCopyFlags=%#x, fCopyIntoExisting=%RTbool, fFollowSymlinks=%RTbool\n",
1856	pList->mSourceSpec.Type.Dir.fCopyFlags, fCopyIntoExisting, fFollowSymlinks));
1857
1858	/* If the directory on the guest already exists, append the name of the root source directory to it. */
1859	if (dstObjData.mType == FsObjType_Directory)
1860	{
1861	if (fCopyIntoExisting)
1862	{
1863	if ( !strDstRootAbs.endsWith("/")
1864	&& !strDstRootAbs.endsWith("\\"))
1865	strDstRootAbs += "/";
1866	strDstRootAbs += Utf8Str(RTPathFilenameEx(strSrcRootAbs.c_str(), mfPathStyle));
1867	}
1868	else
1869	{
1870	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
1871	Utf8StrFmt(GuestSession::tr("Guest directory \"%s\" already exists"),
1872	strDstRootAbs.c_str()));
1873	rc = VERR_ALREADY_EXISTS;
1874	}
1875	}
1876
1877	/* Make sure the destination root directory exists. */
1878	if ( RT_SUCCESS(rc)
1879	&& pList->mSourceSpec.fDryRun == false)
1880	{
1881	rc = directoryCreateOnGuest(strDstRootAbs, DirectoryCreateFlag_None, fDirMode,
1882	fFollowSymlinks, true /* fCanExist */);
1883	}
1884
1885	/* No tweaking of fFileCopyFlags needed here. */
1886	}
1887	else if (pList->mSourceSpec.enmType == FsObjType_File)
1888	{
1889	fCopyIntoExisting = !(pList->mSourceSpec.Type.File.fCopyFlags & FileCopyFlag_NoReplace);
1890	fFollowSymlinks = RT_BOOL(pList->mSourceSpec.Type.File.fCopyFlags & FileCopyFlag_FollowLinks);
1891
1892	LogFlowFunc(("File: fFileCopyFlags=%#x, fCopyIntoExisting=%RTbool, fFollowSymlinks=%RTbool\n",
1893	pList->mSourceSpec.Type.File.fCopyFlags, fCopyIntoExisting, fFollowSymlinks));
1894
1895	fFileCopyFlags = pList->mSourceSpec.Type.File.fCopyFlags; /* Just use the flags directly from the spec. */
1896	}
1897	else
1898	AssertFailedStmt(rc = VERR_NOT_SUPPORTED);
1899
1900	if (RT_FAILURE(rc))
1901	break;
1902
1903	LogFlowFunc(("List final: rc=%Rrc, srcRootAbs=%s, dstRootAbs=%s, fFileCopyFlags=%#x\n",
1904	rc, strSrcRootAbs.c_str(), strDstRootAbs.c_str(), fFileCopyFlags));
1905
1906	LogRel2(("Guest Control: Copying '%s' from host to '%s' on guest ...\n", strSrcRootAbs.c_str(), strDstRootAbs.c_str()));
1907
1908	FsEntries::const_iterator itEntry = pList->mVecEntries.begin();
1909	while ( RT_SUCCESS(rc)
1910	&& itEntry != pList->mVecEntries.end())
1911	{
1912	FsEntry pEntry = itEntry;
1913	AssertPtr(pEntry);
1914
1915	Utf8Str strSrcAbs = strSrcRootAbs;
1916	Utf8Str strDstAbs = strDstRootAbs;
1917
1918	if (pList->mSourceSpec.enmType == FsObjType_Directory)
1919	{
1920	if ( !strSrcAbs.endsWith("/")
1921	&& !strSrcAbs.endsWith("\\"))
1922	strSrcAbs += "/";
1923	strSrcAbs += pEntry->strPath;
1924	}
1925
1926	/** @todo Handle stuff like "C:" for destination, where the destination will be the CWD for drive C. */
1927	if (dstObjData.mType == FsObjType_Directory)
1928	{
1929	if ( !strDstAbs.endsWith("/")
1930	&& !strDstAbs.endsWith("\\"))
1931	strDstAbs += "/";
1932	strDstAbs += pEntry->strPath;
1933	}
1934
1935	mProgress->SetNextOperation(Bstr(strSrcAbs).raw(), 1);
1936
1937	LogFlowFunc(("strEntry='%s'\n", pEntry->strPath.c_str()));
1938	LogFlowFunc(("\tsrcAbs='%s'\n", strSrcAbs.c_str()));
1939	LogFlowFunc(("\tdstAbs='%s'\n", strDstAbs.c_str()));
1940
1941	switch (pEntry->fMode & RTFS_TYPE_MASK)
1942	{
1943	case RTFS_TYPE_DIRECTORY:
1944	{
1945	if (!pList->mSourceSpec.fDryRun)
1946	rc = directoryCreateOnGuest(strDstAbs, DirectoryCreateFlag_None, fDirMode,
1947	fFollowSymlinks, fCopyIntoExisting);
1948	break;
1949	}
1950
1951	case RTFS_TYPE_FILE:
1952	{
1953	if (!pList->mSourceSpec.fDryRun)
1954	rc = fileCopyToGuest(strSrcAbs, strDstAbs, fFileCopyFlags);
1955	break;
1956	}
1957
1958	default:
1959	LogRel2(("Guest Control: Warning: Type 0x%x for '%s' is not supported, skipping\n",
1960	pEntry->fMode & RTFS_TYPE_MASK, strSrcAbs.c_str()));
1961	break;
1962	}
1963
1964	if (RT_FAILURE(rc))
1965	break;
1966
1967	++itEntry;
1968	}
1969
1970	if (RT_FAILURE(rc))
1971	break;
1972
1973	++itList;
1974	}
1975
1976	if (RT_SUCCESS(rc))
1977	rc = setProgressSuccess();
1978
1979	LogFlowFuncLeaveRC(rc);
1980	return rc;
1981	}
1982
1983	GuestSessionTaskUpdateAdditions::GuestSessionTaskUpdateAdditions(GuestSession *pSession,
1984	const Utf8Str &strSource,
1985	const ProcessArguments &aArguments,
1986	uint32_t fFlags)
1987	: GuestSessionTask(pSession)
1988	{
1989	m_strTaskName = "gctlUpGA";
1990
1991	mSource = strSource;
1992	mArguments = aArguments;
1993	mFlags = fFlags;
1994	}
1995
1996	GuestSessionTaskUpdateAdditions::~GuestSessionTaskUpdateAdditions(void)
1997	{
1998
1999	}
2000
2001	int GuestSessionTaskUpdateAdditions::addProcessArguments(ProcessArguments &aArgumentsDest, const ProcessArguments &aArgumentsSource)
2002	{
2003	int rc = VINF_SUCCESS;
2004
2005	try
2006	{
2007	/* Filter out arguments which already are in the destination to
2008	* not end up having them specified twice. Not the fastest method on the
2009	* planet but does the job. */
2010	ProcessArguments::const_iterator itSource = aArgumentsSource.begin();
2011	while (itSource != aArgumentsSource.end())
2012	{
2013	bool fFound = false;
2014	ProcessArguments::iterator itDest = aArgumentsDest.begin();
2015	while (itDest != aArgumentsDest.end())
2016	{
2017	if ((itDest).equalsIgnoreCase((itSource)))
2018	{
2019	fFound = true;
2020	break;
2021	}
2022	++itDest;
2023	}
2024
2025	if (!fFound)
2026	aArgumentsDest.push_back((*itSource));
2027
2028	++itSource;
2029	}
2030	}
2031	catch(std::bad_alloc &)
2032	{
2033	return VERR_NO_MEMORY;
2034	}
2035
2036	return rc;
2037	}
2038
2039	int GuestSessionTaskUpdateAdditions::copyFileToGuest(GuestSession *pSession, RTVFS hVfsIso,
2040	Utf8Str const &strFileSrc, const Utf8Str &strFileDst,
2041	bool fOptional)
2042	{
2043	AssertPtrReturn(pSession, VERR_INVALID_POINTER);
2044	AssertReturn(hVfsIso != NIL_RTVFS, VERR_INVALID_POINTER);
2045
2046	RTVFSFILE hVfsFile = NIL_RTVFSFILE;
2047	int rc = RTVfsFileOpen(hVfsIso, strFileSrc.c_str(),
2048	RTFILE_O_OPEN \| RTFILE_O_READ \| RTFILE_O_DENY_WRITE, & hVfsFile);
2049	if (RT_SUCCESS(rc))
2050	{
2051	uint64_t cbSrcSize = 0;
2052	rc = RTVfsFileQuerySize(hVfsFile, &cbSrcSize);
2053	if (RT_SUCCESS(rc))
2054	{
2055	LogRel(("Copying Guest Additions installer file \"%s\" to \"%s\" on guest ...\n",
2056	strFileSrc.c_str(), strFileDst.c_str()));
2057
2058	GuestFileOpenInfo dstOpenInfo;
2059	dstOpenInfo.mFilename = strFileDst;
2060	dstOpenInfo.mOpenAction = FileOpenAction_CreateOrReplace;
2061	dstOpenInfo.mAccessMode = FileAccessMode_WriteOnly;
2062	dstOpenInfo.mSharingMode = FileSharingMode_All; /** @todo Use _Read when implemented. */
2063
2064	ComObjPtr<GuestFile> dstFile;
2065	int rcGuest = VERR_IPE_UNINITIALIZED_STATUS;
2066	rc = mSession->i_fileOpen(dstOpenInfo, dstFile, &rcGuest);
2067	if (RT_FAILURE(rc))
2068	{
2069	switch (rc)
2070	{
2071	case VERR_GSTCTL_GUEST_ERROR:
2072	setProgressErrorMsg(VBOX_E_IPRT_ERROR, GuestFile::i_guestErrorToString(rcGuest, strFileDst.c_str()));
2073	break;
2074
2075	default:
2076	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
2077	Utf8StrFmt(GuestSession::tr("Guest file \"%s\" could not be opened: %Rrc"),
2078	strFileDst.c_str(), rc));
2079	break;
2080	}
2081	}
2082	else
2083	{
2084	rc = fileCopyToGuestInner(strFileSrc, hVfsFile, strFileDst, dstFile,
2085	FileCopyFlag_None, 0 /cbOffset/, cbSrcSize);
2086
2087	int rc2 = dstFile->i_closeFile(&rcGuest);
2088	AssertRC(rc2);
2089	}
2090	}
2091
2092	RTVfsFileRelease(hVfsFile);
2093	if (RT_FAILURE(rc))
2094	return rc;
2095	}
2096	else
2097	{
2098	if (fOptional)
2099	return VINF_SUCCESS;
2100
2101	return rc;
2102	}
2103
2104	return rc;
2105	}
2106
2107	int GuestSessionTaskUpdateAdditions::runFileOnGuest(GuestSession *pSession, GuestProcessStartupInfo &procInfo)
2108	{
2109	AssertPtrReturn(pSession, VERR_INVALID_POINTER);
2110
2111	LogRel(("Running %s ...\n", procInfo.mName.c_str()));
2112
2113	GuestProcessTool procTool;
2114	int rcGuest = VERR_IPE_UNINITIALIZED_STATUS;
2115	int vrc = procTool.init(pSession, procInfo, false /* Async */, &rcGuest);
2116	if (RT_SUCCESS(vrc))
2117	{
2118	if (RT_SUCCESS(rcGuest))
2119	vrc = procTool.wait(GUESTPROCESSTOOL_WAIT_FLAG_NONE, &rcGuest);
2120	if (RT_SUCCESS(vrc))
2121	vrc = procTool.getTerminationStatus();
2122	}
2123
2124	if (RT_FAILURE(vrc))
2125	{
2126	switch (vrc)
2127	{
2128	case VERR_GSTCTL_PROCESS_EXIT_CODE:
2129	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
2130	Utf8StrFmt(GuestSession::tr("Running update file \"%s\" on guest failed: %Rrc"),
2131	procInfo.mExecutable.c_str(), procTool.getRc()));
2132	break;
2133
2134	case VERR_GSTCTL_GUEST_ERROR:
2135	setProgressErrorMsg(VBOX_E_IPRT_ERROR, GuestSession::tr("Running update file on guest failed"),
2136	GuestErrorInfo(GuestErrorInfo::Type_Process, rcGuest, procInfo.mExecutable.c_str()));
2137	break;
2138
2139	case VERR_INVALID_STATE: /** @todo Special guest control rc needed! */
2140	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
2141	Utf8StrFmt(GuestSession::tr("Update file \"%s\" reported invalid running state"),
2142	procInfo.mExecutable.c_str()));
2143	break;
2144
2145	default:
2146	setProgressErrorMsg(VBOX_E_IPRT_ERROR,
2147	Utf8StrFmt(GuestSession::tr("Error while running update file \"%s\" on guest: %Rrc"),
2148	procInfo.mExecutable.c_str(), vrc));
2149	break;
2150	}
2151	}
2152
2153	return vrc;
2154	}
2155
2156	int GuestSessionTaskUpdateAdditions::Run(void)
2157	{
2158	LogFlowThisFuncEnter();
2159
2160	ComObjPtr<GuestSession> pSession = mSession;
2161	Assert(!pSession.isNull());
2162
2163	AutoCaller autoCaller(pSession);
2164	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2165
2166	int rc = setProgress(10);
2167	if (RT_FAILURE(rc))
2168	return rc;
2169
2170	HRESULT hr = S_OK;
2171
2172	LogRel(("Automatic update of Guest Additions started, using \"%s\"\n", mSource.c_str()));
2173
2174	ComObjPtr<Guest> pGuest(mSession->i_getParent());
2175	#if 0
2176	/*
2177	* Wait for the guest being ready within 30 seconds.
2178	*/
2179	AdditionsRunLevelType_T addsRunLevel;
2180	uint64_t tsStart = RTTimeSystemMilliTS();
2181	while ( SUCCEEDED(hr = pGuest->COMGETTER(AdditionsRunLevel)(&addsRunLevel))
2182	&& ( addsRunLevel != AdditionsRunLevelType_Userland
2183	&& addsRunLevel != AdditionsRunLevelType_Desktop))
2184	{
2185	if ((RTTimeSystemMilliTS() - tsStart) > 30 * 1000)
2186	{
2187	rc = VERR_TIMEOUT;
2188	break;
2189	}
2190
2191	RTThreadSleep(100); /* Wait a bit. */
2192	}
2193
2194	if (FAILED(hr)) rc = VERR_TIMEOUT;
2195	if (rc == VERR_TIMEOUT)
2196	hr = setProgressErrorMsg(VBOX_E_NOT_SUPPORTED,
2197	Utf8StrFmt(GuestSession::tr("Guest Additions were not ready within time, giving up")));
2198	#else
2199	/*
2200	* For use with the GUI we don't want to wait, just return so that the manual .ISO mounting
2201	* can continue.
2202	*/
2203	AdditionsRunLevelType_T addsRunLevel;
2204	if ( FAILED(hr = pGuest->COMGETTER(AdditionsRunLevel)(&addsRunLevel))
2205	\|\| ( addsRunLevel != AdditionsRunLevelType_Userland
2206	&& addsRunLevel != AdditionsRunLevelType_Desktop))
2207	{
2208	if (addsRunLevel == AdditionsRunLevelType_System)
2209	hr = setProgressErrorMsg(VBOX_E_NOT_SUPPORTED,
2210	Utf8StrFmt(GuestSession::tr("Guest Additions are installed but not fully loaded yet, aborting automatic update")));
2211	else
2212	hr = setProgressErrorMsg(VBOX_E_NOT_SUPPORTED,
2213	Utf8StrFmt(GuestSession::tr("Guest Additions not installed or ready, aborting automatic update")));
2214	rc = VERR_NOT_SUPPORTED;
2215	}
2216	#endif
2217
2218	if (RT_SUCCESS(rc))
2219	{
2220	/*
2221	* Determine if we are able to update automatically. This only works
2222	* if there are recent Guest Additions installed already.
2223	*/
2224	Utf8Str strAddsVer;
2225	rc = getGuestProperty(pGuest, "/VirtualBox/GuestAdd/Version", strAddsVer);
2226	if ( RT_SUCCESS(rc)
2227	&& RTStrVersionCompare(strAddsVer.c_str(), "4.1") < 0)
2228	{
2229	hr = setProgressErrorMsg(VBOX_E_NOT_SUPPORTED,
2230	Utf8StrFmt(GuestSession::tr("Guest has too old Guest Additions (%s) installed for automatic updating, please update manually"),
2231	strAddsVer.c_str()));
2232	rc = VERR_NOT_SUPPORTED;
2233	}
2234	}
2235
2236	Utf8Str strOSVer;
2237	eOSType osType = eOSType_Unknown;
2238	if (RT_SUCCESS(rc))
2239	{
2240	/*
2241	* Determine guest OS type and the required installer image.
2242	*/
2243	Utf8Str strOSType;
2244	rc = getGuestProperty(pGuest, "/VirtualBox/GuestInfo/OS/Product", strOSType);
2245	if (RT_SUCCESS(rc))
2246	{
2247	if ( strOSType.contains("Microsoft", Utf8Str::CaseInsensitive)
2248	\|\| strOSType.contains("Windows", Utf8Str::CaseInsensitive))
2249	{
2250	osType = eOSType_Windows;
2251
2252	/*
2253	* Determine guest OS version.
2254	*/
2255	rc = getGuestProperty(pGuest, "/VirtualBox/GuestInfo/OS/Release", strOSVer);
2256	if (RT_FAILURE(rc))
2257	{
2258	hr = setProgressErrorMsg(VBOX_E_NOT_SUPPORTED,
2259	Utf8StrFmt(GuestSession::tr("Unable to detected guest OS version, please update manually")));
2260	rc = VERR_NOT_SUPPORTED;
2261	}
2262
2263	/* Because Windows 2000 + XP and is bitching with WHQL popups even if we have signed drivers we
2264	* can't do automated updates here. */
2265	/* Windows XP 64-bit (5.2) is a Windows 2003 Server actually, so skip this here. */
2266	if ( RT_SUCCESS(rc)
2267	&& RTStrVersionCompare(strOSVer.c_str(), "5.0") >= 0)
2268	{
2269	if ( strOSVer.startsWith("5.0") /* Exclude the build number. */
2270	\|\| strOSVer.startsWith("5.1") /* Exclude the build number. */)
2271	{
2272	/* If we don't have AdditionsUpdateFlag_WaitForUpdateStartOnly set we can't continue
2273	* because the Windows Guest Additions installer will fail because of WHQL popups. If the
2274	* flag is set this update routine ends successfully as soon as the installer was started
2275	* (and the user has to deal with it in the guest). */
2276	if (!(mFlags & AdditionsUpdateFlag_WaitForUpdateStartOnly))
2277	{
2278	hr = setProgressErrorMsg(VBOX_E_NOT_SUPPORTED,
2279	Utf8StrFmt(GuestSession::tr("Windows 2000 and XP are not supported for automatic updating due to WHQL interaction, please update manually")));
2280	rc = VERR_NOT_SUPPORTED;
2281	}
2282	}
2283	}
2284	else
2285	{
2286	hr = setProgressErrorMsg(VBOX_E_NOT_SUPPORTED,
2287	Utf8StrFmt(GuestSession::tr("%s (%s) not supported for automatic updating, please update manually"),
2288	strOSType.c_str(), strOSVer.c_str()));
2289	rc = VERR_NOT_SUPPORTED;
2290	}
2291	}
2292	else if (strOSType.contains("Solaris", Utf8Str::CaseInsensitive))
2293	{
2294	osType = eOSType_Solaris;
2295	}
2296	else /* Everything else hopefully means Linux :-). */
2297	osType = eOSType_Linux;
2298
2299	if ( RT_SUCCESS(rc)
2300	&& ( osType != eOSType_Windows
2301	&& osType != eOSType_Linux))
2302	/** @todo Support Solaris. */
2303	{
2304	hr = setProgressErrorMsg(VBOX_E_NOT_SUPPORTED,
2305	Utf8StrFmt(GuestSession::tr("Detected guest OS (%s) does not support automatic Guest Additions updating, please update manually"),
2306	strOSType.c_str()));
2307	rc = VERR_NOT_SUPPORTED;
2308	}
2309	}
2310	}
2311
2312	if (RT_SUCCESS(rc))
2313	{
2314	/*
2315	* Try to open the .ISO file to extract all needed files.
2316	*/
2317	RTVFSFILE hVfsFileIso;
2318	rc = RTVfsFileOpenNormal(mSource.c_str(), RTFILE_O_OPEN \| RTFILE_O_READ \| RTFILE_O_DENY_WRITE, &hVfsFileIso);
2319	if (RT_FAILURE(rc))
2320	{
2321	hr = setProgressErrorMsg(VBOX_E_IPRT_ERROR,
2322	Utf8StrFmt(GuestSession::tr("Unable to open Guest Additions .ISO file \"%s\": %Rrc"),
2323	mSource.c_str(), rc));
2324	}
2325	else
2326	{
2327	RTVFS hVfsIso;
2328	rc = RTFsIso9660VolOpen(hVfsFileIso, 0 /fFlags/, &hVfsIso, NULL);
2329	if (RT_FAILURE(rc))
2330	{
2331	hr = setProgressErrorMsg(VBOX_E_IPRT_ERROR,
2332	Utf8StrFmt(GuestSession::tr("Unable to open file as ISO 9660 file system volume: %Rrc"), rc));
2333	}
2334	else
2335	{
2336	Utf8Str strUpdateDir;
2337
2338	rc = setProgress(5);
2339	if (RT_SUCCESS(rc))
2340	{
2341	/* Try getting the installed Guest Additions version to know whether we
2342	* can install our temporary Guest Addition data into the original installation
2343	* directory.
2344	*
2345	* Because versions prior to 4.2 had bugs wrt spaces in paths we have to choose
2346	* a different location then.
2347	*/
2348	bool fUseInstallDir = false;
2349
2350	Utf8Str strAddsVer;
2351	rc = getGuestProperty(pGuest, "/VirtualBox/GuestAdd/Version", strAddsVer);
2352	if ( RT_SUCCESS(rc)
2353	&& RTStrVersionCompare(strAddsVer.c_str(), "4.2r80329") > 0)
2354	{
2355	fUseInstallDir = true;
2356	}
2357
2358	if (fUseInstallDir)
2359	{
2360	rc = getGuestProperty(pGuest, "/VirtualBox/GuestAdd/InstallDir", strUpdateDir);
2361	if (RT_SUCCESS(rc))
2362	{
2363	if (strUpdateDir.isNotEmpty())
2364	{
2365	if (osType == eOSType_Windows)
2366	{
2367	strUpdateDir.findReplace('/', '\\');
2368	strUpdateDir.append("\\Update\\");
2369	}
2370	else
2371	strUpdateDir.append("/update/");
2372	}
2373	/* else Older Guest Additions might not handle this property correctly. */
2374	}
2375	/* Ditto. */
2376	}
2377
2378	/** @todo Set fallback installation directory. Make this a lot smarter. Later. */
2379	if (strUpdateDir.isEmpty())
2380	{
2381	if (osType == eOSType_Windows)
2382	strUpdateDir = "C:\\Temp\\";
2383	else
2384	strUpdateDir = "/tmp/";
2385	}
2386	}
2387
2388	/* Create the installation directory. */
2389	int rcGuest = VERR_IPE_UNINITIALIZED_STATUS;
2390	if (RT_SUCCESS(rc))
2391	{
2392	LogRel(("Guest Additions update directory is: %s\n", strUpdateDir.c_str()));
2393
2394	rc = pSession->i_directoryCreate(strUpdateDir, 755 /* Mode */, DirectoryCreateFlag_Parents, &rcGuest);
2395	if (RT_FAILURE(rc))
2396	{
2397	switch (rc)
2398	{
2399	case VERR_GSTCTL_GUEST_ERROR:
2400	hr = setProgressErrorMsg(VBOX_E_IPRT_ERROR, GuestSession::tr("Creating installation directory on guest failed"),
2401	GuestErrorInfo(GuestErrorInfo::Type_Directory, rcGuest, strUpdateDir.c_str()));
2402	break;
2403
2404	default:
2405	hr = setProgressErrorMsg(VBOX_E_IPRT_ERROR,
2406	Utf8StrFmt(GuestSession::tr("Creating installation directory \"%s\" on guest failed: %Rrc"),
2407	strUpdateDir.c_str(), rc));
2408	break;
2409	}
2410	}
2411	}
2412
2413	if (RT_SUCCESS(rc))
2414	rc = setProgress(10);
2415
2416	if (RT_SUCCESS(rc))
2417	{
2418	/* Prepare the file(s) we want to copy over to the guest and
2419	* (maybe) want to run. */
2420	switch (osType)
2421	{
2422	case eOSType_Windows:
2423	{
2424	/* Do we need to install our certificates? We do this for W2K and up. */
2425	bool fInstallCert = false;
2426
2427	/* Only Windows 2000 and up need certificates to be installed. */
2428	if (RTStrVersionCompare(strOSVer.c_str(), "5.0") >= 0)
2429	{
2430	fInstallCert = true;
2431	LogRel(("Certificates for auto updating WHQL drivers will be installed\n"));
2432	}
2433	else
2434	LogRel(("Skipping installation of certificates for WHQL drivers\n"));
2435
2436	if (fInstallCert)
2437	{
2438	static struct { const char pszDst, pszIso; } const s_aCertFiles[] =
2439	{
2440	{ "vbox.cer", "/CERT/VBOX.CER" },
2441	{ "vbox-sha1.cer", "/CERT/VBOX-SHA1.CER" },
2442	{ "vbox-sha256.cer", "/CERT/VBOX-SHA256.CER" },
2443	{ "vbox-sha256-r3.cer", "/CERT/VBOX-SHA256-R3.CER" },
2444	{ "oracle-vbox.cer", "/CERT/ORACLE-VBOX.CER" },
2445	};
2446	uint32_t fCopyCertUtil = ISOFILE_FLAG_COPY_FROM_ISO;
2447	for (uint32_t i = 0; i < RT_ELEMENTS(s_aCertFiles); i++)
2448	{
2449	/* Skip if not present on the ISO. */
2450	RTFSOBJINFO ObjInfo;
2451	rc = RTVfsQueryPathInfo(hVfsIso, s_aCertFiles[i].pszIso, &ObjInfo, RTFSOBJATTRADD_NOTHING,
2452	RTPATH_F_ON_LINK);
2453	if (RT_FAILURE(rc))
2454	continue;
2455
2456	/* Copy the certificate certificate. */
2457	Utf8Str const strDstCert(strUpdateDir + s_aCertFiles[i].pszDst);
2458	mFiles.push_back(ISOFile(s_aCertFiles[i].pszIso,
2459	strDstCert,
2460	ISOFILE_FLAG_COPY_FROM_ISO \| ISOFILE_FLAG_OPTIONAL));
2461
2462	/* Out certificate installation utility. */
2463	/* First pass: Copy over the file (first time only) + execute it to remove any
2464	* existing VBox certificates. */
2465	GuestProcessStartupInfo siCertUtilRem;
2466	siCertUtilRem.mName = "VirtualBox Certificate Utility, removing old VirtualBox certificates";
2467	/* The argv[0] should contain full path to the executable module */
2468	siCertUtilRem.mArguments.push_back(strUpdateDir + "VBoxCertUtil.exe");
2469	siCertUtilRem.mArguments.push_back(Utf8Str("remove-trusted-publisher"));
2470	siCertUtilRem.mArguments.push_back(Utf8Str("--root")); /* Add root certificate as well. */
2471	siCertUtilRem.mArguments.push_back(strDstCert);
2472	siCertUtilRem.mArguments.push_back(strDstCert);
2473	mFiles.push_back(ISOFile("CERT/VBOXCERTUTIL.EXE",
2474	strUpdateDir + "VBoxCertUtil.exe",
2475	fCopyCertUtil \| ISOFILE_FLAG_EXECUTE \| ISOFILE_FLAG_OPTIONAL,
2476	siCertUtilRem));
2477	fCopyCertUtil = 0;
2478	/* Second pass: Only execute (but don't copy) again, this time installng the
2479	* recent certificates just copied over. */
2480	GuestProcessStartupInfo siCertUtilAdd;
2481	siCertUtilAdd.mName = "VirtualBox Certificate Utility, installing VirtualBox certificates";
2482	/* The argv[0] should contain full path to the executable module */
2483	siCertUtilAdd.mArguments.push_back(strUpdateDir + "VBoxCertUtil.exe");
2484	siCertUtilAdd.mArguments.push_back(Utf8Str("add-trusted-publisher"));
2485	siCertUtilAdd.mArguments.push_back(Utf8Str("--root")); /* Add root certificate as well. */
2486	siCertUtilAdd.mArguments.push_back(strDstCert);
2487	siCertUtilAdd.mArguments.push_back(strDstCert);
2488	mFiles.push_back(ISOFile("CERT/VBOXCERTUTIL.EXE",
2489	strUpdateDir + "VBoxCertUtil.exe",
2490	ISOFILE_FLAG_EXECUTE \| ISOFILE_FLAG_OPTIONAL,
2491	siCertUtilAdd));
2492	}
2493	}
2494	/* The installers in different flavors, as we don't know (and can't assume)
2495	* the guest's bitness. */
2496	mFiles.push_back(ISOFile("VBOXWINDOWSADDITIONS-X86.EXE",
2497	strUpdateDir + "VBoxWindowsAdditions-x86.exe",
2498	ISOFILE_FLAG_COPY_FROM_ISO));
2499	mFiles.push_back(ISOFile("VBOXWINDOWSADDITIONS-AMD64.EXE",
2500	strUpdateDir + "VBoxWindowsAdditions-amd64.exe",
2501	ISOFILE_FLAG_COPY_FROM_ISO));
2502	/* The stub loader which decides which flavor to run. */
2503	GuestProcessStartupInfo siInstaller;
2504	siInstaller.mName = "VirtualBox Windows Guest Additions Installer";
2505	/* Set a running timeout of 5 minutes -- the Windows Guest Additions
2506	* setup can take quite a while, so be on the safe side. */
2507	siInstaller.mTimeoutMS = 5 * 60 * 1000;
2508
2509	/* The argv[0] should contain full path to the executable module */
2510	siInstaller.mArguments.push_back(strUpdateDir + "VBoxWindowsAdditions.exe");
2511	siInstaller.mArguments.push_back(Utf8Str("/S")); /* We want to install in silent mode. */
2512	siInstaller.mArguments.push_back(Utf8Str("/l")); /* ... and logging enabled. */
2513	/* Don't quit VBoxService during upgrade because it still is used for this
2514	* piece of code we're in right now (that is, here!) ... */
2515	siInstaller.mArguments.push_back(Utf8Str("/no_vboxservice_exit"));
2516	/* Tell the installer to report its current installation status
2517	* using a running VBoxTray instance via balloon messages in the
2518	* Windows taskbar. */
2519	siInstaller.mArguments.push_back(Utf8Str("/post_installstatus"));
2520	/* Add optional installer command line arguments from the API to the
2521	* installer's startup info. */
2522	rc = addProcessArguments(siInstaller.mArguments, mArguments);
2523	AssertRC(rc);
2524	/* If the caller does not want to wait for out guest update process to end,
2525	* complete the progress object now so that the caller can do other work. */
2526	if (mFlags & AdditionsUpdateFlag_WaitForUpdateStartOnly)
2527	siInstaller.mFlags \|= ProcessCreateFlag_WaitForProcessStartOnly;
2528	mFiles.push_back(ISOFile("VBOXWINDOWSADDITIONS.EXE",
2529	strUpdateDir + "VBoxWindowsAdditions.exe",
2530	ISOFILE_FLAG_COPY_FROM_ISO \| ISOFILE_FLAG_EXECUTE, siInstaller));
2531	break;
2532	}
2533	case eOSType_Linux:
2534	{
2535	/* Copy over the installer to the guest but don't execute it.
2536	* Execution will be done by the shell instead. */
2537	mFiles.push_back(ISOFile("VBOXLINUXADDITIONS.RUN",
2538	strUpdateDir + "VBoxLinuxAdditions.run", ISOFILE_FLAG_COPY_FROM_ISO));
2539
2540	GuestProcessStartupInfo siInstaller;
2541	siInstaller.mName = "VirtualBox Linux Guest Additions Installer";
2542	/* Set a running timeout of 5 minutes -- compiling modules and stuff for the Linux Guest Additions
2543	* setup can take quite a while, so be on the safe side. */
2544	siInstaller.mTimeoutMS = 5 * 60 * 1000;
2545	/* The argv[0] should contain full path to the shell we're using to execute the installer. */
2546	siInstaller.mArguments.push_back("/bin/sh");
2547	/* Now add the stuff we need in order to execute the installer. */
2548	siInstaller.mArguments.push_back(strUpdateDir + "VBoxLinuxAdditions.run");
2549	/* Make sure to add "--nox11" to the makeself wrapper in order to not getting any blocking xterm
2550	* window spawned when doing any unattended Linux GA installations. */
2551	siInstaller.mArguments.push_back("--nox11");
2552	siInstaller.mArguments.push_back("--");
2553	/* Force the upgrade. Needed in order to skip the confirmation dialog about warning to upgrade. */
2554	siInstaller.mArguments.push_back("--force"); /** @todo We might want a dedicated "--silent" switch here. */
2555	/* If the caller does not want to wait for out guest update process to end,
2556	* complete the progress object now so that the caller can do other work. */
2557	if (mFlags & AdditionsUpdateFlag_WaitForUpdateStartOnly)
2558	siInstaller.mFlags \|= ProcessCreateFlag_WaitForProcessStartOnly;
2559	mFiles.push_back(ISOFile("/bin/sh" /* Source /, "/bin/sh" / Dest */,
2560	ISOFILE_FLAG_EXECUTE, siInstaller));
2561	break;
2562	}
2563	case eOSType_Solaris:
2564	/** @todo Add Solaris support. */
2565	break;
2566	default:
2567	AssertReleaseMsgFailed(("Unsupported guest type: %d\n", osType));
2568	break;
2569	}
2570	}
2571
2572	if (RT_SUCCESS(rc))
2573	{
2574	/* We want to spend 40% total for all copying operations. So roughly
2575	* calculate the specific percentage step of each copied file. */
2576	uint8_t uOffset = 20; /* Start at 20%. */
2577	uint8_t uStep = 40 / (uint8_t)mFiles.size(); Assert(mFiles.size() <= 10);
2578
2579	LogRel(("Copying over Guest Additions update files to the guest ...\n"));
2580
2581	std::vector<ISOFile>::const_iterator itFiles = mFiles.begin();
2582	while (itFiles != mFiles.end())
2583	{
2584	if (itFiles->fFlags & ISOFILE_FLAG_COPY_FROM_ISO)
2585	{
2586	bool fOptional = false;
2587	if (itFiles->fFlags & ISOFILE_FLAG_OPTIONAL)
2588	fOptional = true;
2589	rc = copyFileToGuest(pSession, hVfsIso, itFiles->strSource, itFiles->strDest, fOptional);
2590	if (RT_FAILURE(rc))
2591	{
2592	hr = setProgressErrorMsg(VBOX_E_IPRT_ERROR,
2593	Utf8StrFmt(GuestSession::tr("Error while copying file \"%s\" to \"%s\" on the guest: %Rrc"),
2594	itFiles->strSource.c_str(), itFiles->strDest.c_str(), rc));
2595	break;
2596	}
2597	}
2598
2599	rc = setProgress(uOffset);
2600	if (RT_FAILURE(rc))
2601	break;
2602	uOffset += uStep;
2603
2604	++itFiles;
2605	}
2606	}
2607
2608	/* Done copying, close .ISO file. */
2609	RTVfsRelease(hVfsIso);
2610
2611	if (RT_SUCCESS(rc))
2612	{
2613	/* We want to spend 35% total for all copying operations. So roughly
2614	* calculate the specific percentage step of each copied file. */
2615	uint8_t uOffset = 60; /* Start at 60%. */
2616	uint8_t uStep = 35 / (uint8_t)mFiles.size(); Assert(mFiles.size() <= 10);
2617
2618	LogRel(("Executing Guest Additions update files ...\n"));
2619
2620	std::vector<ISOFile>::iterator itFiles = mFiles.begin();
2621	while (itFiles != mFiles.end())
2622	{
2623	if (itFiles->fFlags & ISOFILE_FLAG_EXECUTE)
2624	{
2625	rc = runFileOnGuest(pSession, itFiles->mProcInfo);
2626	if (RT_FAILURE(rc))
2627	break;
2628	}
2629
2630	rc = setProgress(uOffset);
2631	if (RT_FAILURE(rc))
2632	break;
2633	uOffset += uStep;
2634
2635	++itFiles;
2636	}
2637	}
2638
2639	if (RT_SUCCESS(rc))
2640	{
2641	LogRel(("Automatic update of Guest Additions succeeded\n"));
2642	rc = setProgressSuccess();
2643	}
2644	}
2645
2646	RTVfsFileRelease(hVfsFileIso);
2647	}
2648	}
2649
2650	if (RT_FAILURE(rc))
2651	{
2652	if (rc == VERR_CANCELLED)
2653	{
2654	LogRel(("Automatic update of Guest Additions was canceled\n"));
2655
2656	hr = setProgressErrorMsg(VBOX_E_IPRT_ERROR,
2657	Utf8StrFmt(GuestSession::tr("Installation was canceled")));
2658	}
2659	else
2660	{
2661	Utf8Str strError = Utf8StrFmt("No further error information available (%Rrc)", rc);
2662	if (!mProgress.isNull()) /* Progress object is optional. */
2663	{
2664	#ifdef VBOX_STRICT
2665	/* If we forgot to set the progress object accordingly, let us know. */
2666	LONG rcProgress;
2667	AssertMsg( SUCCEEDED(mProgress->COMGETTER(ResultCode(&rcProgress)))
2668	&& FAILED(rcProgress), ("Task indicated an error (%Rrc), but progress did not indicate this (%Rhrc)\n",
2669	rc, rcProgress));
2670	#endif
2671	com::ProgressErrorInfo errorInfo(mProgress);
2672	if ( errorInfo.isFullAvailable()
2673	\|\| errorInfo.isBasicAvailable())
2674	{
2675	strError = errorInfo.getText();
2676	}
2677	}
2678
2679	LogRel(("Automatic update of Guest Additions failed: %s (%Rhrc)\n",
2680	strError.c_str(), hr));
2681	}
2682
2683	LogRel(("Please install Guest Additions manually\n"));
2684	}
2685
2686	/** @todo Clean up copied / left over installation files. */
2687
2688	LogFlowFuncLeaveRC(rc);
2689	return rc;
2690	}
2691

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

Download in other formats:

© 2023 Oracle
Contact – Privacy policy – Terms of Use