Implement boundary check (#243)

Author: qwreey

crates/lune-std-ffi/src/c/c_arr.rs

@@ -2,7 +2,7 @@ use libffi::middle::Type;
 use mlua::prelude::*;
 
 use super::association_names::CARR_INNER;
-use super::c_helper::{get_ensured_size, pretty_format_userdata, type_from_userdata};
+use super::c_helper::{get_ensured_size, libffi_type_from_userdata, pretty_format_userdata};
 use super::c_ptr::CPtr;
 use crate::ffi::ffi_association::{get_association, set_association};
 
@@ -44,13 +44,21 @@ impl CArr {
         luatype: &LuaAnyUserData<'lua>,
         length: usize,
     ) -> LuaResult<LuaAnyUserData<'lua>> {
-        let fields = type_from_userdata(lua, luatype)?;
+        let fields = libffi_type_from_userdata(lua, luatype)?;
         let carr = lua.create_userdata(Self::new(fields, length)?)?;
 
         set_association(lua, CARR_INNER, &carr, luatype)?;
         Ok(carr)
     }
 
+    pub fn get_size(&self) -> usize {
+        self.size
+    }
+
+    pub fn get_length(&self) -> usize {
+        self.length
+    }
+
     pub fn get_type(&self) -> &Type {
         &self.struct_type
     }
