Coverage Report

Created: 2025-07-23 06:21

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