rust-libteec 0.4.0

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

//! TEE 操作参数管理模块
//!
//! 提供安全的 TEEC_Operation 参数访问和转换功能。
//!
//! ## 重要说明
//!
//! 此模块负责将 TEEC_Operation 中的参数（VALUE、MEMREF 等）转换为可序列化的格式，
//! 以便通过机密通信通道发送给 TA。MEMREF 参数引用的数据来自共享内存缓冲区，
//! 这些数据会被读取并序列化到请求数据包中，通过网络传输到 TA。

use log::debug;

use super::{safe_ptr, shared_memory::SharedMemoryManager};
use crate::{Error, ErrorKind, Result, raw};
use teec_protocol::{TEE_ParamType, TEE_Parameters};

/// 操作参数包装器，提供安全的操作参数访问
///
/// **注意**: 此结构体仅在 teec 模块内部使用，不对外公开。
pub(super) struct OperationParams {
    operation: *mut raw::TEEC_Operation,
}

impl OperationParams {
    /// 验证并包装 TEEC_Operation 指针
    pub(super) fn new(operation: *mut raw::TEEC_Operation) -> Result<Self> {
        let _ = safe_ptr::deref_mut(operation)?;
        Ok(Self { operation })
    }

    /// 获取参数类型位掩码
    pub(super) 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)
    }

    /// 读取 VALUE 类型参数的 (a, b) 值
    pub(super) 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)) }
    }

    /// 写入 VALUE 类型参数的 (a, b) 值
    pub(super) 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(())
    }

    /// 读取 TEMPREF 参数的数据缓冲区
    pub(super) 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())
        }
    }

    /// 写入 TEMPREF 参数并更新 size 字段
    pub(super) 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(())
    }

    /// 获取 MEMREF 参数的父内存标志（用于判断 IN/OUT 方向）
    pub(super) 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)
    }

    /// 读取 WHOLE MEMREF 参数（从父共享内存缓冲区）
    ///
    /// 注意：这里读取的是本地缓冲区的数据，这些数据将被序列化并通过网络发送给 TA。
    pub(super) 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]))
        }
    }

    /// 写入 WHOLE MEMREF 参数到父共享内存缓冲区
    ///
    /// 注意：这里写入的是本地缓冲区，这些数据将从 TA 返回的响应中反序列化得到。
    pub(super) 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(())
    }

    /// 读取 PARTIAL MEMREF 参数（带方向标志检查）
    pub(super) 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))
        }
    }

    /// 写入 PARTIAL MEMREF 参数（带 offset 偏移）
    pub(super) 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(())
    }
}

/// 从 TEEC_Operation 构建协议参数
pub 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 结构
pub 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(())
}

#[cfg(test)]
mod operation_tests {
    use super::*;
    use std::ffi::c_void;

    #[test]
    fn test_operation_params_value() {
        // 测试值参数（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), "应该能正确设置值参数");
    }

