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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
|
/* $Id: GuestFileImpl.h $ */
/** @file
* VirtualBox Main - Guest file handling implementation.
*/
/*
* Copyright (C) 2012-2023 Oracle and/or its affiliates.
*
* This file is part of VirtualBox base platform packages, as
* available from https://www.virtualbox.org.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation, in version 3 of the
* License.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <https://www.gnu.org/licenses>.
*
* SPDX-License-Identifier: GPL-3.0-only
*/
#ifndef MAIN_INCLUDED_GuestFileImpl_h
#define MAIN_INCLUDED_GuestFileImpl_h
#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_COMMON_CLASS_METHODS(GuestFile)
int init(Console *pConsole, GuestSession *pSession, ULONG uFileID, const GuestFileOpenInfo &openInfo);
void uninit(void);
HRESULT FinalConstruct(void);
void FinalRelease(void);
/** @} */
public:
/** @name Implemented virtual methods from GuestObject.
* @{ */
int i_callbackDispatcher(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb);
int i_onUnregister(void);
int i_onSessionStatusChange(GuestSessionStatus_T enmSessionStatus);
/** @} */
public:
/** @name Public internal methods.
* @{ */
int i_closeFile(int *pGuestRc);
EventSource *i_getEventSource(void) { return mEventSource; }
int i_onFileNotify(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
int i_onGuestDisconnected(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
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);
int i_setFileStatus(FileStatus_T fileStatus, int vrcFile);
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, const void *pvData, uint32_t cbData, uint32_t *pcbWritten);
int i_writeDataAt(uint64_t uOffset, uint32_t uTimeoutMS, const void *pvData, uint32_t cbData, uint32_t *pcbWritten);
/** @} */
/** @name Static helper methods.
* @{ */
static Utf8Str i_guestErrorToString(int guestRc, const char *pcszWhat);
/** @} */
public:
/** @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);
/** @} */
private:
/** 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 /* !MAIN_INCLUDED_GuestFileImpl_h */
|
