/// <summary> /// Deep copy constructor. /// </summary> public CifsClientPerSession(CifsClientPerSession session) : base(session) { lock (session) { // in request: this.MaxBufferSize = session.MaxBufferSize; this.MaxMpxCount = session.MaxMpxCount; this.VcNumber = session.VcNumber; this.SessionKeyOfNegotiated = session.SessionKeyOfNegotiated; this.Capabilities = session.Capabilities; this.UserAccount = new CifsUserAccount(session.UserAccount); this.ClientNativeOs = session.ClientNativeOs; this.ClientNativeLanMan = session.ClientNativeLanMan; // in response: this.Action = session.Action; this.ServerNativeOs = session.ServerNativeOs; this.ServerNativeLanMan = session.ServerNativeLanMan; this.ServerPrimaryDomain = session.ServerPrimaryDomain; // others: this.OpenSearchTable = new Collection<Open>(); foreach (CifsClientPerOpenSearch open in session.openSearchTable) { this.OpenSearchTable.Add(new CifsClientPerOpenSearch(open)); } // base class Session: this.OpenFileTable = new Collection<Open>(); foreach (CifsClientPerOpenFile open in session.openTable) { this.OpenFileTable.Add(open.Clone()); } this.TreeConnectTable = new Collection<TreeConnect>(); foreach (CifsClientPerTreeConnect treeConnect in session.treeConnectTable) { this.TreeConnectTable.Add(treeConnect.Clone()); } } }
/// <summary> /// Deep copy constructor. /// </summary> public CifsClientPerSession(CifsClientPerSession session) : base(session) { lock (session) { // in request: this.MaxBufferSize = session.MaxBufferSize; this.MaxMpxCount = session.MaxMpxCount; this.VcNumber = session.VcNumber; this.SessionKeyOfNegotiated = session.SessionKeyOfNegotiated; this.Capabilities = session.Capabilities; this.UserAccount = new CifsUserAccount(session.UserAccount); this.ClientNativeOs = session.ClientNativeOs; this.ClientNativeLanMan = session.ClientNativeLanMan; // in response: this.Action = session.Action; this.ServerNativeOs = session.ServerNativeOs; this.ServerNativeLanMan = session.ServerNativeLanMan; this.ServerPrimaryDomain = session.ServerPrimaryDomain; // others: this.OpenSearchTable = new Collection <Open>(); foreach (CifsClientPerOpenSearch open in session.openSearchTable) { this.OpenSearchTable.Add(new CifsClientPerOpenSearch(open)); } // base class Session: this.OpenFileTable = new Collection <Open>(); foreach (CifsClientPerOpenFile open in session.openTable) { this.OpenFileTable.Add(open.Clone()); } this.TreeConnectTable = new Collection <TreeConnect>(); foreach (CifsClientPerTreeConnect treeConnect in session.treeConnectTable) { this.TreeConnectTable.Add(treeConnect.Clone()); } } }
/// <summary> /// if the session identified by the connectionId and sessionId has been existed in the /// globalSessionTable, this session will be updated into the globalSessionTable. /// otherwise, this session will be added into the globalSessionTable. /// </summary> /// <param name="session">the session to be added or updated.</param> /// <exception cref="System.InvalidOperationException">Failed in AddOrUpdateSession /// because the Connection of the Session does not found.</exception> public void AddOrUpdateSession(CifsClientPerSession session) { if (session == null) { return; } lock (this.contextCollection) { if (AddOrUpdateSessionTableInConnection(session)) { AddOrUpdateSessionTableInGlobal(session); } else { throw new InvalidOperationException( "Failed in AddOrUpdateSession because the Connection of the Session doesnot found."); } } }
/// <summary> /// to add or update session into global session table. /// </summary> /// <param name="session">the session to be added.</param> private void AddOrUpdateSessionTableInGlobal(CifsClientPerSession session) { for (int i = this.contextCollection.GlobalSessionTable.Count - 1; i >= 0; i--) { if (this.contextCollection.GlobalSessionTable[i].ConnectionId == session.ConnectionId && this.contextCollection.GlobalSessionTable[i].SessionId == session.SessionId) { // update the session: this.contextCollection.GlobalSessionTable[i] = session; return; } } // add the session: session.GlobalIndex = this.contextCollection.NextSessionGlobalIndex; this.contextCollection.GlobalSessionTable.Add(session); this.contextCollection.NextSessionGlobalIndex += 1; }
/// <summary> /// to add or update session into connection. /// </summary> /// <param name="session">the session to be added.</param> /// <returns>true: added successfully. false:the connection does not existed.</returns> private bool AddOrUpdateSessionTableInConnection(CifsClientPerSession session) { for (int i = this.contextCollection.ConnectionList.Count - 1; i >= 0; i--) { // if the connection exists, add or update the session: if (this.contextCollection.ConnectionList[i].ConnectionId == session.ConnectionId) { CifsClientPerConnection connection = this.contextCollection.ConnectionList[i] as CifsClientPerConnection; // if the session does exist, update it: for (int j = connection.SessionTable.Count - 1; j >= 0; j--) { if (connection.SessionTable[j].SessionId == session.SessionId) { // update the session: connection.SessionTable[j] = session; return true; } } // add the session: session.GlobalIndex = this.contextCollection.NextSessionGlobalIndex; connection.SessionTable.Add(session); return true; } } return false; }
protected virtual void ResponsePacketUpdateRoleContext( CifsClientPerConnection connection, SmbPacket request, SmbPacket response) { int connectionId = connection.ConnectionId; if (request ==null | response == null) { return; } #region To update Connection/Session/Tree/Open with response // Update context with success response: if (response.SmbHeader.Status == 0) { CifsClientPerSession session = new CifsClientPerSession(); CifsClientPerTreeConnect tree = new CifsClientPerTreeConnect(); CifsClientPerOpenFile openFile = new CifsClientPerOpenFile(); CifsClientPerOpenSearch openSearch = new CifsClientPerOpenSearch(); switch (response.SmbHeader.Command) { #region connection case SmbCommand.SMB_COM_NEGOTIATE: #region SMB_COM_NEGOTIATE SmbNegotiateRequestPacket negotiateRequest = request as SmbNegotiateRequestPacket; SmbNegotiateResponsePacket negotiateResponse = response as SmbNegotiateResponsePacket; if (negotiateRequest == null || negotiateResponse == null) { break; } // base class Connection: connection.NegotiateReceived = true; // common ADM: int dialectIndex = (int)(negotiateResponse.SmbParameters.DialectIndex); byte[] dialectBytes = negotiateRequest.SmbData.Dialects; int startIndex = 0; for (int i = 0; i < dialectIndex; i++) { startIndex = Array.IndexOf<byte>(dialectBytes, 0, startIndex, dialectBytes.Length - startIndex) + 1; } connection.SelectedDialect = CifsMessageUtils.ToSmbString(dialectBytes, startIndex, true); // client ADM: connection.ShareLevelAccessControl = ((negotiateResponse.SmbParameters.SecurityMode & SecurityModes.NEGOTIATE_ENCRYPT_PASSWORDS) == SecurityModes.NONE); connection.ServerChallengeResponse = ((negotiateResponse.SmbParameters.SecurityMode & SecurityModes.NEGOTIATE_ENCRYPT_PASSWORDS) == SecurityModes.NEGOTIATE_ENCRYPT_PASSWORDS); if (connection.ServerChallengeResponse && ((negotiateResponse.SmbParameters.SecurityMode & SecurityModes.NEGOTIATE_SECURITY_SIGNATURES_ENABLED) == SecurityModes.NEGOTIATE_SECURITY_SIGNATURES_ENABLED)) { connection.ServerSigningState = SignStateValue.ENABLED; } if (connection.ServerSigningState == SignStateValue.ENABLED && ((negotiateResponse.SmbParameters.SecurityMode & SecurityModes.NEGOTIATE_SECURITY_SIGNATURES_REQUIRED) == SecurityModes.NEGOTIATE_SECURITY_SIGNATURES_REQUIRED)) { connection.ServerSigningState = SignStateValue.REQUIRED; } connection.ServerCapabilities = negotiateResponse.SmbParameters.Capabilities; connection.MaxBufferSize = negotiateResponse.SmbParameters.MaxBufferSize; // negotiate response: connection.SecurityMode = negotiateResponse.SmbParameters.SecurityMode; connection.MaxMpxCount = negotiateResponse.SmbParameters.MaxMpxCount; connection.MaxNumberVcs = negotiateResponse.SmbParameters.MaxNumberVcs; connection.MaxRawSize = negotiateResponse.SmbParameters.MaxRawSize; connection.SessionKey = negotiateResponse.SmbParameters.SessionKey; connection.SystemTime = negotiateResponse.SmbParameters.SystemTime.Time; connection.ServerTimeZone = negotiateResponse.SmbParameters.ServerTimeZone; if (negotiateResponse.SmbData.Challenge != null && negotiateResponse.SmbData.Challenge.Length >= 8) { connection.Challenge = BitConverter.ToUInt64(negotiateResponse.SmbData.Challenge, 0); } if (negotiateResponse.SmbData.DomainName != null) { connection.DomainName = new byte[negotiateResponse.SmbData.DomainName.Length]; Array.Copy(negotiateResponse.SmbData.DomainName, connection.DomainName, negotiateResponse.SmbData.DomainName.Length); } // stack sdk design: connection.ConnectionState = StackTransportState.ConnectionEstablished; // update: this.AddOrUpdateConnection(connection); #endregion break; #endregion #region session case SmbCommand.SMB_COM_SESSION_SETUP_ANDX: #region SMB_COM_SESSION_SETUP_ANDX SmbSessionSetupAndxRequestPacket sessionSetupRequest = request as SmbSessionSetupAndxRequestPacket; SmbSessionSetupAndxResponsePacket sessionSetupResponse = response as SmbSessionSetupAndxResponsePacket; if (sessionSetupRequest == null || sessionSetupResponse == null) { break; } session.ConnectionId = connectionId; session.SessionId = (ulong)sessionSetupResponse.SmbHeader.Uid; // in request: session.SessionKey = sessionSetupRequest.ImplicitNtlmSessionKey; session.MaxBufferSize = sessionSetupRequest.SmbParameters.MaxBufferSize; session.MaxMpxCount = sessionSetupRequest.SmbParameters.MaxMpxCount; session.VcNumber = sessionSetupRequest.SmbParameters.VcNumber; session.SessionKeyOfNegotiated = sessionSetupRequest.SmbParameters.SessionKey; session.Capabilities = sessionSetupRequest.SmbParameters.Capabilities; if ((sessionSetupRequest.SmbHeader.Flags2 & SmbFlags2.SMB_FLAGS2_UNICODE) == SmbFlags2.SMB_FLAGS2_UNICODE) { session.UserAccount = new CifsUserAccount( Encoding.Unicode.GetString(sessionSetupRequest.SmbData.PrimaryDomain), Encoding.Unicode.GetString(sessionSetupRequest.SmbData.AccountName), Encoding.Unicode.GetString(sessionSetupRequest.SmbData.OEMPassword)); session.ClientNativeOs = Encoding.Unicode.GetString(sessionSetupRequest.SmbData.NativeOS); session.ClientNativeLanMan = Encoding.Unicode.GetString(sessionSetupRequest.SmbData.NativeLanMan); } else { session.UserAccount = new CifsUserAccount( Encoding.ASCII.GetString(sessionSetupRequest.SmbData.PrimaryDomain), Encoding.ASCII.GetString(sessionSetupRequest.SmbData.AccountName), Encoding.ASCII.GetString(sessionSetupRequest.SmbData.OEMPassword)); session.ClientNativeOs = Encoding.ASCII.GetString(sessionSetupRequest.SmbData.NativeOS); session.ClientNativeLanMan = Encoding.ASCII.GetString(sessionSetupRequest.SmbData.NativeLanMan); } // in response: session.Action = sessionSetupResponse.SmbParameters.Action; if ((sessionSetupResponse.SmbHeader.Flags2 & SmbFlags2.SMB_FLAGS2_UNICODE) == SmbFlags2.SMB_FLAGS2_UNICODE) { session.ServerNativeOs = Encoding.Unicode.GetString(sessionSetupResponse.SmbData.NativeOS); session.ServerNativeLanMan = Encoding.Unicode.GetString(sessionSetupResponse.SmbData.NativeLanMan); session.ServerPrimaryDomain = Encoding.Unicode.GetString(sessionSetupResponse.SmbData.PrimaryDomain); } else { session.ServerNativeOs = Encoding.ASCII.GetString(sessionSetupResponse.SmbData.NativeOS); session.ServerNativeLanMan = Encoding.ASCII.GetString(sessionSetupResponse.SmbData.NativeLanMan); session.ServerPrimaryDomain = Encoding.ASCII.GetString(sessionSetupResponse.SmbData.PrimaryDomain); } if (connection.ShareLevelAccessControl == false) { connection.IsSigningActive = true; connection.ConnectionSigningSessionKey = sessionSetupRequest.ImplicitNtlmSessionKey; connection.ConnectionSigningChallengeResponse = sessionSetupRequest.SmbData.UnicodePassword; AddOrUpdateConnection(connection); } // update: this.AddOrUpdateSession(session); #endregion break; case SmbCommand.SMB_COM_LOGOFF_ANDX: #region SMB_COM_LOGOFF_ANDX SmbLogoffAndxResponsePacket logoffResponse = response as SmbLogoffAndxResponsePacket; if (logoffResponse == null) { break; } this.RemoveSession(connectionId, (ulong)logoffResponse.SmbHeader.Uid); #endregion break; #endregion #region treeconnect case SmbCommand.SMB_COM_TREE_CONNECT: #region SMB_COM_TREE_CONNECT SmbTreeConnectRequestPacket treeConnectRequest = request as SmbTreeConnectRequestPacket; SmbTreeConnectResponsePacket treeConnectResponse = response as SmbTreeConnectResponsePacket; if (treeConnectRequest == null || treeConnectResponse == null) { break; } tree.ConnectionId = connectionId; tree.SessionId = (ulong)treeConnectResponse.SmbHeader.Uid; tree.TreeId = (ulong)treeConnectResponse.SmbHeader.Tid; tree.ShareName = CifsMessageUtils.ToSmbString(treeConnectRequest.SmbData.Path, 0, false); int index = tree.ShareName.LastIndexOf(@"\"); if (index > 0) { tree.Share = tree.ShareName.Substring(index + 1); } else { tree.Share = tree.ShareName; } this.AddOrUpdateTreeConnect(tree); #endregion break; case SmbCommand.SMB_COM_TREE_CONNECT_ANDX: #region SMB_COM_TREE_CONNECT_ANDX SmbTreeConnectAndxRequestPacket treeConnectAndxRequest = request as SmbTreeConnectAndxRequestPacket; SmbTreeConnectAndxResponsePacket treeConnectAndxResponse = response as SmbTreeConnectAndxResponsePacket; if (treeConnectAndxRequest == null || treeConnectAndxResponse == null) { break; } tree.ConnectionId = connectionId; tree.SessionId = (ulong)treeConnectAndxResponse.SmbHeader.Uid; tree.TreeId = (ulong)treeConnectAndxResponse.SmbHeader.Tid; if ((treeConnectAndxRequest.SmbHeader.Flags2 & SmbFlags2.SMB_FLAGS2_UNICODE) == SmbFlags2.SMB_FLAGS2_UNICODE) { tree.ShareName = Encoding.Unicode.GetString(treeConnectAndxRequest.SmbData.Path); } else { tree.ShareName = Encoding.ASCII.GetString(treeConnectAndxRequest.SmbData.Path); } int IndexOfShare = tree.ShareName.LastIndexOf(@"\"); if (IndexOfShare > 0) { tree.Share = tree.ShareName.Substring(IndexOfShare + 1); } else { tree.Share = tree.ShareName; } this.AddOrUpdateTreeConnect(tree); #endregion break; case SmbCommand.SMB_COM_TREE_DISCONNECT: #region SMB_COM_TREE_DISCONNECT SmbTreeDisconnectResponsePacket treeDisconnectResponse = response as SmbTreeDisconnectResponsePacket; if (treeDisconnectResponse == null) { break; } this.RemoveTreeConnect(connectionId, (ulong)treeDisconnectResponse.SmbHeader.Uid, (ulong)treeDisconnectResponse.SmbHeader.Tid); #endregion break; #endregion #region openfile case SmbCommand.SMB_COM_OPEN: #region SMB_COM_OPEN SmbOpenRequestPacket openRequest = request as SmbOpenRequestPacket; SmbOpenResponsePacket openResponse = response as SmbOpenResponsePacket; if (openRequest == null || openResponse == null) { break; } openFile.ConnectionId = connectionId; openFile.SessionId = (ulong)openResponse.SmbHeader.Uid; openFile.TreeConnectId = (ulong)openResponse.SmbHeader.Tid; openFile.FileHandle = openResponse.SmbParameters.FID; openFile.FileName = CifsMessageUtils.ToSmbString(openRequest.SmbData.FileName, 0, false); this.AddOrUpdateOpenFile(openFile); #endregion break; case SmbCommand.SMB_COM_CREATE: #region SMB_COM_CREATE SmbCreateRequestPacket createRequest = request as SmbCreateRequestPacket; SmbCreateResponsePacket createResponse = response as SmbCreateResponsePacket; if (createRequest == null || createResponse == null) { break; } openFile.ConnectionId = connectionId; openFile.SessionId = (ulong)createResponse.SmbHeader.Uid; openFile.TreeConnectId = (ulong)createResponse.SmbHeader.Tid; openFile.FileHandle = createResponse.SmbParameters.FID; openFile.FileName = CifsMessageUtils.ToSmbString(createRequest.SmbData.FileName, 0, false); this.AddOrUpdateOpenFile(openFile); #endregion break; case SmbCommand.SMB_COM_CREATE_TEMPORARY: #region SMB_COM_CREATE_TEMPORARY SmbCreateTemporaryRequestPacket createTemporaryRequest = request as SmbCreateTemporaryRequestPacket; SmbCreateTemporaryResponsePacket createTemporaryResponse = response as SmbCreateTemporaryResponsePacket; if (createTemporaryRequest == null || createTemporaryResponse == null) { break; } openFile.ConnectionId = connectionId; openFile.SessionId = (ulong)createTemporaryResponse.SmbHeader.Uid; openFile.TreeConnectId = (ulong)createTemporaryResponse.SmbHeader.Tid; openFile.FileHandle = createTemporaryResponse.SmbParameters.FID; openFile.FileName = CifsMessageUtils.ToSmbString( createTemporaryResponse.SmbData.TemporaryFileName, 0, false); this.AddOrUpdateOpenFile(openFile); #endregion break; case SmbCommand.SMB_COM_CREATE_NEW: #region SMB_COM_CREATE_NEW SmbCreateNewRequestPacket createNewRequest = request as SmbCreateNewRequestPacket; SmbCreateNewResponsePacket createNewResponse = response as SmbCreateNewResponsePacket; if (createNewRequest == null || createNewResponse == null) { break; } openFile.ConnectionId = connectionId; openFile.SessionId = (ulong)createNewResponse.SmbHeader.Uid; openFile.TreeConnectId = (ulong)createNewResponse.SmbHeader.Tid; openFile.FileHandle = createNewResponse.SmbParameters.FID; openFile.FileName = CifsMessageUtils.ToSmbString(createNewRequest.SmbData.FileName, 0, false); this.AddOrUpdateOpenFile(openFile); #endregion break; case SmbCommand.SMB_COM_OPEN_ANDX: #region SMB_COM_OPEN_ANDX SmbOpenAndxRequestPacket openAndxRequest = request as SmbOpenAndxRequestPacket; SmbOpenAndxResponsePacket openAndxResponse = response as SmbOpenAndxResponsePacket; if (openAndxRequest == null || openAndxResponse == null) { break; } openFile.ConnectionId = connectionId; openFile.SessionId = (ulong)openAndxResponse.SmbHeader.Uid; openFile.TreeConnectId = (ulong)openAndxResponse.SmbHeader.Tid; openFile.FileHandle = openAndxResponse.SmbParameters.FID; if ((openAndxRequest.SmbHeader.Flags2 & SmbFlags2.SMB_FLAGS2_UNICODE) == SmbFlags2.SMB_FLAGS2_UNICODE) { openFile.FileName = Encoding.Unicode.GetString(openAndxRequest.SmbData.FileName); } else { openFile.FileName = Encoding.ASCII.GetString(openAndxRequest.SmbData.FileName); } this.AddOrUpdateOpenFile(openFile); #endregion //save FID for chained response like: //treeConnect->openAndx->readAndx->close //when "close", FID is need to close the open opened in openAndx. if (openAndxResponse.AndxPacket != null) { //borrow smbHeader.Protocol to save FID for later process. //smbHeader.Protocol also use a flag to differentiate a single packet from a //batched andx packet. //FID is ushort, impossible to impact smbHeader.Protocol's usage as //a real packet header 0x424D53FF(0xFF, 'S', 'M', 'B') SmbHeader andxHeader = openAndxResponse.AndxPacket.SmbHeader; andxHeader.Protocol = openAndxResponse.SmbParameters.FID; openAndxResponse.AndxPacket.SmbHeader = andxHeader; } break; case SmbCommand.SMB_COM_NT_CREATE_ANDX: #region SMB_COM_NT_CREATE_ANDX SmbNtCreateAndxRequestPacket ntCreateAndxRequest = request as SmbNtCreateAndxRequestPacket; SmbNtCreateAndxResponsePacket ntCreateAndxResponse = response as SmbNtCreateAndxResponsePacket; if (ntCreateAndxRequest == null || ntCreateAndxResponse == null) { break; } openFile.ConnectionId = connectionId; openFile.SessionId = (ulong)ntCreateAndxResponse.SmbHeader.Uid; openFile.TreeConnectId = (ulong)ntCreateAndxResponse.SmbHeader.Tid; openFile.FileHandle = ntCreateAndxResponse.SmbParameters.FID; if ((ntCreateAndxRequest.SmbHeader.Flags2 & SmbFlags2.SMB_FLAGS2_UNICODE) == SmbFlags2.SMB_FLAGS2_UNICODE) { openFile.FileName = Encoding.Unicode.GetString(ntCreateAndxRequest.SmbData.FileName); } else { openFile.FileName = Encoding.ASCII.GetString(ntCreateAndxRequest.SmbData.FileName); } this.AddOrUpdateOpenFile(openFile); #endregion break; case SmbCommand.SMB_COM_OPEN_PRINT_FILE: #region SMB_COM_OPEN_PRINT_FILE SmbOpenPrintFileRequestPacket openPrintFileRequest = request as SmbOpenPrintFileRequestPacket; SmbOpenPrintFileResponsePacket openPrintFileResponse = response as SmbOpenPrintFileResponsePacket; if (openPrintFileRequest == null || openPrintFileResponse == null) { break; } openFile.ConnectionId = connectionId; openFile.SessionId = (ulong)openPrintFileResponse.SmbHeader.Uid; openFile.TreeConnectId = (ulong)openPrintFileResponse.SmbHeader.Tid; openFile.FileHandle = openPrintFileResponse.SmbParameters.FID; openFile.FileName = CifsMessageUtils.ToSmbString( openPrintFileRequest.SmbData.Identifier, 0, false); this.AddOrUpdateOpenFile(openFile); #endregion break; case SmbCommand.SMB_COM_TRANSACTION2: #region Trans2Open2 SmbTrans2Open2RequestPacket trans2Open2Request = request as SmbTrans2Open2RequestPacket; SmbTrans2Open2FinalResponsePacket trans2Open2Response = response as SmbTrans2Open2FinalResponsePacket; if (trans2Open2Request != null && trans2Open2Response != null) { openFile.ConnectionId = connectionId; openFile.SessionId = (ulong)trans2Open2Response.SmbHeader.Uid; openFile.TreeConnectId = (ulong)trans2Open2Response.SmbHeader.Tid; openFile.FileHandle = trans2Open2Response.Trans2Parameters.Fid; if ((trans2Open2Request.SmbHeader.Flags2 & SmbFlags2.SMB_FLAGS2_UNICODE) == SmbFlags2.SMB_FLAGS2_UNICODE) { openFile.FileName = Encoding.Unicode.GetString( trans2Open2Request.Trans2Parameters.FileName); } else { openFile.FileName = Encoding.ASCII.GetString( trans2Open2Request.Trans2Parameters.FileName); } this.AddOrUpdateOpenFile(openFile); break; } #endregion #region Trans2FindFirst2 SmbTrans2FindFirst2RequestPacket trans2FindFirst2Request = request as SmbTrans2FindFirst2RequestPacket; SmbTrans2FindFirst2FinalResponsePacket trans2FindFirst2Response = response as SmbTrans2FindFirst2FinalResponsePacket; if (trans2FindFirst2Request != null && trans2FindFirst2Response != null) { openSearch.ConnectionId = connectionId; openSearch.SessionId = (ulong)trans2FindFirst2Response.SmbHeader.Uid; openSearch.TreeConnectId = (ulong)trans2FindFirst2Response.SmbHeader.Tid; openSearch.SearchID = trans2FindFirst2Response.Trans2Parameters.SID; if ((trans2FindFirst2Request.SmbHeader.Flags2 & SmbFlags2.SMB_FLAGS2_UNICODE) == SmbFlags2.SMB_FLAGS2_UNICODE) { openSearch.SearchName = Encoding.Unicode.GetString( trans2FindFirst2Request.Trans2Parameters.FileName); } else { openSearch.SearchName = Encoding.ASCII.GetString( trans2FindFirst2Request.Trans2Parameters.FileName); } this.AddOrUpdateOpenSearch(openSearch); break; } #endregion break; case SmbCommand.SMB_COM_WRITE_AND_CLOSE: #region SMB_COM_WRITE_AND_CLOSE SmbWriteAndCloseRequestPacket writeAndCloseRequest = request as SmbWriteAndCloseRequestPacket; if (writeAndCloseRequest == null) { break; } this.RemoveOpenFile(connectionId, (ulong)response.SmbHeader.Uid, (ulong)response.SmbHeader.Tid, writeAndCloseRequest.SmbParameters.FID); #endregion break; case SmbCommand.SMB_COM_CLOSE: #region SMB_COM_CLOSE // Get FID from CLOSE request. // If fail, then get FID from the Batched Request. // If still fail, then Get FID from the Batched Response. ushort closeFId = 0; SmbCloseRequestPacket closeRequest = request as SmbCloseRequestPacket; if (closeRequest != null) { //Neither SMB_PROTOCOL_IDENTIFIER, or SMB_PROTOCOL_ANDXPACKET, then must be a FID if (response.SmbHeader.Protocol != CifsMessageUtils.SMB_PROTOCOL_IDENTIFIER && response.SmbHeader.Protocol != CifsMessageUtils.SMB_PROTOCOL_ANDXPACKET) { closeFId = (ushort)response.SmbHeader.Protocol; } else { closeFId = closeRequest.SmbParameters.FID; } this.RemoveOpenFile(connectionId, (ulong)response.SmbHeader.Uid, (ulong)response.SmbHeader.Tid, closeFId); } #endregion break; #endregion #region opensearch case SmbCommand.SMB_COM_FIND_CLOSE2: #region SMB_COM_FIND_CLOSE2 SmbFindClose2RequestPacket findClose2Request = request as SmbFindClose2RequestPacket; if (findClose2Request == null) { break; } this.RemoveOpenSearch(connectionId, (ulong)response.SmbHeader.Uid, (ulong)response.SmbHeader.Tid, findClose2Request.SmbParameters.SearchHandle); #endregion break; #endregion default: // No Connection/Session/Tree/Open will be updated if other types of response. break; } SmbBatchedRequestPacket smbBatchedRequest = request as SmbBatchedRequestPacket; SmbBatchedResponsePacket smbBatchedResponse = response as SmbBatchedResponsePacket; if (smbBatchedRequest != null && smbBatchedResponse != null) { //pass the FID stored in the andxHeader.Protocol into response.AndxPacket if (smbBatchedRequest.AndxPacket != null && smbBatchedResponse.AndxPacket != null && response.SmbHeader.Protocol != CifsMessageUtils.SMB_PROTOCOL_ANDXPACKET && response.SmbHeader.Protocol != CifsMessageUtils.SMB_PROTOCOL_IDENTIFIER) { SmbHeader andxHeader = smbBatchedResponse.AndxPacket.SmbHeader; andxHeader.Protocol = smbBatchedResponse.SmbHeader.Protocol; smbBatchedResponse.AndxPacket.SmbHeader = andxHeader; } this.ResponsePacketUpdateRoleContext(connection, smbBatchedRequest.AndxPacket, smbBatchedResponse.AndxPacket); } } #endregion }
/// <summary> /// Constructor with base class. /// </summary> internal SmbClientSession(CifsClientPerSession session) : base(session) { }