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.

//! TEE 客户端库实现，基于 GlobalPlatform TEE Client API 规范
//! 提供与可信执行环境(TEE)通信的接口

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

use std::{
    ffi::{c_char, c_void},
    ptr,
    sync::{
        Arc, Mutex,
        atomic::{AtomicI32, Ordering},
    },
};

use dashmap::DashMap;
use log::{debug, warn};
use once_cell::sync::Lazy;
use postcard::{take_from_bytes, to_allocvec};
use uuid::Uuid;

use crate::cc_client::client::CcClient;
use crate::common::protocol::{
    PacketType, TEE_ParamType, TEE_Parameters, TEE_Request, TEE_Response,
};
use crate::{Error, ErrorKind, ErrorOrigin, Result, raw};

const SHM_FLAG_BUFFER_ALLOCED: u32 = 1 << 0;

type ContextMap = DashMap<i32, Arc<Mutex<CcClient>>>;
type SharedMemoryMap = DashMap<i32, Vec<u8>>;

static TEEC_MUTEX: Lazy<Mutex<()>> = Lazy::new(|| Mutex::new(()));
static CONTEXT_ID_COUNTER: Lazy<AtomicI32> = Lazy::new(|| AtomicI32::new(-1));
static CONTEXTS: Lazy<ContextMap> = Lazy::new(DashMap::new);
static SHMS: Lazy<SharedMemoryMap> = Lazy::new(DashMap::new);

// 安全指针操作模块，封装 unsafe 操作并提供错误处理
mod safe_ptr {
    use super::{Error, ErrorKind, ErrorOrigin, Result};
    use std::ptr::NonNull;

    /// 安全地解引用可变指针，返回 NonNull 包装
    pub fn deref_mut<T>(ptr: *mut T) -> Result<NonNull<T>> {
        NonNull::new(ptr).ok_or(Error::new(ErrorKind::BadParameters).with_origin(ErrorOrigin::API))
    }

    /// 安全地解引用不可变指针，返回 NonNull 包装
    pub fn deref<T>(ptr: *const T) -> Result<NonNull<T>> {
        NonNull::new(ptr as *mut T)
            .ok_or(Error::new(ErrorKind::BadParameters).with_origin(ErrorOrigin::API))
    }

    /// 安全地向指针指向的内存写入值
    pub fn write_raw<T>(ptr: *mut T, value: T) -> Result<()> {
        let nn = NonNull::new(ptr)
            .ok_or(Error::new(ErrorKind::BadParameters).with_origin(ErrorOrigin::API))?;
        // SAFETY: `nn` 已通过上面的 `NonNull::new` 检查为非空。
        // 调用方保证传入的 `ptr` 的所有权/有效性，因此向 `nn.as_ptr()` 写入
        // `value` 是安全的（内存对齐正确且可写）。
        unsafe { nn.as_ptr().write(value) };
        Ok(())
    }

    /// 安全地从指针指向的内存读取值
    pub fn read_raw<T: Copy>(ptr: *const T) -> Result<T> {
        let nn = NonNull::new(ptr as *mut T)
            .ok_or(Error::new(ErrorKind::BadParameters).with_origin(ErrorOrigin::API))?;
        // SAFETY: `nn` 已为非空并指向有效的 `T`（已在上面检查）。
        // `T: Copy` 确保复制该值是安全的。
        Ok(unsafe { *nn.as_ptr() })
    }

    /// 安全地从指针读取指定长度的数据到 Vec
    pub fn read_to_vec<T: Copy>(src: *const T, len: usize) -> Result<Vec<T>> {
        if src.is_null() && len > 0 {
            return Err(Error::new(ErrorKind::BadParameters).with_origin(ErrorOrigin::API));
        }
        let _nn = NonNull::new(src as *mut T)
            .ok_or(Error::new(ErrorKind::BadParameters).with_origin(ErrorOrigin::API))?;
        // SAFETY: 当 `len > 0` 时 `src` 已被检查为非空。调用方保证
        // `src..src+len` 可安全读取且内存对齐正确。
        let slice = unsafe { std::slice::from_raw_parts(src, len) };
        Ok(slice.to_vec())
    }

    /// 安全地将切片数据写入指针指向的内存
    pub fn write_from_slice<T: Copy>(dst: *mut T, src: &[T]) -> Result<()> {
        if dst.is_null() && !src.is_empty() {
            return Err(Error::new(ErrorKind::BadParameters).with_origin(ErrorOrigin::API));
        }

        if src.is_empty() {
            return Err(Error::new(ErrorKind::BadFormat).with_origin(ErrorOrigin::API));
        }

        let _nn = NonNull::new(dst)
            .ok_or(Error::new(ErrorKind::BadParameters).with_origin(ErrorOrigin::API))?;
        // SAFETY: 当 `src` 非空时已检查 `dst` 为非空。调用方保证 `dst` 指向
        // `src.len()` 个可写元素，且内存对齐适合 `T`。
        let dst_slice = unsafe { std::slice::from_raw_parts_mut(dst, src.len()) };
        dst_slice.copy_from_slice(src);
        Ok(())
    }

    /// 安全地进行指针加法运算
    pub fn add_ptr<T>(ptr: *const T, offset: usize) -> *const T {
        // SAFETY: 在同一已分配对象内进行指针运算；调用方保证 `ptr` 有效
        // 且 `offset` 在预期范围内。
        unsafe { ptr.add(offset) }
    }

    /// 安全地进行可变指针加法运算
    pub fn add_ptr_mut<T>(ptr: *mut T, offset: usize) -> *mut T {
        // SAFETY: 在同一已分配对象内进行指针运算；调用方保证 `ptr` 有效
        // 且 `offset` 在预期范围内。
        unsafe { ptr.add(offset) }
    }
}

/// TEE 上下文管理器，负责管理TEE上下文的生命周期和访问
struct ContextManager;

impl ContextManager {
    /// 添加新的 TEE 上下文到全局管理
    fn add_context(ctx: *mut raw::TEEC_Context, client: CcClient) -> Result<()> {
        let mut ctx_nn = safe_ptr::deref_mut(ctx)?;
        // SAFETY: `ctx_nn` 是由 `deref_mut` 返回的 `NonNull`，已验证指针为非空。
        // 调用 `as_mut()` 可获得指向底层 `raw::TEEC_Context` 的可变引用，
        // 该引用在此借用期间有效。
        let ctx_ref = unsafe { ctx_nn.as_mut() };
        let ctx_id: i32 = ctx_ref.imp.fd;
        let client_arc = Arc::new(Mutex::new(client));

        CONTEXTS.insert(ctx_id, client_arc);
        Ok(())
    }

    /// 从全局管理中移除 TEE 上下文
    fn remove_context(ctx: *mut raw::TEEC_Context) {
        if let Ok(mut ctx_nn) = safe_ptr::deref_mut(ctx) {
            // SAFETY: `ctx_nn` 为上文 `deref_mut` 返回的 `NonNull`，已验证非空。
            // `as_mut()` 是安全的，因为指针已检查且在此借用中我们拥有独占访问权。
            let ctx_ref = unsafe { ctx_nn.as_mut() };
            let ctx_id = ctx_ref.imp.fd;
            CONTEXTS.remove(&ctx_id);
            ctx_ref.imp.fd = -1;
        }
    }

    /// 获取指定上下文对应的客户端连接
    fn get_client(ctx: *mut raw::TEEC_Context) -> Result<Arc<Mutex<CcClient>>> {
        let ctx_nn = safe_ptr::deref_mut(ctx)?;
        // SAFETY: `ctx_nn` 已由 `deref_mut` 验证为非空；`as_ref()` 返回的不可变引用
        // 在此作用域内有效。
        let ctx_ref = unsafe { ctx_nn.as_ref() };
        let ctx_id = ctx_ref.imp.fd;

        CONTEXTS
            .get(&ctx_id)
            .map(|entry| entry.value().clone())
            .ok_or_else(|| Error::new(ErrorKind::Generic).with_origin(ErrorOrigin::API))
    }
}

/// 共享内存管理器，负责管理 TEE 共享内存的分配和释放
struct SharedMemoryManager;

impl SharedMemoryManager {
    /// 分配共享内存并注册到指定上下文
    fn allocate(
        ctx: *mut raw::TEEC_Context,
        shm: *mut raw::TEEC_SharedMemory,
        registe: bool,
    ) -> Result<()> {
        let mut shm_nn = safe_ptr::deref_mut(shm)?;
        let ctx_nn = safe_ptr::deref(ctx)?;
        // SAFETY: `shm_nn` 已由 `deref_mut` 检查为非空。调用 `as_mut()` 安全，
        // 并可对 `TEEC_SharedMemory` 结构进行可变访问。
        let shm_ref = unsafe { shm_nn.as_mut() };
        // SAFETY: `ctx_nn` 已由 `deref` 检查为非空。调用 `as_ref()` 安全，
        let ctx_ref = unsafe { ctx_nn.as_ref() };
        let flags = shm_ref.flags;
        let size = shm_ref.size;

        if size == 0 || flags == 0 || flags & !(raw::TEEC_MEM_INPUT | raw::TEEC_MEM_OUTPUT) != 0 {
            return Err(Error::new(ErrorKind::BadParameters));
        }

        let mut buffer = vec![0u8; size];

        if registe {
            if shm_ref.buffer.is_null() {
                return Err(Error::new(ErrorKind::BadParameters));
            }

            buffer = safe_ptr::read_to_vec(shm_ref.buffer as *const u8, size)?;
        }

        let ptr = buffer.as_mut_ptr() as *mut c_void;

        if ptr.is_null() {
            return Err(Error::new(ErrorKind::OutOfMemory));
        }

        let id = ctx_ref.imp.fd;

        shm_ref.buffer = ptr;
        shm_ref.imp.id = id;
        shm_ref.imp.registered_fd = -1;
        shm_ref.imp.shadow_buffer = ptr::null_mut();
        shm_ref.imp.alloced_size = size;
        shm_ref.imp.flags = SHM_FLAG_BUFFER_ALLOCED;

        SHMS.insert(id, buffer);

        Ok(())
    }

    /// 释放共享内存
    fn release(shm: *mut raw::TEEC_SharedMemory) {
        if let Ok(mut shm_nn) = safe_ptr::deref_mut(shm) {
            // SAFETY: `shm_nn` 已验证非空；`as_mut()` 返回的可变引用在此作用域中有效。
            let shm_ref = unsafe { shm_nn.as_mut() };
            if shm_ref.imp.id < 0 {
                return;
            }

            let id = shm_ref.imp.id;

            shm_ref.imp.id = -1;
            shm_ref.size = 0;
            shm_ref.flags = 0;
            shm_ref.buffer = ptr::null_mut();

            SHMS.remove(&id);
        }
    }

    /// 获取共享内存缓冲区数据
    fn get_buffer(shm: *const raw::TEEC_SharedMemory) -> Option<Vec<u8>> {
        if shm.is_null() {
            return None;
        }

        // SAFETY: `shm` 已验证为非空。
        let id = unsafe { (*shm).imp.id };
        SHMS.get(&id).map(|entry| entry.value().clone())
    }
}

