rust-libteec 0.1.0

// SPDX-License-Identifier: Apache-2.0
// Copyright (C) 2025-2026 KylinSoft Co., Ltd. <https://www.kylinos.cn/>
// See LICENSES for license details.

#![allow(dead_code)]
#![allow(non_camel_case_types)]

use bytemuck::{Pod, Zeroable};
use serde::{Deserialize, Serialize};

pub const CHUNK_SIZE: u64 = 512; // 512B 分块

/// 数据包类型枚举，定义协议支持的不同操作类型
#[derive(Debug, PartialEq, Eq, Default)]
pub enum PacketType {
    #[default]
    Unknown = 0,
    OpenSession = 1,
    CloseSession = 2,
    InvokeCommand = 3,
    RequestCancellation = 4,
}

impl From<u64> for PacketType {
    fn from(value: u64) -> Self {
        match value {
            0 => PacketType::Unknown,
            1 => PacketType::OpenSession,
            2 => PacketType::CloseSession,
            3 => PacketType::InvokeCommand,
            4 => PacketType::RequestCancellation,
            _ => PacketType::Unknown,
        }
    }
}

impl From<PacketType> for u64 {
    fn from(value: PacketType) -> Self {
        match value {
            PacketType::Unknown => 0,
            PacketType::OpenSession => 1,
            PacketType::CloseSession => 2,
            PacketType::InvokeCommand => 3,
            PacketType::RequestCancellation => 4,
        }
    }
}
/// 协议头结构，使用 #[repr(C)] 确保内存布局与C兼容
/// 满足 bytemuck::Pod 要求：所有字段必须为基本类型
#[repr(C)]
#[derive(Debug, Copy, Clone, Pod, Zeroable)]
pub struct PacketHeader {
    /// 数据包类型标识，对应 PacketType 枚举的数值表示
    pub data_type: u64,
    /// 数据包负载大小
    pub data_size: u64,
}

impl PacketHeader {
    /// 协议头结构体的大小
    pub const SIZE: usize = size_of::<PacketHeader>();

    /// 将协议头序列化为字节切片
    pub fn as_bytes(&self) -> &[u8] {
        bytemuck::bytes_of(self)
    }

    /// 从字节切片反序列化协议头，
    pub fn from_bytes(buf: &[u8]) -> Self {
        *bytemuck::from_bytes(buf)
    }
}

#[derive(Serialize, Deserialize)]
pub enum TEE_Request {
    OpenSession {
        uuid: String,
        connection_method: u32,
        params: TEE_Parameters,
    },
    CloseSession {
        session_id: u32,
    },
    InvokeCommand {
        session_id: u32,
        cmd_id: u32,
        params: TEE_Parameters,
    },
    RequestCancellation {
        session_id: u32,
    },
}

#[derive(Serialize, Deserialize)]
pub enum TEE_Response {
    OpenSession { session_id: u32, result: u32 },
    CloseSession { result: u32 },
    InvokeCommand { params: TEE_Parameters, result: u32 },
    RequestCancellation { result: u32 },
}

#[derive(Serialize, Deserialize, Default)]
pub struct TEE_Parameters(
    pub TEE_Parameter,
    pub TEE_Parameter,
    pub TEE_Parameter,
    pub TEE_Parameter,
);

#[derive(Serialize, Deserialize, Default)]
pub struct TEE_Parameter {
    pub param: TEE_Param,
    pub param_type: TEE_ParamType,
}

#[derive(Serialize, Deserialize, Default)]
pub struct TEE_Param {
    pub data: Vec<u8>,
    pub value: TEE_Value,
}

#[derive(Serialize, Deserialize, Default)]
pub struct TEE_Value {
    pub a: u32,
    pub b: u32,
}

#[derive(Serialize, Deserialize, Default, Debug, PartialEq, Eq, Clone, Copy)]
pub enum TEE_ParamType {
    #[default]
    None = 0,
    ValueInput = 1,
    ValueOutput = 2,
    ValueInout = 3,
    MemrefInput = 5,
    MemrefOutput = 6,
    MemrefInout = 7,
}

impl From<u32> for TEE_ParamType {
    fn from(value: u32) -> Self {
        match value {
            0 => TEE_ParamType::None,
            1 => TEE_ParamType::ValueInput,
            2 => TEE_ParamType::ValueOutput,
            3 => TEE_ParamType::ValueInout,
            5 => TEE_ParamType::MemrefInput,
            6 => TEE_ParamType::MemrefOutput,
            7 => TEE_ParamType::MemrefInout,
            _ => TEE_ParamType::None,
        }
    }
}

#[cfg(test)]
mod protocol_tests {
    use super::*;

    #[test]
    fn test_tee_param_type_from_u32() {
        // 测试 TEE_ParamType 的 From<u32> 实现 - 覆盖所有分支
        assert_eq!(TEE_ParamType::from(0), TEE_ParamType::None);
        assert_eq!(TEE_ParamType::from(1), TEE_ParamType::ValueInput);
        assert_eq!(TEE_ParamType::from(2), TEE_ParamType::ValueOutput);
        assert_eq!(TEE_ParamType::from(3), TEE_ParamType::ValueInout);
        assert_eq!(TEE_ParamType::from(4), TEE_ParamType::None); // 未知值 -> None
        assert_eq!(TEE_ParamType::from(5), TEE_ParamType::MemrefInput);
        assert_eq!(TEE_ParamType::from(6), TEE_ParamType::MemrefOutput);
        assert_eq!(TEE_ParamType::from(7), TEE_ParamType::MemrefInout);
        assert_eq!(TEE_ParamType::from(8), TEE_ParamType::None); // 未知值 -> None
        assert_eq!(TEE_ParamType::from(99), TEE_ParamType::None); // 未知值 -> None
        assert_eq!(TEE_ParamType::from(255), TEE_ParamType::None); // 边界值
    }

    #[test]
    fn test_tee_value_default() {
        // 测试 TEE_Value 的 Default trait
        let default_val = TEE_Value::default();
        assert_eq!(default_val.a, 0);
        assert_eq!(default_val.b, 0);
    }

    #[test]
    fn test_tee_parameter_default() {
        // 测试 TEE_Parameter 的 Default trait
        let default_param = TEE_Parameter::default();
        assert_eq!(default_param.param_type, TEE_ParamType::None);
        assert_eq!(default_param.param.value.a, 0);
        assert_eq!(default_param.param.value.b, 0);
        assert!(default_param.param.data.is_empty());
    }

    #[test]
    fn test_packet_header_serialization_roundtrip() {
        // 测试 PacketHeader 序列化/反序列化的往返一致性
        let original = PacketHeader {
            data_type: 0x1234_5678_9ABC_DEF0,
            data_size: 0xFEDC_BA98_7654_3210,
        };

        let bytes = original.as_bytes();
        let restored = PacketHeader::from_bytes(bytes);

        assert_eq!(original.data_type, restored.data_type);
        assert_eq!(original.data_size, restored.data_size);
    }
}