@@ -83,8 +91,8 @@ impl CArr {
 
 impl LuaUserData for CArr {
     fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) {
-        fields.add_field_method_get("size", |_, this| Ok(this.size));
-        fields.add_field_method_get("length", |_, this| Ok(this.length));
+        fields.add_field_method_get("size", |_, this| Ok(this.get_size()));
+        fields.add_field_method_get("length", |_, this| Ok(this.get_length()));
         fields.add_field_function_get("inner", |lua, this: LuaAnyUserData| {
             let inner: LuaValue = get_association(lua, CARR_INNER, this)?
                 // It shouldn't happen.
@@ -102,7 +110,7 @@ impl LuaUserData for CArr {
             }
         });
         methods.add_function("ptr", |lua, this: LuaAnyUserData| {
-            let pointer = CPtr::from_lua_userdata(lua, &this)?;
+            let pointer = CPtr::new_from_lua_userdata(lua, &this)?;
             Ok(pointer)
         });
         methods.add_meta_function(LuaMetaMethod::ToString, |lua, this: LuaAnyUserData| {

crates/lune-std-ffi/src/c/c_fn.rs

@@ -1,7 +1,7 @@
 use libffi::middle::{Cif, Type};
 use mlua::prelude::*;
 
-use super::c_helper::{type_from_userdata, type_list_from_table};
+use super::c_helper::{libffi_type_from_userdata, libffi_type_list_from_table};
 
 // cfn is a type declaration for a function.
 // Basically, when calling an external function, this type declaration
@@ -36,8 +36,8 @@ impl CFn {
     }
 
     pub fn new_from_lua_table(lua: &Lua, args: LuaTable, ret: LuaAnyUserData) -> LuaResult<Self> {
-        let args = type_list_from_table(lua, &args)?;
-        let ret = type_from_userdata(lua, &ret)?;
+        let args = libffi_type_list_from_table(lua, &args)?;
+        let ret = libffi_type_from_userdata(lua, &ret)?;
         Ok(Self::new(args, ret))
     }
 }

crates/lune-std-ffi/src/c/c_helper.rs

@@ -1,43 +1,84 @@
+#![allow(clippy::inline_always)]
+
 use std::ptr::{self, null_mut};
 
 use libffi::{low, middle::Type, raw};
 use lune_utils::fmt::{pretty_format_value, ValueFormatConfig};
 use mlua::prelude::*;
 
 use super::association_names::CTYPE_STATIC;
-use super::c_arr::CArr;
-use super::c_ptr::CPtr;
-use super::c_struct::CStruct;
 use super::c_type::CTypeStatic;
-use crate::ffi::ffi_association::get_association;
-use crate::ffi::ffi_helper::FFI_STATUS_NAMES;
+use super::types::get_ctype_conv;
+use super::{CArr, CPtr, CStruct};
+use crate::ffi::{ffi_association::get_association, NativeConvert, FFI_STATUS_NAMES};
+
+// Get the NativeConvert handle from the type UserData
+// this is intended to avoid constant table lookups. (eg: struct)
+// userdata must live longer than the NativeConvert handle.
+// However, c_struct is a strong reference to each field, so this is not a problem.
+pub unsafe fn get_conv(userdata: &LuaAnyUserData) -> LuaResult<*const dyn NativeConvert> {
+    if userdata.is::<CStruct>() {
+        Ok(userdata.to_pointer().cast::<CStruct>() as *const dyn NativeConvert)
+    } else {
+        unsafe { get_ctype_conv(userdata) }
+    }
+}
+pub unsafe fn get_conv_list_from_table(
+    table: &LuaTable,
+) -> LuaResult<Vec<*const dyn NativeConvert>> {
+    let len: usize = table.raw_len();
+    let mut conv_list = Vec::<*const dyn NativeConvert>::with_capacity(len);
+
+    for i in 0..len {
+        let value: LuaValue = table.raw_get(i + 1)?;
+
+        if let LuaValue::UserData(field_type) = value {
+            conv_list.push(get_conv(&field_type)?);
+        } else {
+            return Err(LuaError::external(format!(
+                "Unexpected field. CStruct, CType or CArr is required for element but got {}",
+                pretty_format_value(&value, &ValueFormatConfig::new())
+            )));
+        }
+    }
+
+    Ok(conv_list)
+}
+
+// #[inline(always)]
+// pub fn type_size_from_userdata(this: &LuaAnyUserData) -> LuaResult<usize> {
+//     if this.is::<CStruct>() {
+//         Ok(this.borrow::<CStruct>()?.get_size())
+//     } else if this.is::<CArr>() {
+//         Ok(this.borrow::<CArr>()?.get_size())
+//     } else {
+//         ctype_size_from_userdata(this)
+//     }
+// }
 
 // get Vec<libffi_type> from table(array) of c-types userdata
-pub fn type_list_from_table(lua: &Lua, table: &LuaTable) -> LuaResult<Vec<Type>> {
+pub fn libffi_type_list_from_table(lua: &Lua, table: &LuaTable) -> LuaResult<Vec<Type>> {
     let len: usize = table.raw_len();
     let mut fields = Vec::with_capacity(len);
 
     for i in 0..len {
         // Test required
         let value = table.raw_get(i + 1)?;
-        match value {
-            LuaValue::UserData(field_type) => {
-                fields.push(type_from_userdata(lua, &field_type)?);
-            }
-            _ => {
-                return Err(LuaError::external(format!(
-                    "Unexpected field. CStruct, CType or CArr is required for element but got {}",
-                    pretty_format_value(&value, &ValueFormatConfig::new())
-                )));
-            }
+        if let LuaValue::UserData(field_type) = value {
+            fields.push(libffi_type_from_userdata(lua, &field_type)?);
+        } else {
+            return Err(LuaError::external(format!(
+                "Unexpected field. CStruct, CType or CArr is required for element but got {}",
+                value.type_name()
+            )));
         }
     }
 
     Ok(fields)
 }
 
 // get libffi_type from any c-type userdata
-pub fn type_from_userdata(lua: &Lua, userdata: &LuaAnyUserData) -> LuaResult<Type> {
+pub fn libffi_type_from_userdata(lua: &Lua, userdata: &LuaAnyUserData) -> LuaResult<Type> {
     if userdata.is::<CStruct>() {
         Ok(userdata.borrow::<CStruct>()?.get_type().to_owned())
     } else if let Some(t) = get_association(lua, CTYPE_STATIC, userdata)? {

crates/lune-std-ffi/src/c/c_ptr.rs

@@ -1,19 +1,15 @@
-#![allow(clippy::cargo_common_metadata)]
-
 use libffi::middle::Type;
 use mlua::prelude::*;
 
-use super::association_names::CPTR_INNER;
-use super::c_arr::CArr;
-use super::c_helper::pretty_format_userdata;
+use super::{association_names::CPTR_INNER, c_helper::pretty_format_userdata, CArr};
 use crate::ffi::ffi_association::{get_association, set_association};
 
 pub struct CPtr();
 
 impl CPtr {
     // Create pointer type with '.inner' field
     // inner can be CArr, CType or CStruct
-    pub fn from_lua_userdata<'lua>(
+    pub fn new_from_lua_userdata<'lua>(
         lua: &'lua Lua,
         inner: &LuaAnyUserData,
     ) -> LuaResult<LuaAnyUserData<'lua>> {
@@ -56,7 +52,7 @@ impl LuaUserData for CPtr {
 
     fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) {
         methods.add_function("ptr", |lua, this: LuaAnyUserData| {
-            let pointer = CPtr::from_lua_userdata(lua, &this)?;
+            let pointer = CPtr::new_from_lua_userdata(lua, &this)?;
             Ok(pointer)
         });
         methods.add_function("arr", |lua, (this, length): (LuaAnyUserData, usize)| {