/// 将 GP TEE UUID 格式转换为标准 UUID 字符串
fn uuid_to_string(uuid: &raw::TEEC_UUID) -> Result<String> {
    let bytes: [u8; 16] = [
        (uuid.timeLow >> 24) as u8,
        (uuid.timeLow >> 16) as u8,
        (uuid.timeLow >> 8) as u8,
        uuid.timeLow as u8,
        (uuid.timeMid >> 8) as u8,
        uuid.timeMid as u8,
        (uuid.timeHiAndVersion >> 8) as u8,
        uuid.timeHiAndVersion as u8,
        uuid.clockSeqAndNode[0],
        uuid.clockSeqAndNode[1],
        uuid.clockSeqAndNode[2],
        uuid.clockSeqAndNode[3],
        uuid.clockSeqAndNode[4],
        uuid.clockSeqAndNode[5],
        uuid.clockSeqAndNode[6],
        uuid.clockSeqAndNode[7],
    ];

    Uuid::from_slice(&bytes)
        .map(|u| u.to_string())
        .map_err(|_| Error::new(ErrorKind::BadFormat))
}

/// 操作参数包装器，提供安全的操作参数访问
struct OperationParams {
    operation: *mut raw::TEEC_Operation,
}

impl OperationParams {
    fn new(operation: *mut raw::TEEC_Operation) -> Result<Self> {
        let _ = safe_ptr::deref_mut(operation)?;
        Ok(Self { operation })
    }

    /// 获取操作参数类型位掩码
    fn param_types(&self) -> Result<u32> {
        let op_nn = safe_ptr::deref(self.operation)?;
        // SAFETY: `op_nn` 已由 `deref` 验证为非空。`as_ref()` 是安全的，
        // 因为指针为非空且调用方在此借用期间已初始化该操作结构。
        let op_ref = unsafe { op_nn.as_ref() };
        Ok(op_ref.paramTypes)
    }

    /// 获取值类型参数的值
    fn get_value(&self, idx: usize) -> Result<(u32, u32)> {
        if idx >= raw::TEEC_CONFIG_PAYLOAD_REF_COUNT {
            return Err(Error::new(ErrorKind::BadParameters));
        }

        let op_nn = safe_ptr::deref(self.operation)?;
        // SAFETY: `op_nn` 已验证为非空；`as_ref()` 提供不可变引用。访问
        // `params[idx]` 是安全的，因为上面已做边界检查。
        let op_ref = unsafe { op_nn.as_ref() };
        let param = &op_ref.params[idx];
        // SAFETY: 从 `param.value` 读取简单的 `u32` 字段是安全的。
        unsafe { Ok((param.value.a, param.value.b)) }
    }

    /// 设置值类型参数的值
    fn set_value(&self, idx: usize, a: u32, b: u32) -> Result<()> {
        if idx >= raw::TEEC_CONFIG_PAYLOAD_REF_COUNT {
            return Err(Error::new(ErrorKind::BadParameters));
        }

        let mut op_nn = safe_ptr::deref_mut(self.operation)?;
        // SAFETY: `op_nn` 非空且 `deref_mut` 提供独占访问；`as_mut()` 返回的
        // 可变引用可安全用于写入 params。
        let op_ref = unsafe { op_nn.as_mut() };
        let param = &mut op_ref.params[idx];

        param.value.a = a;
        param.value.b = b;

        Ok(())
    }

    /// 获取临时内存输入参数的数据内容
    fn get_tmpref_data(&self, idx: usize) -> Result<Vec<u8>> {
        if idx >= raw::TEEC_CONFIG_PAYLOAD_REF_COUNT {
            return Err(Error::new(ErrorKind::BadParameters));
        }

        let op_nn = safe_ptr::deref(self.operation)?;
        // SAFETY: `op_nn` 已验证非空；`as_ref()` 返回不可变引用。仅在上面
        // 检查了 `idx` 边界之后才访问 `params[idx].tmpref`，因此是安全的。
        let op_ref = unsafe { op_nn.as_ref() };
        let tmp = unsafe { &op_ref.params[idx].tmpref };

        if tmp.buffer.is_null() && tmp.size > 0 {
            return Err(Error::new(ErrorKind::BadParameters));
        }

        if tmp.size > 0 && !tmp.buffer.is_null() {
            safe_ptr::read_to_vec(tmp.buffer as *const u8, tmp.size)
        } else {
            Ok(Vec::new())
        }
    }

    /// 设置临时内存引用参数的数据
    fn set_tmpref_data(&self, idx: usize, data: &[u8]) -> Result<()> {
        if idx >= raw::TEEC_CONFIG_PAYLOAD_REF_COUNT {
            return Err(Error::new(ErrorKind::BadParameters));
        }

        let mut op_nn = safe_ptr::deref_mut(self.operation)?;
        // SAFETY: `op_nn` 已验证非空且我们通过 `deref_mut` 获得独占访问权。
        // 可变借用 `params[idx].tmpref` 在 `idx` 已检查且调用方保证 tmpref
        // 缓冲区有效的情况下是安全的。
        let op_ref = unsafe { op_nn.as_mut() };
        let tmp = unsafe { &mut op_ref.params[idx].tmpref };

        if tmp.buffer.is_null() {
            return Err(Error::new(ErrorKind::BadParameters));
        }

        let dest_len = data.len().min(tmp.size);
        if dest_len > 0 {
            safe_ptr::write_from_slice(tmp.buffer as *mut u8, &data[..dest_len])?;
        }
        tmp.size = dest_len;

        Ok(())
    }

    /// 获取内存引用参数的父内存标志位
    fn get_memref_parent_flags(&self, idx: usize) -> Result<u32> {
        if idx >= raw::TEEC_CONFIG_PAYLOAD_REF_COUNT {
            return Err(Error::new(ErrorKind::BadParameters));
        }

        let op_nn = safe_ptr::deref(self.operation)?;
        // SAFETY: `op_nn` 已验证非空；`as_ref()` 返回不可变引用。访问
        // `params[idx].memref` 是安全的，因为上文已做 `idx` 边界检查。
        let op_ref = unsafe { op_nn.as_ref() };
        let mem: &raw::TEEC_RegisteredMemoryReference = unsafe { &op_ref.params[idx].memref };

        if mem.parent.is_null() {
            return Err(Error::new(ErrorKind::BadParameters));
        }

        let parent_nn = safe_ptr::deref(mem.parent)?;
        // SAFETY: `parent_nn` 已由 `deref` 验证为非空。`as_ref()` 返回的
        // 不可变引用指向父共享内存描述符，该引用对于下面的读取是有效的。
        let parent = unsafe { parent_nn.as_ref() };

        Ok(parent.flags)
    }

    /// 获取完整内存引用参数的数据
    fn get_memref_data_whole(&self, idx: usize) -> Result<Vec<u8>> {
        if idx >= raw::TEEC_CONFIG_PAYLOAD_REF_COUNT {
            return Err(Error::new(ErrorKind::BadParameters));
        }

        let op_nn = safe_ptr::deref(self.operation)?;
        // SAFETY: `op_nn` 已验证非空；`as_ref()` 返回不可变引用，并且访问
        // `params[idx].memref` 是安全的，因为上文已做 `idx` 边界检查。
        let op_ref = unsafe { op_nn.as_ref() };
        let mem: &raw::TEEC_RegisteredMemoryReference = unsafe { &op_ref.params[idx].memref };

        if mem.parent.is_null() {
            return Err(Error::new(ErrorKind::BadParameters));
        }

        let parent_nn = safe_ptr::deref(mem.parent)?;
        // SAFETY: `parent_nn` 已由 `deref` 验证为非空。`as_ref()` 返回的
        // 不可变引用指向父共享内存描述符，该引用对于下面的读取是有效的。
        let parent = unsafe { parent_nn.as_ref() };
        let mem_size = mem.size;

        if !parent.buffer.is_null() {
            safe_ptr::read_to_vec(parent.buffer as *const u8, mem_size)
        } else {
            Ok(SharedMemoryManager::get_buffer(mem.parent).unwrap_or_else(|| vec![0u8; mem_size]))
        }
    }

    /// 设置完整内存引用参数的数据
    fn set_memref_data_whole(&self, idx: usize, data: &[u8]) -> Result<()> {
        if idx >= raw::TEEC_CONFIG_PAYLOAD_REF_COUNT {
            return Err(Error::new(ErrorKind::BadParameters));
        }

        let op_nn = safe_ptr::deref(self.operation)?;
        // SAFETY: `op_nn` 已验证非空。`as_ref()` 返回引用；访问
        // `params[idx].memref` 是安全的，因为已对 `idx` 做检查。
        let op_ref = unsafe { op_nn.as_ref() };
        let mem = unsafe { &op_ref.params[idx].memref };

        if mem.parent.is_null() {
            return Err(Error::new(ErrorKind::BadParameters));
        }

        let mut parent_nn = safe_ptr::deref_mut(mem.parent)?;
        // SAFETY: `parent_nn` 已由 `deref_mut` 验证为非空；`as_mut()` 返回
        // 可变引用。调用方在需要时保证缓冲区是可写的。
        let parent = unsafe { parent_nn.as_mut() };

        if parent.buffer.is_null() {
            return Err(Error::new(ErrorKind::BadParameters));
        }

        if !data.is_empty() {
            safe_ptr::write_from_slice(parent.buffer as *mut u8, data)?;
        }
        Ok(())
    }

    /// 获取部分内存引用参数的数据
    fn get_memref_data_partial(&self, idx: usize, req_flags: u32) -> Result<Vec<u8>> {
        if idx >= raw::TEEC_CONFIG_PAYLOAD_REF_COUNT {
            return Err(Error::new(ErrorKind::BadParameters));
        }

        let op_nn = safe_ptr::deref(self.operation)?;
        // SAFETY: `op_nn` 已验证非空；`as_ref()` 返回不可变引用，并且访问
        // `params[idx].memref` 是安全的，因为上文已做 `idx` 边界检查。
        let op_ref = unsafe { op_nn.as_ref() };
        let mem: &raw::TEEC_RegisteredMemoryReference = unsafe { &op_ref.params[idx].memref };

        if mem.parent.is_null() {
            return Err(Error::new(ErrorKind::BadParameters));
        }

        let parent_nn = safe_ptr::deref(mem.parent)?;
        // SAFETY: `parent_nn` 已由 `deref` 验证为非空。`as_ref()` 返回的
        // 不可变引用指向父共享内存描述符，该引用对于下面的读取是有效的。
        let parent = unsafe { parent_nn.as_ref() };

        if parent.flags & req_flags != req_flags {
            return Err(Error::new(ErrorKind::BadParameters));
        }

        if mem.offset.saturating_add(mem.size) > parent.size {
            return Err(Error::new(ErrorKind::BadParameters));
        }

        let mem_size = mem.size;
        let offset = mem.offset;

        if !parent.buffer.is_null() {
            let start_ptr = safe_ptr::add_ptr(parent.buffer as *const u8, offset);
            safe_ptr::read_to_vec(start_ptr, mem_size)
        } else {
            Err(Error::new(ErrorKind::BadParameters))
        }
    }

    /// 设置部分内存引用参数的数据
    fn set_memref_data_partial(&self, idx: usize, data: &[u8]) -> Result<()> {
        if idx >= raw::TEEC_CONFIG_PAYLOAD_REF_COUNT {
            return Err(Error::new(ErrorKind::BadParameters));
        }

        let op_nn = safe_ptr::deref(self.operation)?;
        // SAFETY: `op_nn` 已验证非空。`as_ref()` 返回引用；访问
        // `params[idx].memref` 是安全的，因为已对 `idx` 做检查。
        let op_ref = unsafe { op_nn.as_ref() };
        let mem = unsafe { &op_ref.params[idx].memref };

        if mem.parent.is_null() {
            return Err(Error::new(ErrorKind::BadParameters));
        }

        let mut parent_nn = safe_ptr::deref_mut(mem.parent)?;
        // SAFETY: `parent_nn` 已由 `deref_mut` 验证为非空；`as_mut()` 返回
        // 可变引用。调用方在需要时保证缓冲区是可写的。
        let parent = unsafe { parent_nn.as_mut() };

        if parent.buffer.is_null() {
            return Err(Error::new(ErrorKind::BadParameters));
        }

        if !data.is_empty() {
            let offset = mem.offset;
            let start_ptr = safe_ptr::add_ptr_mut(parent.buffer as *mut u8, offset);
            safe_ptr::write_from_slice(start_ptr, data)?;
        }
        Ok(())
    }
}

