public Nfs3FileStream(Nfs3Client client, Nfs3FileHandle handle, FileAccess access)
{
_client = client;
_handle = handle;
_access = access;
_length = _client.GetAttributes(_handle).Size;
}
internal Nfs3MountResult(XdrDataReader reader)
{
FileHandle = new Nfs3FileHandle(reader);
int numAuthFlavours = reader.ReadInt32();
AuthFlavours = new List<int>(numAuthFlavours);
for (int i = 0; i < numAuthFlavours; ++i)
{
AuthFlavours.Add(reader.ReadInt32());
}
}
public Nfs3Client(string address, RpcCredentials credentials, string mountPoint)
{
_rpcClient = new RpcClient(address, credentials);
_mountClient = new Nfs3Mount(_rpcClient);
_rootHandle = _mountClient.Mount(mountPoint).FileHandle;
_nfsClient = new Nfs3(_rpcClient);
Nfs3FileSystemInfoResult fsiResult = _nfsClient.FileSystemInfo(_rootHandle);
_fsInfo = fsiResult.FileSystemInfo;
_cachedAttributes = new Dictionary<Nfs3FileHandle, Nfs3FileAttributes>();
_cachedAttributes[_rootHandle] = fsiResult.PostOpAttributes;
}
public Nfs3DirectoryEntry(XdrDataReader reader)
{
FileId = reader.ReadUInt64();
Name = reader.ReadString();
Cookie = reader.ReadUInt64();
if (reader.ReadBool())
{
FileAttributes = new Nfs3FileAttributes(reader);
}
if (reader.ReadBool())
{
FileHandle = new Nfs3FileHandle(reader);
}
}
public Nfs3DirectoryEntry(XdrDataReader reader)
{
FileId = reader.ReadUInt64();
Name = reader.ReadString();
Cookie = reader.ReadUInt64();
if (reader.ReadBool())
{
FileAttributes = new Nfs3FileAttributes(reader);
}
if (reader.ReadBool())
{
FileHandle = new Nfs3FileHandle(reader);
}
}
public Nfs3CreateResult(XdrDataReader reader)
{
Status = (Nfs3Status)reader.ReadInt32();
if (Status == Nfs3Status.Ok)
{
if (reader.ReadBool())
{
FileHandle = new Nfs3FileHandle(reader);
}
if (reader.ReadBool())
{
FileAttributes = new Nfs3FileAttributes(reader);
}
}
CacheConsistency = new Nfs3WeakCacheConsistency(reader);
}
public Nfs3LookupResult(XdrDataReader reader)
{
Status = (Nfs3Status)reader.ReadInt32();
if (Status == Nfs3Status.Ok)
{
ObjectHandle = new Nfs3FileHandle(reader);
if (reader.ReadBool())
{
ObjectAttributes = new Nfs3FileAttributes(reader);
}
}
if (reader.ReadBool())
{
DirAttributes = new Nfs3FileAttributes(reader);
}
}
public Nfs3CreateResult(XdrDataReader reader)
{
Status = (Nfs3Status)reader.ReadInt32();
if (Status == Nfs3Status.Ok)
{
if (reader.ReadBool())
{
FileHandle = new Nfs3FileHandle(reader);
}
if (reader.ReadBool())
{
FileAttributes = new Nfs3FileAttributes(reader);
}
}
CacheConsistency = new Nfs3WeakCacheConsistency(reader);
}
public Nfs3LookupResult(XdrDataReader reader)
{
Status = (Nfs3Status)reader.ReadInt32();
if (Status == Nfs3Status.Ok)
{
ObjectHandle = new Nfs3FileHandle(reader);
if (reader.ReadBool())
{
ObjectAttributes = new Nfs3FileAttributes(reader);
}
}
if (reader.ReadBool())
{
DirAttributes = new Nfs3FileAttributes(reader);
}
}
public Nfs3AccessPermissions Access(Nfs3FileHandle handle, Nfs3AccessPermissions requested)
{
Nfs3AccessResult result = _nfsClient.Access(handle, requested);
if (result.ObjectAttributes != null)
{
_cachedAttributes[handle] = result.ObjectAttributes;
}
if (result.Status == Nfs3Status.Ok)
{
return result.Access;
}
else
{
throw new Nfs3Exception(result.Status);
}
}
public Nfs3FileAttributes GetAttributes(Nfs3FileHandle handle)
{
Nfs3FileAttributes result;
if (_cachedAttributes.TryGetValue(handle, out result))
{
return result;
}
Nfs3GetAttributesResult getResult = _nfsClient.GetAttributes(handle);
if (getResult.Status == Nfs3Status.Ok)
{
_cachedAttributes[handle] = getResult.Attributes;
return getResult.Attributes;
}
else
{
throw new Nfs3Exception(getResult.Status);
}
}
public void RoundTripTest()
{
Nfs3FileHandle attributes = new Nfs3FileHandle()
{
Value = new byte[] { 0x01 }
};
Nfs3FileHandle clone = null;
using (MemoryStream stream = new MemoryStream())
{
XdrDataWriter writer = new XdrDataWriter(stream);
attributes.Write(writer);
stream.Position = 0;
XdrDataReader reader = new XdrDataReader(stream);
clone = new Nfs3FileHandle(reader);
}
Assert.Equal(attributes, clone);
}
public Nfs3FileHandle MakeDirectory(Nfs3FileHandle dirHandle, string name, Nfs3SetAttributes attributes)
{
Nfs3CreateResult result = _nfsClient.MakeDirectory(dirHandle, name, attributes);
if (result.Status == Nfs3Status.Ok)
{
_cachedAttributes[result.FileHandle] = result.FileAttributes;
return result.FileHandle;
}
else
{
throw new Nfs3Exception(result.Status);
}
}
public int Write(Nfs3FileHandle fileHandle, long position, byte[] buffer, int offset, int count)
{
Nfs3WriteResult result = _nfsClient.Write(fileHandle, position, buffer, offset, count);
_cachedAttributes[fileHandle] = result.CacheConsistency.After;
if (result.Status == Nfs3Status.Ok)
{
return result.Count;
}
else
{
throw new Nfs3Exception(result.Status);
}
}
public Nfs3ReadResult Read(Nfs3FileHandle fileHandle, long position, int count)
{
Nfs3ReadResult result = _nfsClient.Read(fileHandle, position, count);
if (result.FileAttributes != null)
{
_cachedAttributes[fileHandle] = result.FileAttributes;
}
if (result.Status == Nfs3Status.Ok)
{
return result;
}
else
{
throw new Nfs3Exception(result.Status);
}
}
public Nfs3FileHandle Lookup(Nfs3FileHandle dirHandle, string name)
{
Nfs3LookupResult result = _nfsClient.Lookup(dirHandle, name);
if (result.ObjectAttributes != null && result.ObjectHandle != null)
{
_cachedAttributes[result.ObjectHandle] = result.ObjectAttributes;
}
if (result.DirAttributes != null)
{
_cachedAttributes[dirHandle] = result.DirAttributes;
}
if (result.Status == Nfs3Status.Ok)
{
return result.ObjectHandle;
}
else if (result.Status == Nfs3Status.NoSuchEntity)
{
return null;
}
else
{
throw new Nfs3Exception(result.Status);
}
}
public Nfs3ModifyResult SetAttributes(Nfs3FileHandle handle, Nfs3SetAttributes newAttributes)
{
MemoryStream ms = new MemoryStream();
XdrDataWriter writer = StartCallMessage(ms, _client.Credentials, 2);
handle.Write(writer);
newAttributes.Write(writer);
writer.Write(false);
RpcReply reply = DoSend(ms);
if (reply.Header.IsSuccess)
{
return new Nfs3ModifyResult(reply.BodyReader);
}
else
{
throw new RpcException(reply.Header.ReplyHeader);
}
}
public Nfs3WriteResult Write(Nfs3FileHandle handle, long position, byte[] buffer, int bufferOffset, int count)
{
MemoryStream ms = new MemoryStream();
XdrDataWriter writer = StartCallMessage(ms, _client.Credentials, 7);
handle.Write(writer);
writer.Write(position);
writer.Write(count);
writer.Write((int)0); // UNSTABLE
writer.WriteBuffer(buffer, bufferOffset, count);
RpcReply reply = DoSend(ms);
if (reply.Header.IsSuccess)
{
return new Nfs3WriteResult(reply.BodyReader);
}
else
{
throw new RpcException(reply.Header.ReplyHeader);
}
}
internal IEnumerable<Nfs3DirectoryEntry> ReadDirectory(Nfs3FileHandle parent, bool silentFail)
{
ulong cookie = 0;
byte[] cookieVerifier = null;
Nfs3ReadDirPlusResult result;
do
{
result = _nfsClient.ReadDirPlus(parent, cookie, cookieVerifier, _fsInfo.DirectoryPreferredBytes, _fsInfo.ReadMaxBytes);
if (result.Status == Nfs3Status.AccessDenied && silentFail)
{
break;
}
else if (result.Status != Nfs3Status.Ok)
{
throw new Nfs3Exception(result.Status);
}
foreach (var entry in result.DirEntries)
{
_cachedAttributes[entry.FileHandle] = entry.FileAttributes;
yield return entry;
cookie = entry.Cookie;
}
cookieVerifier = result.CookieVerifier;
}
while (!result.Eof);
}
private void DoSearch(List<string> results, Nfs3FileHandle dir, string path, Regex regex, bool subFolders, bool dirs, bool files)
{
foreach (Nfs3DirectoryEntry de in _client.ReadDirectory(dir, true))
{
if (de.Name == "." || de.Name == "..")
{
continue;
}
bool isDir = de.FileAttributes.Type == Nfs3FileType.Directory;
if ((isDir && dirs) || (!isDir && files))
{
string searchName = (de.Name.IndexOf('.') == -1) ? de.Name + "." : de.Name;
if (regex.IsMatch(searchName))
{
results.Add(Utilities.CombinePaths(path, de.Name));
}
}
if (subFolders && isDir)
{
DoSearch(results, de.FileHandle, Utilities.CombinePaths(path, de.Name), regex, subFolders, dirs, files);
}
}
}
public Nfs3FileSystemInfoResult FileSystemInfo(Nfs3FileHandle fileHandle)
{
MemoryStream ms = new MemoryStream();
XdrDataWriter writer = StartCallMessage(ms, _client.Credentials, 19);
fileHandle.Write(writer);
RpcReply reply = DoSend(ms);
if (reply.Header.IsSuccess)
{
Nfs3FileSystemInfoResult fsiReply = new Nfs3FileSystemInfoResult(reply.BodyReader);
if (fsiReply.Status == Nfs3Status.Ok)
{
return fsiReply;
}
else
{
throw new Nfs3Exception(fsiReply.Status);
}
}
else
{
throw new RpcException(reply.Header.ReplyHeader);
}
}
public Nfs3ModifyResult RemoveDirectory(Nfs3FileHandle dirHandle, string name)
{
MemoryStream ms = new MemoryStream();
XdrDataWriter writer = StartCallMessage(ms, _client.Credentials, 13);
dirHandle.Write(writer);
writer.Write(name);
RpcReply reply = DoSend(ms);
if (reply.Header.IsSuccess)
{
return new Nfs3ModifyResult(reply.BodyReader);
}
else
{
throw new RpcException(reply.Header.ReplyHeader);
}
}
public Nfs3CreateResult Create(Nfs3FileHandle dirHandle, string name, bool createNew, Nfs3SetAttributes attributes)
{
MemoryStream ms = new MemoryStream();
XdrDataWriter writer = StartCallMessage(ms, _client.Credentials, 8);
dirHandle.Write(writer);
writer.Write(name);
writer.Write((int)(createNew ? 1 : 0));
attributes.Write(writer);
RpcReply reply = DoSend(ms);
if (reply.Header.IsSuccess)
{
return new Nfs3CreateResult(reply.BodyReader);
}
else
{
throw new RpcException(reply.Header.ReplyHeader);
}
}
public void RemoveDirectory(Nfs3FileHandle dirHandle, string name)
{
Nfs3ModifyResult result = _nfsClient.RemoveDirectory(dirHandle, name);
_cachedAttributes[dirHandle] = result.CacheConsistency.After;
if (result.Status != Nfs3Status.Ok)
{
throw new Nfs3Exception(result.Status);
}
}
private Nfs3FileHandle GetDirectory(Nfs3FileHandle parent, string[] dirs)
{
if (dirs == null)
{
return parent;
}
Nfs3FileHandle handle = parent;
for (int i = 0; i < dirs.Length; ++i)
{
handle = _client.Lookup(handle, dirs[i]);
if (handle == null || _client.GetAttributes(handle).Type != Nfs3FileType.Directory)
{
throw new DirectoryNotFoundException();
}
}
return handle;
}
public void Rename(Nfs3FileHandle fromDirHandle, string fromName, Nfs3FileHandle toDirHandle, string toName)
{
Nfs3RenameResult result = _nfsClient.Rename(fromDirHandle, fromName, toDirHandle, toName);
_cachedAttributes[fromDirHandle] = result.FromDirCacheConsistency.After;
_cachedAttributes[toDirHandle] = result.ToDirCacheConsistency.After;
if (result.Status != Nfs3Status.Ok)
{
throw new Nfs3Exception(result.Status);
}
}
public Nfs3AccessResult Access(Nfs3FileHandle handle, Nfs3AccessPermissions requested)
{
MemoryStream ms = new MemoryStream();
XdrDataWriter writer = StartCallMessage(ms, _client.Credentials, 4);
handle.Write(writer);
writer.Write((int)requested);
RpcReply reply = DoSend(ms);
if (reply.Header.IsSuccess)
{
return new Nfs3AccessResult(reply.BodyReader);
}
else
{
throw new RpcException(reply.Header.ReplyHeader);
}
}
public Nfs3RenameResult Rename(Nfs3FileHandle fromDirHandle, string fromName, Nfs3FileHandle toDirHandle, string toName)
{
MemoryStream ms = new MemoryStream();
XdrDataWriter writer = StartCallMessage(ms, _client.Credentials, 14);
fromDirHandle.Write(writer);
writer.Write(fromName);
toDirHandle.Write(writer);
writer.Write(toName);
RpcReply reply = DoSend(ms);
if (reply.Header.IsSuccess)
{
return new Nfs3RenameResult(reply.BodyReader);
}
else
{
throw new RpcException(reply.Header.ReplyHeader);
}
}
public Nfs3ReadResult Read(Nfs3FileHandle handle, long position, int count)
{
MemoryStream ms = new MemoryStream();
XdrDataWriter writer = StartCallMessage(ms, _client.Credentials, 6);
handle.Write(writer);
writer.Write(position);
writer.Write(count);
RpcReply reply = DoSend(ms);
if (reply.Header.IsSuccess)
{
return new Nfs3ReadResult(reply.BodyReader);
}
else
{
throw new RpcException(reply.Header.ReplyHeader);
}
}
public void SetAttributes(Nfs3FileHandle handle, Nfs3SetAttributes newAttributes)
{
Nfs3ModifyResult result = _nfsClient.SetAttributes(handle, newAttributes);
_cachedAttributes[handle] = result.CacheConsistency.After;
if (result.Status != Nfs3Status.Ok)
{
throw new Nfs3Exception(result.Status);
}
}
public Nfs3ReadDirPlusResult ReadDirPlus(Nfs3FileHandle dir, ulong cookie, byte[] cookieVerifier, uint dirCount, uint maxCount)
{
MemoryStream ms = new MemoryStream();
XdrDataWriter writer = StartCallMessage(ms, _client.Credentials, 17);
dir.Write(writer);
writer.Write(cookie);
writer.WriteBytes(cookieVerifier ?? new byte[Nfs3.CookieVerifierSize]);
writer.Write(dirCount);
writer.Write(maxCount);
RpcReply reply = DoSend(ms);
if (reply.Header.IsSuccess)
{
return new Nfs3ReadDirPlusResult(reply.BodyReader);
}
else
{
throw new RpcException(reply.Header.ReplyHeader);
}
}
