/// <summary>
/// Create Trans2SetFileSystemInformation requestfor client to set the file system information on server.
/// </summary>
/// <param name = "messageId">the id of message, used to identity the request and the server response. </param>
/// <param name = "sessionUid">the valid session id, must be response by server of the session setup request. </param>
/// <param name = "treeId">the valid tree connect id, must be response by server of the tree connect. </param>
/// <param name = "flags">
/// The Flags field contains individual flags, as specified in [CIFS] sections 2.4.2 and 3.1.1.
/// </param>
/// <param name = "flags2">
/// The Flags2 field contains individual bit flags that, depending on the negotiated SMB dialect, indicate
/// various client and server capabilities.
/// </param>
/// <param name = "fileId">the valid file id to operation on, response by server. </param>
/// <param name = "transactOptions">
/// A set of bit flags that alter the behavior of the requested operation. Unused bit fields MUST be set to
/// zero by the client sending the request, and MUST be ignored by the server receiving the request. The
/// client MAY set either or both of the following bit flags
/// </param>
/// <param name = "timeOut">
/// The maximum amount of time in milliseconds to wait for the operation to complete. The client SHOULD set
/// this to 0 to indicate that no time-out is given. If the operation does not complete within the specified
/// time, the server MAY abort the request and send a failure response.
/// </param>
/// <param name = "isUsePathThrough">
/// Indicates that the client is requesting a native Microsoft Windows® NT operating system information level,
/// as specified in section 3.2.4.7 and in [MS-FSCC] section 2.4.
/// </param>
/// <param name = "informationLevel">
/// Indicates that client specifies the information it is requesting. Server return different data based on
/// the client's request.
/// </param>
/// <param name = "data">the information data to be set. </param>
/// <returns>a set file information request packet </returns>
private SmbTrans2SetFsInformationRequestPacket CreateTrans2SetFileSystemInformationRequest(
ushort messageId,
ushort sessionUid,
ushort treeId,
SmbHeader_Flags_Values flags,
SmbHeader_Flags2_Values flags2,
ushort fileId,
Trans2SmbParametersFlags transactOptions,
uint timeOut,
bool isUsePathThrough,
QueryFSInformationLevel informationLevel,
byte[] data)
{
if (isUsePathThrough)
{
informationLevel = (QueryFSInformationLevel)
(informationLevel + SmbCapability.CONST_SMB_INFO_PASSTHROUGH);
}
SmbTrans2SetFsInformationRequestPacket packet =
new SmbTrans2SetFsInformationRequestPacket(
this.cifsClient.CreateTrans2SetFsInformationRequest(
messageId, sessionUid, treeId, (SmbFlags)flags, (SmbFlags2)flags2,
this.capability.MaxParameterCount, this.capability.MaxDataCount, this.capability.MaxSetupCount,
transactOptions, timeOut, ""));
// Set Trans2_Parameters
TRANS2_SET_FILE_SYSTEM_INFORMATION_Request_Trans2_Parameters trans2Parameters =
new TRANS2_SET_FILE_SYSTEM_INFORMATION_Request_Trans2_Parameters();
trans2Parameters.FID = fileId;
trans2Parameters.InformationLevel = informationLevel;
// Set Trans2_Data
TRANS2_SET_FILE_SYSTEM_INFORMATION_Request_Trans2_Data trans2Data =
new TRANS2_SET_FILE_SYSTEM_INFORMATION_Request_Trans2_Data();
trans2Data.Data = data;
packet.Trans2Parameters = trans2Parameters;
packet.Trans2Data = trans2Data;
packet.UpdateCountAndOffset();
return packet;
}
/// <summary>
/// Deep copy constructor.
/// </summary>
public SmbTrans2SetFsInformationRequestPacket(SmbTrans2SetFsInformationRequestPacket packet)
: base(packet)
{
}
/// <summary>
/// TRANS2_SET_FS_INFORMATION Request.
/// </summary>
/// <param name="messageId">This is used to associate a response with a request.</param>
/// <param name="sessionId">
/// Set this value to 0 to request a new session setup, or set this value to a previously established session
/// identifier to request reauthenticate to an existing session.
/// </param>
/// <param name="treeId">
/// This field identifies the subdirectory (or tree) (also referred as a share in this document) on the
/// server that the client is accessing.
/// </param>
/// <param name="isSigned">
/// Indicate whether the SUT has message signing enabled or required.
/// </param>
/// <param name="isUsePassthrough">
/// Indicate whether adding SMB_INFO_PASSTHROUGH in InformationLevel field of the request.
/// </param>
/// <param name="isRequireDisconnectTreeFlags">Indicate whether flags set to Disconnect_TID.</param>
/// <param name="isRequireNoResponseFlags">Indicate whether flags set to NO_RESPONSE.</param>
/// <param name="informationLevel">This can be used to query information from the server.</param>
/// <param name="fid">The file identifier.</param>
/// <param name="otherBits">If it contains other bits.</param>
/// <param name="reserved">The reserved int value.</param>
public void Trans2SetFsInfoRequest(
int messageId,
int sessionId,
int treeId,
bool isSigned,
bool isUsePassthrough,
bool isRequireDisconnectTreeFlags,
bool isRequireNoResponseFlags,
InformationLevel informationLevel,
int fid,
bool otherBits,
int reserved)
{
#region Create Packet
SmbTrans2SetFsInformationRequestPacket smbPacket = new SmbTrans2SetFsInformationRequestPacket();
ushort uid = (ushort)this.uId[(uint)sessionId];
ushort fileId = (ushort)this.fId[(uint)fid];
NamespaceCifs.Trans2SmbParametersFlags transactOptions = NamespaceCifs.Trans2SmbParametersFlags.NONE;
if (isRequireDisconnectTreeFlags && isRequireNoResponseFlags)
{
transactOptions = NamespaceCifs.Trans2SmbParametersFlags.DISCONNECT_TID
| NamespaceCifs.Trans2SmbParametersFlags.NO_RESPONSE;
}
if (isRequireDisconnectTreeFlags && !isRequireNoResponseFlags)
{
transactOptions = NamespaceCifs.Trans2SmbParametersFlags.DISCONNECT_TID;
}
if (!isRequireDisconnectTreeFlags && isRequireNoResponseFlags)
{
transactOptions = NamespaceCifs.Trans2SmbParametersFlags.NO_RESPONSE;
}
if (!isRequireDisconnectTreeFlags && !isRequireNoResponseFlags)
{
transactOptions = NamespaceCifs.Trans2SmbParametersFlags.NONE;
}
ushort level = this.informationLevelBytes[(ushort)informationLevel];
if (isUsePassthrough)
{
level += InformationLevelPathThrouth;
}
// FILE_FS_CONTROL_INFORMATION data
NamespaceFscc.FileFsControlInformation fileFsControlInformation =
new NamespaceFscc.FileFsControlInformation();
fileFsControlInformation.DefaultQuotaLimit = uint.MinValue;
fileFsControlInformation.DefaultQuotaThreshold = uint.MinValue;
fileFsControlInformation.FileSystemControlFlags =
NamespaceFscc.FileSystemControlFlags_Values.FILE_VC_LOG_QUOTA_LIMIT;
fileFsControlInformation.FreeSpaceStartFiltering = uint.MinValue;
fileFsControlInformation.FreeSpaceStopFiltering = uint.MinValue;
fileFsControlInformation.FreeSpaceThreshold = uint.MinValue;
NamespaceFscc.FsccFileFsControlInformationRequestPacket fsControlPacket
= new NamespaceFscc.FsccFileFsControlInformationRequestPacket();
fsControlPacket.Payload = fileFsControlInformation;
byte[] data = new byte[DataCount];
data = fsControlPacket.ToBytes();
smbPacket = this.smbClientStack.CreateTrans2SetFileSystemInformationRequest(
fileId,
transactOptions,
(NamespaceCifs.QueryFSInformationLevel)level,
data);
NamespaceCifs.SMB_COM_TRANSACTION2_Request_SMB_Parameters smbParameters = smbPacket.SmbParameters;
smbParameters.DataCount = DataCount;
smbPacket.SmbParameters = smbParameters;
if (isSigned)
{
NamespaceCifs.CifsClientPerConnection connection =
this.smbClientStack.Context.GetConnection(ConnectionId);
NamespaceCifs.CifsClientPerSession session =
this.smbClientStack.Context.GetSession(ConnectionId, uid);
smbPacket.Sign(connection.ClientNextSendSequenceNumber, session.SessionKey);
}
#endregion
#region Send and Receive ExpectPacket
this.smbClientStack.SendPacket(smbPacket);
StackPacket response = this.smbClientStack.ExpectPacket(this.timeout);
NamespaceCifs.SmbPacket smbPacketResponse = (NamespaceCifs.SmbPacket)response;
this.QueryUidTable(smbPacketResponse);
this.QueryTidTable(smbPacketResponse);
VerifyTransport(smbPacketResponse);
VerifyCommonMessageSyntax(smbPacketResponse);
if (response.GetType() == typeof(SmbErrorResponsePacket))
{
SmbErrorResponsePacket smbErrorResponsePacket = response as SmbErrorResponsePacket;
NamespaceCifs.SmbHeader smbErrorHeader = smbErrorResponsePacket.SmbHeader;
if (smbErrorHeader.Status == (uint)MessageStatus.StatusInvalidInfoClass)
{
smbErrorHeader.Status = (uint)MessageStatus.NotSupported;
}
//Workaround temp code (SetFsInfo Unknown Error TDQ)
if (informationLevel == InformationLevel.FileFsControlInformaiton &&
!bool.Parse(Site.Properties["IsTDQ33016Fixed"]))
{
this.ErrorResponse(smbErrorHeader.Mid + this.addMidMark, MessageStatus.AccessDenied);
}
else
{
this.ErrorResponse(smbErrorHeader.Mid + this.addMidMark, (MessageStatus)smbErrorHeader.Status);
}
}
else
{
SmbTrans2SetFsInformationResponsePacket smbTrans2SetFsInformationPacket
= response as SmbTrans2SetFsInformationResponsePacket;
NamespaceCifs.SmbHeader trans2SetFsInformationResponseHeader =
smbTrans2SetFsInformationPacket.SmbHeader;
if (this.Trans2SetFsInfoResponse != null)
{
this.Trans2SetFsInfoResponse(
trans2SetFsInformationResponseHeader.Mid + this.addMidMark,
this.QueryUidTable(smbPacketResponse),
this.QueryTidTable(smbPacketResponse),
(smbPacketResponse).IsSignRequired,
(MessageStatus)trans2SetFsInformationResponseHeader.Status);
}
else
{
this.Trans2SetFsInfoResponseAdditional(
trans2SetFsInformationResponseHeader.Mid + this.addMidMark,
this.QueryUidTable(smbPacketResponse),
this.QueryTidTable(smbPacketResponse),
(smbPacketResponse).IsSignRequired,
(MessageStatus)trans2SetFsInformationResponseHeader.Status);
}
}
#endregion
}
/// <summary>
/// TRANS2_SET_FS_INFORMATION request additional.
/// </summary>
/// <param name="messageId">This is used to associate a response with a request.</param>
/// <param name="sessionId">
/// Set this value to 0 to request a new session setup, or set this value to a previously established session
/// identifier to request reauthenticate to an existing session.
/// </param>
/// <param name="treeId">
/// This field identifies the subdirectory (or tree) (also referred as a share in this document) on the
/// server that the client is accessing.
/// </param>
/// <param name="fid">The file identifier.</param>
/// <param name="isSigned">
/// Indicate whether the SUT has message signing enabled or required.
/// </param>
/// <param name="informationLevel">This can be used to query information from the server.</param>
/// <param name="requestPara">Trans2SetFSInfo response parameter.</param>
public void Trans2SetFsInfoRequestAdditional(
int messageId,
int sessionId,
int treeId,
int fid,
bool isSigned,
[Domain("InfoLevelSetByFS")] InformationLevel informationLevel,
Trans2SetFsInfoResponseParameter requestPara)
{
#region Create Packet
SmbTrans2SetFsInformationRequestPacket smbPacket = new SmbTrans2SetFsInformationRequestPacket();
ushort uid = (ushort)this.uId[(uint)sessionId];
ushort fileId = (ushort)this.fId[(uint)fid];
NamespaceCifs.Trans2SmbParametersFlags transactOptions = NamespaceCifs.Trans2SmbParametersFlags.NONE;
ushort level = ushort.MaxValue;
if (informationLevel != InformationLevel.Invalid)
{
level = this.informationLevelBytes[(ushort)informationLevel];
//This field MUST be a pass-through Information Level
this.smbClientStack.Capability.IsUsePathThrough = true;
}
else
{
level = this.informationLevelBytes[(ushort)InformationLevel.FileFsControlInformaiton];
//This field MUST be a pass-through Information Level
this.smbClientStack.Capability.IsUsePathThrough = false;
}
byte[] data = new byte[DataCount];
smbPacket = this.smbClientStack.CreateTrans2SetFileSystemInformationRequest(
fileId,
transactOptions,
(NamespaceCifs.QueryFSInformationLevel)level,
data);
bool isInvalidFileId = false;
if (requestPara == Trans2SetFsInfoResponseParameter.FileIdErrror)
{
isInvalidFileId = true;
}
if (isInvalidFileId)
{
TRANS2_SET_FILE_SYSTEM_INFORMATION_Request_Trans2_Parameters trans2Parameters =
smbPacket.Trans2Parameters;
trans2Parameters.FID = ushort.MaxValue;
smbPacket.Trans2Parameters = trans2Parameters;
}
if (isSigned)
{
NamespaceCifs.CifsClientPerConnection connection =
this.smbClientStack.Context.GetConnection(ConnectionId);
NamespaceCifs.CifsClientPerSession session =
this.smbClientStack.Context.GetSession(ConnectionId, uid);
smbPacket.Sign(connection.ClientNextSendSequenceNumber, session.SessionKey);
}
#endregion
#region Send and Receive ExpectPacket
this.smbClientStack.SendPacket(smbPacket);
StackPacket response = this.smbClientStack.ExpectPacket(this.timeout);
NamespaceCifs.SmbPacket smbPacketResponse = (NamespaceCifs.SmbPacket)response;
this.QueryUidTable(smbPacketResponse);
this.QueryTidTable(smbPacketResponse);
VerifyTransport(smbPacketResponse);
VerifyCommonMessageSyntax(smbPacketResponse);
if (response.GetType() == typeof(SmbErrorResponsePacket))
{
SmbErrorResponsePacket smbErrorResponsePacket = response as SmbErrorResponsePacket;
NamespaceCifs.SmbHeader smbErrorHeader = smbErrorResponsePacket.SmbHeader;
if (smbErrorHeader.Status == (uint)MessageStatus.StatusInvalidInfoClass)
{
smbErrorHeader.Status = (uint)MessageStatus.NotSupported;
}
//Workaround temp code (How to trigger the error Status_Data_Error)
if ((informationLevel == InformationLevel.FileFsControlInformaiton) &&
!bool.Parse(Site.Properties["IsTDQ49846Fixed"]))
{
smbErrorHeader.Status = (uint)MessageStatus.StatusDataError;
}
this.ErrorTrans2SetFsInfoResponseAdditional(
smbErrorHeader.Mid + this.addMidMark,
(MessageStatus)smbErrorHeader.Status);
}
else
{
SmbTrans2SetFsInformationResponsePacket smbTrans2SetFsInformationPacket
= response as SmbTrans2SetFsInformationResponsePacket;
NamespaceCifs.SmbHeader trans2SetFsInformationResponseHeader = smbTrans2SetFsInformationPacket.SmbHeader;
this.Trans2SetFsInfoResponseAdditional(
trans2SetFsInformationResponseHeader.Mid + this.addMidMark,
this.QueryUidTable(smbPacketResponse),
this.QueryTidTable(smbPacketResponse),
(smbPacketResponse).IsSignRequired,
(MessageStatus)trans2SetFsInformationResponseHeader.Status);
}
#endregion
}
/// <summary>
/// find the transaction2 packet.
/// </summary>
/// <param name="command">the command of transaction2 packet.</param>
/// <returns>the target transaction2 packet</returns>
private static SmbPacket FindTheTrans2Packet(Trans2SubCommand command)
{
SmbPacket smbPacket = null;
switch ((Trans2SubCommand)command)
{
case Trans2SubCommand.TRANS2_FIND_FIRST2:
smbPacket = new SmbTrans2FindFirst2RequestPacket();
break;
case Trans2SubCommand.TRANS2_FIND_NEXT2:
smbPacket = new SmbTrans2FindNext2RequestPacket();
break;
case Trans2SubCommand.TRANS2_QUERY_FS_INFORMATION:
smbPacket = new SmbTrans2QueryFsInformationRequestPacket();
break;
case Trans2SubCommand.TRANS2_SET_FS_INFORMATION:
smbPacket = new SmbTrans2SetFsInformationRequestPacket();
break;
case Trans2SubCommand.TRANS2_QUERY_PATH_INFORMATION:
smbPacket = new SmbTrans2QueryPathInformationRequestPacket();
break;
case Trans2SubCommand.TRANS2_SET_PATH_INFORMATION:
smbPacket = new SmbTrans2SetPathInformationRequestPacket();
break;
case Trans2SubCommand.TRANS2_QUERY_FILE_INFORMATION:
smbPacket = new SmbTrans2QueryFileInformationRequestPacket();
break;
case Trans2SubCommand.TRANS2_SET_FILE_INFORMATION:
smbPacket = new SmbTrans2SetFileInformationRequestPacket();
break;
case Trans2SubCommand.TRANS2_GET_DFS_REFERRAL:
smbPacket = new SmbTrans2GetDfsReferralRequestPacket();
break;
default:
break;
}
return smbPacket;
}
