evie/rs-matter
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Restore transaction completion code

Browse source
This commit is contained in:
ivmarkov 2023-04-25 19:48:04 +00:00
parent 9a23a2af2d
commit b2805570ea
4 changed files with 82 additions and 50 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
matter/src/data_model/cluster_on_off.rs
View file

@ -112,6 +112,7 @@ impl OnOffCluster {
pub fn invoke( pub fn invoke(
&mut self, &mut self,
transaction: &mut Transaction,
cmd: &CmdDetails, cmd: &CmdDetails,
_data: &TLVElement, _data: &TLVElement,
_encoder: CmdDataEncoder, _encoder: CmdDataEncoder,
@ -131,6 +132,8 @@ impl OnOffCluster {
} }
} }
transaction.complete();
self.data_ver.changed(); self.data_ver.changed();
Ok(()) Ok(())
@ -148,12 +151,12 @@ impl Handler for OnOffCluster {
fn invoke( fn invoke(
&mut self, &mut self,
_transaction: &mut Transaction, transaction: &mut Transaction,
cmd: &CmdDetails, cmd: &CmdDetails,
data: &TLVElement, data: &TLVElement,
encoder: CmdDataEncoder, encoder: CmdDataEncoder,
) -> Result<(), Error> { ) -> Result<(), Error> {
OnOffCluster::invoke(self, cmd, data, encoder) OnOffCluster::invoke(self, transaction, cmd, data, encoder)
} }
} }

106
matter/src/data_model/sdm/noc.rs
View file