/// 设置返回错误来源
fn set_ret_origin(p: *mut u32, v: u32) -> Result<()> {
    safe_ptr::write_raw(p, v)
}

/// 统一处理错误，设置错误来源并返回原始错误码
fn handle_error<T>(result: Result<T>, ret_origin: *mut u32) -> u32 {
    match result {
        Ok(_) => raw::TEEC_SUCCESS,
        Err(e) => {
            let _ = set_ret_origin(ret_origin, e.origin().unwrap_or(ErrorOrigin::API).into());
            e.raw_code()
        }
    }
}

/// 从 TEEC_Operation 构建协议参数
fn build_parameters_from_operation(operation: *mut raw::TEEC_Operation) -> Result<TEE_Parameters> {
    let op_params = OperationParams::new(operation)?;
    let param_types = op_params.param_types()?;
    let mut params = TEE_Parameters::default();

    let param_tuples = [
        (&mut params.0, 0),
        (&mut params.1, 1),
        (&mut params.2, 2),
        (&mut params.3, 3),
    ];

    for (param, idx) in param_tuples {
        let param_type = raw::TEEC_PARAM_TYPE_GET(param_types, idx);

        match param_type {
            raw::TEEC_NONE => {
                param.param_type = TEE_ParamType::None;
            }
            raw::TEEC_VALUE_INPUT => {
                param.param_type = TEE_ParamType::ValueInput;
                if let Ok((a, b)) = op_params.get_value(idx) {
                    param.param.value.a = a;
                    param.param.value.b = b;
                }
            }
            raw::TEEC_VALUE_OUTPUT => {
                // 输出参数只需设置类型，数据从 TEE 返回后填充
                param.param_type = TEE_ParamType::ValueOutput;
            }
            raw::TEEC_VALUE_INOUT => {
                param.param_type = TEE_ParamType::ValueInout;
                if let Ok((a, b)) = op_params.get_value(idx) {
                    param.param.value.a = a;
                    param.param.value.b = b;
                }
            }
            raw::TEEC_MEMREF_TEMP_INPUT => {
                param.param_type = TEE_ParamType::MemrefInput;
                if let Ok(data) = op_params.get_tmpref_data(idx) {
                    param.param.data = data;
                }
            }
            raw::TEEC_MEMREF_TEMP_OUTPUT => {
                param.param_type = TEE_ParamType::MemrefOutput;

                // 输出参数只需传递缓冲区大小，不需要传输实际数据
                let op_nn = safe_ptr::deref(operation)?;
                // SAFETY: `op_nn` 已由 `safe_ptr::deref` 验证为非空指针。
                // `as_ref()` 创建不可变引用，访问 `params[idx]` 是安全的，因为：
                // 1. `idx` 由调用方保证在有效范围内（0..TEEC_CONFIG_PAYLOAD_REF_COUNT）
                // 2. `tmpref` 是 union 的有效成员，由 paramTypes 确定
                let op_ref = unsafe { op_nn.as_ref() };
                // SAFETY: 访问 union 字段 `tmpref` 是安全的，因为：
                // - paramTypes 已确认为 TEEC_MEMREF_TEMP_OUTPUT
                // - idx 已通过边界检查
                let tmp = unsafe { &op_ref.params[idx].tmpref };

                // 注意：对于 MemrefOutput 参数，TA 可能需要知道 CA 期望的缓冲区大小。
                // 因此我们复用 value.a 字段传递 size 信息（这是一种特殊约定）。
                param.param.value.a = tmp.size as u32;
                debug!(
                    "TEEC_MEMREF_TEMP_OUTPUT: size={}, value.a={}",
                    tmp.size, param.param.value.a
                );
            }
            raw::TEEC_MEMREF_TEMP_INOUT => {
                param.param_type = TEE_ParamType::MemrefInout;
                if let Ok(data) = op_params.get_tmpref_data(idx) {
                    param.param.data = data;
                }
            }
            raw::TEEC_MEMREF_WHOLE => {
                // 完整内存引用根据父内存标志确定方向
                const INOUT: u32 = raw::TEEC_MEM_INPUT | raw::TEEC_MEM_OUTPUT;
                let flags = op_params.get_memref_parent_flags(idx)? & INOUT;

                if flags == INOUT {
                    param.param_type = TEE_ParamType::MemrefInout;
                } else if flags & raw::TEEC_MEM_INPUT != 0 {
                    param.param_type = TEE_ParamType::MemrefInput;
                } else if flags & raw::TEEC_MEM_OUTPUT != 0 {
                    param.param_type = TEE_ParamType::MemrefOutput;

                    // 对于 OUTPUT 方向，通过 value.a 传递缓冲区大小（特殊约定）
                    let op_nn = safe_ptr::deref(operation)?;
                    // SAFETY: `op_nn` 已由 `safe_ptr::deref` 验证为非空指针。
                    // `as_ref()` 创建不可变引用，访问 `params[idx]` 是安全的，因为：
                    // 1. `idx` 由调用方保证在有效范围内
                    // 2. `memref` 是 union 的有效成员，由 paramTypes 确定
                    let op_ref = unsafe { op_nn.as_ref() };
                    // SAFETY: 访问 union 字段 `memref` 是安全的，因为：
                    // - paramTypes 已确认为 TEEC_MEMREF_WHOLE
                    // - idx 已通过边界检查
                    let mem = unsafe { &op_ref.params[idx].memref };
                    param.param.value.a = mem.size as u32;
                    debug!(
                        "TEEC_MEMREF_WHOLE OUTPUT: size={}, value.a={}",
                        mem.size, param.param.value.a
                    );
                } else {
                    return Err(Error::new(ErrorKind::BadParameters));
                }

                if flags & raw::TEEC_MEM_INPUT != 0
                    && let Ok(data) = op_params.get_memref_data_whole(idx)
                {
                    param.param.data = data;
                }
            }
            raw::TEEC_MEMREF_PARTIAL_INPUT => {
                param.param_type = TEE_ParamType::MemrefInput;
                let req_flags = raw::TEEC_MEM_INPUT;
                if let Ok(data) = op_params.get_memref_data_partial(idx, req_flags) {
                    param.param.data = data;
                }
            }
            raw::TEEC_MEMREF_PARTIAL_OUTPUT => {
                param.param_type = TEE_ParamType::MemrefOutput;

                // 输出参数只需传递缓冲区大小
                let op_nn = safe_ptr::deref(operation)?;
                // SAFETY: `op_nn` 已由 `safe_ptr::deref` 验证为非空指针。
                // `as_ref()` 创建不可变引用，访问 `params[idx]` 是安全的，因为：
                // 1. `idx` 由调用方保证在有效范围内
                // 2. `memref` 是 union 的有效成员，由 paramTypes 确定
                let op_ref = unsafe { op_nn.as_ref() };
                // SAFETY: 访问 union 字段 `memref` 是安全的，因为：
                // - paramTypes 已确认为 TEEC_MEMREF_PARTIAL_OUTPUT
                // - idx 已通过边界检查
                let mem = unsafe { &op_ref.params[idx].memref };

                // 同 TEMP_OUTPUT，通过 value.a 传递 size（特殊约定）
                param.param.value.a = mem.size as u32;
                debug!(
                    "TEEC_MEMREF_PARTIAL_OUTPUT: size={}, value.a={}",
                    mem.size, param.param.value.a
                );
            }
            raw::TEEC_MEMREF_PARTIAL_INOUT => {
                param.param_type = TEE_ParamType::MemrefInout;
                let req_flags = raw::TEEC_MEM_INPUT | raw::TEEC_MEM_OUTPUT;
                if let Ok(data) = op_params.get_memref_data_partial(idx, req_flags) {
                    param.param.data = data;
                }
            }
            _ => {
                debug!("Unsupported parameter type: {param_type}");
                return Err(Error::new(ErrorKind::BadParameters));
            }
        }
    }

    Ok(params)
}

/// 将协议参数更新回 TEEC_Operation 结构
fn update_operation_from_parameters(
    operation: *mut raw::TEEC_Operation,
    params: TEE_Parameters,
) -> Result<()> {
    let op_params = OperationParams::new(operation)?;
    let param_types = op_params.param_types()?;
    let param_slice = [&params.0, &params.1, &params.2, &params.3];

    for (idx, param) in param_slice
        .iter()
        .enumerate()
        .take(raw::TEEC_CONFIG_PAYLOAD_REF_COUNT)
    {
        let param_type = raw::TEEC_PARAM_TYPE_GET(param_types, idx);

        match param_type {
            raw::TEEC_NONE
            | raw::TEEC_VALUE_INPUT
            | raw::TEEC_MEMREF_TEMP_INPUT
            | raw::TEEC_MEMREF_PARTIAL_INPUT => {
                // NONE 及纯输入参数无需更新
            }
            raw::TEEC_VALUE_OUTPUT | raw::TEEC_VALUE_INOUT => {
                let value = &param.param.value;
                op_params.set_value(idx, value.a, value.b)?;
            }
            raw::TEEC_MEMREF_TEMP_OUTPUT | raw::TEEC_MEMREF_TEMP_INOUT => {
                let data = &param.param.data;
                op_params.set_tmpref_data(idx, data)?;
            }
            raw::TEEC_MEMREF_WHOLE => {
                let data = &param.param.data;
                op_params.set_memref_data_whole(idx, data)?;
            }
            raw::TEEC_MEMREF_PARTIAL_OUTPUT | raw::TEEC_MEMREF_PARTIAL_INOUT => {
                let data = &param.param.data;
                op_params.set_memref_data_partial(idx, data)?;
            }
            _ => {
                debug!("Unsupported parameter type: {param_type}");
                return Err(Error::new(ErrorKind::BadParameters));
            }
        }
    }

    Ok(())
}

/// 发送请求到TEE并接收响应（通用函数）
fn send_request_and_recv_response(
    ctx: *mut raw::TEEC_Context,
    packet_type: PacketType,
    request: &TEE_Request,
) -> Result<TEE_Response> {
    let client_arc = ContextManager::get_client(ctx)?;
    let mut client = client_arc
        .lock()
        .map_err(|_| Error::new(ErrorKind::Generic).with_origin(ErrorOrigin::API))?;

    let request_data = to_allocvec(request).map_err(|e| {
        warn!("序列化请求失败：{e}");
        Error::new(ErrorKind::BadFormat).with_origin(ErrorOrigin::API)
    })?;

    client
        .send_data_with_header(packet_type, &request_data)
        .map_err(|e| {
            warn!("发送请求失败：{e}");
            Error::new(ErrorKind::Communication).with_origin(ErrorOrigin::COMMS)
        })?;

    let mut len_buf = [0u8; 4];
    client.recv_data(&mut len_buf).map_err(|e| {
        warn!("接收响应长度失败：{e}");
        Error::new(ErrorKind::Communication).with_origin(ErrorOrigin::COMMS)
    })?;

    let response_len = u32::from_ne_bytes(len_buf) as usize;
    let mut response_data = vec![0u8; response_len];
    client.recv_data(&mut response_data).map_err(|e| {
        warn!("接收响应数据失败：{e}");
        Error::new(ErrorKind::Communication).with_origin(ErrorOrigin::COMMS)
    })?;

    take_from_bytes::<TEE_Response>(&response_data)
        .map(|(response, _)| response)
        .map_err(|e| {
            warn!("反序列化响应失败：{e}");
            Error::new(ErrorKind::BadFormat).with_origin(ErrorOrigin::API)
        })
}

