GuestFileImpl.cpp@ 73003

Last change on this file since 73003 was 73003, checked in by vboxsync, 6 years ago
Main: Use setErrorBoth when we've got a VBox status code handy. (The COM status codes aren't too specfic and this may help us decode error messages and provide an alternative to strstr for API clients. setErrorBoth isn't new, btw.)
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 42.5 KB

Line
1	/* $Id: GuestFileImpl.cpp 73003 2018-07-09 11:09:32Z vboxsync $ */
2	/** @file
3	* VirtualBox Main - Guest file handling.
4	*/
5
6	/*
7	* Copyright (C) 2012-2018 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_GUESTFILE
23	#include "LoggingNew.h"
24
25	#ifndef VBOX_WITH_GUEST_CONTROL
26	# error "VBOX_WITH_GUEST_CONTROL must defined in this file"
27	#endif
28	#include "GuestFileImpl.h"
29	#include "GuestSessionImpl.h"
30	#include "GuestCtrlImplPrivate.h"
31	#include "ConsoleImpl.h"
32	#include "VirtualBoxErrorInfoImpl.h"
33
34	#include "Global.h"
35	#include "AutoCaller.h"
36	#include "VBoxEvents.h"
37
38	#include <iprt/cpp/utils.h> /* For unconst(). */
39	#include <iprt/file.h>
40
41	#include <VBox/com/array.h>
42	#include <VBox/com/listeners.h>
43
44
45	/**
46	* Internal listener class to serve events in an
47	* active manner, e.g. without polling delays.
48	*/
49	class GuestFileListener
50	{
51	public:
52
53	GuestFileListener(void)
54	{
55	}
56
57	virtual ~GuestFileListener()
58	{
59	}
60
61	HRESULT init(GuestFile *pFile)
62	{
63	AssertPtrReturn(pFile, E_POINTER);
64	mFile = pFile;
65	return S_OK;
66	}
67
68	void uninit(void)
69	{
70	mFile = NULL;
71	}
72
73	STDMETHOD(HandleEvent)(VBoxEventType_T aType, IEvent *aEvent)
74	{
75	switch (aType)
76	{
77	case VBoxEventType_OnGuestFileStateChanged:
78	case VBoxEventType_OnGuestFileOffsetChanged:
79	case VBoxEventType_OnGuestFileRead:
80	case VBoxEventType_OnGuestFileWrite:
81	{
82	AssertPtrReturn(mFile, E_POINTER);
83	int rc2 = mFile->signalWaitEvent(aType, aEvent);
84	NOREF(rc2);
85	#ifdef DEBUG_andy
86	LogFlowFunc(("Signalling events of type=%RU32, file=%p resulted in rc=%Rrc\n",
87	aType, mFile, rc2));
88	#endif
89	break;
90	}
91
92	default:
93	AssertMsgFailed(("Unhandled event %RU32\n", aType));
94	break;
95	}
96
97	return S_OK;
98	}
99
100	private:
101
102	GuestFile *mFile;
103	};
104	typedef ListenerImpl<GuestFileListener, GuestFile*> GuestFileListenerImpl;
105
106	VBOX_LISTENER_DECLARE(GuestFileListenerImpl)
107
108	// constructor / destructor
109	/////////////////////////////////////////////////////////////////////////////
110
111	DEFINE_EMPTY_CTOR_DTOR(GuestFile)
112
113	HRESULT GuestFile::FinalConstruct(void)
114	{
115	LogFlowThisFuncEnter();
116	return BaseFinalConstruct();
117	}
118
119	void GuestFile::FinalRelease(void)
120	{
121	LogFlowThisFuncEnter();
122	uninit();
123	BaseFinalRelease();
124	LogFlowThisFuncLeave();
125	}
126
127	// public initializer/uninitializer for internal purposes only
128	/////////////////////////////////////////////////////////////////////////////
129
130	/**
131	* Initializes a file object but does not open the file on the guest
132	* yet. This is done in the dedidcated openFile call.
133	*
134	* @return IPRT status code.
135	* @param pConsole Pointer to console object.
136	* @param pSession Pointer to session object.
137	* @param aObjectID The object's ID.
138	* @param openInfo File opening information.
139	*/
140	int GuestFile::init(Console pConsole, GuestSession pSession,
141	ULONG aObjectID, const GuestFileOpenInfo &openInfo)
142	{
143	LogFlowThisFunc(("pConsole=%p, pSession=%p, aObjectID=%RU32, strPath=%s\n",
144	pConsole, pSession, aObjectID, openInfo.mFileName.c_str()));
145
146	AssertPtrReturn(pConsole, VERR_INVALID_POINTER);
147	AssertPtrReturn(pSession, VERR_INVALID_POINTER);
148
149	/* Enclose the state transition NotReady->InInit->Ready. */
150	AutoInitSpan autoInitSpan(this);
151	AssertReturn(autoInitSpan.isOk(), VERR_OBJECT_DESTROYED);
152
153	int vrc = bindToSession(pConsole, pSession, aObjectID);
154	if (RT_SUCCESS(vrc))
155	{
156	mSession = pSession;
157
158	mData.mInitialSize = 0;
159	mData.mStatus = FileStatus_Undefined;
160	mData.mOpenInfo = openInfo;
161
162	unconst(mEventSource).createObject();
163	HRESULT hr = mEventSource->init();
164	if (FAILED(hr))
165	vrc = VERR_COM_UNEXPECTED;
166	}
167
168	if (RT_SUCCESS(vrc))
169	{
170	try
171	{
172	GuestFileListener *pListener = new GuestFileListener();
173	ComObjPtr<GuestFileListenerImpl> thisListener;
174	HRESULT hr = thisListener.createObject();
175	if (SUCCEEDED(hr))
176	hr = thisListener->init(pListener, this);
177
178	if (SUCCEEDED(hr))
179	{
180	com::SafeArray <VBoxEventType_T> eventTypes;
181	eventTypes.push_back(VBoxEventType_OnGuestFileStateChanged);
182	eventTypes.push_back(VBoxEventType_OnGuestFileOffsetChanged);
183	eventTypes.push_back(VBoxEventType_OnGuestFileRead);
184	eventTypes.push_back(VBoxEventType_OnGuestFileWrite);
185	hr = mEventSource->RegisterListener(thisListener,
186	ComSafeArrayAsInParam(eventTypes),
187	TRUE /* Active listener */);
188	if (SUCCEEDED(hr))
189	{
190	vrc = baseInit();
191	if (RT_SUCCESS(vrc))
192	{
193	mLocalListener = thisListener;
194	}
195	}
196	else
197	vrc = VERR_COM_UNEXPECTED;
198	}
199	else
200	vrc = VERR_COM_UNEXPECTED;
201	}
202	catch(std::bad_alloc &)
203	{
204	vrc = VERR_NO_MEMORY;
205	}
206	}
207
208	if (RT_SUCCESS(vrc))
209	{
210	/* Confirm a successful initialization when it's the case. */
211	autoInitSpan.setSucceeded();
212	}
213	else
214	autoInitSpan.setFailed();
215
216	LogFlowFuncLeaveRC(vrc);
217	return vrc;
218	}
219
220	/**
221	* Uninitializes the instance.
222	* Called from FinalRelease().
223	*/
224	void GuestFile::uninit(void)
225	{
226	/* Enclose the state transition Ready->InUninit->NotReady. */
227	AutoUninitSpan autoUninitSpan(this);
228	if (autoUninitSpan.uninitDone())
229	return;
230
231	LogFlowThisFuncEnter();
232
233	baseUninit();
234	LogFlowThisFuncLeave();
235	}
236
237	// implementation of public getters/setters for attributes
238	/////////////////////////////////////////////////////////////////////////////
239
240	HRESULT GuestFile::getCreationMode(ULONG *aCreationMode)
241	{
242	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
243
244	*aCreationMode = mData.mOpenInfo.mCreationMode;
245
246	return S_OK;
247	}
248
249	HRESULT GuestFile::getOpenAction(FileOpenAction_T *aOpenAction)
250	{
251	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
252
253	*aOpenAction = mData.mOpenInfo.mOpenAction;
254
255	return S_OK;
256	}
257
258	HRESULT GuestFile::getEventSource(ComPtr<IEventSource> &aEventSource)
259	{
260	/* No need to lock - lifetime constant. */
261	mEventSource.queryInterfaceTo(aEventSource.asOutParam());
262
263	return S_OK;
264	}
265
266	HRESULT GuestFile::getFileName(com::Utf8Str &aFileName)
267	{
268	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
269
270	aFileName = mData.mOpenInfo.mFileName;
271
272	return S_OK;
273	}
274
275	HRESULT GuestFile::getId(ULONG *aId)
276	{
277	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
278
279	*aId = mObjectID;
280
281	return S_OK;
282	}
283
284	HRESULT GuestFile::getInitialSize(LONG64 *aInitialSize)
285	{
286	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
287
288	*aInitialSize = mData.mInitialSize;
289
290	return S_OK;
291	}
292
293	HRESULT GuestFile::getOffset(LONG64 *aOffset)
294	{
295	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
296
297	*aOffset = mData.mOffCurrent;
298
299	return S_OK;
300	}
301
302	HRESULT GuestFile::getAccessMode(FileAccessMode_T *aAccessMode)
303	{
304	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
305
306	*aAccessMode = mData.mOpenInfo.mAccessMode;
307
308	return S_OK;
309	}
310
311	HRESULT GuestFile::getStatus(FileStatus_T *aStatus)
312	{
313	LogFlowThisFuncEnter();
314
315	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
316
317	*aStatus = mData.mStatus;
318
319	return S_OK;
320	}
321
322	// private methods
323	/////////////////////////////////////////////////////////////////////////////
324
325	int GuestFile::i_callbackDispatcher(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb)
326	{
327	AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
328	AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER);
329
330	LogFlowThisFunc(("strName=%s, uContextID=%RU32, uFunction=%RU32, pSvcCb=%p\n",
331	mData.mOpenInfo.mFileName.c_str(), pCbCtx->uContextID, pCbCtx->uFunction, pSvcCb));
332
333	int vrc;
334	switch (pCbCtx->uFunction)
335	{
336	case GUEST_DISCONNECTED:
337	vrc = i_onGuestDisconnected(pCbCtx, pSvcCb);
338	break;
339
340	case GUEST_FILE_NOTIFY:
341	vrc = i_onFileNotify(pCbCtx, pSvcCb);
342	break;
343
344	default:
345	/* Silently ignore not implemented functions. */
346	vrc = VERR_NOT_SUPPORTED;
347	break;
348	}
349
350	#ifdef DEBUG
351	LogFlowFuncLeaveRC(vrc);
352	#endif
353	return vrc;
354	}
355
356	int GuestFile::i_closeFile(int *prcGuest)
357	{
358	LogFlowThisFunc(("strFile=%s\n", mData.mOpenInfo.mFileName.c_str()));
359
360	int vrc;
361
362	GuestWaitEvent *pEvent = NULL;
363	GuestEventTypes eventTypes;
364	try
365	{
366	eventTypes.push_back(VBoxEventType_OnGuestFileStateChanged);
367
368	vrc = registerWaitEvent(eventTypes, &pEvent);
369	}
370	catch (std::bad_alloc)
371	{
372	vrc = VERR_NO_MEMORY;
373	}
374
375	if (RT_FAILURE(vrc))
376	return vrc;
377
378	/* Prepare HGCM call. */
379	VBOXHGCMSVCPARM paParms[4];
380	int i = 0;
381	paParms[i++].setUInt32(pEvent->ContextID());
382	paParms[i++].setUInt32(mObjectID /* Guest file ID */);
383
384	vrc = sendCommand(HOST_FILE_CLOSE, i, paParms);
385	if (RT_SUCCESS(vrc))
386	vrc = i_waitForStatusChange(pEvent, 30 * 1000 /* Timeout in ms */,
387	NULL /* FileStatus */, prcGuest);
388	unregisterWaitEvent(pEvent);
389
390	LogFlowFuncLeaveRC(vrc);
391	return vrc;
392	}
393
394	/* static */
395	Utf8Str GuestFile::i_guestErrorToString(int rcGuest)
396	{
397	Utf8Str strError;
398
399	/** @todo pData->u32Flags: int vs. uint32 -- IPRT errors are negative !!! */
400	switch (rcGuest)
401	{
402	case VERR_ALREADY_EXISTS:
403	strError += Utf8StrFmt(tr("File already exists"));
404	break;
405
406	case VERR_FILE_NOT_FOUND:
407	strError += Utf8StrFmt(tr("File not found"));
408	break;
409
410	case VERR_NET_HOST_NOT_FOUND:
411	strError += Utf8StrFmt(tr("Host name not found"));
412	break;
413
414	case VERR_SHARING_VIOLATION:
415	strError += Utf8StrFmt(tr("Sharing violation"));
416	break;
417
418	default:
419	strError += Utf8StrFmt("%Rrc", rcGuest);
420	break;
421	}
422
423	return strError;
424	}
425
426	int GuestFile::i_onFileNotify(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
427	{
428	AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
429	AssertPtrReturn(pSvcCbData, VERR_INVALID_POINTER);
430
431	LogFlowThisFuncEnter();
432
433	if (pSvcCbData->mParms < 3)
434	return VERR_INVALID_PARAMETER;
435
436	int idx = 1; /* Current parameter index. */
437	CALLBACKDATA_FILE_NOTIFY dataCb;
438	/* pSvcCb->mpaParms[0] always contains the context ID. */
439	pSvcCbData->mpaParms[idx++].getUInt32(&dataCb.uType);
440	pSvcCbData->mpaParms[idx++].getUInt32(&dataCb.rc);
441
442	int rcGuest = (int)dataCb.rc; /* uint32_t vs. int. */
443
444	LogFlowThisFunc(("uType=%RU32, rcGuest=%Rrc\n", dataCb.uType, rcGuest));
445
446	if (RT_FAILURE(rcGuest))
447	{
448	int rc2 = i_setFileStatus(FileStatus_Error, rcGuest);
449	AssertRC(rc2);
450
451	/* Ignore rc, as the event to signal might not be there (anymore). */
452	signalWaitEventInternal(pCbCtx, rcGuest, NULL /* pPayload */);
453	return VINF_SUCCESS; /* Report to the guest. */
454	}
455
456	AssertMsg(mObjectID == VBOX_GUESTCTRL_CONTEXTID_GET_OBJECT(pCbCtx->uContextID),
457	("File ID %RU32 does not match object ID %RU32\n", mObjectID,
458	VBOX_GUESTCTRL_CONTEXTID_GET_OBJECT(pCbCtx->uContextID)));
459
460	int rc = VERR_NOT_SUPPORTED; /* Play safe by default. */
461
462	switch (dataCb.uType)
463	{
464	case GUEST_FILE_NOTIFYTYPE_ERROR:
465	{
466	rc = i_setFileStatus(FileStatus_Error, rcGuest);
467	break;
468	}
469
470	case GUEST_FILE_NOTIFYTYPE_OPEN:
471	{
472	if (pSvcCbData->mParms == 4)
473	{
474	rc = pSvcCbData->mpaParms[idx++].getUInt32(&dataCb.u.open.uHandle);
475	if (RT_FAILURE(rc))
476	break;
477
478	/* Set the process status. */
479	rc = i_setFileStatus(FileStatus_Open, rcGuest);
480	}
481	break;
482	}
483
484	case GUEST_FILE_NOTIFYTYPE_CLOSE:
485	{
486	rc = i_setFileStatus(FileStatus_Closed, rcGuest);
487	break;
488	}
489
490	case GUEST_FILE_NOTIFYTYPE_READ:
491	{
492	if (pSvcCbData->mParms == 4)
493	{
494	rc = pSvcCbData->mpaParms[idx++].getPointer(&dataCb.u.read.pvData, &dataCb.u.read.cbData);
495	if (RT_FAILURE(rc))
496	break;
497
498	const uint32_t cbRead = dataCb.u.read.cbData;
499
500	Log3ThisFunc(("cbRead=%RU32\n", cbRead));
501
502	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
503
504	mData.mOffCurrent += cbRead;
505
506	alock.release();
507
508	com::SafeArray<BYTE> data((size_t)cbRead);
509	data.initFrom((BYTE*)dataCb.u.read.pvData, cbRead);
510
511	fireGuestFileReadEvent(mEventSource, mSession, this, mData.mOffCurrent,
512	cbRead, ComSafeArrayAsInParam(data));
513	}
514	break;
515	}
516
517	case GUEST_FILE_NOTIFYTYPE_WRITE:
518	{
519	if (pSvcCbData->mParms == 4)
520	{
521	rc = pSvcCbData->mpaParms[idx++].getUInt32(&dataCb.u.write.cbWritten);
522	if (RT_FAILURE(rc))
523	break;
524
525	Log3ThisFunc(("cbWritten=%RU32\n", dataCb.u.write.cbWritten));
526
527	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
528
529	mData.mOffCurrent += dataCb.u.write.cbWritten;
530
531	alock.release();
532
533	fireGuestFileWriteEvent(mEventSource, mSession, this, mData.mOffCurrent,
534	dataCb.u.write.cbWritten);
535	}
536	break;
537	}
538
539	case GUEST_FILE_NOTIFYTYPE_SEEK:
540	{
541	if (pSvcCbData->mParms == 4)
542	{
543	rc = pSvcCbData->mpaParms[idx++].getUInt64(&dataCb.u.seek.uOffActual);
544	if (RT_FAILURE(rc))
545	break;
546
547	Log3ThisFunc(("uOffActual=%RU64\n", dataCb.u.seek.uOffActual));
548
549	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
550
551	mData.mOffCurrent = dataCb.u.seek.uOffActual;
552
553	alock.release();
554
555	fireGuestFileOffsetChangedEvent(mEventSource, mSession, this, mData.mOffCurrent, 0 /* Processed */);
556	}
557	break;
558	}
559
560	case GUEST_FILE_NOTIFYTYPE_TELL:
561	{
562	if (pSvcCbData->mParms == 4)
563	{
564	rc = pSvcCbData->mpaParms[idx++].getUInt64(&dataCb.u.tell.uOffActual);
565	if (RT_FAILURE(rc))
566	break;
567
568	Log3ThisFunc(("uOffActual=%RU64\n", dataCb.u.tell.uOffActual));
569
570	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
571
572	mData.mOffCurrent = dataCb.u.tell.uOffActual;
573
574	alock.release();
575
576	fireGuestFileOffsetChangedEvent(mEventSource, mSession, this, mData.mOffCurrent, 0 /* Processed */);
577	}
578	break;
579	}
580
581	default:
582	break;
583	}
584
585	if (RT_SUCCESS(rc))
586	{
587	GuestWaitEventPayload payload(dataCb.uType, &dataCb, sizeof(dataCb));
588
589	/* Ignore rc, as the event to signal might not be there (anymore). */
590	signalWaitEventInternal(pCbCtx, rcGuest, &payload);
591	}
592
593	LogFlowThisFunc(("uType=%RU32, rcGuest=%Rrc, rc=%Rrc\n", dataCb.uType, rcGuest, rc));
594	return rc;
595	}
596
597	int GuestFile::i_onGuestDisconnected(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
598	{
599	AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
600	AssertPtrReturn(pSvcCbData, VERR_INVALID_POINTER);
601
602	int vrc = i_setFileStatus(FileStatus_Down, VINF_SUCCESS);
603
604	LogFlowFuncLeaveRC(vrc);
605	return vrc;
606	}
607
608	/**
609	* Called by IGuestSession right before this file gets removed
610	* from the public file list.
611	*/
612	int GuestFile::i_onRemove(void)
613	{
614	LogFlowThisFuncEnter();
615
616	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
617
618	int vrc = VINF_SUCCESS;
619
620	/*
621	* Note: The event source stuff holds references to this object,
622	* so make sure that this is cleaned up before calling uninit().
623	*/
624	if (!mEventSource.isNull())
625	{
626	mEventSource->UnregisterListener(mLocalListener);
627
628	mLocalListener.setNull();
629	unconst(mEventSource).setNull();
630	}
631
632	LogFlowFuncLeaveRC(vrc);
633	return vrc;
634	}
635
636	int GuestFile::i_openFile(uint32_t uTimeoutMS, int *prcGuest)
637	{
638	AssertReturn(mData.mOpenInfo.mFileName.isNotEmpty(), VERR_INVALID_PARAMETER);
639
640	LogFlowThisFuncEnter();
641
642	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
643
644	LogFlowThisFunc(("strFile=%s, enmAccessMode=0x%x, enmOpenAction=0x%x, uCreationMode=%RU32, mfOpenEx=%RU32\n",
645	mData.mOpenInfo.mFileName.c_str(), mData.mOpenInfo.mAccessMode, mData.mOpenInfo.mOpenAction,
646	mData.mOpenInfo.mCreationMode, mData.mOpenInfo.mfOpenEx));
647
648	/* Validate and translate open action. */
649	const char *pszOpenAction = NULL;
650	switch (mData.mOpenInfo.mOpenAction)
651	{
652	case FileOpenAction_OpenExisting: pszOpenAction = "oe"; break;
653	case FileOpenAction_OpenOrCreate: pszOpenAction = "oc"; break;
654	case FileOpenAction_CreateNew: pszOpenAction = "ce"; break;
655	case FileOpenAction_CreateOrReplace: pszOpenAction = "ca"; break;
656	case FileOpenAction_OpenExistingTruncated: pszOpenAction = "ot"; break;
657	case FileOpenAction_AppendOrCreate:
658	pszOpenAction = "oa"; /** @todo get rid of this one and implement AppendOnly/AppendRead. */
659	break;
660	default:
661	return VERR_INVALID_PARAMETER;
662	}
663
664	/* Validate and translate access mode. */
665	const char *pszAccessMode = NULL;
666	switch (mData.mOpenInfo.mAccessMode)
667	{
668	case FileAccessMode_ReadOnly: pszAccessMode = "r"; break;
669	case FileAccessMode_WriteOnly: pszAccessMode = "w"; break;
670	case FileAccessMode_ReadWrite: pszAccessMode = "r+"; break;
671	case FileAccessMode_AppendOnly: RT_FALL_THRU();
672	case FileAccessMode_AppendRead: return VERR_NOT_IMPLEMENTED;
673	default: return VERR_INVALID_PARAMETER;
674	}
675
676	/* Validate and translate sharing mode. */
677	const char *pszSharingMode = NULL;
678	switch (mData.mOpenInfo.mSharingMode)
679	{
680	case FileSharingMode_All: pszSharingMode = ""; break;
681	case FileSharingMode_Read: RT_FALL_THRU();
682	case FileSharingMode_Write: RT_FALL_THRU();
683	case FileSharingMode_ReadWrite: RT_FALL_THRU();
684	case FileSharingMode_Delete: RT_FALL_THRU();
685	case FileSharingMode_ReadDelete: RT_FALL_THRU();
686	case FileSharingMode_WriteDelete: return VERR_NOT_IMPLEMENTED;
687	default: return VERR_INVALID_PARAMETER;
688	}
689
690	int vrc;
691
692	GuestWaitEvent *pEvent = NULL;
693	GuestEventTypes eventTypes;
694	try
695	{
696	eventTypes.push_back(VBoxEventType_OnGuestFileStateChanged);
697
698	vrc = registerWaitEvent(eventTypes, &pEvent);
699	}
700	catch (std::bad_alloc)
701	{
702	vrc = VERR_NO_MEMORY;
703	}
704
705	if (RT_FAILURE(vrc))
706	return vrc;
707
708	/* Prepare HGCM call. */
709	VBOXHGCMSVCPARM paParms[8];
710	int i = 0;
711	paParms[i++].setUInt32(pEvent->ContextID());
712	paParms[i++].setPointer((void*)mData.mOpenInfo.mFileName.c_str(),
713	(ULONG)mData.mOpenInfo.mFileName.length() + 1);
714	paParms[i++].setString(pszAccessMode);
715	paParms[i++].setString(pszOpenAction);
716	paParms[i++].setString(pszSharingMode);
717	paParms[i++].setUInt32(mData.mOpenInfo.mCreationMode);
718	paParms[i++].setUInt64(mData.mOpenInfo.muOffset);
719	/** @todo Next protocol version: add flags, replace strings, remove initial offset. */
720
721	alock.release(); /* Drop write lock before sending. */
722
723	vrc = sendCommand(HOST_FILE_OPEN, i, paParms);
724	if (RT_SUCCESS(vrc))
725	vrc = i_waitForStatusChange(pEvent, uTimeoutMS, NULL /* FileStatus */, prcGuest);
726
727	unregisterWaitEvent(pEvent);
728
729	LogFlowFuncLeaveRC(vrc);
730	return vrc;
731	}
732
733	int GuestFile::i_queryInfo(GuestFsObjData &objData, int *prcGuest)
734	{
735	AssertPtr(mSession);
736	return mSession->i_fsQueryInfo(mData.mOpenInfo.mFileName, FALSE /* fFollowSymlinks */, objData, prcGuest);
737	}
738
739	int GuestFile::i_readData(uint32_t uSize, uint32_t uTimeoutMS,
740	void* pvData, uint32_t cbData, uint32_t* pcbRead)
741	{
742	AssertPtrReturn(pvData, VERR_INVALID_POINTER);
743	AssertReturn(cbData, VERR_INVALID_PARAMETER);
744
745	LogFlowThisFunc(("uSize=%RU32, uTimeoutMS=%RU32, pvData=%p, cbData=%zu\n",
746	uSize, uTimeoutMS, pvData, cbData));
747
748	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
749
750	int vrc;
751
752	GuestWaitEvent *pEvent = NULL;
753	GuestEventTypes eventTypes;
754	try
755	{
756	eventTypes.push_back(VBoxEventType_OnGuestFileStateChanged);
757	eventTypes.push_back(VBoxEventType_OnGuestFileRead);
758
759	vrc = registerWaitEvent(eventTypes, &pEvent);
760	}
761	catch (std::bad_alloc)
762	{
763	vrc = VERR_NO_MEMORY;
764	}
765
766	if (RT_FAILURE(vrc))
767	return vrc;
768
769	/* Prepare HGCM call. */
770	VBOXHGCMSVCPARM paParms[4];
771	int i = 0;
772	paParms[i++].setUInt32(pEvent->ContextID());
773	paParms[i++].setUInt32(mObjectID /* File handle */);
774	paParms[i++].setUInt32(uSize /* Size (in bytes) to read */);
775
776	alock.release(); /* Drop write lock before sending. */
777
778	vrc = sendCommand(HOST_FILE_READ, i, paParms);
779	if (RT_SUCCESS(vrc))
780	{
781	uint32_t cbRead = 0;
782	vrc = i_waitForRead(pEvent, uTimeoutMS, pvData, cbData, &cbRead);
783	if (RT_SUCCESS(vrc))
784	{
785	LogFlowThisFunc(("cbRead=%RU32\n", cbRead));
786	if (pcbRead)
787	*pcbRead = cbRead;
788	}
789	else if (pEvent->HasGuestError()) /* Return guest rc if available. */
790	{
791	vrc = pEvent->GetGuestError();
792	}
793	}
794
795	unregisterWaitEvent(pEvent);
796
797	LogFlowFuncLeaveRC(vrc);
798	return vrc;
799	}
800
801	int GuestFile::i_readDataAt(uint64_t uOffset, uint32_t uSize, uint32_t uTimeoutMS,
802	void* pvData, size_t cbData, size_t* pcbRead)
803	{
804	LogFlowThisFunc(("uOffset=%RU64, uSize=%RU32, uTimeoutMS=%RU32, pvData=%p, cbData=%zu\n",
805	uOffset, uSize, uTimeoutMS, pvData, cbData));
806
807	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
808
809	int vrc;
810
811	GuestWaitEvent *pEvent = NULL;
812	GuestEventTypes eventTypes;
813	try
814	{
815	eventTypes.push_back(VBoxEventType_OnGuestFileStateChanged);
816	eventTypes.push_back(VBoxEventType_OnGuestFileRead);
817
818	vrc = registerWaitEvent(eventTypes, &pEvent);
819	}
820	catch (std::bad_alloc)
821	{
822	vrc = VERR_NO_MEMORY;
823	}
824
825	if (RT_FAILURE(vrc))
826	return vrc;
827
828	/* Prepare HGCM call. */
829	VBOXHGCMSVCPARM paParms[4];
830	int i = 0;
831	paParms[i++].setUInt32(pEvent->ContextID());
832	paParms[i++].setUInt32(mObjectID /* File handle */);
833	paParms[i++].setUInt64(uOffset /* Offset (in bytes) to start reading */);
834	paParms[i++].setUInt32(uSize /* Size (in bytes) to read */);
835
836	alock.release(); /* Drop write lock before sending. */
837
838	vrc = sendCommand(HOST_FILE_READ_AT, i, paParms);
839	if (RT_SUCCESS(vrc))
840	{
841	uint32_t cbRead = 0;
842	vrc = i_waitForRead(pEvent, uTimeoutMS, pvData, cbData, &cbRead);
843	if (RT_SUCCESS(vrc))
844	{
845	LogFlowThisFunc(("cbRead=%RU32\n", cbRead));
846
847	if (pcbRead)
848	*pcbRead = cbRead;
849	}
850	else if (pEvent->HasGuestError()) /* Return guest rc if available. */
851	{
852	vrc = pEvent->GetGuestError();
853	}
854	}
855
856	unregisterWaitEvent(pEvent);
857
858	LogFlowFuncLeaveRC(vrc);
859	return vrc;
860	}
861
862	int GuestFile::i_seekAt(int64_t iOffset, GUEST_FILE_SEEKTYPE eSeekType,
863	uint32_t uTimeoutMS, uint64_t *puOffset)
864	{
865	LogFlowThisFunc(("iOffset=%RI64, uTimeoutMS=%RU32\n",
866	iOffset, uTimeoutMS));
867
868	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
869
870	int vrc;
871
872	GuestWaitEvent *pEvent = NULL;
873	GuestEventTypes eventTypes;
874	try
875	{
876	eventTypes.push_back(VBoxEventType_OnGuestFileStateChanged);
877	eventTypes.push_back(VBoxEventType_OnGuestFileOffsetChanged);
878
879	vrc = registerWaitEvent(eventTypes, &pEvent);
880	}
881	catch (std::bad_alloc)
882	{
883	vrc = VERR_NO_MEMORY;
884	}
885
886	if (RT_FAILURE(vrc))
887	return vrc;
888
889	/* Prepare HGCM call. */
890	VBOXHGCMSVCPARM paParms[4];
891	int i = 0;
892	paParms[i++].setUInt32(pEvent->ContextID());
893	paParms[i++].setUInt32(mObjectID /* File handle */);
894	paParms[i++].setUInt32(eSeekType /* Seek method */);
895	/** @todo uint64_t vs. int64_t! */
896	paParms[i++].setUInt64((uint64_t)iOffset /* Offset (in bytes) to start reading */);
897
898	alock.release(); /* Drop write lock before sending. */
899
900	vrc = sendCommand(HOST_FILE_SEEK, i, paParms);
901	if (RT_SUCCESS(vrc))
902	{
903	uint64_t uOffset;
904	vrc = i_waitForOffsetChange(pEvent, uTimeoutMS, &uOffset);
905	if (RT_SUCCESS(vrc))
906	{
907	LogFlowThisFunc(("uOffset=%RU64\n", uOffset));
908
909	if (puOffset)
910	*puOffset = uOffset;
911	}
912	else if (pEvent->HasGuestError()) /* Return guest rc if available. */
913	{
914	vrc = pEvent->GetGuestError();
915	}
916	}
917
918	unregisterWaitEvent(pEvent);
919
920	LogFlowFuncLeaveRC(vrc);
921	return vrc;
922	}
923
924	/* static */
925	HRESULT GuestFile::i_setErrorExternal(VirtualBoxBase *pInterface, int rcGuest)
926	{
927	AssertPtr(pInterface);
928	AssertMsg(RT_FAILURE(rcGuest), ("Guest rc does not indicate a failure when setting error\n"));
929
930	return pInterface->setError(VBOX_E_IPRT_ERROR, GuestFile::i_guestErrorToString(rcGuest).c_str());
931	}
932
933	int GuestFile::i_setFileStatus(FileStatus_T fileStatus, int fileRc)
934	{
935	LogFlowThisFuncEnter();
936
937	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
938
939	LogFlowThisFunc(("oldStatus=%RU32, newStatus=%RU32, fileRc=%Rrc\n",
940	mData.mStatus, fileStatus, fileRc));
941
942	#ifdef VBOX_STRICT
943	if (fileStatus == FileStatus_Error)
944	{
945	AssertMsg(RT_FAILURE(fileRc), ("Guest rc must be an error (%Rrc)\n", fileRc));
946	}
947	else
948	AssertMsg(RT_SUCCESS(fileRc), ("Guest rc must not be an error (%Rrc)\n", fileRc));
949	#endif
950
951	if (mData.mStatus != fileStatus)
952	{
953	mData.mStatus = fileStatus;
954	mData.mLastError = fileRc;
955
956	ComObjPtr<VirtualBoxErrorInfo> errorInfo;
957	HRESULT hr = errorInfo.createObject();
958	ComAssertComRC(hr);
959	if (RT_FAILURE(fileRc))
960	{
961	hr = errorInfo->initEx(VBOX_E_IPRT_ERROR, fileRc,
962	COM_IIDOF(IGuestFile), getComponentName(),
963	i_guestErrorToString(fileRc));
964	ComAssertComRC(hr);
965	}
966
967	alock.release(); /* Release lock before firing off event. */
968
969	fireGuestFileStateChangedEvent(mEventSource, mSession,
970	this, fileStatus, errorInfo);
971	}
972
973	return VINF_SUCCESS;
974	}
975
976	int GuestFile::i_waitForOffsetChange(GuestWaitEvent *pEvent,
977	uint32_t uTimeoutMS, uint64_t *puOffset)
978	{
979	AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
980
981	VBoxEventType_T evtType;
982	ComPtr<IEvent> pIEvent;
983	int vrc = waitForEvent(pEvent, uTimeoutMS,
984	&evtType, pIEvent.asOutParam());
985	if (RT_SUCCESS(vrc))
986	{
987	if (evtType == VBoxEventType_OnGuestFileOffsetChanged)
988	{
989	if (puOffset)
990	{
991	ComPtr<IGuestFileOffsetChangedEvent> pFileEvent = pIEvent;
992	Assert(!pFileEvent.isNull());
993
994	HRESULT hr = pFileEvent->COMGETTER(Offset)((LONG64*)puOffset);
995	ComAssertComRC(hr);
996	}
997	}
998	else
999	vrc = VWRN_GSTCTL_OBJECTSTATE_CHANGED;
1000	}
1001
1002	return vrc;
1003	}
1004
1005	int GuestFile::i_waitForRead(GuestWaitEvent *pEvent, uint32_t uTimeoutMS,
1006	void pvData, size_t cbData, uint32_t pcbRead)
1007	{
1008	AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
1009
1010	VBoxEventType_T evtType;
1011	ComPtr<IEvent> pIEvent;
1012	int vrc = waitForEvent(pEvent, uTimeoutMS,
1013	&evtType, pIEvent.asOutParam());
1014	if (RT_SUCCESS(vrc))
1015	{
1016	if (evtType == VBoxEventType_OnGuestFileRead)
1017	{
1018	ComPtr<IGuestFileReadEvent> pFileEvent = pIEvent;
1019	Assert(!pFileEvent.isNull());
1020
1021	HRESULT hr;
1022	if (pvData)
1023	{
1024	com::SafeArray <BYTE> data;
1025	hr = pFileEvent->COMGETTER(Data)(ComSafeArrayAsOutParam(data));
1026	ComAssertComRC(hr);
1027	const size_t cbRead = data.size();
1028	if (cbRead)
1029	{
1030	if (cbRead <= cbData)
1031	memcpy(pvData, data.raw(), cbRead);
1032	else
1033	vrc = VERR_BUFFER_OVERFLOW;
1034	}
1035	else
1036	vrc = VERR_NO_DATA;
1037	}
1038	if (pcbRead)
1039	{
1040	hr = pFileEvent->COMGETTER(Processed)((ULONG*)pcbRead);
1041	ComAssertComRC(hr);
1042	}
1043	}
1044	else
1045	vrc = VWRN_GSTCTL_OBJECTSTATE_CHANGED;
1046	}
1047
1048	return vrc;
1049	}
1050
1051	int GuestFile::i_waitForStatusChange(GuestWaitEvent *pEvent, uint32_t uTimeoutMS,
1052	FileStatus_T pFileStatus, int prcGuest)
1053	{
1054	AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
1055	/* pFileStatus is optional. */
1056
1057	VBoxEventType_T evtType;
1058	ComPtr<IEvent> pIEvent;
1059	int vrc = waitForEvent(pEvent, uTimeoutMS,
1060	&evtType, pIEvent.asOutParam());
1061	if (RT_SUCCESS(vrc))
1062	{
1063	Assert(evtType == VBoxEventType_OnGuestFileStateChanged);
1064	ComPtr<IGuestFileStateChangedEvent> pFileEvent = pIEvent;
1065	Assert(!pFileEvent.isNull());
1066
1067	HRESULT hr;
1068	if (pFileStatus)
1069	{
1070	hr = pFileEvent->COMGETTER(Status)(pFileStatus);
1071	ComAssertComRC(hr);
1072	}
1073
1074	ComPtr<IVirtualBoxErrorInfo> errorInfo;
1075	hr = pFileEvent->COMGETTER(Error)(errorInfo.asOutParam());
1076	ComAssertComRC(hr);
1077
1078	LONG lGuestRc;
1079	hr = errorInfo->COMGETTER(ResultDetail)(&lGuestRc);
1080	ComAssertComRC(hr);
1081
1082	LogFlowThisFunc(("resultDetail=%RI32 (%Rrc)\n",
1083	lGuestRc, lGuestRc));
1084
1085	if (RT_FAILURE((int)lGuestRc))
1086	vrc = VERR_GSTCTL_GUEST_ERROR;
1087
1088	if (prcGuest)
1089	*prcGuest = (int)lGuestRc;
1090	}
1091
1092	return vrc;
1093	}
1094
1095	int GuestFile::i_waitForWrite(GuestWaitEvent *pEvent,
1096	uint32_t uTimeoutMS, uint32_t *pcbWritten)
1097	{
1098	AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
1099
1100	VBoxEventType_T evtType;
1101	ComPtr<IEvent> pIEvent;
1102	int vrc = waitForEvent(pEvent, uTimeoutMS,
1103	&evtType, pIEvent.asOutParam());
1104	if (RT_SUCCESS(vrc))
1105	{
1106	if (evtType == VBoxEventType_OnGuestFileWrite)
1107	{
1108	if (pcbWritten)
1109	{
1110	ComPtr<IGuestFileWriteEvent> pFileEvent = pIEvent;
1111	Assert(!pFileEvent.isNull());
1112
1113	HRESULT hr = pFileEvent->COMGETTER(Processed)((ULONG*)pcbWritten);
1114	ComAssertComRC(hr);
1115	}
1116	}
1117	else
1118	vrc = VWRN_GSTCTL_OBJECTSTATE_CHANGED;
1119	}
1120
1121	return vrc;
1122	}
1123
1124	int GuestFile::i_writeData(uint32_t uTimeoutMS, void *pvData, uint32_t cbData,
1125	uint32_t *pcbWritten)
1126	{
1127	AssertPtrReturn(pvData, VERR_INVALID_POINTER);
1128	AssertReturn(cbData, VERR_INVALID_PARAMETER);
1129
1130	LogFlowThisFunc(("uTimeoutMS=%RU32, pvData=%p, cbData=%zu\n",
1131	uTimeoutMS, pvData, cbData));
1132
1133	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1134
1135	int vrc;
1136
1137	GuestWaitEvent *pEvent = NULL;
1138	GuestEventTypes eventTypes;
1139	try
1140	{
1141	eventTypes.push_back(VBoxEventType_OnGuestFileStateChanged);
1142	eventTypes.push_back(VBoxEventType_OnGuestFileWrite);
1143
1144	vrc = registerWaitEvent(eventTypes, &pEvent);
1145	}
1146	catch (std::bad_alloc)
1147	{
1148	vrc = VERR_NO_MEMORY;
1149	}
1150
1151	if (RT_FAILURE(vrc))
1152	return vrc;
1153
1154	/* Prepare HGCM call. */
1155	VBOXHGCMSVCPARM paParms[8];
1156	int i = 0;
1157	paParms[i++].setUInt32(pEvent->ContextID());
1158	paParms[i++].setUInt32(mObjectID /* File handle */);
1159	paParms[i++].setUInt32(cbData /* Size (in bytes) to write */);
1160	paParms[i++].setPointer(pvData, cbData);
1161
1162	alock.release(); /* Drop write lock before sending. */
1163
1164	vrc = sendCommand(HOST_FILE_WRITE, i, paParms);
1165	if (RT_SUCCESS(vrc))
1166	{
1167	uint32_t cbWritten = 0;
1168	vrc = i_waitForWrite(pEvent, uTimeoutMS, &cbWritten);
1169	if (RT_SUCCESS(vrc))
1170	{
1171	LogFlowThisFunc(("cbWritten=%RU32\n", cbWritten));
1172	if (pcbWritten)
1173	*pcbWritten = cbWritten;
1174	}
1175	else if (pEvent->HasGuestError()) /* Return guest rc if available. */
1176	{
1177	vrc = pEvent->GetGuestError();
1178	}
1179	}
1180
1181	unregisterWaitEvent(pEvent);
1182
1183	LogFlowFuncLeaveRC(vrc);
1184	return vrc;
1185	}
1186
1187	int GuestFile::i_writeDataAt(uint64_t uOffset, uint32_t uTimeoutMS,
1188	void pvData, uint32_t cbData, uint32_t pcbWritten)
1189	{
1190	AssertPtrReturn(pvData, VERR_INVALID_POINTER);
1191	AssertReturn(cbData, VERR_INVALID_PARAMETER);
1192
1193	LogFlowThisFunc(("uOffset=%RU64, uTimeoutMS=%RU32, pvData=%p, cbData=%zu\n",
1194	uOffset, uTimeoutMS, pvData, cbData));
1195
1196	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1197
1198	int vrc;
1199
1200	GuestWaitEvent *pEvent = NULL;
1201	GuestEventTypes eventTypes;
1202	try
1203	{
1204	eventTypes.push_back(VBoxEventType_OnGuestFileStateChanged);
1205	eventTypes.push_back(VBoxEventType_OnGuestFileWrite);
1206
1207	vrc = registerWaitEvent(eventTypes, &pEvent);
1208	}
1209	catch (std::bad_alloc)
1210	{
1211	vrc = VERR_NO_MEMORY;
1212	}
1213
1214	if (RT_FAILURE(vrc))
1215	return vrc;
1216
1217	/* Prepare HGCM call. */
1218	VBOXHGCMSVCPARM paParms[8];
1219	int i = 0;
1220	paParms[i++].setUInt32(pEvent->ContextID());
1221	paParms[i++].setUInt32(mObjectID /* File handle */);
1222	paParms[i++].setUInt64(uOffset /* Offset where to starting writing */);
1223	paParms[i++].setUInt32(cbData /* Size (in bytes) to write */);
1224	paParms[i++].setPointer(pvData, cbData);
1225
1226	alock.release(); /* Drop write lock before sending. */
1227
1228	vrc = sendCommand(HOST_FILE_WRITE_AT, i, paParms);
1229	if (RT_SUCCESS(vrc))
1230	{
1231	uint32_t cbWritten = 0;
1232	vrc = i_waitForWrite(pEvent, uTimeoutMS, &cbWritten);
1233	if (RT_SUCCESS(vrc))
1234	{
1235	LogFlowThisFunc(("cbWritten=%RU32\n", cbWritten));
1236	if (pcbWritten)
1237	*pcbWritten = cbWritten;
1238	}
1239	else if (pEvent->HasGuestError()) /* Return guest rc if available. */
1240	{
1241	vrc = pEvent->GetGuestError();
1242	}
1243	}
1244
1245	unregisterWaitEvent(pEvent);
1246
1247	LogFlowFuncLeaveRC(vrc);
1248	return vrc;
1249	}
1250
1251	// Wrapped IGuestFile methods
1252	/////////////////////////////////////////////////////////////////////////////
1253	HRESULT GuestFile::close()
1254	{
1255	AutoCaller autoCaller(this);
1256	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1257
1258	LogFlowThisFuncEnter();
1259
1260	/* Close file on guest. */
1261	int rcGuest;
1262	int vrc = i_closeFile(&rcGuest);
1263	/* On failure don't return here, instead do all the cleanup
1264	* work first and then return an error. */
1265
1266	AssertPtr(mSession);
1267	int vrc2 = mSession->i_fileUnregister(this);
1268	if (RT_SUCCESS(vrc))
1269	vrc = vrc2;
1270
1271	if (RT_FAILURE(vrc))
1272	{
1273	if (vrc == VERR_GSTCTL_GUEST_ERROR)
1274	return GuestFile::i_setErrorExternal(this, rcGuest);
1275	return setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Closing guest file failed with %Rrc\n"), vrc);
1276	}
1277
1278	LogFlowThisFunc(("Returning S_OK / vrc=%Rrc\n", vrc));
1279	return S_OK;
1280	}
1281
1282	HRESULT GuestFile::queryInfo(ComPtr<IFsObjInfo> &aObjInfo)
1283	{
1284	AutoCaller autoCaller(this);
1285	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1286
1287	LogFlowThisFuncEnter();
1288
1289	HRESULT hr = S_OK;
1290
1291	GuestFsObjData fsObjData; int rcGuest;
1292	int vrc = i_queryInfo(fsObjData, &rcGuest);
1293	if (RT_SUCCESS(vrc))
1294	{
1295	ComObjPtr<GuestFsObjInfo> ptrFsObjInfo;
1296	hr = ptrFsObjInfo.createObject();
1297	if (SUCCEEDED(hr))
1298	{
1299	vrc = ptrFsObjInfo->init(fsObjData);
1300	if (RT_SUCCESS(vrc))
1301	hr = ptrFsObjInfo.queryInterfaceTo(aObjInfo.asOutParam());
1302	else
1303	hr = setErrorVrc(vrc);
1304	}
1305	}
1306	else
1307	{
1308	if (GuestProcess::i_isGuestError(vrc))
1309	hr = GuestProcess::i_setErrorExternal(this, rcGuest);
1310	else
1311	hr = setErrorVrc(vrc, tr("Querying file information failed: %Rrc"), vrc);
1312	}
1313
1314	LogFlowFuncLeaveRC(vrc);
1315	return hr;
1316	}
1317
1318	HRESULT GuestFile::querySize(LONG64 *aSize)
1319	{
1320	AutoCaller autoCaller(this);
1321	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1322
1323	LogFlowThisFuncEnter();
1324
1325	HRESULT hr = S_OK;
1326
1327	GuestFsObjData fsObjData; int rcGuest;
1328	int vrc = i_queryInfo(fsObjData, &rcGuest);
1329	if (RT_SUCCESS(vrc))
1330	{
1331	*aSize = fsObjData.mObjectSize;
1332	}
1333	else
1334	{
1335	if (GuestProcess::i_isGuestError(vrc))
1336	hr = GuestProcess::i_setErrorExternal(this, rcGuest);
1337	else
1338	hr = setErrorVrc(vrc, tr("Querying file size failed: %Rrc"), vrc);
1339	}
1340
1341	LogFlowFuncLeaveRC(vrc);
1342	return hr;
1343	}
1344
1345	HRESULT GuestFile::read(ULONG aToRead, ULONG aTimeoutMS, std::vector<BYTE> &aData)
1346	{
1347	AutoCaller autoCaller(this);
1348	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1349
1350	if (aToRead == 0)
1351	return setError(E_INVALIDARG, tr("The size to read is zero"));
1352
1353	LogFlowThisFuncEnter();
1354
1355	aData.resize(aToRead);
1356
1357	HRESULT hr = S_OK;
1358
1359	uint32_t cbRead;
1360	int vrc = i_readData(aToRead, aTimeoutMS,
1361	&aData.front(), aToRead, &cbRead);
1362
1363	if (RT_SUCCESS(vrc))
1364	{
1365	if (aData.size() != cbRead)
1366	aData.resize(cbRead);
1367	}
1368	else
1369	{
1370	aData.resize(0);
1371
1372	hr = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Reading from file \"%s\" failed: %Rrc"),
1373	mData.mOpenInfo.mFileName.c_str(), vrc);
1374	}
1375
1376	LogFlowFuncLeaveRC(vrc);
1377	return hr;
1378	}
1379
1380	HRESULT GuestFile::readAt(LONG64 aOffset, ULONG aToRead, ULONG aTimeoutMS, std::vector<BYTE> &aData)
1381	{
1382	AutoCaller autoCaller(this);
1383	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1384
1385	if (aToRead == 0)
1386	return setError(E_INVALIDARG, tr("The size to read is zero"));
1387
1388	LogFlowThisFuncEnter();
1389
1390	aData.resize(aToRead);
1391
1392	HRESULT hr = S_OK;
1393
1394	size_t cbRead;
1395	int vrc = i_readDataAt(aOffset, aToRead, aTimeoutMS,
1396	&aData.front(), aToRead, &cbRead);
1397	if (RT_SUCCESS(vrc))
1398	{
1399	if (aData.size() != cbRead)
1400	aData.resize(cbRead);
1401	}
1402	else
1403	{
1404	aData.resize(0);
1405
1406	hr = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Reading from file \"%s\" (at offset %RU64) failed: %Rrc"),
1407	mData.mOpenInfo.mFileName.c_str(), aOffset, vrc);
1408	}
1409
1410	LogFlowFuncLeaveRC(vrc);
1411	return hr;
1412	}
1413
1414	HRESULT GuestFile::seek(LONG64 aOffset, FileSeekOrigin_T aWhence, LONG64 *aNewOffset)
1415	{
1416	AutoCaller autoCaller(this);
1417	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1418
1419	HRESULT hr = S_OK;
1420
1421	GUEST_FILE_SEEKTYPE eSeekType;
1422	switch (aWhence)
1423	{
1424	case FileSeekOrigin_Begin:
1425	eSeekType = GUEST_FILE_SEEKTYPE_BEGIN;
1426	break;
1427
1428	case FileSeekOrigin_Current:
1429	eSeekType = GUEST_FILE_SEEKTYPE_CURRENT;
1430	break;
1431
1432	case FileSeekOrigin_End:
1433	eSeekType = GUEST_FILE_SEEKTYPE_END;
1434	break;
1435
1436	default:
1437	return setError(E_INVALIDARG, tr("Invalid seek type specified"));
1438	}
1439
1440	LogFlowThisFuncEnter();
1441
1442	uint64_t uNewOffset;
1443	int vrc = i_seekAt(aOffset, eSeekType,
1444	30 * 1000 /* 30s timeout */, &uNewOffset);
1445	if (RT_SUCCESS(vrc))
1446	*aNewOffset = RT_MIN(uNewOffset, (uint64_t)INT64_MAX);
1447	else
1448	hr = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Seeking file \"%s\" (to offset %RI64) failed: %Rrc"),
1449	mData.mOpenInfo.mFileName.c_str(), aOffset, vrc);
1450
1451	LogFlowFuncLeaveRC(vrc);
1452	return hr;
1453	}
1454
1455	HRESULT GuestFile::setACL(const com::Utf8Str &aAcl, ULONG aMode)
1456	{
1457	RT_NOREF(aAcl, aMode);
1458	ReturnComNotImplemented();
1459	}
1460
1461	HRESULT GuestFile::setSize(LONG64 aSize)
1462	{
1463	RT_NOREF(aSize);
1464	ReturnComNotImplemented();
1465	}
1466
1467	HRESULT GuestFile::write(const std::vector<BYTE> &aData, ULONG aTimeoutMS, ULONG *aWritten)
1468	{
1469	AutoCaller autoCaller(this);
1470	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1471
1472	LogFlowThisFuncEnter();
1473
1474	HRESULT hr = S_OK;
1475
1476	uint32_t cbData = (uint32_t)aData.size();
1477	void pvData = cbData > 0? (void )&aData.front(): NULL;
1478	int vrc = i_writeData(aTimeoutMS, pvData, cbData, (uint32_t*)aWritten);
1479	if (RT_FAILURE(vrc))
1480	hr = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Writing %zubytes to file \"%s\" failed: %Rrc"),
1481	aData.size(), mData.mOpenInfo.mFileName.c_str(), vrc);
1482
1483	LogFlowFuncLeaveRC(vrc);
1484	return hr;
1485	}
1486
1487	HRESULT GuestFile::writeAt(LONG64 aOffset, const std::vector<BYTE> &aData, ULONG aTimeoutMS, ULONG *aWritten)
1488	{
1489	AutoCaller autoCaller(this);
1490	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1491
1492	LogFlowThisFuncEnter();
1493
1494	HRESULT hr = S_OK;
1495
1496	uint32_t cbData = (uint32_t)aData.size();
1497	void pvData = cbData > 0? (void )&aData.front(): NULL;
1498	int vrc = i_writeData(aTimeoutMS, pvData, cbData, (uint32_t*)aWritten);
1499	if (RT_FAILURE(vrc))
1500	hr = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Writing %zubytes to file \"%s\" (at offset %RU64) failed: %Rrc"),
1501	aData.size(), mData.mOpenInfo.mFileName.c_str(), aOffset, vrc);
1502
1503	LogFlowFuncLeaveRC(vrc);
1504	return hr;
1505	}
1506

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

source: vbox/trunk/src/VBox/Main/src-client/GuestFileImpl.cpp@ 73003

Download in other formats: