/// <summary> /// Create tree disconnect request packet for client to dis connect a share on server. This command can follow /// the tree connect command. /// </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 = "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 = "treeId">the valid tree id to disconnect </param> /// <returns>a tree disconnect request packet. </returns> private SmbTreeDisconnectRequestPacket CreateTreeDisconnectRequest( ushort messageId, ushort sessionUid, ushort treeId, SmbHeader_Flags_Values flags, SmbHeader_Flags2_Values flags2 ) { return new SmbTreeDisconnectRequestPacket( this.cifsClient.CreateTreeDisconnectRequest( messageId, sessionUid, treeId, (SmbFlags)flags, (SmbFlags2)flags2)); }
/// <summary> /// Create a close request packet for client to close a opened share. /// </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 id of file to close </param> /// <returns>a close request packet </returns> private SmbCloseRequestPacket CreateCloseRequest( ushort messageId, ushort sessionUid, ushort treeId, SmbHeader_Flags_Values flags, SmbHeader_Flags2_Values flags2, ushort fileId) { return new SmbCloseRequestPacket( this.cifsClient.CreateCloseRequest( messageId, sessionUid, treeId, (SmbFlags)flags, (SmbFlags2)flags2, fileId, new UTime())); }
/// <summary> /// Create TransQueryNamedPipeInfo request for client to query the information of named pipe. /// </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 = "informationLevel"> /// A USHORT value (as specified in [MS-DTYP] section 2.2.54) that describes the information level being /// queried for the pipe. The only supported value is 0x0001. /// </param> /// <returns>a query named pipe information request packet </returns> /// <exception cref="ArgumentException">The only supported value is 0x0001.</exception> private SmbTransQueryNmpipeInfoRequestPacket CreateTransQueryNamedPipeInfoRequest( ushort messageId, ushort sessionUid, ushort treeId, SmbHeader_Flags_Values flags, SmbHeader_Flags2_Values flags2, ushort fileId, TransSmbParametersFlags transactOptions, uint timeOut, NamedPipeInformationLevel informationLevel) { if (informationLevel != NamedPipeInformationLevel.VALID) { throw new ArgumentException("The only supported value is 0x0001.", "informationLevel"); } return new SmbTransQueryNmpipeInfoRequestPacket( this.cifsClient.CreateTransQueryNmpipeInfoRequest( messageId, sessionUid, treeId, (SmbFlags)flags, (SmbFlags2)flags2, this.capability.MaxParameterCount, this.capability.MaxDataCount, this.capability.MaxSetupCount, transactOptions, timeOut, fileId, "")); }
/// <summary> /// Create TransWriteNamedPipe request for client to write data to named pipe. /// </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 = "writeData">The data to write to named pipe. </param> /// <returns>a write named pipe request packet </returns> private SmbTransWriteNmpipeRequestPacket CreateTransWriteNamedPipeRequest( ushort messageId, ushort sessionUid, ushort treeId, SmbHeader_Flags_Values flags, SmbHeader_Flags2_Values flags2, ushort fileId, TransSmbParametersFlags transactOptions, uint timeOut, byte[] writeData) { return new SmbTransWriteNmpipeRequestPacket( this.cifsClient.CreateTransWriteNmpipeRequest( messageId, sessionUid, treeId, (SmbFlags)flags, (SmbFlags2)flags2, this.capability.MaxParameterCount, this.capability.MaxDataCount, this.capability.MaxSetupCount, transactOptions, timeOut, fileId, writeData, "")); }
/// <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> /// Create TransMailslotWrite request for client to write data to mailslot 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 = "mailslotName">The name of maislot to write to. </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 = "writeData">The data to write to mailslot. </param> /// <param name = "priority"> /// This field MUST be in the range of 0 to 9. The larger value being the higher priority. /// </param> /// <param name = "className"> /// The third setup word and the class of the mailslot request. This value MUST be set to one of the following /// values. /// </param> /// <returns>a write mailslot request packet </returns> private SmbTransMailslotWriteRequestPacket CreateTransMailslotWriteRequest( ushort messageId, ushort sessionUid, ushort treeId, SmbHeader_Flags_Values flags, SmbHeader_Flags2_Values flags2, string mailslotName, TransSmbParametersFlags transactOptions, uint timeOut, byte[] writeData, ushort priority, SmbTransMailslotClass className) { if (mailslotName == null) { mailslotName = string.Empty; } SmbTransMailslotWriteRequestPacket packet = new SmbTransMailslotWriteRequestPacket(); packet.SmbHeader = CifsMessageUtils.CreateSmbHeader(SmbCommand.SMB_COM_TRANSACTION, messageId, sessionUid, treeId, (SmbFlags)flags, (SmbFlags2)flags2); // Set Smb Parameters SMB_COM_TRANSACTION_Request_SMB_Parameters smbParameters = new SMB_COM_TRANSACTION_Request_SMB_Parameters(); smbParameters.MaxParameterCount = this.capability.MaxParameterCount; smbParameters.MaxDataCount = this.capability.MaxDataCount; smbParameters.MaxSetupCount = this.capability.MaxSetupCount; smbParameters.Flags = transactOptions; smbParameters.Timeout = timeOut; smbParameters.SetupCount = 3; // the correct count in word of the Setup is always 3. smbParameters.Setup = new ushort[3]; smbParameters.Setup[0] = (ushort)TransSubCommand.TRANS_MAILSLOT_WRITE; smbParameters.Setup[1] = (ushort)priority; smbParameters.Setup[2] = (ushort)className; smbParameters.WordCount = (byte)(CifsMessageUtils.GetSize<SMB_COM_TRANSACTION_Request_SMB_Parameters>( smbParameters) / SmbCapability.NUM_BYTES_OF_WORD); // Set Smb Data SMB_COM_TRANSACTION_Request_SMB_Data smbData = new SMB_COM_TRANSACTION_Request_SMB_Data(); smbData.Name = CifsMessageUtils.ToSmbStringBytes(mailslotName, this.capability.IsUnicode); smbData.Trans_Data = writeData; packet.SmbParameters = smbParameters; packet.SmbData = smbData; packet.UpdateCountAndOffset(); // update TransactionSubCommand in SmbGlobalContext, record the transact action this.capability.TransactionSubCommand = TransSubCommandExtended.TRANS_EXT_MAILSLOT_WRITE; return packet; }
/// <summary> /// Create NTTransIOCtl request for the client to request an IO control 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 = "isFsctl"> /// This field is TRUE if the command is a file system control command and the FID is a file system control /// device. Otherwise, the command is a device control command and FID is an I/O device. /// </param> /// <param name = "isFlags"> /// If bit 0 is set, the command is to be applied to a share root handle. The share MUST be a Distributed File /// System (DFS) type /// </param> /// <param name = "FunctionCode">The code for the sub function. </param> /// <param name = "data"> /// The raw bytes that are passed to the fsctl or ioctl function as the input buffer. /// </param> /// <returns>a nt transaction rename request packet </returns> /// <remarks> /// If an application running on a client requests an FSCTL or IOCTL of which the SMB implementation is /// unaware, the format of the data is not well-known outside of the caller. The SMB protocol SHOULD pass /// through the request. A server that receives an unexpected FSCTL or IOCTL SHOULD fail the operation by /// returning STATUS_NOT_SUPPORTED. /// </remarks> private SmbNtTransactIoctlRequestPacket CreateNTTransIOCtlRequest( ushort messageId, ushort sessionUid, ushort treeId, SmbHeader_Flags_Values flags, SmbHeader_Flags2_Values flags2, ushort fileId, bool isFsctl, byte isFlags, NtTransFunctionCode FunctionCode, byte[] data) { return this.cifsClient.CreateNtTransactIoctlRequest( messageId, sessionUid, treeId, (SmbFlags)flags, (SmbFlags2)flags2, this.capability.MaxSetupCount, this.capability.MaxParameterCount, this.capability.MaxDataCount, (uint)FunctionCode, fileId, isFsctl, isFlags, data); }
/// <summary> /// Create Trans2GetDFSReferral request for client to get the dfs referral 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 = "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 = "dfsPathName">use to indicate the REQ_GET_DFS_REFERRAL([MS-DFSC] section 2.2.2). </param> /// <param name = "referralRequest">This field MUST be a properly formatted DFS referral request </param> /// <returns>a get dfs referral request packet </returns> private SmbTrans2GetDfsReferralRequestPacket CreateTrans2GetDFSReferralRequest( ushort messageId, ushort sessionUid, ushort treeId, SmbHeader_Flags_Values flags, SmbHeader_Flags2_Values flags2, Trans2SmbParametersFlags transactOptions, uint timeOut, string dfsPathName, REQ_GET_DFS_REFERRAL referralRequest) { return new SmbTrans2GetDfsReferralRequestPacket( this.cifsClient.CreateTrans2GetDfsReferalRequest( messageId, sessionUid, treeId, (SmbFlags)flags, (SmbFlags2)flags2, this.capability.MaxParameterCount, this.capability.MaxDataCount, this.capability.MaxSetupCount, transactOptions, timeOut, dfsPathName, referralRequest)); }
/// <summary> /// Create NTTransIOCtlCopyChunk request for client to copy chunk to server file. /// </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 = "isFsctl"> /// This field is TRUE if the command is a file system control command and the FID is a file system control /// device. Otherwise, the command is a device control command and FID is an I/O device. /// </param> /// <param name = "isFlags"> /// If bit 0 is set, the command is to be applied to a share root handle. The share MUST be a Distributed File /// System (DFS) type /// </param> /// <param name = "copychunkResumeKey"> /// A 24-byte resume key generated by the SMB server that can be subsequently used by the client to uniquely /// identify the open source file in a FSCTL_SRV_COPYCHUNK request. /// </param> /// <param name = "list"> /// A concatenated list of copychunk blocks. This field is as specified in section 2.2.14.7.3.1. /// </param> /// <returns>a nt transaction rename request packet </returns> /// <exception cref = "ArgumentNullException">list must not be null </exception> /// <exception cref = "ArgumentException"> /// The number of entries in the copychunk list. MUST NOT be 0. /// </exception> private SmbNtTransFsctlSrvCopyChunkRequestPacket CreateNTTransIOCtlCopyChunkRequest( ushort messageId, ushort sessionUid, ushort treeId, SmbHeader_Flags_Values flags, SmbHeader_Flags2_Values flags2, ushort fileId, bool isFsctl, byte isFlags, byte[] copychunkResumeKey, NT_TRANSACT_COPY_CHUNK_List[] list) { if (list == null) { throw new ArgumentNullException("list"); } if (list.Length == 0) { throw new ArgumentException( "The number of entries in the copychunk list. MUST NOT be 0.", "list"); } SmbNtTransFsctlSrvCopyChunkRequestPacket request = new SmbNtTransFsctlSrvCopyChunkRequestPacket( this.cifsClient.CreateNtTransactIoctlRequest( messageId, sessionUid, treeId, (SmbFlags)flags, (SmbFlags2)flags2, this.capability.MaxSetupCount, this.capability.MaxParameterCount, this.capability.MaxDataCount, (uint)NtTransFunctionCode.FSCTL_SRV_COPYCHUNK, fileId, isFsctl, isFlags, null)); // update the copy chunk trans data. NT_TRANSACT_COPY_CHUNK_Request_NT_Trans_Data ntTransData = request.NtTransData; ntTransData.CopyChunkResumeKey = copychunkResumeKey; ntTransData.ChunkCount = (uint)list.Length; ntTransData.List = list; request.NtTransData = ntTransData; request.UpdateCountAndOffset(); return request; }
/// <summary> /// Create NTTransIOCtlEnumerateSnapShots request for client to enumerate snapshots 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 = "isFsctl"> /// This field is TRUE if the command is a file system control command and the FID is a file system control /// device. Otherwise, the command is a device control command and FID is an I/O device. /// </param> /// <param name = "isFlags"> /// If bit 0 is set, the command is to be applied to a share root handle. The share MUST be a Distributed File /// System (DFS) type /// </param> /// <param name = "maxDataCount">The max size of data to query. </param> /// <returns>a nt transaction IO control to enumerate snap shots request packet </returns> private SmbNtTransFsctlSrvEnumerateSnapshotsRequestPacket CreateNTTransIOCtlEnumerateSnapShotsRequest( ushort messageId, ushort sessionUid, ushort treeId, SmbHeader_Flags_Values flags, SmbHeader_Flags2_Values flags2, ushort fileId, bool isFsctl, byte isFlags, int maxDataCount) { return new SmbNtTransFsctlSrvEnumerateSnapshotsRequestPacket( this.cifsClient.CreateNtTransactIoctlRequest( messageId, sessionUid, treeId, (SmbFlags)flags, (SmbFlags2)flags2, this.capability.MaxSetupCount, this.capability.MaxParameterCount, (uint)maxDataCount, (uint)NtTransFunctionCode.FSCTL_SRV_ENUMERATE_SNAPSHOTS, fileId, isFsctl, isFlags, null)); }
/// <summary> /// create negotiate request packet. client sends this packet to server to negotiate the dialects. /// </summary> /// <param name = "messageId"> /// This field SHOULD be the multiplex ID that is used to associate a response with a request, as specified in /// [CIFS] sections 2.4.2 and 3.1.5. /// </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 = "dialects"> /// Array of null-terminated ASCII strings that indicate the SMB dialects supported by the client. /// </param> /// <returns>a smb negotiate packet. </returns> private SmbNegotiateRequestPacket CreateNegotiateRequest( ushort messageId, SmbHeader_Flags_Values flags, SmbHeader_Flags2_Values flags2, params string[] dialects) { // update global context using flags2 this.capability.IsSupportsExtendedSecurity = (flags2 & SmbHeader_Flags2_Values.SMB_FLAGS2_EXTENDED_SECURITY) == SmbHeader_Flags2_Values.SMB_FLAGS2_EXTENDED_SECURITY; this.capability.IsUnicode = (flags2 & SmbHeader_Flags2_Values.SMB_FLAGS2_UNICODE) == SmbHeader_Flags2_Values.SMB_FLAGS2_UNICODE; this.capability.IsKnowEAS = (flags2 & SmbHeader_Flags2_Values.SMB_FLAGS2_KNOWS_EAS) == SmbHeader_Flags2_Values.SMB_FLAGS2_KNOWS_EAS; // initialize the dialects SMB_Dialect[] smbDialects = new SMB_Dialect[dialects.Length]; for (int i = 0; i < smbDialects.Length; i++) { SMB_Dialect dialect = new SMB_Dialect(); // Each string MUST be prefixed with ASCII code 0x02 dialect.BufferFormat = 0x02; dialect.DialectString = dialects[i]; smbDialects[i] = dialect; } return new SmbNegotiateRequestPacket( this.cifsClient.CreateNegotiateRequest(messageId, (SmbFlags)flags, (SmbFlags2)flags2, smbDialects)); }
/// <summary> /// Create logoff request packet for client to log off server. This command can follow the session setup /// success. /// </summary> /// <param name = "messageId">the id of message, used to identity the request and the server response. </param> /// <param name = "sessionUid">the session id to logoff </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> /// <returns>a log off packet </returns> private SmbLogoffAndxRequestPacket CreateLogoffRequest( ushort messageId, ushort sessionUid, SmbHeader_Flags_Values flags, SmbHeader_Flags2_Values flags2 ) { return new SmbLogoffAndxRequestPacket( this.cifsClient.CreateLogoffAndxRequest(messageId, sessionUid, (SmbFlags)flags, (SmbFlags2)flags2, null)); }
/// <summary> /// Create a create request packet for client to create new or open share 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 = "fileName">A string that represents the name of the file to open or create. </param> /// <param name = "desiredAccess"> /// Access wanted. This value MUST be specified in the ACCESS_MASK format, as specified in [CIFS] section 3.7. /// </param> /// <param name = "extFileAttributes">Extended attributes and flags for this file or directory. </param> /// <param name = "shareAccess">Type of shared access requested for this file or directory. </param> /// <param name = "createDisposition">The action to take if a file does or does not exist. </param> /// <param name = "createOptions">The options to use if creating the file or directory. </param> /// <param name = "impersonationLevel"> /// This field specifies the information given to the server about the client and how the server MUST /// represent, or impersonate, the client. /// </param> /// <param name = "createFlags"> /// A 32-bit field containing a set of options that specify the security tracking mode. /// </param> /// <returns>a create packet </returns> private SmbNtCreateAndxRequestPacket CreateCreateRequest( ushort messageId, ushort sessionUid, ushort treeId, SmbHeader_Flags_Values flags, SmbHeader_Flags2_Values flags2, string fileName, NtTransactDesiredAccess desiredAccess, SMB_EXT_FILE_ATTR extFileAttributes, NtTransactShareAccess shareAccess, NtTransactCreateDisposition createDisposition, NtTransactCreateOptions createOptions, NtTransactImpersonationLevel impersonationLevel, CreateFlags createFlags) { return new SmbNtCreateAndxRequestPacket( this.cifsClient.CreateNtCreateAndxRequest( messageId, sessionUid, treeId, (SmbFlags)flags, (SmbFlags2)flags2, (NtTransactFlags)createFlags, 0, desiredAccess, 0, extFileAttributes, shareAccess, createDisposition, (Cifs.NtTransactCreateOptions)createOptions, impersonationLevel, (NtTransactSecurityFlags)0x00, fileName, null)); }
/// <summary> /// Create session setup request packet. Using the Extended Session Security mechanism. This is the long /// parameter packet Api for creating all Extended Security authenticate packet. /// </summary> /// <param name = "messageId">the id of message, used to identity the request and the server response. </param> /// <param name = "sessionUid"> /// Set this value to 0 to request a new session setup, or set this value to a previously established session /// identifier to request reauthenticating an existing session. /// </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 = "capabilities"> /// A set of client capabilities. These flags are a subset of those specified in section for the server /// capabilities returned in the SMB_COM_NEGOTIATE response. /// </param> /// <param name = "maxBufferSize"> /// The maximum size, in bytes, of the client buffer for sending and receiving SMB messages. /// </param> /// <param name = "securityPackage">the package name of security. </param> /// <param name = "serverName">the server name to authenticate </param> /// <param name = "domainName">the domain name of user credential </param> /// <param name = "userName">the name of user credential </param> /// <param name = "password">the password of user credential </param> /// <returns>A session setup packet. </returns> /// <exception cref = "InvalidOperationException">the ExtendedSessionSecurity must set to 1 </exception> private SmbSessionSetupAndxRequestPacket CreateSessionSetupRequest( ushort messageId, ushort sessionUid, SmbHeader_Flags_Values flags, SmbHeader_Flags2_Values flags2, Capabilities capabilities, ushort maxBufferSize, SmbSecurityPackage securityPackage, string serverName, string domainName, string userName, string password) { if (!Capability.IsSupportsExtendedSecurity) { throw new InvalidOperationException("the ExtendedSessionSecurity must set to 1"); } SmbSessionSetupAndxRequestPacket packet = new SmbSessionSetupAndxRequestPacket(); // create smb packet header packet.SmbHeader = CifsMessageUtils.CreateSmbHeader( SmbCommand.SMB_COM_SESSION_SETUP_ANDX, messageId, sessionUid, 0, (SmbFlags)flags, (SmbFlags2)flags2); // update smb parameters SMB_COM_SESSION_SETUP_ANDX_Request_SMB_Parameters smbParameters = packet.SmbParameters; smbParameters.MaxBufferSize = maxBufferSize; smbParameters.Capabilities = (uint)capabilities; // update smb data SMB_COM_SESSION_SETUP_ANDX_Request_SMB_Data smbData = packet.SmbData; #region Generate the security blob, using Negotiate, Kerberos or Ntlm // get the default connection SmbClientConnection connection = this.Context.GetConnection(this.ConnectionId) as SmbClientConnection; if (connection == null) { return null; } // initialize gss api. if (connection.GssApi == null) { string serverPrincipal = GSS_API_TARGET_NAME_PREFIX + serverName; switch (securityPackage) { case SmbSecurityPackage.NTLM: connection.GssApi = new NlmpClientSecurityContext( new NlmpClientCredential(serverPrincipal, domainName, userName, password)); break; case SmbSecurityPackage.Kerberos: connection.GssApi = new SspiClientSecurityContext( SecurityPackageType.Kerberos, new AccountCredential(domainName, userName, password), serverPrincipal, ClientSecurityContextAttribute.Connection, SecurityTargetDataRepresentation.SecurityNetworkDrep); break; default: connection.GssApi = new SspiClientSecurityContext( SecurityPackageType.Negotiate, new AccountCredential(domainName, userName, password), serverPrincipal, ClientSecurityContextAttribute.Connection, SecurityTargetDataRepresentation.SecurityNetworkDrep); break; } } // initialize the token. // if ntlm, this is used to generate the negotiate and authenticate token. // if kerberos, this is used to generate the token which is sent to server. connection.GssApi.Initialize(connection.SecurityBlob); // update connection this.Context.AddOrUpdateConnection(connection); // store token to security blob of packet byte[] securityBlob = connection.GssApi.Token; smbParameters.SecurityBlobLength = (ushort)securityBlob.Length; smbData.SecurityBlob = new byte[securityBlob.Length]; Array.Copy(securityBlob, smbData.SecurityBlob, securityBlob.Length); #endregion // initialize default values smbData.Pad = new byte[0]; if (Capability.IsUnicode && smbParameters.SecurityBlobLength % SmbCapability.TWO_BYTES_ALIGN == 0) { smbData.Pad = new byte[1]; } // null terminate. smbData.NativeOS = new byte[2]; smbData.NativeLanMan = new byte[2]; // update smbData.ByteCount smbData.ByteCount = 0; if (smbData.SecurityBlob != null) { smbData.ByteCount += (ushort)smbData.SecurityBlob.Length; } if (smbData.Pad != null) { smbData.ByteCount += (ushort)smbData.Pad.Length; } if (smbData.NativeOS != null) { smbData.ByteCount += (ushort)smbData.NativeOS.Length; } if (smbData.NativeLanMan != null) { smbData.ByteCount += (ushort)smbData.NativeLanMan.Length; } // store the parameters and data to packet. packet.SmbParameters = smbParameters; packet.SmbData = smbData; // upate context this.Context.SetSecurityPackage(securityPackage); return packet; }
/// <summary> /// Create NTTransIOCtlRequestResumeKey request for client to resume key from server file. /// </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 = "isFsctl"> /// This field is TRUE if the command is a file system control command and the FID is a file system control /// device. Otherwise, the command is a device control command and FID is an I/O device. /// </param> /// <param name = "isFlags"> /// If bit 0 is set, the command is to be applied to a share root handle. The share MUST be a Distributed File /// System (DFS) type /// </param> /// <returns>a nt transaction IO control to resume key request packet </returns> private SmbNtTransFsctlSrvRequestResumeKeyRequestPacket CreateNTTransIOCtlRequestResumeKeyRequest( ushort messageId, ushort sessionUid, ushort treeId, SmbHeader_Flags_Values flags, SmbHeader_Flags2_Values flags2, ushort fileId, bool isFsctl, byte isFlags ) { return new SmbNtTransFsctlSrvRequestResumeKeyRequestPacket( this.cifsClient.CreateNtTransactIoctlRequest( messageId, sessionUid, treeId, (SmbFlags)flags, (SmbFlags2)flags2, this.capability.MaxSetupCount, this.capability.MaxParameterCount, this.capability.MaxDataCount, (uint)NtTransFunctionCode.FSCTL_SRV_REQUEST_RESUME_KEY, fileId, isFsctl, isFlags, null)); }
/// <summary> /// Create Trans2FindNext2 request for client to find next file 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 = "fileName">The file name to find. </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 = "searchCount"> /// The server MUST NOT return more entries than indicated by the value of this field. /// </param> /// <param name = "findFlags"> /// This 16-bit field of flags is used to request that the server take certain actions. /// </param> /// <param name = "sid">used to set the field Trans2FindNext2RequestHeader.Sid (Search handle). </param> /// <param name = "resumeKey"> /// This field MUST be the value of a ResumeKey field returned in the response from a TRANS2_FIND_FIRST2 or /// TRANS2_FIND_NEXT2 that is part of the same search (same SID). /// </param> /// <param name = "informationLevel"> /// Indicates that client specifies the information it is requesting. Server return different data based on /// the client's request. /// </param> /// <returns>a find file the next request packet </returns> private SmbTrans2FindNext2RequestPacket CreateTrans2FindNext2Request( ushort messageId, ushort sessionUid, ushort treeId, SmbHeader_Flags_Values flags, SmbHeader_Flags2_Values flags2, string fileName, Trans2SmbParametersFlags transactOptions, uint timeOut, ushort searchCount, ushort sid, uint resumeKey, Trans2FindFlags findFlags, FindInformationLevel informationLevel) { return new SmbTrans2FindNext2RequestPacket( this.cifsClient.CreateTrans2FindNext2Request( messageId, sessionUid, treeId, (SmbFlags)flags, (SmbFlags2)flags2, this.capability.MaxParameterCount, this.capability.MaxDataCount, this.capability.MaxSetupCount, transactOptions, timeOut, sid, searchCount, (Cifs.FindInformationLevel)informationLevel, resumeKey, findFlags, fileName, null)); }
/// <summary> /// Create NTTransQueryQuota request for client to query quota 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 = "isReturnSingleEntry"> /// Indicates only a single entry is to be returned instead of filling the entire buffer. /// </param> /// <param name = "isRestartScan">Indicates that the scan of the quota information is to be restarted. </param> /// <param name = "sidListLength"> /// Supplies the length in bytes of the SidList (see below), or 0 if there is no SidList. /// </param> /// <param name = "startSidLength"> /// Supplies the length in bytes of the StartSid (see below), or 0 if there is no StartSid. MUST be ignored by /// the receiver if SidListLength is non-zero. /// </param> /// <param name = "startSidOffset"> /// Supplies the offset, in bytes, to the StartSid in the Parameter buffer /// </param> /// <returns>a nt transaction query quota request packet </returns> private SmbNtTransQueryQuotaRequestPacket CreateNTTransQueryQuotaRequest( ushort messageId, ushort sessionUid, ushort treeId, SmbHeader_Flags_Values flags, SmbHeader_Flags2_Values flags2, ushort fileId, bool isReturnSingleEntry, bool isRestartScan, int sidListLength, int startSidLength, int startSidOffset) { SmbNtTransQueryQuotaRequestPacket packet = new SmbNtTransQueryQuotaRequestPacket(); packet.SmbHeader = CifsMessageUtils.CreateSmbHeader(SmbCommand.SMB_COM_NT_TRANSACT, messageId, sessionUid, treeId, (SmbFlags)flags, (SmbFlags2)flags2); // Set Smb_Parameters SMB_COM_NT_TRANSACT_Request_SMB_Parameters smbParameters = new SMB_COM_NT_TRANSACT_Request_SMB_Parameters(); smbParameters.MaxSetupCount = this.capability.MaxSetupCount; smbParameters.MaxParameterCount = this.capability.MaxParameterCount; smbParameters.MaxDataCount = this.capability.MaxDataCount; smbParameters.SetupCount = 0; // the correct count in word of the Setup is always 0. smbParameters.Function = (NtTransSubCommand)SmbNtTransSubCommand.NT_TRANSACT_QUERY_QUOTA; smbParameters.Setup = new ushort[0]; smbParameters.WordCount = (byte)(CifsMessageUtils.GetSize<SMB_COM_NT_TRANSACT_Request_SMB_Parameters>( smbParameters) / SmbCapability.NUM_BYTES_OF_WORD); // Set Smb_Data SMB_COM_NT_TRANSACT_Request_SMB_Data smbData = new SMB_COM_NT_TRANSACT_Request_SMB_Data(); // Set Nt Transaction Parameters NT_TRANSACT_QUERY_QUOTA_Request_NT_Trans_Parameters ntTransParameters = new NT_TRANSACT_QUERY_QUOTA_Request_NT_Trans_Parameters(); ntTransParameters.Fid = fileId; if (isReturnSingleEntry) { ntTransParameters.ReturnSingleEntry = 0x01; } if (isRestartScan) { ntTransParameters.RestartScan = 0x01; } ntTransParameters.SidListLength = (uint)sidListLength; ntTransParameters.StartSidLength = (uint)startSidLength; ntTransParameters.StartSidOffset = (uint)startSidOffset; packet.SmbParameters = smbParameters; packet.SmbData = smbData; packet.NtTransParameters = ntTransParameters; packet.UpdateCountAndOffset(); return packet; }
/// <summary> /// Create Trans2QueryPathInformation request for client to query path information from 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 = "fileName">The name of path to query information from. </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 = "maxDataCount">The max size to query path information. </param> /// <returns>a query path information request packet </returns> private SmbTrans2QueryPathInformationRequestPacket CreateTrans2QueryPathInformationRequest( ushort messageId, ushort sessionUid, ushort treeId, SmbHeader_Flags_Values flags, SmbHeader_Flags2_Values flags2, string fileName, Trans2SmbParametersFlags transactOptions, uint timeOut, bool isUsePathThrough, QueryInformationLevel informationLevel, ushort maxDataCount) { // update information level if (isUsePathThrough) { informationLevel = (QueryInformationLevel) (informationLevel + SmbCapability.CONST_SMB_INFO_PASSTHROUGH); } return new SmbTrans2QueryPathInformationRequestPacket( this.cifsClient.CreateTrans2QueryPathInformationRequest( messageId, sessionUid, treeId, (SmbFlags)flags, (SmbFlags2)flags2, this.capability.MaxParameterCount, maxDataCount, this.capability.MaxSetupCount, transactOptions, timeOut, informationLevel, fileName, null)); }
/// <summary> /// Create NTTransRename request for client to rename file 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 = "isReplaceIfExists"> /// If this param is true and the target exists, the server SHOULD attempt to replace the target. /// </param> /// <param name = "newFileName">The new name of file. </param> /// <returns>a nt transaction rename request packet </returns> private SmbNtTransRenameRequestPacket CreateNTTransRenameRequest( ushort messageId, ushort sessionUid, ushort treeId, SmbHeader_Flags_Values flags, SmbHeader_Flags2_Values flags2, ushort fileId, bool isReplaceIfExists, string newFileName) { SmbNtTransRenameRequestPacket packet = new SmbNtTransRenameRequestPacket( this.cifsClient.CreateNtTransactRenameRequest( messageId, sessionUid, treeId, (SmbFlags)flags, (SmbFlags2)flags2, this.capability.MaxSetupCount, this.capability.MaxParameterCount, this.capability.MaxDataCount)); NT_TRANSACT_RENAME_Request_NT_Trans_Parameters ntTransParameters = packet.NtTransParameters; ntTransParameters.Fid = fileId; if (isReplaceIfExists) { ntTransParameters.RenameFlags = 0x01; } if (Capability.IsUnicode) { ntTransParameters.Pad1 = new byte[1]; } ntTransParameters.NewName = CifsMessageUtils.ToSmbStringBytes(newFileName, this.capability.IsUnicode); packet.NtTransParameters = ntTransParameters; packet.UpdateCountAndOffset(); return packet; }
/// <summary> /// Create Trans2SetPathInformation request for client to set the path 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 = "fileName">The name of path to set the information on server. </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 = "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 = "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 path information request packet </returns> private SmbTrans2SetPathInformationRequestPacket CreateTrans2SetPathInformationRequest( ushort messageId, ushort sessionUid, ushort treeId, SmbHeader_Flags_Values flags, SmbHeader_Flags2_Values flags2, string fileName, bool isUsePathThrough, Trans2SmbParametersFlags transactOptions, uint timeOut, SetInformationLevel informationLevel, byte[] data) { if (isUsePathThrough) { informationLevel = (SetInformationLevel) (informationLevel + SmbCapability.CONST_SMB_INFO_PASSTHROUGH); } SmbTrans2SetPathInformationRequestPacket packet = new SmbTrans2SetPathInformationRequestPacket( this.cifsClient.CreateTrans2SetPathInformationRequest( messageId, sessionUid, treeId, (SmbFlags)flags, (SmbFlags2)flags2, this.capability.MaxParameterCount, this.capability.MaxDataCount, this.capability.MaxSetupCount, transactOptions, timeOut, informationLevel, fileName, data)); packet.UpdateCountAndOffset(); return packet; }
/// <summary> /// Create NTTransSetQuota request for client to set quota 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 = "nextEntryOffset"> /// An offset to the start of the subsequent entry from the start of this entry, or 0 for the final entry. /// </param> /// <param name = "changeTime">This value MUST be the time the quota was last changed, in TIME format. </param> /// <param name = "quotaUsed"> /// The amount of quota, in bytes, used by this user. This field is formatted as a LARGE_INTEGER, as specified /// in [CIFS] section 2.4.2. /// </param> /// <param name = "quotaThreshold"> /// The quota warning limit, in bytes, for this user. This field is formatted as a LARGE_INTEGER, as specified /// in [CIFS] section 2.4.2. /// </param> /// <param name = "quotaLimit"> /// The quota limit, in bytes, for this user. This field is formatted as a LARGE_INTEGER, as specified in /// [CIFS] section 2.4.2. /// </param> /// <param name = "sid"> /// The security identifier of this user. For details, see [MS-DTYP] section 2.4.2. Note that [CIFS] sections /// 4.3.4, 4.3.4.7, 4.3.5, and 4.3.5.6 use Sid as the field name for a search handle. In [XOPEN-SMB], the /// search handle field is called a findfirst_dirhandle or findnext_dirhandle. These are better field names /// for a search handle. this param can not be null. /// </param> /// <returns>a nt transaction set quota request packet </returns> /// <exception cref="ArgumentNullException">sid can not be null.</exception> private SmbNtTransSetQuotaRequestPacket CreateNTTransSetQuotaRequest( ushort messageId, ushort sessionUid, ushort treeId, SmbHeader_Flags_Values flags, SmbHeader_Flags2_Values flags2, ushort fileId, uint nextEntryOffset, ulong changeTime, ulong quotaUsed, ulong quotaThreshold, ulong quotaLimit, byte[] sid) { if (sid == null) { throw new ArgumentNullException("sid"); } SmbNtTransSetQuotaRequestPacket packet = new SmbNtTransSetQuotaRequestPacket(); packet.SmbHeader = CifsMessageUtils.CreateSmbHeader(SmbCommand.SMB_COM_NT_TRANSACT, messageId, sessionUid, treeId, (SmbFlags)flags, (SmbFlags2)flags2); // Set Smb_Parameters SMB_COM_NT_TRANSACT_Request_SMB_Parameters smbParameters = new SMB_COM_NT_TRANSACT_Request_SMB_Parameters(); smbParameters.MaxSetupCount = this.capability.MaxSetupCount; smbParameters.MaxParameterCount = this.capability.MaxParameterCount; smbParameters.MaxDataCount = this.capability.MaxDataCount; smbParameters.SetupCount = 0; // the correct count in word of the Setup is always 0. smbParameters.Function = (NtTransSubCommand)SmbNtTransSubCommand.NT_TRANSACT_SET_QUOTA; smbParameters.Setup = new ushort[0]; smbParameters.WordCount = (byte)(CifsMessageUtils.GetSize<SMB_COM_NT_TRANSACT_Request_SMB_Parameters>( smbParameters) / SmbCapability.NUM_BYTES_OF_WORD); // Set Smb_Data SMB_COM_NT_TRANSACT_Request_SMB_Data smbData = new SMB_COM_NT_TRANSACT_Request_SMB_Data(); // Set Nt Transaction Parameters NT_TRANSACT_SET_QUOTA_Request_NT_Trans_Parameters ntTransParameters = new NT_TRANSACT_SET_QUOTA_Request_NT_Trans_Parameters(); ntTransParameters.Fid = fileId; // Set Nt Transaction Data NT_TRANSACT_SET_QUOTA_Request_NT_Trans_Data ntTransData = new NT_TRANSACT_SET_QUOTA_Request_NT_Trans_Data(); ntTransData.NextEntryOffset = nextEntryOffset; ntTransData.SidLength = (uint)sid.Length; ntTransData.ChangeTime = changeTime; ntTransData.QuotaUsed = quotaUsed; ntTransData.QuotaThreshold = quotaThreshold; ntTransData.QuotaLimit = quotaLimit; ntTransData.Sid = sid; packet.SmbParameters = smbParameters; packet.SmbData = smbData; packet.NtTransParameters = ntTransParameters; packet.NtTransData = ntTransData; packet.UpdateCountAndOffset(); return packet; }
/// <summary> /// Create TransNamedRap request for client to send a rap request to 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 = "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="rapOPCode"> /// The operation code for the particular operation. For more information on valid operation codes, see 2.5.4. /// </param> /// <param name="paramDesc"> /// This value MUST be a null-terminated ASCII descriptor string. The server SHOULD validate that the ParamDesc /// value passed by the client matches what is specified by the RAPOpcode. The following table specifies the /// descriptor character and the notation for each data type. /// </param> /// <param name="dataDesc"> /// (Optional) If this value is specified, it MUST be a null-terminated ASCII descriptor string that describes /// the contents of the data returned to the client. Certain RAPOpcodes specify a DataDesc field; for a list /// of Remote Administration Protocol commands that specify a DataDesc field, see section 2.5.5. /// </param> /// <param name="rapParamsAndAuxDesc"> /// This field combines the following fields, because each of their length is unknown:<para/> /// RAPParams: Remote Administration Protocol command-specific parameters, as specified in sections 2.5.5, 2.5.6, 2.5.7, /// 2.5.8, and 2.5.9.<para/> /// AuxDesc: (Optional) If this value is specified, it MUST be a null-terminated ASCII descriptor string that describes /// auxiliary data returned to the client. If no AuxDesc field is specified for the Remote Administration /// Protocol command, this field MUST NOT be present. For the origin of the descriptor string values, see /// section 4.2. /// </param> /// <param name="rapInData"> /// Additional data for the Remote Administration Protocol request. This field MUST be present in the /// NetPrintJobSetInfoRequest command. This field cannot be present in any other command. /// </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> /// <returns>a named rap request packet </returns> private SmbTransRapRequestPacket CreateTransNamedRapRequest( ushort messageId, ushort sessionUid, ushort treeId, SmbHeader_Flags_Values flags, SmbHeader_Flags2_Values flags2, TransSmbParametersFlags transactOptions, ushort rapOPCode, byte[] paramDesc, byte[] dataDesc, byte[] rapParamsAndAuxDesc, byte[] rapInData, uint timeOut) { SmbTransRapRequestPacket packet = new SmbTransRapRequestPacket(); packet.SmbHeader = CifsMessageUtils.CreateSmbHeader(SmbCommand.SMB_COM_TRANSACTION, messageId, sessionUid, treeId, (SmbFlags)flags, (SmbFlags2)flags2); // Set Smb Parameters SMB_COM_TRANSACTION_Request_SMB_Parameters smbParameters = new SMB_COM_TRANSACTION_Request_SMB_Parameters(); smbParameters.MaxParameterCount = this.capability.MaxParameterCount; smbParameters.MaxDataCount = this.capability.MaxDataCount; smbParameters.MaxSetupCount = this.capability.MaxSetupCount; smbParameters.Flags = transactOptions; smbParameters.Timeout = timeOut; smbParameters.SetupCount = 0; // the correct count in word of the Setup is always 0. smbParameters.Setup = new ushort[0]; smbParameters.WordCount = (byte)(CifsMessageUtils.GetSize<SMB_COM_TRANSACTION_Request_SMB_Parameters>( smbParameters) / SmbCapability.NUM_BYTES_OF_WORD); // Set Smb Data SMB_COM_TRANSACTION_Request_SMB_Data smbData = new SMB_COM_TRANSACTION_Request_SMB_Data(); smbData.Name = CifsMessageUtils.ToSmbStringBytes("", this.capability.IsUnicode); // Set Transaction Parameters TRANSACTION_Rap_Request_Trans_Parameters transParameters = new TRANSACTION_Rap_Request_Trans_Parameters(); transParameters.RapOPCode = rapOPCode; transParameters.ParamDesc = paramDesc; transParameters.DataDesc = dataDesc; transParameters.RAPParamsAndAuxDesc = rapParamsAndAuxDesc; // Set Transaction Data TRANSACTION_Rap_Request_Trans_Data transData = new TRANSACTION_Rap_Request_Trans_Data(); transData.RAPInData = rapInData; packet.SmbParameters = smbParameters; packet.SmbData = smbData; packet.TransParameters = transParameters; packet.TransData = transData; packet.UpdateCountAndOffset(); // update TransactionSubCommand in SmbGlobalContext, record the transact action this.capability.TransactionSubCommand = TransSubCommandExtended.TRANS_EXT_RAP; return packet; }
/// <summary> /// Create a open request packet for client to open a share 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 = "shareName">the file name to open </param> /// <param name = "fileOpenMode">file open mode </param> /// <param name = "fileOpenFunction"> /// A 16-bit field that controls the way a file SHOULD be treated when it is opened for use by certain /// extended SMB requests. /// </param> /// <param name = "extFileAttributes">the extend file attributes </param> /// <param name = "extSearchAttributes">the search attributes of file </param> /// <param name = "allocationSize">Bytes to reserve on create or truncate </param> /// <param name = "openFlags">A 16-bit field of flags for requesting attribute data and locking </param> /// <returns>a open request packet </returns> private SmbOpenAndxRequestPacket CreateOpenRequest( ushort messageId, ushort sessionUid, ushort treeId, SmbHeader_Flags_Values flags, SmbHeader_Flags2_Values flags2, string shareName, AccessMode fileOpenMode, OpenMode fileOpenFunction, SmbFileAttributes extFileAttributes, SmbFileAttributes extSearchAttributes, uint allocationSize, OpenFlags openFlags) { return new SmbOpenAndxRequestPacket( this.cifsClient.CreateOpenAndxRequest(messageId, sessionUid, treeId, (SmbFlags)flags, (SmbFlags2)flags2, (Flags)openFlags, fileOpenMode, extSearchAttributes, extFileAttributes, new UTime(), fileOpenFunction, allocationSize, this.capability.Timeout, shareName, null)); }
/// <summary> /// Create TransWaitNamedPipe request for client to wait named pipe 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 = "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 = "priority"> /// This field MUST be in the range of 0 to 9. The larger value being the higher priority. /// </param> /// <param name = "name"> /// The pathname of the mailslot or named pipe to which the transaction subcommand applies or a client /// supplied identifier that provides a name for the transaction. /// </param> /// <returns>a wait named pipe request packet </returns> private SmbTransWaitNmpipeRequestPacket CreateTransWaitNamedPipeRequest( ushort messageId, ushort sessionUid, ushort treeId, SmbHeader_Flags_Values flags, SmbHeader_Flags2_Values flags2, TransSmbParametersFlags transactOptions, uint timeOut, ushort priority, string name) { return new SmbTransWaitNmpipeRequestPacket( this.cifsClient.CreateTransWaitNmpipeRequest( messageId, sessionUid, treeId, (SmbFlags)flags, (SmbFlags2)flags2, this.capability.MaxParameterCount, this.capability.MaxDataCount, this.capability.MaxSetupCount, transactOptions, timeOut, priority, name)); }
/// <summary> /// Create read request for client to read data from 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 = "maxCount">the max count to read </param> /// <param name = "minCount">the min count to read </param> /// <param name = "offsetHigh">the high offset to write to file </param> /// <param name = "offset">the offset to write to file </param> /// <returns>a read request packet. </returns> private SmbReadAndxRequestPacket CreateReadRequest( ushort messageId, ushort sessionUid, ushort treeId, SmbHeader_Flags_Values flags, SmbHeader_Flags2_Values flags2, ushort fileId, ushort maxCount, ushort minCount, uint offsetHigh, uint offset) { return new SmbReadAndxRequestPacket( this.cifsClient.CreateReadAndxRequest( messageId, sessionUid, treeId, (SmbFlags)flags, (SmbFlags2)flags2, fileId, offset, maxCount, minCount, this.capability.Timeout, offsetHigh, null)); }
/// <summary> /// Create tree connect request for client to access share of server. This command match all device type, and /// must following the session setup. /// </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 = "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 = "path">the share name to treeconnect to </param> /// <param name = "services"> /// The type of resource that the client intends to access. This field MUST be a null-terminated array of OEM /// characters even if the client and server have negotiated to use Unicode strings. /// </param> /// <param name = "treeConnectFlags"> /// A 16-bit field used to modify the SMB_COM_TREE_CONNECT_ANDX request. /// </param> /// <returns>a tree connect request packet. </returns> private SmbTreeConnectAndxRequestPacket CreateTreeConnectRequest( ushort messageId, ushort sessionUid, SmbHeader_Flags_Values flags, SmbHeader_Flags2_Values flags2, string path, string services, TreeConnectFlags treeConnectFlags) { return new SmbTreeConnectAndxRequestPacket( this.cifsClient.CreateTreeConnectAndxRequest( messageId, sessionUid, (SmbFlags)flags, (SmbFlags2)flags2, (TreeConnectAndxFlags)treeConnectFlags, path, services, new byte[1], // null-terminated. null)); }
/// <summary> /// create the implicit NTLM SessionSetup request packet /// </summary> /// <param name = "messageId">the id of message, used to identity the request and the server response. </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 = "capabilities"> /// A set of client capabilities. These flags are a subset of those specified in section for the server /// capabilities returned in the SMB_COM_NEGOTIATE response. /// </param> /// <param name = "maxBufferSize"> /// The maximum size, in bytes, of the client buffer for sending and receiving SMB messages. /// </param> /// <param name = "maxMpxCount"> /// The maximum number of pending multiplexed requests supported by the client. This value MUST be less than /// or equal to the MaxMpxCount value provided by the server in the SMB_COM_NEGOTIATE response /// </param> /// <param name = "implicitNtlmVersion"> /// the version of smb to using: PlainTextPassword: transport password as plain-text. the /// NEGOTIATE_ENCRYPT_PASSWORDS of SecurityMode in negotiate response should set to 0. NtlmVersion1:using ntlm /// v1 NtlmVersion2:using ntlm v2 /// </param> /// <param name = "domainName">the domain name of user credential </param> /// <param name = "userName">the name of user credential </param> /// <param name = "password">the password of user credential </param> /// <returns>A session setup packet. </returns> /// <exception cref = "InvalidOperationException"> /// the implicit NTLM only support when ExtendedSessionSecurity is set to 0 /// </exception> private SmbSessionSetupImplicitNtlmAndxRequestPacket CreateSessionSetupImplicitNtlmRequest( ushort messageId, SmbHeader_Flags_Values flags, SmbHeader_Flags2_Values flags2, Capabilities capabilities, ushort maxBufferSize, ushort maxMpxCount, ImplicitNtlmVersion implicitNtlmVersion, string domainName, string userName, string password) { if (Capability.IsSupportsExtendedSecurity) { throw new InvalidOperationException( "the implicit NTLM only support when ExtendedSessionSecurity is set to 0"); } NTLMAuthenticationPolicyValues ntlmAuthenticationPolicyValues; LMAuthenticationPolicyValues lmAuthenticationPolicyValues; if (implicitNtlmVersion == ImplicitNtlmVersion.PlainTextPassword) { ntlmAuthenticationPolicyValues = NTLMAuthenticationPolicyValues.Disabled; lmAuthenticationPolicyValues = LMAuthenticationPolicyValues.Disabled; } else if (implicitNtlmVersion == ImplicitNtlmVersion.NtlmVersion1) { ntlmAuthenticationPolicyValues = NTLMAuthenticationPolicyValues.Disabled; lmAuthenticationPolicyValues = LMAuthenticationPolicyValues.LmEnabled; } // ntlm version 2 else { ntlmAuthenticationPolicyValues = NTLMAuthenticationPolicyValues.NtlmV2Enabled; lmAuthenticationPolicyValues = LMAuthenticationPolicyValues.LmV2Enabled; } return new SmbSessionSetupImplicitNtlmAndxRequestPacket( this.cifsClient.CreateSessionSetupAndxRequest( messageId, (SmbFlags)flags, (SmbFlags2)flags2, maxBufferSize, maxMpxCount, 0, 0, (Cifs.Capabilities)capabilities, new CifsUserAccount(domainName, userName, password), "\0", "\0", null, ntlmAuthenticationPolicyValues, lmAuthenticationPolicyValues)); }
/// <summary> /// Create write request packet for client to write data to 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 = "offsetHigh">the high offset to write to file </param> /// <param name = "offset">the offset to write to file </param> /// <param name = "data">the data to write to file </param> /// <returns>a write request packet. </returns> private SmbWriteAndxRequestPacket CreateWriteRequest( ushort messageId, ushort sessionUid, ushort treeId, SmbHeader_Flags_Values flags, SmbHeader_Flags2_Values flags2, ushort fileId, uint offsetHigh, uint offset, byte[] data) { return new SmbWriteAndxRequestPacket( this.cifsClient.CreateWriteAndxRequest( messageId, sessionUid, treeId, (SmbFlags)flags, (SmbFlags2)flags2, fileId, offset, this.capability.Timeout, WriteAndxWriteMode.NONE, offsetHigh, data, null)); }
/// <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); }