/// TEEC_InitializeContext() - 初始化一个上下文，保存与指定 TEE 的连接信息。
///
/// @param name    指向以 NULL 结尾的字符串，标识要连接的 TEE。如果 `name` 为
///                NULL，则连接到默认的 TEE。对于本 API 实现，唯一支持的值
///                是 NULL。
///
/// @param ctx     要初始化的上下文结构体指针。
/// @return TEEC_SUCCESS  初始化成功。
/// @return TEEC_Result   出现错误。
#[unsafe(no_mangle)]
pub extern "C" fn TEEC_InitializeContext(
    _name: *const c_char,
    ctx: *mut raw::TEEC_Context,
) -> raw::TEEC_Result {
    debug!("TEEC_InitializeContext");

    let result = (|| -> Result<()> {
        let mut ctx_nn = safe_ptr::deref_mut(ctx)?;
        // SAFETY: `ctx_nn` 已由 `deref_mut` 验证为非空。`as_mut()` 返回指向
        // 上下文的可变引用，该引用在此作用域中有效。
        let ctx_ref = unsafe { ctx_nn.as_mut() };

        let client = CcClient::init().map_err(|e| {
            warn!("TEEC_InitializeContext：初始化机密通信上下文失败：{e}");
            Error::new(ErrorKind::Communication)
        })?;

        let id = CONTEXT_ID_COUNTER.fetch_add(1, Ordering::SeqCst);

        ctx_ref.imp.fd = id;
        ctx_ref.imp.reg_mem = true;
        ctx_ref.imp.memref_null = true;

        ContextManager::add_context(ctx, client)
    })();

    match result {
        Ok(_) => raw::TEEC_SUCCESS,
        Err(e) => e.raw_code(),
    }
}

/// TEEC_FinalizeContext() - 销毁保存连接信息的上下文。
///
/// 该函数用于销毁已初始化的 TEE 上下文，关闭客户端应用与 TEE 之间的连接。
/// 仅当与该上下文关联的所有会话已关闭且所有共享内存块已释放时才可调用。
///
/// @param ctx       要销毁的上下文。
#[unsafe(no_mangle)]
pub extern "C" fn TEEC_FinalizeContext(ctx: *mut raw::TEEC_Context) {
    debug!("TEEC_FinalizeContext");
    ContextManager::remove_context(ctx);
}

/// TEEC_OpenSession() - 与指定的受信任应用打开一个新会话。
///
/// @param ctx                已初始化的 TEE 上下文，在其作用域内打开会话。
/// @param session            要初始化的会话结构体指针。
/// @param destination        标识要打开会话的受信任应用的 UUID 结构。
/// @param connection_method  要使用的连接方法。
/// @param connection_data    与所选连接方法有关的连接数据。本实现不支持，
///                           应设置为 NULL。
/// @param operation          用于会话的操作结构。若不需要则传入 NULL。
/// @param ret_origin         若函数返回非 TEEC_SUCCESS，此参数将保存错误来源。
///
/// @return TEEC_SUCCESS      成功打开会话。
/// @return TEEC_Result       出现错误。
#[unsafe(no_mangle)]
pub extern "C" fn TEEC_OpenSession(
    ctx: *mut raw::TEEC_Context,
    session: *mut raw::TEEC_Session,
    destination: *const raw::TEEC_UUID,
    connection_method: u32,
    _connection_data: *const c_void,
    operation: *mut raw::TEEC_Operation,
    ret_origin: *mut u32,
) -> raw::TEEC_Result {
    debug!("TEEC_OpenSession");

    let result = (|| -> Result<u32> {
        let _ = safe_ptr::deref_mut(ctx)?;
        let _ = safe_ptr::deref_mut(session)?;
        let uuid_nn = safe_ptr::deref(destination)?;
        // SAFETY: `uuid_nn` 已由 `deref` 验证为非空。`as_ref()` 返回对
        // 调用方提供的 UUID 的不可变引用，该引用在此处有效。
        let uuid = unsafe { uuid_nn.as_ref() };

        let uuid_str = uuid_to_string(uuid)?;
        let params = if operation.is_null() {
            TEE_Parameters::default()
        } else {
            build_parameters_from_operation(operation)?
        };

        let request = TEE_Request::OpenSession {
            uuid: uuid_str,
            connection_method,
            params,
        };

        let mut session_nn = safe_ptr::deref_mut(session)?;
        // SAFETY: `session_nn` 已验证非空；`as_mut()` 返回针对会话结构的
        // 可变引用，该引用在此作用域中有效。
        let session_ref = unsafe { session_nn.as_mut() };

        let response = send_request_and_recv_response(ctx, PacketType::OpenSession, &request)?;

        match response {
            TEE_Response::OpenSession { session_id, result } => {
                debug!("TEEC_OpenSession: 接收 session_id 和结果: {session_id}, {result}");

                session_ref.imp.ctx = ctx;
                session_ref.imp.session_id = session_id;

                let _ = set_ret_origin(ret_origin, ErrorOrigin::TEE.into());
                Ok(result)
            }
            _ => Err(Error::new(ErrorKind::BadParameters).with_origin(ErrorOrigin::API)),
        }
    })();

    handle_error(result, ret_origin)
}

/// TEEC_CloseSession() - 关闭已与受信任应用打开的会话。
///
/// @param session 要关闭的会话。
#[unsafe(no_mangle)]
pub extern "C" fn TEEC_CloseSession(session: *mut raw::TEEC_Session) {
    debug!("TEEC_CloseSession");

    let result = (|| -> Result<()> {
        let mut session_nn = safe_ptr::deref_mut(session)?;
        // SAFETY: `session_nn` 已验证非空；`as_mut()` 返回针对会话结构的
        // 可变引用，可用于读取其字段。
        let session_ref = unsafe { session_nn.as_mut() };
        let session_id = session_ref.imp.session_id;
        let ctx = session_ref.imp.ctx;

        if ctx.is_null() {
            return Err(Error::new(ErrorKind::BadParameters));
        }

        let request = TEE_Request::CloseSession { session_id };
        let response = send_request_and_recv_response(ctx, PacketType::CloseSession, &request)?;

        match response {
            TEE_Response::CloseSession { result } => {
                debug!("TEEC_CloseSession: 接收结果: {result}");
                session_ref.imp.ctx = ptr::null_mut();
                session_ref.imp.session_id = 0;
                Ok(())
            }
            _ => Err(Error::new(ErrorKind::BadParameters)),
        }
    })();

    if let Err(e) = result {
        warn!("TEEC_CloseSession：{e}");
    }
}

/// TEEC_InvokeCommand() - 在指定的受信任应用中执行命令。
///
/// @param session        已打开的受信任应用会话句柄。
/// @param cmd_id         要在受信任应用中调用的命令标识符。
/// @param operation      用于调用命令的操作结构；若不需要则传入 NULL。
/// @param error_origin   若函数返回非 TEEC_SUCCESS，此参数将保存错误来源。
///
/// @return TEEC_SUCCESS  操作成功。
/// @return TEEC_Result   出现错误。
#[unsafe(no_mangle)]
pub extern "C" fn TEEC_InvokeCommand(
    session: *mut raw::TEEC_Session,
    cmd_id: u32,
    operation: *mut raw::TEEC_Operation,
    error_origin: *mut u32,
) -> raw::TEEC_Result {
    debug!("TEEC_InvokeCommand");

    let result = (|| -> Result<u32> {
        let mut session_nn = safe_ptr::deref_mut(session)?;
        // SAFETY: `session_nn` 已验证非空；`as_mut()` 返回的可变引用在此
        // 作用域内有效，可用于读取 `imp.session_id` 和 `imp.ctx`。
        let session_ref = unsafe { session_nn.as_mut() };
        let session_id = session_ref.imp.session_id;
        let ctx = session_ref.imp.ctx;

        if ctx.is_null() {
            return Err(Error::new(ErrorKind::BadParameters));
        }

        let params = if operation.is_null() {
            TEE_Parameters::default()
        } else {
            let mut operation_nn = safe_ptr::deref_mut(operation)?;
            // SAFETY: `operation_nn` 已验证非空，且 `deref_mut` 提供独占访问；
            // 调用 `as_mut()` 可获得可变引用，可安全修改 `imp.session` 字段。
            let operation_ref = unsafe { operation_nn.as_mut() };
            let _lock = TEEC_MUTEX
                .lock()
                .map_err(|_| Error::new(ErrorKind::Generic))?;
            operation_ref.imp.session = session;
            drop(_lock);

            build_parameters_from_operation(operation)?
        };

        let request = TEE_Request::InvokeCommand {
            session_id,
            cmd_id,
            params,
        };

        let response = send_request_and_recv_response(ctx, PacketType::InvokeCommand, &request)?;

        match response {
            TEE_Response::InvokeCommand { params, result } => {
                if result != raw::TEEC_SUCCESS {
                    return Err(Error::new(ErrorKind::from(result)).with_origin(ErrorOrigin::API));
                }

                if !operation.is_null() {
                    update_operation_from_parameters(operation, params)?;
                }
                Ok(result)
            }
            _ => Err(Error::new(ErrorKind::BadParameters).with_origin(ErrorOrigin::API)),
        }
    })();

    handle_error(result, error_origin)
}

/// TEEC_RegisterSharedMemory() - 将现有内存块注册为在指定上下文作用域内的
/// 共享内存块。
///
/// @param ctx    已初始化的 TEE 上下文。
/// @param sharedMem  要注册的共享内存结构指针。
///
/// @return TEEC_SUCCESS              注册成功。
/// @return TEEC_ERROR_OUT_OF_MEMORY  内存不足。
/// @return TEEC_Result               其他错误。
#[unsafe(no_mangle)]
pub extern "C" fn TEEC_RegisterSharedMemory(
    ctx: *mut raw::TEEC_Context,
    shm: *mut raw::TEEC_SharedMemory,
) -> raw::TEEC_Result {
    debug!("TEEC_RegisterSharedMemory");

    let result = SharedMemoryManager::allocate(ctx, shm, true);

    match result {
        Ok(_) => raw::TEEC_SUCCESS,
        Err(e) => e.raw_code(),
    }
}

#[unsafe(no_mangle)]
pub extern "C" fn TEEC_RegisterSharedMemoryFileDescriptor(
    _ctx: *mut raw::TEEC_Context,
    _shm: *mut raw::TEEC_SharedMemory,
    _fd: i32,
) -> raw::TEEC_Result {
    // TODO: 实现此函数
    ErrorKind::NotImplemented.into()
}

/// TEEC_AllocateSharedMemory() - 为 TEE 分配共享内存。
///
/// @param ctx         已初始化的 TEE 上下文。
/// @param sharedMem   指向要分配的共享内存结构的指针（由调用者填写希望的属性）。
///
/// @return TEEC_SUCCESS              分配/注册成功。
/// @return TEEC_ERROR_OUT_OF_MEMORY  内存不足。
/// @return TEEC_Result               其他错误。
#[unsafe(no_mangle)]
pub extern "C" fn TEEC_AllocateSharedMemory(
    ctx: *mut raw::TEEC_Context,
    shm: *mut raw::TEEC_SharedMemory,
) -> raw::TEEC_Result {
    debug!("TEEC_AllocateSharedMemory");

    match SharedMemoryManager::allocate(ctx, shm, false) {
        Ok(_) => raw::TEEC_SUCCESS,
        Err(e) => e.raw_code(),
    }
}

/// TEEC_ReleaseSharedMemory() - 释放或取消注册共享内存。
///
/// @param sharedMem  要释放或取消注册的共享内存指针。
#[unsafe(no_mangle)]
pub extern "C" fn TEEC_ReleaseSharedMemory(shm: *mut raw::TEEC_SharedMemory) {
    debug!("TEEC_ReleaseSharedMemory");
    SharedMemoryManager::release(shm);
}

/// TEEC_RequestCancellation() - 请求取消正在等待的打开会话或命令调用。
///
/// @param operation 指向先前传递给 open session 或 invoke 的操作结构的指针。
#[unsafe(no_mangle)]
pub extern "C" fn TEEC_RequestCancellation(operation: *mut raw::TEEC_Operation) {
    debug!("TEEC_RequestCancellation");

    let result = (|| -> Result<()> {
        let mut operation_nn = safe_ptr::deref_mut(operation)?;
        // SAFETY: `operation_nn` 已验证非空，`deref_mut` 提供独占访问；
        // `as_mut()` 返回的可变引用可安全用于读取 `imp.session`。
        let operation_ref = unsafe { operation_nn.as_mut() };
        let _lock = TEEC_MUTEX
            .lock()
            .map_err(|_| Error::new(ErrorKind::Generic))?;
        let session = operation_ref.imp.session;
        drop(_lock);

        if session.is_null() {
            return Ok(());
        }

        let mut session_nn = safe_ptr::deref_mut(session)?;
        // SAFETY: `session_nn` 已验证非空；`as_mut()` 返回的可变引用在此作用域内有效，
        // 可用于读取 `imp.session_id` 和 `imp.ctx`。
        let session_ref = unsafe { session_nn.as_mut() };
        let session_id = session_ref.imp.session_id;
        let ctx = session_ref.imp.ctx;

        if ctx.is_null() {
            return Ok(());
        }

        let request = TEE_Request::RequestCancellation { session_id };
        let response =
            send_request_and_recv_response(ctx, PacketType::RequestCancellation, &request)?;

        match response {
            TEE_Response::RequestCancellation { result: _ } => {
                debug!("TEEC_RequestCancellation: 接收结果");
                Ok(())
            }
            _ => Err(Error::new(ErrorKind::BadParameters)),
        }
    })();

    if let Err(e) = result {
        warn!("TEEC_RequestCancellation：{e}");
    }
}

#[cfg(test)]
mod teec_priv_tests {
    #[allow(unused_imports)]
    use super::*;
    use crate::common::protocol::{CHUNK_SIZE, PacketHeader, PacketType};

    #[test]
    fn test_write_and_read_raw() {
        // 测试安全指针写入和读取功能
        // 验证基本的内存读写操作是否正确
        let mut v: u32 = 0;
        let p: *mut u32 = &mut v as *mut u32;

        safe_ptr::write_raw(p, 0xDEADBEEF).expect("写入原始数据应该成功");
        let r = safe_ptr::read_raw(p as *const u32).expect("读取原始数据应该成功");
        assert_eq!(r, 0xDEADBEEF, "写入后读取的值应该与写入值相同");
    }

    #[test]
    fn test_read_to_vec_and_write_from_slice() {
        // 测试从指针读取数据到 Vec 和从切片写入到指针
        // 验证批量数据复制功能
        let arr = [1u8, 2, 3, 4, 5];
        let vec =
            safe_ptr::read_to_vec(arr.as_ptr(), arr.len()).expect("从指针读取到 Vec 应该成功");
        assert_eq!(vec, arr.to_vec(), "从数组读取的数据应该与原始数组相同");

        let mut buf = [0u8; 5];
        safe_ptr::write_from_slice(buf.as_mut_ptr(), &vec).expect("从切片写入指针应该成功");
        assert_eq!(buf.to_vec(), vec, "写入缓冲区后应该与原始数据相同");
    }

    #[test]
    fn test_add_ptr() {
        // 测试指针加法运算
        // 验证指针偏移计算是否正确
        let arr = [10u8, 20, 30, 40];
        let p = arr.as_ptr();
        let p2 = safe_ptr::add_ptr(p, 2);

        assert_eq!(unsafe { *p2 }, 30, "偏移2个元素后应该指向第3个元素");
    }

    #[test]
    fn test_add_ptr_mut_and_read() {
        // 测试可变指针的加法运算
        // 验证可变指针偏移计算是否正确
        let mut arr = [5u8, 6, 7, 8];
        let p = arr.as_mut_ptr();
        let p2 = safe_ptr::add_ptr_mut(p, 1);
        assert_eq!(unsafe { *p2 }, 6, "偏移1个元素后应该指向第2个元素");
    }

    #[test]
    fn test_uuid_to_string_roundtrip() {
        // 测试 UUID 转换功能
        // 验证GP TEE UUID 格式到标准 UUID 字符串的转换
        let uuid = raw::TEEC_UUID {
            timeLow: 0x00112233,
            timeMid: 0x4455,
            timeHiAndVersion: 0x6677,
            clockSeqAndNode: [0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff],
        };

        let s = uuid_to_string(&uuid).expect("UUID转换应该成功");
        assert_eq!(
            s, "00112233-4455-6677-8899-aabbccddeeff",
            "转换后的UUID字符串应该符合标准格式"
        );
    }

    #[test]
    fn test_deref_and_deref_mut_null() {
        // 测试空指针解引用错误处理
        // 验证对空指针调用 deref/deref_mut 应该返回错误
        use std::ptr;

        assert!(
            safe_ptr::deref(ptr::null::<u8>()).is_err(),
            "对空指针解引用应该失败"
        );
        assert!(
            safe_ptr::deref_mut(ptr::null_mut::<u8>()).is_err(),
            "对空可变指针解引用应该失败"
        );
    }

    #[test]
    fn test_read_raw_and_read_to_vec_null_errors() {
        // 测试从空指针读取数据的错误处理
        // 验证安全读取函数对空指针的防御性编程
        use std::ptr;

        assert!(
            safe_ptr::read_raw(ptr::null::<u32>()).is_err(),
            "从空指针读取值应该失败"
        );
        assert!(
            safe_ptr::read_to_vec(ptr::null::<u8>(), 1).is_err(),
            "从空指针读取向量应该失败"
        );
    }

    #[test]
    fn test_write_from_slice_null_dst_behaviour() {
        // 测试向空指针写入数据的错误处理
        // 验证写入函数对目标指针的校验
        use std::ptr;

        let src = [9u8, 8, 7];
        assert!(
            safe_ptr::write_from_slice(ptr::null_mut(), &src).is_err(),
            "向空指针写入非空切片应该失败"
        );

        // 特殊情况：空切片可以写入空指针
        let empty: [u8; 0] = [];
        assert!(
            safe_ptr::write_from_slice(ptr::null_mut(), &empty).is_err(),
            "向空指针写入空切片也应该失败（根据实现逻辑）"
        );
    }

    #[test]
    fn test_shared_memory_allocate_release_get_buffer() {
        // 测试共享内存管理器的完整生命周期
        // 验证分配、获取和释放共享内存的功能

        // 创建模拟上下文
        let mut ctx = raw::TEEC_Context {
            imp: raw::TEEC_Context__Imp {
                fd: 4242, // 使用特定 ID 便于追踪
                reg_mem: false,
                memref_null: false,
            },
        };

        // 创建要分配的共享内存结构
        let mut shm = raw::TEEC_SharedMemory {
            buffer: std::ptr::null_mut(),
            size: 8, // 请求 8 字节内存
            flags: raw::TEEC_MEM_INPUT,
            imp: raw::TEEC_SharedMemory__Imp {
                id: -1, // 初始无效 ID
                alloced_size: 0,
                shadow_buffer: std::ptr::null_mut(),
                registered_fd: -1,
                flags: 0,
            },
        };

        // 测试分配功能
        SharedMemoryManager::allocate(&mut ctx as *mut _, &mut shm as *mut _, false)
            .expect("共享内存分配应该成功");

        assert_eq!(shm.imp.id, 4242, "共享内存ID应该与上下文ID匹配");
        assert!(!shm.buffer.is_null(), "分配的缓冲区指针不应该为空");
        assert_eq!(shm.imp.alloced_size, 8usize, "分配的缓冲区大小应该正确");

        // 测试获取缓冲区数据
        let buf =
            SharedMemoryManager::get_buffer(&shm as *const _).expect("应该能获取到共享内存缓冲区");
        assert_eq!(buf.len(), 8, "获取的缓冲区大小应该正确");
        assert_eq!(buf, vec![0u8; 8], "新分配的缓冲区应该初始化为0");

        // 测试释放功能
        SharedMemoryManager::release(&mut shm as *mut _);

        assert!(shm.buffer.is_null(), "释放后缓冲区指针应该置空");
        assert_eq!(shm.flags, 0, "释放后标志位应该清零");
        assert_eq!(shm.imp.id, -1, "释放后ID应该重置为-1");
    }

    #[test]
    fn test_operation_params_value_and_tmpref_and_memref() {
        // 测试操作参数包装器的各种参数类型处理
        // 包括值参数、临时内存引用和注册内存引用

        use std::ffi::c_void;

        // 1. 测试值参数（Value 参数）
        let mut op = raw::TEEC_Operation {
            started: 0,
            paramTypes: 0,
            params: [raw::TEEC_Parameter {
                value: raw::TEEC_Value { a: 1, b: 2 },
            }; raw::TEEC_CONFIG_PAYLOAD_REF_COUNT],
            imp: raw::TEEC_Operation__Imp {
                session: std::ptr::null_mut(),
            },
        };

        let op_ptr: *mut raw::TEEC_Operation = &mut op;
        let op_params = OperationParams::new(op_ptr).unwrap();

        // 读取现有值
        let (a, b) = op_params.get_value(0).unwrap();
        assert_eq!((a, b), (1, 2), "应该能正确读取值参数");

        // 设置新值
        op_params.set_value(0, 10, 20).unwrap();
        let (a2, b2) = op_params.get_value(0).unwrap();
        assert_eq!((a2, b2), (10, 20), "应该能正确设置值参数");

        // 2. 测试临时内存引用参数（TempMemoryReference）
        let mut tmp_buf = vec![0u8; 6];
        let mut op2 = op;
        op2.params[1] = raw::TEEC_Parameter {
            tmpref: raw::TEEC_TempMemoryReference {
                buffer: tmp_buf.as_mut_ptr() as *mut c_void,
                size: tmp_buf.len(),
            },
        };
        let op2_ptr: *mut raw::TEEC_Operation = &mut op2;
        let op2_params = OperationParams::new(op2_ptr).unwrap();

        // 写入临时内存引用
        let to_write = [9u8, 8, 7];
        op2_params.set_tmpref_data(1, &to_write).unwrap();
        assert_eq!(tmp_buf[0..3], to_write[..], "应该正确写入临时内存");

        // 读取临时内存引用
        let got = op2_params.get_tmpref_data(1).unwrap();
        assert_eq!(got, vec![9u8, 8, 7], "应该正确读取临时内存");

        // 3. 测试注册内存引用参数（RegisteredMemoryReference）
        let mut parent_buf = vec![1u8, 2, 3, 4, 5, 6];
        let mut parent = raw::TEEC_SharedMemory {
            buffer: parent_buf.as_mut_ptr() as *mut c_void,
            size: parent_buf.len(),
            flags: raw::TEEC_MEM_INPUT | raw::TEEC_MEM_OUTPUT,
            imp: raw::TEEC_SharedMemory__Imp {
                id: 7777,
                alloced_size: parent_buf.len(),
                shadow_buffer: std::ptr::null_mut(),
                registered_fd: -1,
                flags: 0,
            },
        };

        // 创建部分内存引用：从偏移 2 开始，长度 3
        let memref = raw::TEEC_RegisteredMemoryReference {
            parent: &mut parent as *mut _,
            size: 3,
            offset: 2, // 指向父缓冲区的索引 2-4
        };

        let mut op3 = op2;
        op3.params[2] = raw::TEEC_Parameter { memref };
        let op3_ptr: *mut raw::TEEC_Operation = &mut op3;
        let op3_params = OperationParams::new(op3_ptr).unwrap();

        // 读取部分内存引用
        let memdata = op3_params
            .get_memref_data_partial(2, raw::TEEC_MEM_INPUT)
            .unwrap();
        assert_eq!(
            memdata,
            parent_buf[2..5].to_vec(),
            "应该正确读取部分内存引用"
        );

        // 写入部分内存引用（只写 2 个字节）
        let to_set = [7u8, 7u8];
        op3_params.set_memref_data_partial(2, &to_set).unwrap();

        // 验证写入效果
        unsafe {
            let start = parent.buffer as *mut u8;
            // 索引2（偏移2）应该被修改为7
            assert_eq!(*start.add(2), 7u8, "偏移2处的值应该被修改");
            // 索引3（偏移2+1）应该被修改为7
            assert_eq!(*start.add(3), 7u8, "偏移3处的值应该被修改");
            // 索引4（偏移2+2）应该保持原来的值5，因为只写了2个字节
            assert_eq!(*start.add(4), 5u8, "偏移4处的值应该保持不变");
        }
    }

    #[test]
    fn test_build_and_update_operation_parameters() {
        // 测试操作参数的构建和更新功能
        // 验证从原始操作结构到协议参数的转换
        use crate::common::protocol::TEE_ParamType;

        // 创建包含各种参数类型的操作结构
        let mut ctx = raw::TEEC_Context {
            imp: raw::TEEC_Context__Imp {
                fd: 1001,
                reg_mem: false,
                memref_null: false,
            },
        };

        let mut shm = raw::TEEC_SharedMemory {
            buffer: std::ptr::null_mut(),
            size: 10,
            flags: raw::TEEC_MEM_INPUT | raw::TEEC_MEM_OUTPUT,
            imp: raw::TEEC_SharedMemory__Imp {
                id: 1001,
                alloced_size: 10,
                shadow_buffer: std::ptr::null_mut(),
                registered_fd: -1,
                flags: 0,
            },
        };

        // 分配共享内存
        SharedMemoryManager::allocate(&mut ctx as *mut _, &mut shm as *mut _, false)
            .expect("共享内存分配应该成功");

        // 设置一些初始数据
        unsafe {
            let buf_ptr = shm.buffer as *mut u8;
            for i in 0..10 {
                *buf_ptr.add(i) = i as u8;
            }
        }

        // 创建一个复杂的操作结构，包含多种参数类型
        let mut op = raw::TEEC_Operation {
            started: 0,
            paramTypes: 0,
            params: [
                // param0: 值输入参数
                raw::TEEC_Parameter {
                    value: raw::TEEC_Value {
                        a: 0x1234,
                        b: 0x5678,
                    },
                },
                // param1: 临时内存输入参数
                raw::TEEC_Parameter {
                    tmpref: raw::TEEC_TempMemoryReference {
                        buffer: [1u8, 2, 3, 4].as_ptr() as *mut std::ffi::c_void,
                        size: 4,
                    },
                },
                // param2: 部分内存引用输入
                raw::TEEC_Parameter {
                    memref: raw::TEEC_RegisteredMemoryReference {
                        parent: &mut shm as *mut _,
                        size: 3,
                        offset: 2, // 指向数据[2, 3, 4]
                    },
                },
                // param3: 无参数
                raw::TEEC_Parameter {
                    value: raw::TEEC_Value { a: 0, b: 0 },
                },
            ],
            imp: raw::TEEC_Operation__Imp {
                session: std::ptr::null_mut(),
            },
        };

        // 设置参数类型位掩码
        let param_types = raw::TEEC_PARAM_TYPES(
            raw::TEEC_VALUE_INPUT,
            raw::TEEC_MEMREF_TEMP_INPUT,
            raw::TEEC_MEMREF_PARTIAL_INPUT,
            raw::TEEC_NONE,
        );
        op.paramTypes = param_types;

        let op_ptr: *mut raw::TEEC_Operation = &mut op;

        // 测试构建参数
        let params = build_parameters_from_operation(op_ptr).unwrap();

        // 验证构建的参数
        assert_eq!(
            params.0.param_type,
            TEE_ParamType::ValueInput,
            "参数0应该是值输入类型"
        );
        assert_eq!(params.0.param.value.a, 0x1234, "值参数a应该正确");
        assert_eq!(params.0.param.value.b, 0x5678, "值参数b应该正确");

        assert_eq!(
            params.1.param_type,
            TEE_ParamType::MemrefInput,
            "参数1应该是临时内存输入类型"
        );
        assert_eq!(
            params.1.param.data,
            vec![1, 2, 3, 4],
            "临时内存数据应该正确"
        );

        assert_eq!(
            params.2.param_type,
            TEE_ParamType::MemrefInput,
            "参数2应该是内存引用输入类型"
        );
        assert_eq!(
            params.2.param.data,
            vec![2, 3, 4],
            "部分内存引用数据应该正确"
        );

        assert_eq!(
            params.3.param_type,
            TEE_ParamType::None,
            "参数3应该是无参数类型"
        );

        // 清理
        SharedMemoryManager::release(&mut shm as *mut _);
    }

    #[test]
    fn test_error_handling_functions() {
        // 测试错误处理辅助函数
        // 验证错误码和错误来源的设置
        let mut ret_origin = 0u32;

        // 测试成功情况
        let success_result: Result<()> = Ok(());
        let success_code = handle_error(success_result, &mut ret_origin as *mut u32);
        assert_eq!(
            success_code,
            raw::TEEC_SUCCESS,
            "成功结果应该返回TEEC_SUCCESS"
        );

        // 测试错误情况
        let error_result: Result<()> =
            Err(Error::new(ErrorKind::BadParameters).with_origin(ErrorOrigin::API));
        let error_code = handle_error(error_result, &mut ret_origin as *mut u32);
        assert_ne!(
            error_code,
            raw::TEEC_SUCCESS,
            "错误结果不应该返回TEEC_SUCCESS"
        );
        assert_eq!(ret_origin, ErrorOrigin::API.into(), "错误来源应该正确设置");
    }

    #[test]
    fn test_edge_cases_and_boundary_conditions() {
        // 测试边界条件和异常情况
        // 验证代码对异常输入的鲁棒性

        // 测试超出边界的参数索引
        let mut op = raw::TEEC_Operation {
            started: 0,
            paramTypes: 0,
            params: [raw::TEEC_Parameter {
                value: raw::TEEC_Value { a: 0, b: 0 },
            }; raw::TEEC_CONFIG_PAYLOAD_REF_COUNT],
            imp: raw::TEEC_Operation__Imp {
                session: std::ptr::null_mut(),
            },
        };

        let op_ptr: *mut raw::TEEC_Operation = &mut op;
        let op_params = OperationParams::new(op_ptr).unwrap();

        // 测试超出有效范围的索引
        assert!(
            op_params
                .get_value(raw::TEEC_CONFIG_PAYLOAD_REF_COUNT)
                .is_err(),
            "超出范围的索引应该返回错误"
        );

        assert!(
            op_params
                .set_value(raw::TEEC_CONFIG_PAYLOAD_REF_COUNT, 1, 2)
                .is_err(),
            "超出范围的索引设置应该返回错误"
        );

        // 测试空缓冲区但有大小的情况
        op.params[0] = raw::TEEC_Parameter {
            tmpref: raw::TEEC_TempMemoryReference {
                buffer: std::ptr::null_mut(),
                size: 10, // 有大小但缓冲区为空
            },
        };

        assert!(
            op_params.get_tmpref_data(0).is_err(),
            "缓冲区为空但有大小应该返回错误"
        );
    }

    #[test]
    fn test_context_manager_operations() {
        // 测试 ContextManager 的添加、获取和移除操作

        // 创建模拟上下文
        let mut ctx = raw::TEEC_Context {
            imp: raw::TEEC_Context__Imp {
                fd: 9999,
                reg_mem: false,
                memref_null: false,
            },
        };

        // 注意：由于 CcClient 需要实际的 TLS 环境，这里只测试管理逻辑
        // 实际测试中我们验证 ID 的设置和移除

        // 测试 remove_context 对无效 ID 的处理
        ctx.imp.fd = -1; // 设置无效 ID
        ContextManager::remove_context(&mut ctx);
        // 不应崩溃

        // 验证 ID 被重置
        assert_eq!(ctx.imp.fd, -1);
    }

    #[test]
    fn test_shared_memory_manager_allocate_errors() {
        // 测试 SharedMemoryManager::allocate 的错误路径

        // 测试 1: size 为 0
        let mut ctx = raw::TEEC_Context {
            imp: raw::TEEC_Context__Imp {
                fd: 100,
                reg_mem: false,
                memref_null: false,
            },
        };
        let mut shm = raw::TEEC_SharedMemory {
            buffer: std::ptr::null_mut(),
            size: 0, // 大小为 0
            flags: raw::TEEC_MEM_INPUT,
            imp: raw::TEEC_SharedMemory__Imp {
                id: -1,
                alloced_size: 0,
                shadow_buffer: std::ptr::null_mut(),
                registered_fd: -1,
                flags: 0,
            },
        };

        let result = SharedMemoryManager::allocate(&mut ctx, &mut shm, false);
        assert!(result.is_err());

        // 测试 2: flags 为 0
        shm.size = 100;
        shm.flags = 0; // flags 为 0
        let result = SharedMemoryManager::allocate(&mut ctx, &mut shm, false);
        assert!(result.is_err());

        // 测试 3: 无效的标志位组合
        shm.flags = 0xFFFFFFFF; // 无效标志
        let result = SharedMemoryManager::allocate(&mut ctx, &mut shm, false);
        assert!(result.is_err());
    }

    #[test]
    fn test_shared_memory_manager_release_edge_cases() {
        // 测试 SharedMemoryManager::release 的边界情况

        // 测试：id 为 -1（未注册）的情况
        let mut shm = raw::TEEC_SharedMemory {
            buffer: std::ptr::null_mut(),
            size: 100,
            flags: raw::TEEC_MEM_INPUT,
            imp: raw::TEEC_SharedMemory__Imp {
                id: -1, // 未注册的 ID
                alloced_size: 100,
                shadow_buffer: std::ptr::null_mut(),
                registered_fd: -1,
                flags: 0,
            },
        };

        SharedMemoryManager::release(&mut shm);
        // 不应崩溃，且应提前返回
        assert_eq!(shm.imp.id, -1); // ID 应保持为 -1
    }

    #[test]
    fn test_get_buffer_null_pointer() {
        // 测试 get_buffer 对空指针的处理
        let result = SharedMemoryManager::get_buffer(std::ptr::null());
        assert!(result.is_none());
    }

    #[test]
    fn test_uuid_to_string_invalid_format() {
        // 测试 UUID 转换的错误处理
        // 虽然主要测试在上面的 test_uuid_to_string_roundtrip 中
        // 但我们可以测试边界情况

        // 创建一个正常的 UUID
        let uuid = raw::TEEC_UUID {
            timeLow: 0x12345678,
            timeMid: 0x1234,
            timeHiAndVersion: 0x5678,
            clockSeqAndNode: [0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0],
        };

        let result = uuid_to_string(&uuid);
        assert!(result.is_ok());
        let uuid_str = result.unwrap();
        assert!(!uuid_str.is_empty());
    }

    #[test]
    fn test_operation_params_index_boundary() {
        // 测试 OperationParams 的索引边界检查
        let mut op = raw::TEEC_Operation {
            started: 0,
            paramTypes: 0,
            params: [raw::TEEC_Parameter {
                value: raw::TEEC_Value { a: 0, b: 0 },
            }; raw::TEEC_CONFIG_PAYLOAD_REF_COUNT],
            imp: raw::TEEC_Operation__Imp {
                session: std::ptr::null_mut(),
            },
        };

        let op_ptr: *mut raw::TEEC_Operation = &mut op;
        let op_params = OperationParams::new(op_ptr).unwrap();

        // 测试所有有效索引 (0-3)
        for i in 0..raw::TEEC_CONFIG_PAYLOAD_REF_COUNT {
            // 这些调用应该成功（虽然可能返回默认值）
            let _ = op_params.get_value(i);
        }

        // 测试超出边界的索引
        assert!(
            op_params
                .get_value(raw::TEEC_CONFIG_PAYLOAD_REF_COUNT)
                .is_err()
        );
        assert!(
            op_params
                .set_value(raw::TEEC_CONFIG_PAYLOAD_REF_COUNT, 1, 2)
                .is_err()
        );
    }

    #[test]
    fn test_set_ret_origin_function() {
        // 测试 set_ret_origin 辅助函数
        let mut origin = 0u32;
        let result = set_ret_origin(&mut origin as *mut u32, 123);
        assert!(result.is_ok());
        assert_eq!(origin, 123);
    }

    #[test]
    fn test_handle_error_success_case() {
        // 测试 handle_error 函数的成功路径
        let mut ret_origin = 0u32;
        let success_result: Result<()> = Ok(());

        let code = handle_error(success_result, &mut ret_origin as *mut u32);
        assert_eq!(code, raw::TEEC_SUCCESS);
        // 成功时不应修改 origin
        assert_eq!(ret_origin, 0);
    }

    #[test]
    fn test_build_parameters_with_all_param_types() {
        // 测试 build_parameters_from_operation 支持的所有参数类型
        use crate::common::protocol::TEE_ParamType;

        // 创建一个包含各种参数类型的操作
        let mut op = raw::TEEC_Operation {
            started: 0,
            paramTypes: 0,
            params: [unsafe { std::mem::zeroed() }; 4],
            imp: raw::TEEC_Operation__Imp {
                session: std::ptr::null_mut(),
            },
        };

        // 测试 TEEC_NONE 类型
        op.paramTypes = raw::TEEC_PARAM_TYPES(
            raw::TEEC_NONE,
            raw::TEEC_NONE,
            raw::TEEC_NONE,
            raw::TEEC_NONE,
        );

        let params = build_parameters_from_operation(&mut op).unwrap();
        assert_eq!(params.0.param_type, TEE_ParamType::None);
        assert_eq!(params.1.param_type, TEE_ParamType::None);
        assert_eq!(params.2.param_type, TEE_ParamType::None);
        assert_eq!(params.3.param_type, TEE_ParamType::None);
    }

    #[test]
    fn test_update_operation_with_output_params() {
        // 测试 update_operation_from_parameters 的输出参数更新
        use crate::common::protocol::{TEE_Param, TEE_ParamType, TEE_Parameter, TEE_Value};

        // 为临时内存引用准备缓冲区
        let mut tmp_buffer = [0u8; 10];

        let mut op = raw::TEEC_Operation {
            started: 0,
            paramTypes: raw::TEEC_PARAM_TYPES(
                raw::TEEC_VALUE_OUTPUT,
                raw::TEEC_MEMREF_TEMP_OUTPUT,
                raw::TEEC_NONE,
                raw::TEEC_NONE,
            ),
            params: [
                // param0: value 输出
                raw::TEEC_Parameter {
                    value: raw::TEEC_Value { a: 0, b: 0 },
                },
                // param1: temp memory reference 输出
                raw::TEEC_Parameter {
                    tmpref: raw::TEEC_TempMemoryReference {
                        buffer: tmp_buffer.as_mut_ptr() as *mut std::ffi::c_void,
                        size: tmp_buffer.len(),
                    },
                },
                // param2: none
                raw::TEEC_Parameter {
                    value: raw::TEEC_Value { a: 0, b: 0 },
                },
                // param3: none
                raw::TEEC_Parameter {
                    value: raw::TEEC_Value { a: 0, b: 0 },
                },
            ],
            imp: raw::TEEC_Operation__Imp {
                session: std::ptr::null_mut(),
            },
        };

        // 创建模拟参数数据
        let params = TEE_Parameters(
            TEE_Parameter {
                param_type: TEE_ParamType::ValueOutput,
                param: TEE_Param {
                    value: TEE_Value { a: 100, b: 200 },
                    data: vec![],
                },
            },
            TEE_Parameter {
                param_type: TEE_ParamType::MemrefOutput,
                param: TEE_Param {
                    value: TEE_Value::default(),
                    data: vec![1, 2, 3],
                },
            },
            TEE_Parameter::default(),
            TEE_Parameter::default(),
        );

        let result = update_operation_from_parameters(&mut op, params);
        assert!(result.is_ok());

        // 验证值参数被更新 - 访问 union 字段需要 unsafe
        unsafe {
            assert_eq!(op.params[0].value.a, 100);
            assert_eq!(op.params[0].value.b, 200);
        }
    }

    /// 测试 PacketType 的各种转换和边界情况
    #[test]
    fn test_packet_type_comprehensive() {
        // 测试所有 PacketType 变体的转换
        assert_eq!(PacketType::from(0), PacketType::Unknown);
        assert_eq!(PacketType::from(1), PacketType::OpenSession);
        assert_eq!(PacketType::from(2), PacketType::CloseSession);
        assert_eq!(PacketType::from(3), PacketType::InvokeCommand);
        assert_eq!(PacketType::from(4), PacketType::RequestCancellation);
        assert_eq!(PacketType::from(999), PacketType::Unknown); // 未知值

        // 测试反向转换
        assert_eq!(u64::from(PacketType::Unknown), 0);
        assert_eq!(u64::from(PacketType::OpenSession), 1);
        assert_eq!(u64::from(PacketType::CloseSession), 2);
        assert_eq!(u64::from(PacketType::InvokeCommand), 3);
        assert_eq!(u64::from(PacketType::RequestCancellation), 4);

        // 测试 PacketHeader 序列化
        let header = PacketHeader {
            data_type: 1,
            data_size: 1024,
        };
        let bytes = header.as_bytes();
        assert_eq!(bytes.len(), 16);

        // 测试 PacketHeader 反序列化
        let restored = PacketHeader::from_bytes(bytes);
        assert_eq!(restored.data_type, 1);
        assert_eq!(restored.data_size, 1024);

        // 测试 CHUNK_SIZE 常量
        assert!(CHUNK_SIZE > 0);
    }

    /// 测试 TEEC_RequestCancellation 的错误处理路径
    #[test]
    fn test_tee_cancellation_error_paths() {
        // 测试 session 为 null 的情况
        let mut operation = raw::TEEC_Operation {
            started: 0,
            paramTypes: 0,
            params: [unsafe { std::mem::zeroed() }; 4],
            imp: raw::TEEC_Operation__Imp {
                session: std::ptr::null_mut(), // null session
            },
        };

        // 调用 cancellation（应该安全返回，不崩溃）
        super::TEEC_RequestCancellation(&mut operation);
        // 不应崩溃
    }

    /// 测试 SharedMemoryManager 的边界情况
    #[test]
    fn test_shared_memory_edge_cases() {
        // 测试已释放的共享内存再次释放
        let mut shm = raw::TEEC_SharedMemory {
            buffer: std::ptr::null_mut(),
            size: 100,
            flags: raw::TEEC_MEM_INPUT,
            imp: raw::TEEC_SharedMemory__Imp {
                id: -1, // 已释放的 ID
                alloced_size: 0,
                shadow_buffer: std::ptr::null_mut(),
                registered_fd: -1,
                flags: 0,
            },
        };

        SharedMemoryManager::release(&mut shm);
        // 不应崩溃
        assert_eq!(shm.imp.id, -1);
    }

    /// 测试 uuid_to_string 的边界情况
    #[test]
    fn test_uuid_conversion_edge_cases() {
        // 测试全零 UUID
        let zero_uuid = raw::TEEC_UUID {
            timeLow: 0,
            timeMid: 0,
            timeHiAndVersion: 0,
            clockSeqAndNode: [0; 8],
        };

        let result = uuid_to_string(&zero_uuid);
        assert!(result.is_ok());
        let uuid_str = result.unwrap();
        assert!(!uuid_str.is_empty());

        // 测试最大值 UUID
        let max_uuid = raw::TEEC_UUID {
            timeLow: u32::MAX,
            timeMid: u16::MAX,
            timeHiAndVersion: u16::MAX,
            clockSeqAndNode: [u8::MAX; 8],
        };

        let result = uuid_to_string(&max_uuid);
        assert!(result.is_ok());
    }

    /// 测试 OperationParams 的空指针处理
    #[test]
    fn test_operation_params_null_pointer_handling() {
        use std::ptr;

        // 测试空指针操作
        let null_op: *mut raw::TEEC_Operation = ptr::null_mut();
        let result = OperationParams::new(null_op);
        assert!(result.is_err());
    }

    /// 测试 build_parameters_from_operation 的错误路径
    #[test]
    fn test_build_parameters_error_paths() {
        // 测试不支持的参数类型
        // 注意：参数类型必须是 4 位有效值（0-15），所以不能使用 99
        // 我们使用 TEEC_MEMREF_WHOLE 但没有设置正确的父内存标志来触发错误
        let mut op = raw::TEEC_Operation {
            started: 0,
            paramTypes: raw::TEEC_PARAM_TYPES(
                raw::TEEC_MEMREF_WHOLE, // 需要父内存标志
                raw::TEEC_NONE,
                raw::TEEC_NONE,
                raw::TEEC_NONE,
            ),
            params: [
                // param0: MEMREF_WHOLE - 但没有设置 parent
                raw::TEEC_Parameter {
                    memref: raw::TEEC_RegisteredMemoryReference {
                        parent: std::ptr::null_mut(), // null parent 会导致错误
                        size: 100,
                        offset: 0,
                    },
                },
                // param1-3: none
                raw::TEEC_Parameter {
                    value: raw::TEEC_Value { a: 0, b: 0 },
                },
                raw::TEEC_Parameter {
                    value: raw::TEEC_Value { a: 0, b: 0 },
                },
                raw::TEEC_Parameter {
                    value: raw::TEEC_Value { a: 0, b: 0 },
                },
            ],
            imp: raw::TEEC_Operation__Imp {
                session: std::ptr::null_mut(),
            },
        };

        let result = build_parameters_from_operation(&mut op);
        assert!(result.is_err());
    }

