VFSExplorerImpl.cpp@ 56035

Last change on this file since 56035 was 55611, checked in by vboxsync, 10 years ago
Main: Merged the VFSFileType and FsObjType enums, keeping the 'FsObjType' name while picking the values and most of the names from VFSFileType (because they make more sense to someone who came up with the RTFS_TYPE_XXX and RTDIRENTRYTYPE_XXX bits). VFSFileType used 'SymLink', that's not 'Symlink' in keeping with the rest of the API and IPRT.
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 55611 2015-05-03 01:31:34Z 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, FsObjType_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	FsObjType_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	FsObjType_T VFSExplorer::i_iprtToVfsObjType(RTFMODE aType) const
261	{
262	int a = aType & RTFS_TYPE_MASK;
263	FsObjType_T t = FsObjType_Unknown;
264	if ((a & RTFS_TYPE_DIRECTORY) == RTFS_TYPE_DIRECTORY)
265	t = FsObjType_Directory;
266	else if ((a & RTFS_TYPE_FILE) == RTFS_TYPE_FILE)
267	t = FsObjType_File;
268	else if ((a & RTFS_TYPE_SYMLINK) == RTFS_TYPE_SYMLINK)
269	t = FsObjType_Symlink;
270	else if ((a & RTFS_TYPE_FIFO) == RTFS_TYPE_FIFO)
271	t = FsObjType_Fifo;
272	else if ((a & RTFS_TYPE_DEV_CHAR) == RTFS_TYPE_DEV_CHAR)
273	t = FsObjType_DevChar;
274	else if ((a & RTFS_TYPE_DEV_BLOCK) == RTFS_TYPE_DEV_BLOCK)
275	t = FsObjType_DevBlock;
276	else if ((a & RTFS_TYPE_SOCKET) == RTFS_TYPE_SOCKET)
277	t = FsObjType_Socket;
278	else if ((a & RTFS_TYPE_WHITEOUT) == RTFS_TYPE_WHITEOUT)
279	t = FsObjType_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_iprtToVfsObjType(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, FsObjType_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, FsObjType_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.size;
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@ 56035

Download in other formats: