1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
/* $Id$ */
/** @file
* VirtualBox Main - Guest file handling implementation.
*/
/*
* Copyright (C) 2012-2019 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* you can redistribute it and/or modify it under the terms of the GNU
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*/
#ifndef ____H_GUESTFILEIMPL
#define ____H_GUESTFILEIMPL
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif
#include "VirtualBoxBase.h"
#include "EventImpl.h"
#include "GuestCtrlImplPrivate.h"
#include "GuestFileWrap.h"
class Console;
class GuestSession;
class GuestProcess;
class ATL_NO_VTABLE GuestFile :
public GuestFileWrap,
public GuestObject
{
public:
/** @name COM and internal init/term/mapping cruft.
* @{ */
DECLARE_EMPTY_CTOR_DTOR(GuestFile)
int init(Console *pConsole, GuestSession *pSession, ULONG uFileID, const GuestFileOpenInfo &openInfo);
void uninit(void);
HRESULT FinalConstruct(void);
void FinalRelease(void);
/** @} */
public:
/** @name Public internal methods.
* @{ */
int i_callbackDispatcher(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb);
int i_closeFile(int *pGuestRc);
EventSource *i_getEventSource(void) { return mEventSource; }
static Utf8Str i_guestErrorToString(int guestRc);
int i_onFileNotify(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
int i_onGuestDisconnected(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
int i_onRemove(void);
int i_openFile(uint32_t uTimeoutMS, int *pGuestRc);
int i_queryInfo(GuestFsObjData &objData, int *prcGuest);
int i_readData(uint32_t uSize, uint32_t uTimeoutMS, void* pvData, uint32_t cbData, uint32_t* pcbRead);
int i_readDataAt(uint64_t uOffset, uint32_t uSize, uint32_t uTimeoutMS,
void* pvData, size_t cbData, size_t* pcbRead);
int i_seekAt(int64_t iOffset, GUEST_FILE_SEEKTYPE eSeekType, uint32_t uTimeoutMS, uint64_t *puOffset);
static HRESULT i_setErrorExternal(VirtualBoxBase *pInterface, int guestRc);
int i_setFileStatus(FileStatus_T fileStatus, int fileRc);
int i_waitForOffsetChange(GuestWaitEvent *pEvent, uint32_t uTimeoutMS, uint64_t *puOffset);
int i_waitForRead(GuestWaitEvent *pEvent, uint32_t uTimeoutMS, void *pvData, size_t cbData, uint32_t *pcbRead);
int i_waitForStatusChange(GuestWaitEvent *pEvent, uint32_t uTimeoutMS, FileStatus_T *pFileStatus, int *pGuestRc);
int i_waitForWrite(GuestWaitEvent *pEvent, uint32_t uTimeoutMS, uint32_t *pcbWritten);
int i_writeData(uint32_t uTimeoutMS, void *pvData, uint32_t cbData, uint32_t *pcbWritten);
int i_writeDataAt(uint64_t uOffset, uint32_t uTimeoutMS, void *pvData, uint32_t cbData, uint32_t *pcbWritten);
/** @} */
private:
/** @name Wrapped IGuestFile properties.
* @{ */
HRESULT getCreationMode(ULONG *aCreationMode);
HRESULT getEventSource(ComPtr<IEventSource> &aEventSource);
HRESULT getId(ULONG *aId);
HRESULT getInitialSize(LONG64 *aInitialSize);
HRESULT getOffset(LONG64 *aOffset);
HRESULT getStatus(FileStatus_T *aStatus);
HRESULT getFilename(com::Utf8Str &aFilename);
HRESULT getAccessMode(FileAccessMode_T *aAccessMode);
HRESULT getOpenAction(FileOpenAction_T *aOpenAction);
/** @} */
/** @name Wrapped IGuestFile methods.
* @{ */
HRESULT close();
HRESULT queryInfo(ComPtr<IFsObjInfo> &aObjInfo);
HRESULT querySize(LONG64 *aSize);
HRESULT read(ULONG aToRead,
ULONG aTimeoutMS,
std::vector<BYTE> &aData);
HRESULT readAt(LONG64 aOffset,
ULONG aToRead,
ULONG aTimeoutMS,
std::vector<BYTE> &aData);
HRESULT seek(LONG64 aOffset,
FileSeekOrigin_T aWhence,
LONG64 *aNewOffset);
HRESULT setACL(const com::Utf8Str &aAcl,
ULONG aMode);
HRESULT setSize(LONG64 aSize);
HRESULT write(const std::vector<BYTE> &aData,
ULONG aTimeoutMS,
ULONG *aWritten);
HRESULT writeAt(LONG64 aOffset,
const std::vector<BYTE> &aData,
ULONG aTimeoutMS,
ULONG *aWritten);
/** @} */
/** This can safely be used without holding any locks.
* An AutoCaller suffices to prevent it being destroy while in use and
* internally there is a lock providing the necessary serialization. */
const ComObjPtr<EventSource> mEventSource;
struct Data
{
/** The file's open info. */
GuestFileOpenInfo mOpenInfo;
/** The file's initial size on open. */
uint64_t mInitialSize;
/** The current file status. */
FileStatus_T mStatus;
/** The last returned process status
* returned from the guest side. */
int mLastError;
/** The file's current offset. */
uint64_t mOffCurrent;
} mData;
};
#endif /* !____H_GUESTFILEIMPL */
|
