/// <summary>
/// Deep copy constructor.
/// </summary>
public SmbTransRapResponsePacket(SmbTransRapResponsePacket packet)
: base(packet)
{
}
/// <summary>
/// Create Named Rap Response
/// </summary>
/// <param name="connection">the connection identified the client</param>
/// <param name="win32ErrorCode">
/// This MUST be a 16-bit unsigned integer. It contains a Win32 error code representing the result of the
/// Remote Administration Protocol command. The following table lists error codes that have particular meaning
/// to the Remote Administration Protocol, as indicated in this specification.
/// </param>
/// <param name="converter">
/// This field MUST contain a 16-bit signed integer, which a client MUST subtract from the string offset
/// contained in the low 16 bits of a variable-length field in the Remote Administration Protocol response
/// buffer. This is to derive the actual byte offset from the start of the response buffer for that field.
/// </param>
/// <param name="rapOutParams">
/// If present, this structure MUST contain the response information for the Remote Administration Protocol
/// command in the corresponding Remote Administration Protocol request message. Certain RAPOpcodes require
/// a RAPOutParams structure; for Remote Administration Protocol commands that require a RAPOutParams
/// structure, see sections 2.5.5, 2.5.6, 2.5.7, 2.5.8, and 2.5.9.
/// </param>
/// <param name="rapOutData">
/// This is the response data for the Remote Administration Protocol operation. The content of the RAPOutData
/// structure varies according to the Remote Administration Protocol command and the parameters of each Remote
/// Administration Protocol command. See Remote Administration Protocol responses for each Remote
/// Administration Protocol command in sections 2.5.5, 2.5.6, 2.5.7, 2.5.8, and 2.5.9.
/// </param>
/// <returns>a Named Rap write response </returns>
/// <exception cref="ArgumentNullException">connection must not be null</exception>
public virtual SmbTransRapResponsePacket CreateTransNamedRapResponse(
SmbServerConnection connection,
ushort win32ErrorCode,
ushort converter,
byte[] rapOutParams,
byte[] rapOutData)
{
if (connection == null)
{
throw new ArgumentNullException("connection");
}
SmbTransRapResponsePacket packet = new SmbTransRapResponsePacket();
// get the request packet
SmbPacket request = connection.GetRequestPacket(connection.MessageId);
// create smb packet header
packet.SmbHeader = CifsMessageUtils.CreateSmbHeader(
SmbCommand.SMB_COM_TRANSACTION,
connection.ProcessId, connection.MessageId, request.SmbHeader.Uid, request.SmbHeader.Tid,
(SmbFlags)connection.Capability.Flag, (SmbFlags2)connection.Capability.Flags2);
// update smb parameters
SMB_COM_TRANSACTION_SuccessResponse_SMB_Parameters smbParameters = packet.SmbParameters;
smbParameters.Setup = new ushort[0];
smbParameters.WordCount = (byte)(CifsMessageUtils.GetSize<SMB_COM_TRANSACTION_SuccessResponse_SMB_Parameters>(
smbParameters) / SmbCapability.NUM_BYTES_OF_WORD);
// update smb data
SMB_COM_TRANSACTION_SuccessResponse_SMB_Data smbData = packet.SmbData;
// update trans parameters
TRANSACTION_Rap_Response_Trans_Parameters transParameters = packet.TransParameters;
transParameters.Win32ErrorCode = win32ErrorCode;
transParameters.Converter = converter;
transParameters.RAPOutParams = rapOutParams;
// update trans data
TRANSACTION_Rap_Response_Trans_Data transData = packet.TransData;
transData.RAPOutData = rapOutData;
// store the parameters and data to packet.
packet.TransParameters = transParameters;
packet.TransData = transData;
packet.SmbParameters = smbParameters;
packet.SmbData = smbData;
packet.UpdateCountAndOffset();
return packet;
}
/// <summary>
/// createt the transactions packet
/// </summary>
/// <param name="request">the request packet</param>
/// <param name="smbHeader">the smb header of response packet</param>
/// <param name="channel">the channel contains the packet bytes</param>
/// <returns>the response packet</returns>
private SmbPacket CreateTransactionResponsePacket(SmbPacket request, SmbHeader smbHeader, Channel channel)
{
SmbPacket smbPacket = null;
if (smbHeader.Status == 0 && channel.Peek<byte>(0) == 0 && channel.Peek<ushort>(1) == 0)
{
return smbPacket;
}
SmbTransactionRequestPacket transactionRequest = request as SmbTransactionRequestPacket;
if (transactionRequest == null)
{
return smbPacket;
}
switch (smbClient.Capability.TransactionSubCommand)
{
case TransSubCommandExtended.TRANS_EXT_MAILSLOT_WRITE:
smbPacket = new SmbTransMailslotWriteResponsePacket();
break;
case TransSubCommandExtended.TRANS_EXT_RAP:
smbPacket = new SmbTransRapResponsePacket();
break;
default:
break;
}
// the packet is find
if (smbPacket != null)
{
return smbPacket;
}
// if no setup command. break
if (transactionRequest.SmbParameters.SetupCount == 0)
{
return smbPacket;
}
// decode packet using the setup command
switch ((TransSubCommand)transactionRequest.SmbParameters.Setup[0])
{
case TransSubCommand.TRANS_SET_NMPIPE_STATE:
smbPacket = new SmbTransSetNmpipeStateResponsePacket();
break;
case TransSubCommand.TRANS_QUERY_NMPIPE_STATE:
smbPacket = new SmbTransQueryNmpipeStateResponsePacket();
break;
case TransSubCommand.TRANS_RAW_READ_NMPIPE:
smbPacket = new SmbTransRawReadNmpipeResponsePacket();
break;
case TransSubCommand.TRANS_QUERY_NMPIPE_INFO:
smbPacket = new SmbTransQueryNmpipeInfoResponsePacket();
break;
case TransSubCommand.TRANS_PEEK_NMPIPE:
smbPacket = new SmbTransPeekNmpipeResponsePacket();
break;
case TransSubCommand.TRANS_TRANSACT_NMPIPE:
smbPacket = new SmbTransTransactNmpipeResponsePacket();
break;
case TransSubCommand.TRANS_READ_NMPIPE:
smbPacket = new SmbTransReadNmpipeResponsePacket();
break;
case TransSubCommand.TRANS_WRITE_NMPIPE:
smbPacket = new SmbTransWriteNmpipeResponsePacket();
break;
case TransSubCommand.TRANS_WAIT_NMPIPE:
smbPacket = new SmbTransWaitNmpipeResponsePacket();
break;
case TransSubCommand.TRANS_CALL_NMPIPE:
smbPacket = new SmbTransCallNmpipeResponsePacket();
break;
default:
break;
}
return smbPacket;
}