    #[test]
    fn test_operation_params_tmpref() {
        // 测试临时内存引用参数（TempMemoryReference）
        let mut tmp_buf = vec![0u8; 6];
        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(),
            },
        };

        op.params[1] = raw::TEEC_Parameter {
            tmpref: raw::TEEC_TempMemoryReference {
                buffer: tmp_buf.as_mut_ptr() as *mut c_void,
                size: tmp_buf.len(),
            },
        };

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

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

        // 读取临时内存引用
        let got = op_params.get_tmpref_data(1).unwrap();
        assert_eq!(got, to_write.to_vec(), "应该正确读取临时内存");
    }

    #[test]
    fn test_operation_params_null() {
        // 测试空指针处理
        let result = OperationParams::new(std::ptr::null_mut());
        assert!(result.is_err());
    }

    #[test]
    fn test_build_parameters_from_operation() {
        // 测试从 operation 构建参数
        let mut op = raw::TEEC_Operation {
            started: 0,
            paramTypes: raw::TEEC_VALUE_INPUT,
            params: [raw::TEEC_Parameter {
                value: raw::TEEC_Value { a: 42, b: 100 },
            }; 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 params = build_parameters_from_operation(op_ptr).unwrap();

        // TEE_Parameters 是元组结构体，检查第一个参数的类型
        assert_eq!(params.0.param_type as u32, raw::TEEC_VALUE_INPUT);
    }

    #[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_tmpref_null_buffer() {
        // 测试设置临时内存引用时缓冲区为空的情况
        let mut op = raw::TEEC_Operation {
            started: 0,
            paramTypes: 0,
            params: [raw::TEEC_Parameter {
                tmpref: raw::TEEC_TempMemoryReference {
                    buffer: std::ptr::null_mut(),
                    size: 10, // 有大小但缓冲区为空
                },
            }; 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_tmpref_data(0).is_err(),
            "缓冲区为空但有大小应该返回错误"
        );
    }

    #[test]
    fn test_build_parameters_with_all_param_types() {
        // 测试 build_parameters_from_operation 支持的所有参数类型
        use teec_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 teec_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);
        }
    }

    #[test]
    fn test_operation_params_new_null_ptr() {
        // 测试 OperationParams::new 传入空指针（应该失败）
        let result = OperationParams::new(std::ptr::null_mut());
        assert!(result.is_err(), "空指针应该导致失败");
    }

    #[test]
    fn test_get_value_all_invalid_indices() {
        // 测试 get_value 的所有无效索引
        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.get_value(100).is_err());
        assert!(op_params.get_value(usize::MAX).is_err());
    }

    #[test]
    fn test_set_value_all_invalid_indices() {
        // 测试 set_value 的所有无效索引
        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
                .set_value(raw::TEEC_CONFIG_PAYLOAD_REF_COUNT, 1, 2)
                .is_err()
        );

        // 测试远超出边界的索引
        assert!(op_params.set_value(100, 1, 2).is_err());
        assert!(op_params.set_value(usize::MAX, 1, 2).is_err());
    }

    #[test]
    #[allow(unused_assignments)]
    fn test_get_tmpref_data_all_error_paths() {
        // 测试 get_tmpref_data 的所有错误路径
        let mut op = raw::TEEC_Operation {
            started: 0,
            paramTypes: 0,
            params: [raw::TEEC_Parameter {
                tmpref: raw::TEEC_TempMemoryReference {
                    buffer: std::ptr::null_mut(),
                    size: 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();

        // 测试 1: 索引越界
        assert!(
            op_params
                .get_tmpref_data(raw::TEEC_CONFIG_PAYLOAD_REF_COUNT)
                .is_err()
        );
        assert!(op_params.get_tmpref_data(100).is_err());

        // 测试 2: 缓冲区为空但大小 > 0
        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());

        // 测试 3: 正常情况 - 缓冲区为空且大小为 0（应该返回空 Vec）
        op.params[0] = raw::TEEC_Parameter {
            tmpref: raw::TEEC_TempMemoryReference {
                buffer: std::ptr::null_mut(),
                size: 0,
            },
        };
        let result = op_params.get_tmpref_data(0);
        assert!(result.is_ok());
        assert_eq!(result.unwrap().len(), 0);
    }

    #[test]
    #[allow(unused_assignments)]
    fn test_set_tmpref_data_all_error_paths() {
        // 测试 set_tmpref_data 的所有错误路径
        let mut op = raw::TEEC_Operation {
            started: 0,
            paramTypes: 0,
            params: [raw::TEEC_Parameter {
                tmpref: raw::TEEC_TempMemoryReference {
                    buffer: std::ptr::null_mut(),
                    size: 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();

        // 测试 1: 索引越界
        let data = vec![1u8, 2, 3];
        assert!(
            op_params
                .set_tmpref_data(raw::TEEC_CONFIG_PAYLOAD_REF_COUNT, &data)
                .is_err()
        );
        assert!(op_params.set_tmpref_data(100, &data).is_err());

        // 测试 2: 正常写入（应该有缓冲区）
        let mut buffer = vec![0u8; 10];
        op.params[0] = raw::TEEC_Parameter {
            tmpref: raw::TEEC_TempMemoryReference {
                buffer: buffer.as_mut_ptr() as *mut std::ffi::c_void,
                size: buffer.len(),
            },
        };
        let small_data = vec![1u8, 2, 3];
        let result = op_params.set_tmpref_data(0, &small_data);
        assert!(result.is_ok());
    }

    #[test]
    fn test_param_types_null_operation() {
        // 测试 param_types 在空指针时的行为
        let op_params = OperationParams {
            operation: std::ptr::null_mut(),
        };
        let result = op_params.param_types();
        assert!(result.is_err(), "空指针操作应该失败");
    }

    #[test]
    fn test_build_parameters_null_operation() {
        // 测试 build_parameters_from_operation 传入空指针
        let result = build_parameters_from_operation(std::ptr::null_mut());
        assert!(result.is_err(), "空指针应该导致失败");
    }

    #[test]
    fn test_update_operation_null_operation() {
        // 测试 update_operation_from_parameters 传入空指针
        use teec_protocol::{TEE_Param, TEE_ParamType, TEE_Parameter, TEE_Value};

        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::default(),
            TEE_Parameter::default(),
            TEE_Parameter::default(),
        );

        let result = update_operation_from_parameters(std::ptr::null_mut(), params);
        assert!(result.is_err(), "空指针应该导致失败");
    }

    #[test]
    fn test_mixed_valid_and_invalid_operations() {
        // 测试混合有效和无效操作的场景
        let mut op = raw::TEEC_Operation {
            started: 0,
            paramTypes: raw::TEEC_PARAM_TYPES(
                raw::TEEC_VALUE_INPUT,
                raw::TEEC_NONE,
                raw::TEEC_NONE,
                raw::TEEC_NONE,
            ),
            params: [
                raw::TEEC_Parameter {
                    value: raw::TEEC_Value { a: 42, b: 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_ptr: *mut raw::TEEC_Operation = &mut op;
        let op_params = OperationParams::new(op_ptr).unwrap();

        // 有效操作应该成功
        assert!(op_params.get_value(0).is_ok());
        assert!(op_params.set_value(0, 1, 2).is_ok());

        // 无效操作应该失败
        assert!(op_params.get_value(4).is_err());
        assert!(op_params.set_value(4, 1, 2).is_err());
    }

    #[test]
    fn test_memref_partial_operations() {
        // 测试 PARTIAL MEMREF 的读写操作
        use std::ptr;

        // 准备父共享内存缓冲区
        let mut parent_buffer = vec![0u8; 100];
        for i in 0..100 {
            parent_buffer[i] = i as u8;
        }

        let mut parent_shm = raw::TEEC_SharedMemory {
            buffer: parent_buffer.as_mut_ptr() as *mut _,
            size: 100,
            flags: raw::TEEC_MEM_INPUT | raw::TEEC_MEM_OUTPUT,
            imp: raw::TEEC_SharedMemory__Imp {
                id: 1,
                registered_fd: -1,
                shadow_buffer: ptr::null_mut(),
                alloced_size: 100,
                flags: 1,
            },
        };

        // 创建带有 PARTIAL MEMREF 的操作
        let mut op = raw::TEEC_Operation {
            started: 0,
            paramTypes: raw::TEEC_PARAM_TYPES(
                raw::TEEC_MEMREF_PARTIAL_INPUT,
                raw::TEEC_NONE,
                raw::TEEC_NONE,
                raw::TEEC_NONE,
            ),
            params: [
                raw::TEEC_Parameter {
                    memref: raw::TEEC_RegisteredMemoryReference {
                        parent: &mut parent_shm as *mut _,
                        size: 10,
                        offset: 5,
                    },
                },
                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: ptr::null_mut(),
            },
        };

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

        // 测试读取 PARTIAL MEMREF
        let data = op_params.get_memref_data_partial(0, raw::TEEC_MEM_INPUT);
        assert!(data.is_ok());
        let data = data.unwrap();
        assert_eq!(data.len(), 10);
        // 验证读取的是偏移 5-14 的数据
        for (i, &byte) in data.iter().enumerate() {
            assert_eq!(byte, (i + 5) as u8);
        }

        // 测试写入 PARTIAL MEMREF
        let write_data = vec![0xFF; 10];
        let result = op_params.set_memref_data_partial(0, &write_data);
        assert!(result.is_ok());

        // 验证写入成功
        for i in 5..15 {
            assert_eq!(parent_buffer[i], 0xFF);
        }
    }

    #[test]
    fn test_build_parameters_memref_output() {
        // 测试 build_parameters_from_operation 处理 MEMREF_OUTPUT
        use std::ptr;

        let mut buffer = vec![0u8; 50];
        let mut op = raw::TEEC_Operation {
            started: 0,
            paramTypes: raw::TEEC_PARAM_TYPES(
                raw::TEEC_MEMREF_TEMP_OUTPUT,
                raw::TEEC_NONE,
                raw::TEEC_NONE,
                raw::TEEC_NONE,
            ),
            params: [
                raw::TEEC_Parameter {
                    tmpref: raw::TEEC_TempMemoryReference {
                        buffer: buffer.as_mut_ptr() as *mut _,
                        size: 50,
                    },
                },
                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: ptr::null_mut(),
            },
        };

        let params = build_parameters_from_operation(&mut op).unwrap();
        assert_eq!(params.0.param_type, TEE_ParamType::MemrefOutput);
        // MEMREF_OUTPUT 不应该包含数据，只传递大小
        assert_eq!(params.0.param.data.len(), 0);
    }

    #[test]
    fn test_update_operation_memref_output() {
        // 测试 update_operation_from_parameters 更新 MEMREF 输出参数
        use std::ptr;
        use teec_protocol::{TEE_Param, TEE_Parameter};

        let mut output_buffer = vec![0u8; 20];
        let mut op = raw::TEEC_Operation {
            started: 0,
            paramTypes: raw::TEEC_PARAM_TYPES(
                raw::TEEC_MEMREF_TEMP_OUTPUT,
                raw::TEEC_NONE,
                raw::TEEC_NONE,
                raw::TEEC_NONE,
            ),
            params: [
                raw::TEEC_Parameter {
                    tmpref: raw::TEEC_TempMemoryReference {
                        buffer: output_buffer.as_mut_ptr() as *mut _,
                        size: 20,
                    },
                },
                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: ptr::null_mut(),
            },
        };

        // 模拟 TA 返回的数据
        let returned_data = vec![0xAA; 10];
        let params = TEE_Parameters(
            TEE_Parameter {
                param_type: TEE_ParamType::MemrefOutput,
                param: TEE_Param {
                    data: returned_data.clone(),
                    value: Default::default(),
                },
            },
            Default::default(),
            Default::default(),
            Default::default(),
        );

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

        // 验证数据已写回缓冲区
        for i in 0..10 {
            assert_eq!(output_buffer[i], 0xAA);
        }
    }
}