1// ShareVolume.h
2
3#ifndef NET_FS_SHARE_VOLUME_H
4#define NET_FS_SHARE_VOLUME_H
5
6#include <fsproto.h>
7
8#include "DLList.h"
9#include "EntryInfo.h"
10#include "FSObject.h"
11#include "Locker.h"
12#include "RequestHandler.h"
13#include "RequestMemberArray.h"
14#include "ServerNodeID.h"
15#include "Volume.h"
16
17class AttrDirInfo;
18class ExtendedServerInfo;
19class ExtendedShareInfo;
20class Node;
21class ReadQueryReply;
22class RemoteShareDirIterator;
23class RequestConnection;
24class RootShareVolume;
25class ServerConnection;
26class ServerConnectionProvider;
27class ShareAttrDirIterator;
28class ShareDir;
29class ShareDirEntry;
30class ShareNode;
31class WalkReply;
32
33class ShareVolume : public Volume {
34public:
35								ShareVolume(VolumeManager* volumeManager,
36									ServerConnectionProvider*
37										connectionProvider,
38									ExtendedServerInfo* serverInfo,
39									ExtendedShareInfo* shareInfo);
40								~ShareVolume();
41
42			int32				GetID() const;
43
44			bool				IsReadOnly() const;
45			bool				SupportsQueries() const;
46
47			status_t			Init(const char* name);
48			void				Uninit();
49
50	virtual	Node*				GetRootNode() const;
51
52	virtual	void				PrepareToUnmount();
53
54	virtual	void				RemoveChildVolume(Volume* volume);
55
56			// FS
57	virtual	status_t			Unmount();
58	virtual	status_t			Sync();
59
60			// vnodes
61	virtual	status_t			ReadVNode(vnode_id vnid, char reenter,
62									Node** node);
63	virtual	status_t			WriteVNode(Node* node, char reenter);
64	virtual	status_t			RemoveVNode(Node* node, char reenter);
65
66			// nodes
67	virtual	status_t			FSync(Node* node);
68	virtual	status_t			ReadStat(Node* node, struct stat* st);
69	virtual	status_t			WriteStat(Node* node, struct stat *st,
70									uint32 mask);
71	virtual	status_t			Access(Node* node, int mode);
72
73			// files
74	virtual	status_t			Create(Node* dir, const char* name,
75									int openMode, int mode, vnode_id* vnid,
76									void** cookie);
77	virtual	status_t			Open(Node* node, int openMode,
78									void** cookie);
79	virtual	status_t			Close(Node* node, void* cookie);
80	virtual	status_t			FreeCookie(Node* node, void* cookie);
81	virtual	status_t			Read(Node* node, void* cookie, off_t pos,
82									void* buffer, size_t bufferSize,
83									size_t* bytesRead);
84	virtual	status_t			Write(Node* node, void* cookie, off_t pos,
85									const void* buffer, size_t bufferSize,
86									size_t* bytesWritten);
87
88			// hard links / symlinks
89	virtual	status_t			Link(Node* dir, const char* name,
90									Node* node);
91	virtual	status_t			Unlink(Node* dir, const char* name);
92	virtual	status_t			Symlink(Node* dir, const char* name,
93									const char* target);
94	virtual	status_t			ReadLink(Node* node, char* buffer,
95									size_t bufferSize, size_t* bytesRead);
96	virtual	status_t			Rename(Node* oldDir, const char* oldName,
97									Node* newDir, const char* newName);
98
99			// directories
100	virtual	status_t			MkDir(Node* dir, const char* name,
101									int mode);
102	virtual	status_t			RmDir(Node* dir, const char* name);
103	virtual	status_t			OpenDir(Node* node, void** cookie);
104	virtual	status_t			CloseDir(Node* node, void* cookie);
105	virtual	status_t			FreeDirCookie(Node* node, void* cookie);
106	virtual	status_t			ReadDir(Node* node, void* cookie,
107									struct dirent* buffer, size_t bufferSize,
108									int32 count, int32* countRead);
109	virtual	status_t			RewindDir(Node* node, void* cookie);
110	virtual	status_t			Walk(Node* dir, const char* entryName,
111									char** resolvedPath, vnode_id* vnid);
112
113			// attributes
114	virtual	status_t			OpenAttrDir(Node* node, void** cookie);
115	virtual	status_t			CloseAttrDir(Node* node, void* cookie);
116	virtual	status_t			FreeAttrDirCookie(Node* node,
117									void* cookie);
118	virtual	status_t			ReadAttrDir(Node* node, void* cookie,
119									struct dirent* buffer, size_t bufferSize,
120									int32 count, int32* countRead);
121	virtual	status_t			RewindAttrDir(Node* node, void* cookie);
122	virtual	status_t			ReadAttr(Node* node, const char* name,
123									int type, off_t pos, void* buffer,
124									size_t bufferSize, size_t* bytesRead);
125	virtual	status_t			WriteAttr(Node* node, const char* name,
126									int type, off_t pos, const void* buffer,
127									size_t bufferSize, size_t* bytesWritten);
128	virtual	status_t			RemoveAttr(Node* node, const char* name);
129	virtual	status_t			RenameAttr(Node* node,
130									const char* oldName, const char* newName);
131	virtual	status_t			StatAttr(Node* node, const char* name,
132									struct attr_info* attrInfo);
133
134			// queries
135			status_t			GetQueryEntry(const EntryInfo& entryInfo,
136									const NodeInfo& dirInfo,
137									struct dirent* buffer, size_t bufferSize,
138									int32* countRead);
139
140
141			// service methods called from "outside"
142			void				ProcessNodeMonitoringRequest(
143									NodeMonitoringRequest* request);
144			void				ConnectionClosed();
145
146private:
147			struct NodeMap;
148			struct EntryKey;
149			struct EntryMap;
150			struct LocalNodeIDMap;
151			struct RemoteNodeIDMap;
152			struct DirCookie;
153			struct AttrDirCookie;
154			struct AttrDirIteratorMap;
155
156private:
157			status_t			_ReadRemoteDir(ShareDir* directory,
158									RemoteShareDirIterator* remoteIterator);
159
160			void				_HandleEntryCreatedRequest(
161									EntryCreatedRequest* request);
162			void				_HandleEntryRemovedRequest(
163									EntryRemovedRequest* request);
164			void				_HandleEntryMovedRequest(
165									EntryMovedRequest* request);
166			void				_HandleStatChangedRequest(
167									StatChangedRequest* request);
168			void				_HandleAttributeChangedRequest(
169									AttributeChangedRequest* request);
170
171			status_t			_GetLocalNodeID(NodeID remoteID, ino_t* localID,
172									bool enter);
173			status_t			_GetRemoteNodeID(ino_t localID,
174									NodeID* remoteID);
175			void				_RemoveLocalNodeID(ino_t localID);
176
177			ShareNode*			_GetNodeByLocalID(ino_t localID);
178			ShareNode*			_GetNodeByRemoteID(NodeID remoteID);
179			status_t			_LoadNode(const NodeInfo& nodeInfo,
180									ShareNode** node);
181			status_t			_UpdateNode(const NodeInfo& nodeInfo);
182
183			ShareDirEntry*		_GetEntryByLocalID(ino_t localDirID,
184									const char* name);
185			ShareDirEntry*		_GetEntryByRemoteID(NodeID remoteDirID,
186									const char* name);
187			status_t			_LoadEntry(ShareDir* directory,
188									const EntryInfo& entryInfo,
189									ShareDirEntry** entry);
190			void				_RemoveEntry(ShareDirEntry* entry);
191			bool				_IsObsoleteEntryInfo(
192									const EntryInfo& entryInfo);
193
194			status_t			_AddAttrDirIterator(ShareNode* node,
195									ShareAttrDirIterator* iterator);
196			void				_RemoveAttrDirIterator(ShareNode* node,
197									ShareAttrDirIterator* iterator);
198			status_t			_LoadAttrDir(ShareNode* node,
199									const AttrDirInfo& attrDirInfo);
200			status_t			_UpdateAttrDir(NodeID remoteID,
201									const AttrDirInfo& attrDirInfo);
202
203			void				_NodeRemoved(NodeID remoteID);
204			void				_EntryCreated(NodeID remoteDirID,
205									const char* name,
206									const EntryInfo* entryInfo, int64 revision);
207			void				_EntryRemoved(NodeID remoteDirID,
208									const char* name, int64 revision);
209			void				_EntryMoved(NodeID remoteOldDirID,
210									const char* oldName, NodeID remoteNewDirID,
211									const char* name,
212									const EntryInfo* entryInfo, int64 revision);
213
214			status_t			_Walk(NodeID remoteDirID, const char* entryName,
215									bool resolveLink, WalkReply** reply);
216			status_t			_MultiWalk(
217									RequestMemberArray<EntryInfo>& entryInfos,
218									MultiWalkReply** reply);
219			status_t			_Close(int32 cookie);
220
221			uint32				_GetConnectionState();
222			bool				_IsConnected();
223			bool				_EnsureShareMounted();
224			status_t			_MountShare();
225
226private:
227			int32				fID;
228			uint32				fFlags;
229			Locker				fMountLock;
230			ShareDir*			fRootNode;
231			NodeMap*			fNodes;			// local ID -> ShareNode
232			EntryMap*			fEntries;		// local ID, name -> ShareDirEntry
233			AttrDirIteratorMap*	fAttrDirIterators;	// local ID -> DLList<>
234			LocalNodeIDMap*		fLocalNodeIDs;	// remote ID -> local ID
235			RemoteNodeIDMap*	fRemoteNodeIDs;	// local ID -> remote ID
236			ServerConnectionProvider* fServerConnectionProvider;
237			ExtendedServerInfo*	fServerInfo;
238			ExtendedShareInfo*	fShareInfo;
239			ServerConnection*	fServerConnection;
240			RequestConnection*	fConnection;
241			uint32				fSharePermissions;
242			uint32				fConnectionState;
243};
244
245#endif	// NET_FS_SHARE_VOLUME_H
246