    /// 测试 update_operation_from_parameters 的错误路径
    #[test]
    fn test_update_operation_error_paths() {
        use crate::common::protocol::{TEE_ParamType, TEE_Parameter};

        // 测试不支持的参数类型
        // 注意：参数类型必须是 4 位有效值（0-15），所以不能使用 99
        // 我们使用一个有效的 OUTPUT 类型来触发更新逻辑
        let mut op = raw::TEEC_Operation {
            started: 0,
            paramTypes: raw::TEEC_PARAM_TYPES(
                raw::TEEC_VALUE_OUTPUT, // 有效的输出类型
                raw::TEEC_NONE,
                raw::TEEC_NONE,
                raw::TEEC_NONE,
            ),
            params: [raw::TEEC_Parameter {
                value: raw::TEEC_Value { a: 0, b: 0 },
            }; 4],
            imp: raw::TEEC_Operation__Imp {
                session: std::ptr::null_mut(),
            },
        };

        // 创建一个包含有效数据的参数
        let params = TEE_Parameters(
            TEE_Parameter {
                param_type: TEE_ParamType::ValueOutput,
                param: crate::common::protocol::TEE_Param {
                    value: crate::common::protocol::TEE_Value { a: 100, b: 200 },
                    data: vec![],
                },
            },
            TEE_Parameter::default(),
            TEE_Parameter::default(),
            TEE_Parameter::default(),
        );

        // 这个应该成功，因为 VALUE_OUTPUT 是支持的类型
        let result = update_operation_from_parameters(&mut op, params);
        assert!(result.is_ok());

        // 验证值被正确更新
        unsafe {
            assert_eq!(op.params[0].value.a, 100);
            assert_eq!(op.params[0].value.b, 200);
        }
    }

    /// 测试 safe_ptr 模块的各种错误情况
    #[test]
    fn test_safe_ptr_error_conditions() {
        use std::ptr;

        // 测试从空指针读取
        let read_result = safe_ptr::read_raw::<u32>(ptr::null());
        assert!(read_result.is_err());

        // 测试向空指针写入
        let write_result = safe_ptr::write_raw(ptr::null_mut(), 42u32);
        assert!(write_result.is_err());

        // 测试从空指针读取到 vec
        let vec_result = safe_ptr::read_to_vec(ptr::null::<u8>(), 10);
        assert!(vec_result.is_err());

        // 测试向空指针写入切片
        let data = [1u8, 2, 3];
        let slice_result = safe_ptr::write_from_slice(ptr::null_mut(), &data);
        assert!(slice_result.is_err());
    }

    /// 测试 TEEC_Result 到 Error 的转换
    #[test]
    fn test_tee_c_result_to_error_conversion() {
        // 测试各种 TEEC_Result 值到 Error 的转换
        //use crate::error::{ErrorKind, ErrorOrigin};

        // 验证 TEEC_SUCCESS 是 0
        assert_eq!(raw::TEEC_SUCCESS, 0);

        // 验证错误码不为 0
        assert_ne!(raw::TEEC_ERROR_GENERIC, 0);
        assert_ne!(raw::TEEC_ERROR_BAD_PARAMETERS, 0);

        // 测试 Error::from_teec_result 的行为（如果存在）
        // 或者测试错误码的比较逻辑
        let success_code: u32 = raw::TEEC_SUCCESS;
        let error_code: u32 = raw::TEEC_ERROR_GENERIC;

        // 验证成功和错误的区分
        assert_eq!(success_code == 0, true);
        assert_eq!(error_code != 0, true);
    }

    /// 测试 Session 相关的错误处理
    #[test]
    fn test_session_error_handling() {
        use std::ptr;

        // 测试空指针 session
        let null_session: *mut raw::TEEC_Session = ptr::null_mut();

        // 验证空指针的处理
        assert!(null_session.is_null());

        // 验证 TEEC_Session 结构体的存在性
        // 创建一个空的 session 用于测试
        let _session = raw::TEEC_Session {
            imp: raw::TEEC_Session__Imp {
                ctx: ptr::null_mut(),
                session_id: 0,
            },
        };
    }

    /// 测试 SharedMemoryManager 的正常分配和释放
    #[test]
    fn test_shared_memory_normal_allocation_release() {
        use std::ptr;

        // 创建一个模拟的上下文
        let mut ctx = raw::TEEC_Context {
            imp: raw::TEEC_Context__Imp {
                fd: -1,             // 无效的文件描述符
                reg_mem: false,     // 未注册内存
                memref_null: false, // 不使用 null memref
            },
        };

        // 测试共享内存的正常分配流程
        let mut shm = raw::TEEC_SharedMemory {
            buffer: ptr::null_mut(),
            size: 1024,
            flags: raw::TEEC_MEM_INPUT,
            imp: raw::TEEC_SharedMemory__Imp {
                id: -1,
                alloced_size: 0,
                shadow_buffer: ptr::null_mut(),
                registered_fd: -1,
                flags: 0,
            },
        };

        // 分配（会失败，因为需要实际环境）
        let _result = SharedMemoryManager::allocate(&mut ctx, &mut shm, false);
        // 可能失败，但不应该崩溃

        // 释放
        SharedMemoryManager::release(&mut shm);
        // 不应崩溃
    }

    /// 测试 uuid_to_string 的格式正确性
    #[test]
    fn test_uuid_to_string_format() {
        let uuid = raw::TEEC_UUID {
            timeLow: 0x12345678,
            timeMid: 0xABCD,
            timeHiAndVersion: 0xEF01,
            clockSeqAndNode: [0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01],
        };

        let result = uuid_to_string(&uuid);
        assert!(result.is_ok());

        let uuid_str = result.unwrap();
        // UUID 字符串应该是 36 个字符（包括连字符）
        assert_eq!(uuid_str.len(), 36);
        // 应该包含连字符
        assert!(uuid_str.contains('-'));
    }

    /// 测试 build_parameters 的 MEMREF_TEMP_INPUT 路径
    #[test]
    fn test_build_parameters_memref_temp_input() {
        let mut buffer = [0x01u8, 0x02, 0x03, 0x04];
        let mut op = raw::TEEC_Operation {
            started: 0,
            paramTypes: raw::TEEC_PARAM_TYPES(
                raw::TEEC_MEMREF_TEMP_INPUT,
                raw::TEEC_NONE,
                raw::TEEC_NONE,
                raw::TEEC_NONE,
            ),
            params: [
                raw::TEEC_Parameter {
                    tmpref: raw::TEEC_TempMemoryReference {
                        buffer: buffer.as_mut_ptr() as *mut std::ffi::c_void,
                        size: buffer.len(),
                    },
                },
                raw::TEEC_Parameter {
                    value: raw::TEEC_Value { a: 0, b: 0 },
                },
                raw::TEEC_Parameter {
                    value: raw::TEEC_Value { a: 0, b: 0 },
                },
                raw::TEEC_Parameter {
                    value: raw::TEEC_Value { a: 0, b: 0 },
                },
            ],
            imp: raw::TEEC_Operation__Imp {
                session: std::ptr::null_mut(),
            },
        };

        let result = build_parameters_from_operation(&mut op);
        assert!(result.is_ok());

        let params = result.unwrap();
        assert_eq!(params.0.param_type, TEE_ParamType::MemrefInput);
        assert_eq!(params.0.param.data.len(), 4);
    }

    /// 测试 get_memref_parent_flags 的错误路径
    #[test]
    fn test_get_memref_parent_flags_null_parent() {
        // 测试 memref.parent 为 null 的情况
        let mut op = raw::TEEC_Operation {
            started: 0,
            paramTypes: raw::TEEC_PARAM_TYPES(
                raw::TEEC_MEMREF_WHOLE,
                raw::TEEC_NONE,
                raw::TEEC_NONE,
                raw::TEEC_NONE,
            ),
            params: [
                raw::TEEC_Parameter {
                    memref: raw::TEEC_RegisteredMemoryReference {
                        parent: std::ptr::null_mut(), // null parent
                        size: 100,
                        offset: 0,
                    },
                },
                raw::TEEC_Parameter {
                    value: raw::TEEC_Value { a: 0, b: 0 },
                },
                raw::TEEC_Parameter {
                    value: raw::TEEC_Value { a: 0, b: 0 },
                },
                raw::TEEC_Parameter {
                    value: raw::TEEC_Value { a: 0, b: 0 },
                },
            ],
            imp: raw::TEEC_Operation__Imp {
                session: std::ptr::null_mut(),
            },
        };

        let op_params = OperationParams::new(&mut op).unwrap();
        let result = op_params.get_memref_parent_flags(0);
        assert!(result.is_err());
    }

    /// 测试 set_tmpref_data 的空缓冲区处理
    #[test]
    fn test_set_tmpref_data_null_buffer() {
        // 测试 tmp.buffer 为 null 的情况
        let mut op = raw::TEEC_Operation {
            started: 0,
            paramTypes: raw::TEEC_PARAM_TYPES(
                raw::TEEC_MEMREF_TEMP_INPUT,
                raw::TEEC_NONE,
                raw::TEEC_NONE,
                raw::TEEC_NONE,
            ),
            params: [
                raw::TEEC_Parameter {
                    tmpref: raw::TEEC_TempMemoryReference {
                        buffer: std::ptr::null_mut(), // null buffer
                        size: 100,
                    },
                },
                raw::TEEC_Parameter {
                    value: raw::TEEC_Value { a: 0, b: 0 },
                },
                raw::TEEC_Parameter {
                    value: raw::TEEC_Value { a: 0, b: 0 },
                },
                raw::TEEC_Parameter {
                    value: raw::TEEC_Value { a: 0, b: 0 },
                },
            ],
            imp: raw::TEEC_Operation__Imp {
                session: std::ptr::null_mut(),
            },
        };

        let op_params = OperationParams::new(&mut op).unwrap();
        let result = op_params.get_tmpref_data(0);
        assert!(result.is_err());
    }

    /// 测试 build_parameters 的 VALUE_INOUT 路径
    #[test]
    fn test_build_parameters_value_inout() {
        let mut op = raw::TEEC_Operation {
            started: 0,
            paramTypes: raw::TEEC_PARAM_TYPES(
                raw::TEEC_VALUE_INOUT,
                raw::TEEC_NONE,
                raw::TEEC_NONE,
                raw::TEEC_NONE,
            ),
            params: [
                raw::TEEC_Parameter {
                    value: raw::TEEC_Value { a: 123, b: 456 },
                },
                raw::TEEC_Parameter {
                    value: raw::TEEC_Value { a: 0, b: 0 },
                },
                raw::TEEC_Parameter {
                    value: raw::TEEC_Value { a: 0, b: 0 },
                },
                raw::TEEC_Parameter {
                    value: raw::TEEC_Value { a: 0, b: 0 },
                },
            ],
            imp: raw::TEEC_Operation__Imp {
                session: std::ptr::null_mut(),
            },
        };

        let result = build_parameters_from_operation(&mut op);
        assert!(result.is_ok());

        let params = result.unwrap();
        assert_eq!(params.0.param_type, TEE_ParamType::ValueInout);
        assert_eq!(params.0.param.value.a, 123);
        assert_eq!(params.0.param.value.b, 456);
    }
}