@ -27,7 +27,7 @@ use crate::fabric::{Fabric, FabricMgr, MAX_SUPPORTED_FABRICS};
use crate::interaction_model::core::Transaction; use crate::interaction_model::core::Transaction;
use crate::mdns::MdnsMgr; use crate::mdns::MdnsMgr;
use crate::tlv::{FromTLV, OctetStr, TLVElement, TLVWriter, TagType, ToTLV, UtfStr}; use crate::tlv::{FromTLV, OctetStr, TLVElement, TLVWriter, TagType, ToTLV, UtfStr};
use crate::transport::session::{Session, SessionMode}; use crate::transport::session::SessionMode;
use crate::utils::epoch::Epoch; use crate::utils::epoch::Epoch;
use crate::utils::rand::Rand; use crate::utils::rand::Rand;
use crate::utils::writebuf::WriteBuf; use crate::utils::writebuf::WriteBuf;
@ -294,21 +294,17 @@ impl<'a> NocCluster<'a> {
encoder: CmdDataEncoder, encoder: CmdDataEncoder,
) -> Result<(), Error> { ) -> Result<(), Error> {
match cmd.cmd_id.try_into()? { match cmd.cmd_id.try_into()? {
Commands::AddNOC => { Commands::AddNOC => self.handle_command_addnoc(transaction, data, encoder)?,
self.handle_command_addnoc(transaction.session_mut(), data, encoder)? Commands::CSRReq => self.handle_command_csrrequest(transaction, data, encoder)?,
}
Commands::CSRReq => {
self.handle_command_csrrequest(transaction.session_mut(), data, encoder)?
}
Commands::AddTrustedRootCert => { Commands::AddTrustedRootCert => {
self.handle_command_addtrustedrootcert(transaction.session_mut(), data)? self.handle_command_addtrustedrootcert(transaction, data)?
} }
Commands::AttReq => { Commands::AttReq => self.handle_command_attrequest(transaction, data, encoder)?,
self.handle_command_attrequest(transaction.session(), data, encoder)? Commands::CertChainReq => {
self.handle_command_certchainrequest(transaction, data, encoder)?
} }
Commands::CertChainReq => self.handle_command_certchainrequest(data, encoder)?,
Commands::UpdateFabricLabel => { Commands::UpdateFabricLabel => {
self.handle_command_updatefablabel(transaction.session(), data, encoder)?; self.handle_command_updatefablabel(transaction, data, encoder)?;
} }
Commands::RemoveFabric => self.handle_command_rmfabric(transaction, data, encoder)?, Commands::RemoveFabric => self.handle_command_rmfabric(transaction, data, encoder)?,
} }
@ -326,10 +322,13 @@ impl<'a> NocCluster<'a> {
fn _handle_command_addnoc( fn _handle_command_addnoc(
&mut self, &mut self,
session: &mut Session, transaction: &mut Transaction,
data: &TLVElement, data: &TLVElement,
) -> Result<u8, NocError> { ) -> Result<u8, NocError> {
let noc_data = session.take_noc_data().ok_or(NocStatus::MissingCsr)?; let noc_data = transaction
.session_mut()
.take_noc_data()
.ok_or(NocStatus::MissingCsr)?;
if !self if !self
.failsafe .failsafe
@ -389,6 +388,7 @@ impl<'a> NocCluster<'a> {
self.failsafe.borrow_mut().record_add_noc(fab_idx)?; self.failsafe.borrow_mut().record_add_noc(fab_idx)?;
transaction.complete();
Ok(fab_idx) Ok(fab_idx)
} }
@ -411,32 +411,36 @@ impl<'a> NocCluster<'a> {
fn handle_command_updatefablabel( fn handle_command_updatefablabel(
&mut self, &mut self,
session: &Session, transaction: &mut Transaction,
data: &TLVElement, data: &TLVElement,
encoder: CmdDataEncoder, encoder: CmdDataEncoder,
) -> Result<(), Error> { ) -> Result<(), Error> {
cmd_enter!("Update Fabric Label"); cmd_enter!("Update Fabric Label");
let req = UpdateFabricLabelReq::from_tlv(data).map_err(Error::map_invalid_data_type)?; let req = UpdateFabricLabelReq::from_tlv(data).map_err(Error::map_invalid_data_type)?;
let (result, fab_idx) = if let SessionMode::Case(c) = session.get_session_mode() { let (result, fab_idx) =
if self if let SessionMode::Case(c) = transaction.session().get_session_mode() {
.fabric_mgr if self
.borrow_mut() .fabric_mgr
.set_label( .borrow_mut()
c.fab_idx, .set_label(
req.label.as_str().map_err(Error::map_invalid_data_type)?, c.fab_idx,
) req.label.as_str().map_err(Error::map_invalid_data_type)?,
.is_err() )
{ .is_err()
(NocStatus::LabelConflict, c.fab_idx) {
(NocStatus::LabelConflict, c.fab_idx)
} else {
(NocStatus::Ok, c.fab_idx)
}
} else { } else {
(NocStatus::Ok, c.fab_idx) // Update Fabric Label not allowed
} (NocStatus::InvalidFabricIndex, 0)
} else { };
// Update Fabric Label not allowed
(NocStatus::InvalidFabricIndex, 0)
};
Self::create_nocresponse(encoder, result, fab_idx, "") Self::create_nocresponse(encoder, result, fab_idx, "")?;
transaction.complete();
Ok(())
} }
fn handle_command_rmfabric( fn handle_command_rmfabric(
@ -463,13 +467,13 @@ impl<'a> NocCluster<'a> {
fn handle_command_addnoc( fn handle_command_addnoc(
&mut self, &mut self,
session: &mut Session, transaction: &mut Transaction,
data: &TLVElement, data: &TLVElement,
encoder: CmdDataEncoder, encoder: CmdDataEncoder,
) -> Result<(), Error> { ) -> Result<(), Error> {
cmd_enter!("AddNOC"); cmd_enter!("AddNOC");
let (status, fab_idx) = match self._handle_command_addnoc(session, data) { let (status, fab_idx) = match self._handle_command_addnoc(transaction, data) {
Ok(fab_idx) => (NocStatus::Ok, fab_idx), Ok(fab_idx) => (NocStatus::Ok, fab_idx),
Err(NocError::Status(status)) => (status, 0), Err(NocError::Status(status)) => (status, 0),
Err(NocError::Error(error)) => Err(error)?, Err(NocError::Error(error)) => Err(error)?,
@ -480,7 +484,7 @@ impl<'a> NocCluster<'a> {
fn handle_command_attrequest( fn handle_command_attrequest(
&mut self, &mut self,
session: &Session, transaction: &mut Transaction,
data: &TLVElement, data: &TLVElement,
encoder: CmdDataEncoder, encoder: CmdDataEncoder,
) -> Result<(), Error> { ) -> Result<(), Error> {
@ -490,7 +494,7 @@ impl<'a> NocCluster<'a> {
info!("Received Attestation Nonce:{:?}", req.str); info!("Received Attestation Nonce:{:?}", req.str);
let mut attest_challenge = [0u8; crypto::SYMM_KEY_LEN_BYTES]; let mut attest_challenge = [0u8; crypto::SYMM_KEY_LEN_BYTES];
attest_challenge.copy_from_slice(session.get_att_challenge()); attest_challenge.copy_from_slice(transaction.session().get_att_challenge());
let mut writer = encoder.with_command(RespCommands::AttReqResp as _)?; let mut writer = encoder.with_command(RespCommands::AttReqResp as _)?;
@ -512,11 +516,15 @@ impl<'a> NocCluster<'a> {
)?; )?;
writer.end_container()?; writer.end_container()?;
writer.complete() writer.complete()?;
transaction.complete();
Ok(())
} }
fn handle_command_certchainrequest( fn handle_command_certchainrequest(
&mut self, &mut self,
transaction: &mut Transaction,
data: &TLVElement, data: &TLVElement,
encoder: CmdDataEncoder, encoder: CmdDataEncoder,
) -> Result<(), Error> { ) -> Result<(), Error> {
@ -535,12 +543,15 @@ impl<'a> NocCluster<'a> {
encoder encoder
.with_command(RespCommands::CertChainResp as _)? .with_command(RespCommands::CertChainResp as _)?
.set(cmd_data) .set(cmd_data)?;
transaction.complete();
Ok(())
} }
fn handle_command_csrrequest( fn handle_command_csrrequest(
&mut self, &mut self,
session: &mut Session, transaction: &mut Transaction,
data: &TLVElement, data: &TLVElement,
encoder: CmdDataEncoder, encoder: CmdDataEncoder,
) -> Result<(), Error> { ) -> Result<(), Error> {
@ -555,7 +566,7 @@ impl<'a> NocCluster<'a> {
let noc_keypair = KeyPair::new()?; let noc_keypair = KeyPair::new()?;
let mut attest_challenge = [0u8; crypto::SYMM_KEY_LEN_BYTES]; let mut attest_challenge = [0u8; crypto::SYMM_KEY_LEN_BYTES];
attest_challenge.copy_from_slice(session.get_att_challenge()); attest_challenge.copy_from_slice(transaction.session().get_att_challenge());
let mut writer = encoder.with_command(RespCommands::CSRResp as _)?; let mut writer = encoder.with_command(RespCommands::CSRResp as _)?;
@ -576,14 +587,15 @@ impl<'a> NocCluster<'a> {
let noc_data = NocData::new(noc_keypair); let noc_data = NocData::new(noc_keypair);
// Store this in the session data instead of cluster data, so it gets cleared // Store this in the session data instead of cluster data, so it gets cleared
// if the session goes away for some reason // if the session goes away for some reason
session.set_noc_data(noc_data); transaction.session_mut().set_noc_data(noc_data);
transaction.complete();
Ok(()) Ok(())
} }
fn handle_command_addtrustedrootcert( fn handle_command_addtrustedrootcert(
&mut self, &mut self,
session: &mut Session, transaction: &mut Transaction,
data: &TLVElement, data: &TLVElement,
) -> Result<(), Error> { ) -> Result<(), Error> {
cmd_enter!("AddTrustedRootCert"); cmd_enter!("AddTrustedRootCert");
@ -592,10 +604,13 @@ impl<'a> NocCluster<'a> {
} }
// This may happen on CASE or PASE. For PASE, the existence of NOC Data is necessary // This may happen on CASE or PASE. For PASE, the existence of NOC Data is necessary
match session.get_session_mode() { match transaction.session().get_session_mode() {
SessionMode::Case(_) => error!("CASE: AddTrustedRootCert handling pending"), // For a CASE Session, we just return success for now, SessionMode::Case(_) => error!("CASE: AddTrustedRootCert handling pending"), // For a CASE Session, we just return success for now,
SessionMode::Pase => { SessionMode::Pase => {
let noc_data = session.get_noc_data::<NocData>().ok_or(Error::NoSession)?; let noc_data = transaction
.session_mut()
.get_noc_data::<NocData>()
.ok_or(Error::NoSession)?;
let req = CommonReq::from_tlv(data).map_err(Error::map_invalid_command)?; let req = CommonReq::from_tlv(data).map_err(Error::map_invalid_command)?;
info!("Received Trusted Cert:{:x?}", req.str); info!("Received Trusted Cert:{:x?}", req.str);
@ -607,6 +622,7 @@ impl<'a> NocCluster<'a> {
_ => (), _ => (),
} }
transaction.complete();
Ok(()) Ok(())
} }
} }

10
matter/src/interaction_model/core.rs
View file

@ -395,7 +395,6 @@ impl<'a> WriteReq<'a> {
Interaction::create_status_response(tx, IMStatusCode::Timeout)?; Interaction::create_status_response(tx, IMStatusCode::Timeout)?;
transaction.complete(); transaction.complete();
transaction.ctx.exch.close();
Ok(false) Ok(false)
} else { } else {
@ -436,7 +435,6 @@ impl<'a> InvReq<'a> {
Interaction::create_status_response(tx, IMStatusCode::Timeout)?; Interaction::create_status_response(tx, IMStatusCode::Timeout)?;
transaction.complete(); transaction.complete();
transaction.ctx.exch.close();
Ok(false) Ok(false)
} else { } else {
@ -738,6 +736,10 @@ where
true true
}; };
if transaction.is_complete() {
transaction.exch_mut().close();
}
Ok(reply) Ok(reply)
} }
} }
@ -757,6 +759,10 @@ where
true true
}; };
if transaction.is_complete() {
transaction.exch_mut().close();
}
Ok(reply) Ok(reply)
} }
} }

9
matter/tests/common/im_engine.rs
View file

@ -109,7 +109,14 @@ impl<'a> ImInput<'a> {
pub type DmHandler<'a> = handler_chain_type!(OnOffCluster, EchoCluster, DescriptorCluster, EchoCluster | RootEndpointHandler<'a>); pub type DmHandler<'a> = handler_chain_type!(OnOffCluster, EchoCluster, DescriptorCluster, EchoCluster | RootEndpointHandler<'a>);
pub fn matter(mdns: &mut dyn Mdns) -> Matter<'_> { pub fn matter(mdns: &mut dyn Mdns) -> Matter<'_> {
Matter::new(&BASIC_INFO, mdns, sys_epoch, dummy_rand, sys_utc_calendar) Matter::new(
&BASIC_INFO,
mdns,
sys_epoch,
dummy_rand,
sys_utc_calendar,
5540,
)
} }
/// An Interaction Model Engine to facilitate easy testing /// An Interaction Model Engine to facilitate easy testing