/// <summary>
/// Read data from server, start at the positon indicated by offset
/// </summary>
/// <param name="timeout">The pending time to get server's response</param>
/// <param name="offset">From where it will read</param>
/// <param name="length">The length of the data client wants to read</param>
/// <param name="data">The read data</param>
/// <returns>
/// a uint value that specifies the status of response packet.
/// </returns>
/// <exception cref="System.InvalidOperationException">Thrown if there is any error occurred</exception>
public override uint Read(TimeSpan timeout, ulong offset, uint length, out byte[] data)
{
this.internalTimeout = timeout;
SmbReadAndxRequestPacket request = smbClient.CreateReadRequest(this.fid, (ushort)length, (uint)offset);
if (this.isSignRequired)
{
request.Sign(this.NextSequenceNumber, this.sessionKey);
}
uint status = 0;
SmbReadAndxResponsePacket response =
this.SendAndExpectSmbPacket(request, internalTimeout, out status) as SmbReadAndxResponsePacket;
data = ArrayUtility.SubArray <byte>(response.SmbData.Data, 0);
return(SmbMessageUtils.CheckStatus(status));
}
/// <summary>
/// Deep copy constructor.
/// </summary>
public SmbReadAndxRequestPacket(SmbReadAndxRequestPacket packet)
: base(packet)
{
}
/// <summary>
/// find the target packet.
/// </summary>
/// <param name="smbHeader">the header of smb packet</param>
/// <param name="channel">the channel to access bytes</param>
/// <returns>the target packet</returns>
private static SmbPacket FindTheTargetPacket(SmbHeader smbHeader, Channel channel)
{
SmbPacket smbPacket = null;
switch (smbHeader.Command)
{
case SmbCommand.SMB_COM_NEGOTIATE:
smbPacket = new SmbNegotiateRequestPacket();
break;
case SmbCommand.SMB_COM_SESSION_SETUP_ANDX:
SmbHeader_Flags2_Values flags2 = (SmbHeader_Flags2_Values)smbHeader.Flags2;
if ((flags2 & SmbHeader_Flags2_Values.SMB_FLAGS2_EXTENDED_SECURITY)
== SmbHeader_Flags2_Values.SMB_FLAGS2_EXTENDED_SECURITY)
{
smbPacket = new Smb.SmbSessionSetupAndxRequestPacket();
}
else
{
smbPacket = new Cifs.SmbSessionSetupAndxRequestPacket();
}
break;
case SmbCommand.SMB_COM_TREE_CONNECT_ANDX:
smbPacket = new SmbTreeConnectAndxRequestPacket();
break;
case SmbCommand.SMB_COM_NT_CREATE_ANDX:
smbPacket = new SmbNtCreateAndxRequestPacket();
break;
case SmbCommand.SMB_COM_OPEN_ANDX:
smbPacket = new SmbOpenAndxRequestPacket();
break;
case SmbCommand.SMB_COM_WRITE_ANDX:
smbPacket = new SmbWriteAndxRequestPacket();
break;
case SmbCommand.SMB_COM_READ_ANDX:
smbPacket = new SmbReadAndxRequestPacket();
break;
case SmbCommand.SMB_COM_CLOSE:
smbPacket = new SmbCloseRequestPacket();
break;
case SmbCommand.SMB_COM_TREE_DISCONNECT:
smbPacket = new SmbTreeDisconnectRequestPacket();
break;
case SmbCommand.SMB_COM_LOGOFF_ANDX:
smbPacket = new SmbLogoffAndxRequestPacket();
break;
case SmbCommand.SMB_COM_TRANSACTION:
SMB_COM_TRANSACTION_Request_SMB_Parameters transaction =
channel.Read <SMB_COM_TRANSACTION_Request_SMB_Parameters>();
if (transaction.SetupCount == 0)
{
smbPacket = new SmbTransRapRequestPacket();
}
else
{
smbPacket = FindTheTransactionPacket(
transaction.SetupCount, (TransSubCommand)transaction.Setup[0]);
}
break;
case SmbCommand.SMB_COM_TRANSACTION2:
SMB_COM_TRANSACTION2_Request_SMB_Parameters transaction2 =
channel.Read <SMB_COM_TRANSACTION2_Request_SMB_Parameters>();
smbPacket = FindTheTrans2Packet((Trans2SubCommand)transaction2.Subcommand);
break;
case SmbCommand.SMB_COM_NT_TRANSACT:
SMB_COM_NT_TRANSACT_Request_SMB_Parameters ntTransactoin =
channel.Read <SMB_COM_NT_TRANSACT_Request_SMB_Parameters>();
smbPacket = FindTheNtTransPacket(ntTransactoin.Function, CifsMessageUtils.ToBytesArray <ushort>(ntTransactoin.Setup));
break;
default:
break;
}
return(smbPacket);
}
/// <summary>
/// Deep copy constructor.
/// </summary>
public SmbReadAndxRequestPacket(SmbReadAndxRequestPacket packet)
: base(packet)
{
}
