/src/spdm-rs/spdmlib/src/requester/heartbeat_req.rs
Line | Count | Source |
1 | | // Copyright (c) 2020 Intel Corporation |
2 | | // |
3 | | // SPDX-License-Identifier: Apache-2.0 or MIT |
4 | | |
5 | | use crate::error::{SpdmResult, SPDM_STATUS_ERROR_PEER, SPDM_STATUS_INVALID_MSG_FIELD}; |
6 | | use crate::message::*; |
7 | | use crate::requester::*; |
8 | | |
9 | | impl RequesterContext { |
10 | | #[maybe_async::maybe_async] |
11 | 0 | pub async fn send_spdm_heartbeat(&mut self, session_id: u32) -> SpdmResult { |
12 | 0 | info!("send spdm heartbeat\n"); |
13 | | |
14 | 0 | self.common.reset_buffer_via_request_code( |
15 | 0 | SpdmRequestResponseCode::SpdmRequestHeartbeat, |
16 | 0 | Some(session_id), |
17 | | ); |
18 | | |
19 | 0 | let mut send_buffer = [0u8; config::MAX_SPDM_MSG_SIZE]; |
20 | 0 | let used = self.encode_spdm_heartbeat(&mut send_buffer)?; |
21 | 0 | self.send_message(Some(session_id), &send_buffer[..used], false) |
22 | 0 | .await |
23 | 0 | } |
24 | | |
25 | | #[maybe_async::maybe_async] |
26 | 0 | pub async fn receive_spdm_heartbeat(&mut self, session_id: u32) -> SpdmResult { |
27 | 0 | info!("!!! receive heartbeat !!!"); |
28 | 0 | let mut receive_buffer = [0u8; config::MAX_SPDM_MSG_SIZE]; |
29 | 0 | let used = self |
30 | 0 | .receive_message(Some(session_id), &mut receive_buffer, false) |
31 | 0 | .await?; |
32 | 0 | self.handle_spdm_heartbeat_response(session_id, &receive_buffer[..used]) |
33 | 0 | } |
34 | | |
35 | | #[maybe_async::maybe_async] |
36 | 0 | pub async fn send_receive_spdm_heartbeat(&mut self, session_id: u32) -> SpdmResult { |
37 | 0 | self.send_spdm_heartbeat(session_id).await?; |
38 | 0 | self.receive_spdm_heartbeat(session_id).await |
39 | 0 | } |
40 | | |
41 | | pub fn encode_spdm_heartbeat(&mut self, buf: &mut [u8]) -> SpdmResult<usize> { |
42 | | let mut writer = Writer::init(buf); |
43 | | let request = SpdmMessage { |
44 | | header: SpdmMessageHeader { |
45 | | version: self.common.negotiate_info.spdm_version_sel, |
46 | | request_response_code: SpdmRequestResponseCode::SpdmRequestHeartbeat, |
47 | | }, |
48 | | payload: SpdmMessagePayload::SpdmHeartbeatRequest(SpdmHeartbeatRequestPayload {}), |
49 | | }; |
50 | | request.spdm_encode(&mut self.common, &mut writer) |
51 | | } |
52 | | |
53 | | pub fn handle_spdm_heartbeat_response( |
54 | | &mut self, |
55 | | session_id: u32, |
56 | | receive_buffer: &[u8], |
57 | | ) -> SpdmResult { |
58 | | let mut reader = Reader::init(receive_buffer); |
59 | | match SpdmMessageHeader::read(&mut reader) { |
60 | | Some(message_header) => { |
61 | | if message_header.version != self.common.negotiate_info.spdm_version_sel { |
62 | | return Err(SPDM_STATUS_INVALID_MSG_FIELD); |
63 | | } |
64 | | match message_header.request_response_code { |
65 | | SpdmRequestResponseCode::SpdmResponseHeartbeatAck => { |
66 | | let heartbeat_rsp = |
67 | | SpdmHeartbeatResponsePayload::spdm_read(&mut self.common, &mut reader); |
68 | | if let Some(heartbeat_rsp) = heartbeat_rsp { |
69 | | debug!("!!! heartbeat rsp : {:02x?}\n", heartbeat_rsp); |
70 | | Ok(()) |
71 | | } else { |
72 | | error!("!!! heartbeat : fail !!!\n"); |
73 | | Err(SPDM_STATUS_INVALID_MSG_FIELD) |
74 | | } |
75 | | } |
76 | | SpdmRequestResponseCode::SpdmResponseError => self |
77 | | .spdm_handle_error_response_main( |
78 | | Some(session_id), |
79 | | receive_buffer, |
80 | | SpdmRequestResponseCode::SpdmRequestHeartbeat, |
81 | | SpdmRequestResponseCode::SpdmResponseHeartbeatAck, |
82 | | ), |
83 | | _ => Err(SPDM_STATUS_ERROR_PEER), |
84 | | } |
85 | | } |
86 | | None => Err(SPDM_STATUS_INVALID_MSG_FIELD), |
87 | | } |
88 | | } |
89 | | } |