VFSExplorerImpl.cpp@ 50874

Last change on this file since 50874 was 50874, checked in by vboxsync, 11 years ago
6813 src-all/ProgressImp.cpp + some formatting/line length sorting
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 18.9 KB

Line
1	/* $Id: VFSExplorerImpl.cpp 50874 2014-03-25 18:29:02Z vboxsync $ */
2	/** @file
3	*
4	* IVFSExplorer COM class implementations.
5	*/
6
7	/*
8	* Copyright (C) 2009-2013 Oracle Corporation
9	*
10	* This file is part of VirtualBox Open Source Edition (OSE), as
11	* available from http://www.virtualbox.org. This file is free software;
12	* you can redistribute it and/or modify it under the terms of the GNU
13	* General Public License (GPL) as published by the Free Software
14	* Foundation, in version 2 as it comes in the "COPYING" file of the
15	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
16	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
17	*/
18
19	#include <iprt/dir.h>
20	#include <iprt/path.h>
21	#include <iprt/file.h>
22	#include <iprt/s3.h>
23	#include <iprt/cpp/utils.h>
24
25	#include <VBox/com/array.h>
26
27	#include <VBox/param.h>
28	#include <VBox/version.h>
29
30	#include "VFSExplorerImpl.h"
31	#include "VirtualBoxImpl.h"
32	#include "ProgressImpl.h"
33
34	#include "AutoCaller.h"
35	#include "Logging.h"
36
37	#include <memory>
38
39	struct VFSExplorer::Data
40	{
41	struct DirEntry
42	{
43	DirEntry(Utf8Str strName, VFSFileType_T fileType, uint64_t cbSize, uint32_t fMode)
44	: name(strName)
45	, type(fileType)
46	, size(cbSize)
47	, mode(fMode) {}
48
49	Utf8Str name;
50	VFSFileType_T type;
51	uint64_t size;
52	uint32_t mode;
53	};
54
55	VFSType_T storageType;
56	Utf8Str strUsername;
57	Utf8Str strPassword;
58	Utf8Str strHostname;
59	Utf8Str strPath;
60	Utf8Str strBucket;
61	std::list<DirEntry> entryList;
62	};
63
64
65	VFSExplorer::VFSExplorer()
66	: mVirtualBox(NULL)
67	{
68	}
69
70	VFSExplorer::~VFSExplorer()
71	{
72	}
73
74
75	/**
76	* VFSExplorer COM initializer.
77	* @param
78	* @return
79	*/
80	HRESULT VFSExplorer::init(VFSType_T aType, Utf8Str aFilePath, Utf8Str aHostname, Utf8Str aUsername,
81	Utf8Str aPassword, VirtualBox *aVirtualBox)
82	{
83	/* Enclose the state transition NotReady->InInit->Ready */
84	AutoInitSpan autoInitSpan(this);
85	AssertReturn(autoInitSpan.isOk(), E_FAIL);
86
87	/* Weak reference to a VirtualBox object */
88	unconst(mVirtualBox) = aVirtualBox;
89
90	/* initialize data */
91	m = new Data;
92
93	m->storageType = aType;
94	m->strPath = aFilePath;
95	m->strHostname = aHostname;
96	m->strUsername = aUsername;
97	m->strPassword = aPassword;
98
99	if (m->storageType == VFSType_S3)
100	{
101	size_t bpos = aFilePath.find("/", 1);
102	if (bpos != Utf8Str::npos)
103	{
104	m->strBucket = aFilePath.substr(1, bpos - 1); /* The bucket without any slashes */
105	aFilePath = aFilePath.substr(bpos); /* The rest of the file path */
106	}
107	}
108
109	/* Confirm a successful initialization */
110	autoInitSpan.setSucceeded();
111
112	return S_OK;
113	}
114
115	/**
116	* VFSExplorer COM uninitializer.
117	* @return
118	*/
119	void VFSExplorer::uninit()
120	{
121	delete m;
122	m = NULL;
123	}
124
125	/**
126	* Public method implementation.
127	* @param
128	* @return
129	*/
130	HRESULT VFSExplorer::getPath(com::Utf8Str &aPath)
131	{
132	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
133
134	aPath = m->strPath;
135
136	return S_OK;
137	}
138
139
140	HRESULT VFSExplorer::getType(VFSType_T *aType)
141	{
142	if (!aType)
143	return E_POINTER;
144
145	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
146
147	*aType = m->storageType;
148
149	return S_OK;
150	}
151
152	struct VFSExplorer::TaskVFSExplorer
153	{
154	enum TaskType
155	{
156	Update,
157	Delete
158	};
159
160	TaskVFSExplorer(TaskType aTaskType, VFSExplorer aThat, Progress aProgress)
161	: taskType(aTaskType),
162	pVFSExplorer(aThat),
163	progress(aProgress),
164	rc(S_OK)
165	{}
166	~TaskVFSExplorer() {}
167
168	int startThread();
169	static int taskThread(RTTHREAD aThread, void *pvUser);
170	static int uploadProgress(unsigned uPercent, void *pvUser);
171
172	TaskType taskType;
173	VFSExplorer *pVFSExplorer;
174	ComObjPtr<Progress> progress;
175	HRESULT rc;
176
177	/* task data */
178	std::list<Utf8Str> filenames;
179	};
180
181	int VFSExplorer::TaskVFSExplorer::startThread()
182	{
183	int vrc = RTThreadCreate(NULL, VFSExplorer::TaskVFSExplorer::taskThread, this,
184	0, RTTHREADTYPE_MAIN_HEAVY_WORKER, 0,
185	"Explorer::Task");
186
187	if (RT_FAILURE(vrc))
188	return VFSExplorer::setErrorStatic(E_FAIL, Utf8StrFmt("Could not create taskThreadVFS (%Rrc)\n", vrc));
189
190	return vrc;
191	}
192
193	/* static */
194	DECLCALLBACK(int) VFSExplorer::TaskVFSExplorer::taskThread(RTTHREAD /* aThread /, void pvUser)
195	{
196	std::auto_ptr<TaskVFSExplorer> task(static_cast<TaskVFSExplorer*>(pvUser));
197	AssertReturn(task.get(), VERR_GENERAL_FAILURE);
198
199	VFSExplorer *pVFSExplorer = task->pVFSExplorer;
200
201	LogFlowFuncEnter();
202	LogFlowFunc(("VFSExplorer %p\n", pVFSExplorer));
203
204	HRESULT rc = S_OK;
205
206	switch(task->taskType)
207	{
208	case TaskVFSExplorer::Update:
209	{
210	if (pVFSExplorer->m->storageType == VFSType_File)
211	rc = pVFSExplorer->i_updateFS(task.get());
212	else if (pVFSExplorer->m->storageType == VFSType_S3)
213	#ifdef VBOX_WITH_S3
214	rc = pVFSExplorer->i_updateS3(task.get());
215	#else
216	rc = VERR_NOT_IMPLEMENTED;
217	#endif
218	break;
219	}
220	case TaskVFSExplorer::Delete:
221	{
222	if (pVFSExplorer->m->storageType == VFSType_File)
223	rc = pVFSExplorer->i_deleteFS(task.get());
224	else if (pVFSExplorer->m->storageType == VFSType_S3)
225	#ifdef VBOX_WITH_S3
226	rc = pVFSExplorer->i_deleteS3(task.get());
227	#else
228	rc = VERR_NOT_IMPLEMENTED;
229	#endif
230	break;
231	}
232	default:
233	AssertMsgFailed(("Invalid task type %u specified!\n", task->taskType));
234	break;
235	}
236
237	LogFlowFunc(("rc=%Rhrc\n", rc)); NOREF(rc);
238	LogFlowFuncLeave();
239
240	return VINF_SUCCESS;
241	}
242
243	/* static */
244	int VFSExplorer::TaskVFSExplorer::uploadProgress(unsigned uPercent, void *pvUser)
245	{
246	VFSExplorer::TaskVFSExplorer* pTask = (VFSExplorer::TaskVFSExplorer*)pvUser;
247
248	if (pTask &&
249	!pTask->progress.isNull())
250	{
251	BOOL fCanceled;
252	pTask->progress->COMGETTER(Canceled)(&fCanceled);
253	if (fCanceled)
254	return -1;
255	pTask->progress->SetCurrentOperationProgress(uPercent);
256	}
257	return VINF_SUCCESS;
258	}
259
260	VFSFileType_T VFSExplorer::i_RTToVFSFileType(int aType) const
261	{
262	int a = aType & RTFS_TYPE_MASK;
263	VFSFileType_T t = VFSFileType_Unknown;
264	if ((a & RTFS_TYPE_DIRECTORY) == RTFS_TYPE_DIRECTORY)
265	t = VFSFileType_Directory;
266	else if ((a & RTFS_TYPE_FILE) == RTFS_TYPE_FILE)
267	t = VFSFileType_File;
268	else if ((a & RTFS_TYPE_SYMLINK) == RTFS_TYPE_SYMLINK)
269	t = VFSFileType_SymLink;
270	else if ((a & RTFS_TYPE_FIFO) == RTFS_TYPE_FIFO)
271	t = VFSFileType_Fifo;
272	else if ((a & RTFS_TYPE_DEV_CHAR) == RTFS_TYPE_DEV_CHAR)
273	t = VFSFileType_DevChar;
274	else if ((a & RTFS_TYPE_DEV_BLOCK) == RTFS_TYPE_DEV_BLOCK)
275	t = VFSFileType_DevBlock;
276	else if ((a & RTFS_TYPE_SOCKET) == RTFS_TYPE_SOCKET)
277	t = VFSFileType_Socket;
278	else if ((a & RTFS_TYPE_WHITEOUT) == RTFS_TYPE_WHITEOUT)
279	t = VFSFileType_WhiteOut;
280
281	return t;
282	}
283
284	HRESULT VFSExplorer::i_updateFS(TaskVFSExplorer *aTask)
285	{
286	LogFlowFuncEnter();
287
288	AutoCaller autoCaller(this);
289	if (FAILED(autoCaller.rc())) return autoCaller.rc();
290
291	AutoWriteLock appLock(this COMMA_LOCKVAL_SRC_POS);
292
293	HRESULT rc = S_OK;
294
295	std::list<VFSExplorer::Data::DirEntry> fileList;
296	char *pszPath = NULL;
297	PRTDIR pDir = NULL;
298	try
299	{
300	int vrc = RTDirOpen(&pDir, m->strPath.c_str());
301	if (RT_FAILURE(vrc))
302	throw setError(VBOX_E_FILE_ERROR, tr ("Can't open directory '%s' (%Rrc)"), pszPath, vrc);
303
304	if (aTask->progress)
305	aTask->progress->SetCurrentOperationProgress(33);
306	RTDIRENTRYEX entry;
307	while (RT_SUCCESS(vrc))
308	{
309	vrc = RTDirReadEx(pDir, &entry, NULL, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
310	if (RT_SUCCESS(vrc))
311	{
312	Utf8Str name(entry.szName);
313	if ( name != "."
314	&& name != "..")
315	fileList.push_back(VFSExplorer::Data::DirEntry(name, i_RTToVFSFileType(entry.Info.Attr.fMode),
316	entry.Info.cbObject,
317	entry.Info.Attr.fMode & (RTFS_UNIX_IRWXU \| RTFS_UNIX_IRWXG \| RTFS_UNIX_IRWXO)));
318	}
319	}
320	if (aTask->progress)
321	aTask->progress->SetCurrentOperationProgress(66);
322	}
323	catch(HRESULT aRC)
324	{
325	rc = aRC;
326	}
327
328	/* Clean up */
329	if (pszPath)
330	RTStrFree(pszPath);
331	if (pDir)
332	RTDirClose(pDir);
333
334	if (aTask->progress)
335	aTask->progress->SetCurrentOperationProgress(99);
336
337	/* Assign the result on success (this clears the old list) */
338	if (rc == S_OK)
339	m->entryList.assign(fileList.begin(), fileList.end());
340
341	aTask->rc = rc;
342
343	if (!aTask->progress.isNull())
344	aTask->progress->i_notifyComplete(rc);
345
346	LogFlowFunc(("rc=%Rhrc\n", rc));
347	LogFlowFuncLeave();
348
349	return VINF_SUCCESS;
350	}
351
352	HRESULT VFSExplorer::i_deleteFS(TaskVFSExplorer *aTask)
353	{
354	LogFlowFuncEnter();
355
356	AutoCaller autoCaller(this);
357	if (FAILED(autoCaller.rc())) return autoCaller.rc();
358
359	AutoWriteLock appLock(this COMMA_LOCKVAL_SRC_POS);
360
361	HRESULT rc = S_OK;
362
363	float fPercentStep = 100.0f / aTask->filenames.size();
364	try
365	{
366	char szPath[RTPATH_MAX];
367	std::list<Utf8Str>::const_iterator it;
368	size_t i = 0;
369	for (it = aTask->filenames.begin();
370	it != aTask->filenames.end();
371	++it, ++i)
372	{
373	int vrc = RTPathJoin(szPath, sizeof(szPath), m->strPath.c_str(), (*it).c_str());
374	if (RT_FAILURE(vrc))
375	throw setError(E_FAIL, tr("Internal Error (%Rrc)"), vrc);
376	vrc = RTFileDelete(szPath);
377	if (RT_FAILURE(vrc))
378	throw setError(VBOX_E_FILE_ERROR, tr("Can't delete file '%s' (%Rrc)"), szPath, vrc);
379	if (aTask->progress)
380	aTask->progress->SetCurrentOperationProgress((ULONG)(fPercentStep * i));
381	}
382	}
383	catch(HRESULT aRC)
384	{
385	rc = aRC;
386	}
387
388	aTask->rc = rc;
389
390	if (!aTask->progress.isNull())
391	aTask->progress->i_notifyComplete(rc);
392
393	LogFlowFunc(("rc=%Rhrc\n", rc));
394	LogFlowFuncLeave();
395
396	return VINF_SUCCESS;
397	}
398
399	#ifdef VBOX_WITH_S3
400	HRESULT VFSExplorer::i_updateS3(TaskVFSExplorer *aTask)
401	{
402	LogFlowFuncEnter();
403
404	AutoCaller autoCaller(this);
405	if (FAILED(autoCaller.rc())) return autoCaller.rc();
406
407	AutoWriteLock appLock(this COMMA_LOCKVAL_SRC_POS);
408
409	HRESULT rc = S_OK;
410
411	RTS3 hS3 = NULL;
412	std::list<VFSExplorer::Data::DirEntry> fileList;
413	try
414	{
415	int vrc = RTS3Create(&hS3, m->strUsername.c_str(), m->strPassword.c_str(),
416	m->strHostname.c_str(), "virtualbox-agent/" VBOX_VERSION_STRING);
417	if (RT_FAILURE(vrc))
418	throw setError(E_FAIL, tr ("Can't open S3 storage service (%Rrc)"), vrc);
419
420	RTS3SetProgressCallback(hS3, VFSExplorer::TaskVFSExplorer::uploadProgress, &aTask);
421	/* Do we need the list of buckets or keys? */
422	if (m->strBucket.isEmpty())
423	{
424	PCRTS3BUCKETENTRY pBuckets = NULL;
425	vrc = RTS3GetBuckets(hS3, &pBuckets);
426	if (RT_FAILURE(vrc))
427	throw setError(E_FAIL, tr ("Can't get buckets (%Rrc)"), vrc);
428
429	PCRTS3BUCKETENTRY pTmpBuckets = pBuckets;
430	while (pBuckets)
431	{
432	/* Set always read/write permissions of the current logged in user. */
433	fileList.push_back(VFSExplorer::Data::DirEntry(pBuckets->pszName, VFSFileType_Directory,
434	0, RTFS_UNIX_IRUSR \| RTFS_UNIX_IWUSR));
435	pBuckets = pBuckets->pNext;
436	}
437	RTS3BucketsDestroy(pTmpBuckets);
438	}
439	else
440	{
441	PCRTS3KEYENTRY pKeys = NULL;
442	vrc = RTS3GetBucketKeys(hS3, m->strBucket.c_str(), &pKeys);
443	if (RT_FAILURE(vrc))
444	throw setError(E_FAIL, tr ("Can't get keys for bucket (%Rrc)"), vrc);
445
446	PCRTS3KEYENTRY pTmpKeys = pKeys;
447	while (pKeys)
448	{
449	Utf8Str name(pKeys->pszName);
450	/* Set always read/write permissions of the current logged in user. */
451	fileList.push_back(VFSExplorer::Data::DirEntry(pKeys->pszName, VFSFileType_File, pKeys->cbFile,
452	RTFS_UNIX_IRUSR \| RTFS_UNIX_IWUSR));
453	pKeys = pKeys->pNext;
454	}
455	RTS3KeysDestroy(pTmpKeys);
456	}
457	}
458	catch(HRESULT aRC)
459	{
460	rc = aRC;
461	}
462
463	if (hS3 != NULL)
464	RTS3Destroy(hS3);
465
466	/* Assign the result on success (this clears the old list) */
467	if (rc == S_OK)
468	m->entryList.assign(fileList.begin(), fileList.end());
469
470	aTask->rc = rc;
471
472	if (!aTask->progress.isNull())
473	aTask->progress->i_notifyComplete(rc);
474
475	LogFlowFunc(("rc=%Rhrc\n", rc));
476	LogFlowFuncLeave();
477
478	return VINF_SUCCESS;
479	}
480
481	HRESULT VFSExplorer::i_deleteS3(TaskVFSExplorer *aTask)
482	{
483	LogFlowFuncEnter();
484
485	AutoCaller autoCaller(this);
486	if (FAILED(autoCaller.rc())) return autoCaller.rc();
487
488	AutoWriteLock appLock(this COMMA_LOCKVAL_SRC_POS);
489
490	HRESULT rc = S_OK;
491
492	RTS3 hS3 = NULL;
493	float fPercentStep = 100.0f / aTask->filenames.size();
494	try
495	{
496	int vrc = RTS3Create(&hS3, m->strUsername.c_str(), m->strPassword.c_str(),
497	m->strHostname.c_str(), "virtualbox-agent/" VBOX_VERSION_STRING);
498	if (RT_FAILURE(vrc))
499	throw setError(E_FAIL, tr ("Can't open S3 storage service (%Rrc)"), vrc);
500
501	RTS3SetProgressCallback(hS3, VFSExplorer::TaskVFSExplorer::uploadProgress, &aTask);
502
503	std::list<Utf8Str>::const_iterator it;
504	size_t i = 0;
505	for (it = aTask->filenames.begin();
506	it != aTask->filenames.end();
507	++it, ++i)
508	{
509	vrc = RTS3DeleteKey(hS3, m->strBucket.c_str(), (*it).c_str());
510	if (RT_FAILURE(vrc))
511	throw setError(VBOX_E_FILE_ERROR, tr ("Can't delete file '%s' (%Rrc)"), (*it).c_str(), vrc);
512	if (aTask->progress)
513	aTask->progress->SetCurrentOperationProgress((ULONG)(fPercentStep * i));
514	}
515	}
516	catch(HRESULT aRC)
517	{
518	rc = aRC;
519	}
520
521	aTask->rc = rc;
522
523	if (hS3 != NULL)
524	RTS3Destroy(hS3);
525
526	if (!aTask->progress.isNull())
527	aTask->progress->i_notifyComplete(rc);
528
529	LogFlowFunc(("rc=%Rhrc\n", rc));
530	LogFlowFuncLeave();
531
532	return VINF_SUCCESS;
533	}
534	#endif /* VBOX_WITH_S3 */
535
536	HRESULT VFSExplorer::update(ComPtr<IProgress> &aProgress)
537	{
538	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
539
540	HRESULT rc = S_OK;
541
542	ComObjPtr<Progress> progress;
543	try
544	{
545	Bstr progressDesc = BstrFmt(tr("Update directory info for '%s'"),
546	m->strPath.c_str());
547	/* Create the progress object */
548	progress.createObject();
549
550	rc = progress->init(mVirtualBox,
551	static_cast<IVFSExplorer*>(this),
552	progressDesc.raw(),
553	TRUE /* aCancelable */);
554	if (FAILED(rc)) throw rc;
555
556	/* Initialize our worker task */
557	std::auto_ptr<TaskVFSExplorer> task(new TaskVFSExplorer(TaskVFSExplorer::Update, this, progress));
558
559	rc = task->startThread();
560	if (FAILED(rc)) throw rc;
561
562	/* Don't destruct on success */
563	task.release();
564	}
565	catch (HRESULT aRC)
566	{
567	rc = aRC;
568	}
569
570	if (SUCCEEDED(rc))
571	/* Return progress to the caller */
572	progress.queryInterfaceTo(aProgress.asOutParam());
573
574	return rc;
575	}
576
577	HRESULT VFSExplorer::cd(const com::Utf8Str &aDir, ComPtr<IProgress> &aProgress)
578	{
579	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
580	m->strPath = aDir;
581	return update(aProgress);
582	}
583
584	HRESULT VFSExplorer::cdUp(ComPtr<IProgress> &aProgress)
585	{
586	Utf8Str strUpPath;
587	{
588	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
589	/* Remove lowest dir entry in a platform neutral way. */
590	char *pszNewPath = RTStrDup(m->strPath.c_str());
591	RTPathStripTrailingSlash(pszNewPath);
592	RTPathStripFilename(pszNewPath);
593	strUpPath = pszNewPath;
594	RTStrFree(pszNewPath);
595	}
596
597	return cd(strUpPath, aProgress);
598	}
599
600	HRESULT VFSExplorer::entryList(std::vector<com::Utf8Str> &aNames,
601	std::vector<ULONG> &aTypes,
602	std::vector<LONG64> &aSizes,
603	std::vector<ULONG> &aModes)
604	{
605	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
606	aNames.resize(m->entryList.size());
607	aTypes.resize(m->entryList.size());
608	aSizes.resize(m->entryList.size());
609	aModes.resize(m->entryList.size());
610
611	std::list<VFSExplorer::Data::DirEntry>::const_iterator it;
612	size_t i = 0;
613	for (it = m->entryList.begin();
614	it != m->entryList.end();
615	++it, ++i)
616	{
617	const VFSExplorer::Data::DirEntry &entry = (*it);
618	aNames[i] = entry.name;
619	aTypes[i] = entry.type;
620	aSizes[i] = entry.type;
621	aModes[i] = entry.mode;
622	}
623
624	return S_OK;
625	}
626
627	HRESULT VFSExplorer::exists(const std::vector<com::Utf8Str> &aNames,
628	std::vector<com::Utf8Str> &aExists)
629	{
630
631	AutoCaller autoCaller(this);
632	if (FAILED(autoCaller.rc())) return autoCaller.rc();
633
634	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
635	aExists.resize(0);
636	for (size_t i=0; i < aNames.size(); ++i)
637	{
638	std::list<VFSExplorer::Data::DirEntry>::const_iterator it;
639	for (it = m->entryList.begin();
640	it != m->entryList.end();
641	++it)
642	{
643	const VFSExplorer::Data::DirEntry &entry = (*it);
644	if (entry.name == RTPathFilename(aNames[i].c_str()))
645	aExists.push_back(aNames[i]);
646	}
647	}
648
649	return S_OK;
650	}
651
652	HRESULT VFSExplorer::remove(const std::vector<com::Utf8Str> &aNames,
653	ComPtr<IProgress> &aProgress)
654	{
655	AutoCaller autoCaller(this);
656	if (FAILED(autoCaller.rc())) return autoCaller.rc();
657
658	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
659
660	HRESULT rc = S_OK;
661
662	ComObjPtr<Progress> progress;
663	try
664	{
665	/* Create the progress object */
666	progress.createObject();
667
668	rc = progress->init(mVirtualBox, static_cast<IVFSExplorer*>(this),
669	Bstr(tr("Delete files")).raw(),
670	TRUE /* aCancelable */);
671	if (FAILED(rc)) throw rc;
672
673	/* Initialize our worker task */
674	std::auto_ptr<TaskVFSExplorer> task(new TaskVFSExplorer(TaskVFSExplorer::Delete, this, progress));
675
676	/* Add all filenames to delete as task data */
677	for (size_t i = 0; i < aNames.size(); ++i)
678	task->filenames.push_back(aNames[i]);
679
680	rc = task->startThread();
681	if (FAILED(rc)) throw rc;
682
683	/* Don't destruct on success */
684	task.release();
685	}
686	catch (HRESULT aRC)
687	{
688	rc = aRC;
689	}
690
691	if (SUCCEEDED(rc))
692	/* Return progress to the caller */
693	progress.queryInterfaceTo(aProgress.asOutParam());
694
695	return rc;
696	}
697

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

source: vbox/trunk/src/VBox/Main/src-server/VFSExplorerImpl.cpp@ 50874

Download in other formats: