Revert "[flatbuffer] updated flatbuffer schema to remove host_function_*"

This reverts commit af6c1a9.

Signed-off-by: danbugs <[email protected]>

Author: danbugs

src/hyperlight_common/src/flatbuffer_wrappers/function_types.rs

@@ -710,7 +710,7 @@ impl TryFrom<&ReturnValue> for Vec<u8> {
                         &mut builder,
                         &hlsizeprefixedbufferArgs {
                             value: Some(val),
-                            size: v.len() as i32,
+                            size_: v.len() as i32,
                         },
                     )
                 };

src/hyperlight_common/src/flatbuffer_wrappers/host_function_definition.rs

@@ -0,0 +1,160 @@
+/*
+Copyright 2025 The Hyperlight Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+use alloc::string::{String, ToString};
+use alloc::vec::Vec;
+
+use anyhow::{Error, Result, anyhow};
+use flatbuffers::{FlatBufferBuilder, WIPOffset};
+#[cfg(feature = "tracing")]
+use tracing::{Span, instrument};
+
+use super::function_types::{ParameterType, ReturnType};
+use crate::flatbuffers::hyperlight::generated::{
+    HostFunctionDefinition as FbHostFunctionDefinition,
+    HostFunctionDefinitionArgs as FbHostFunctionDefinitionArgs, ParameterType as FbParameterType,
+};
+
+/// The definition of a function exposed from the host to the guest
+#[derive(Debug, Default, Clone, PartialEq, Eq)]
+pub struct HostFunctionDefinition {
+    /// The function name
+    pub function_name: String,
+    /// The type of the parameter values for the host function call.
+    pub parameter_types: Option<Vec<ParameterType>>,
+    /// The type of the return value from the host function call
+    pub return_type: ReturnType,
+}
+
+impl HostFunctionDefinition {
+    /// Create a new `HostFunctionDefinition`.
+    #[cfg_attr(feature = "tracing", instrument(skip_all, parent = Span::current(), level= "Trace"))]
+    pub fn new(
+        function_name: String,
+        parameter_types: Option<Vec<ParameterType>>,
+        return_type: ReturnType,
+    ) -> Self {
+        Self {
+            function_name,
+            parameter_types,
+            return_type,
+        }
+    }
+
+    /// Convert this `HostFunctionDefinition` into a `WIPOffset<FbHostFunctionDefinition>`.
+    #[cfg_attr(feature = "tracing", instrument(err(Debug), skip_all, parent = Span::current(), level= "Trace"))]
+    pub(crate) fn convert_to_flatbuffer_def<'a>(
+        &self,
+        builder: &mut FlatBufferBuilder<'a>,
+    ) -> Result<WIPOffset<FbHostFunctionDefinition<'a>>> {
+        let host_function_name = builder.create_string(&self.function_name);
+        let return_value_type = self.return_type.into();
+        let vec_parameters = match &self.parameter_types {
+            Some(vec_pvt) => {
+                let num_items = vec_pvt.len();
+                let mut parameters: Vec<FbParameterType> = Vec::with_capacity(num_items);
+                for pvt in vec_pvt {
+                    let fb_pvt = pvt.clone().into();
+                    parameters.push(fb_pvt);
+                }
+                Some(builder.create_vector(&parameters))
+            }
+            None => None,
+        };
+
+        let fb_host_function_definition: WIPOffset<FbHostFunctionDefinition> =
+            FbHostFunctionDefinition::create(
+                builder,
+                &FbHostFunctionDefinitionArgs {
+                    function_name: Some(host_function_name),
+                    return_type: return_value_type,
+                    parameters: vec_parameters,
+                },
+            );
+
+        Ok(fb_host_function_definition)
+    }
+
+    /// Verify that the function call has the correct parameter types.
+    #[cfg_attr(feature = "tracing", instrument(err(Debug), skip_all, parent = Span::current(), level= "Trace"))]
+    pub fn verify_equal_parameter_types(
+        &self,
+        function_call_parameter_types: &[ParameterType],
+    ) -> Result<()> {
+        if let Some(parameter_types) = &self.parameter_types {
+            for (i, parameter_type) in parameter_types.iter().enumerate() {
+                if parameter_type != &function_call_parameter_types[i] {
+                    return Err(anyhow!("Incorrect parameter type for parameter {}", i + 1));
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+impl TryFrom<&FbHostFunctionDefinition<'_>> for HostFunctionDefinition {
+    type Error = Error;
+    #[cfg_attr(feature = "tracing", instrument(err(Debug), skip_all, parent = Span::current(), level= "Trace"))]
+    fn try_from(value: &FbHostFunctionDefinition) -> Result<Self> {
+        let function_name = value.function_name().to_string();
+        let return_type = value.return_type().try_into().map_err(|_| {
+            anyhow!(
+                "Failed to convert return type for function {}",
+                function_name
+            )
+        })?;
+        let parameter_types = match value.parameters() {
+            Some(pvt) => {
+                let len = pvt.len();
+                let mut pv: Vec<ParameterType> = Vec::with_capacity(len);
+                for fb_pvt in pvt {
+                    let pvt: ParameterType = fb_pvt.try_into().map_err(|_| {
+                        anyhow!(
+                            "Failed to convert parameter type for function {}",
+                            function_name
+                        )
+                    })?;
+                    pv.push(pvt);
+                }
+                Some(pv)
+            }
+            None => None,
+        };
+
+        Ok(Self::new(function_name, parameter_types, return_type))
+    }
+}
+
+impl TryFrom<&[u8]> for HostFunctionDefinition {
+    type Error = Error;
+    #[cfg_attr(feature = "tracing", instrument(err(Debug), skip_all, parent = Span::current(), level= "Trace"))]
+    fn try_from(value: &[u8]) -> Result<Self> {
+        let fb_host_function_definition = flatbuffers::root::<FbHostFunctionDefinition<'_>>(value)
+            .map_err(|e| anyhow!("Error while reading HostFunctionDefinition: {:?}", e))?;
+        Self::try_from(&fb_host_function_definition)
+    }
+}
+
+impl TryFrom<&HostFunctionDefinition> for Vec<u8> {
+    type Error = Error;
+    #[cfg_attr(feature = "tracing", instrument(err(Debug), skip_all, parent = Span::current(), level= "Trace"))]
+    fn try_from(hfd: &HostFunctionDefinition) -> Result<Vec<u8>> {
+        let mut builder = flatbuffers::FlatBufferBuilder::new();
+        let host_function_definition = hfd.convert_to_flatbuffer_def(&mut builder)?;
+        builder.finish_size_prefixed(host_function_definition, None);
+        Ok(builder.finished_data().to_vec())
+    }
+}

src/hyperlight_common/src/flatbuffer_wrappers/host_function_details.rs

@@ -0,0 +1,102 @@
+/*
+Copyright 2025 The Hyperlight Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+use alloc::vec::Vec;
+
+use anyhow::{Error, Result};
+use flatbuffers::{WIPOffset, size_prefixed_root};
+#[cfg(feature = "tracing")]
+use tracing::{Span, instrument};
+
+use super::host_function_definition::HostFunctionDefinition;
+use crate::flatbuffers::hyperlight::generated::{
+    HostFunctionDefinition as FbHostFunctionDefinition,
+    HostFunctionDetails as FbHostFunctionDetails,
+    HostFunctionDetailsArgs as FbHostFunctionDetailsArgs,
+};
+
+/// `HostFunctionDetails` represents the set of functions that the host exposes to the guest.
+#[derive(Debug, Default, Clone)]
+pub struct HostFunctionDetails {
+    /// The host functions.
+    pub host_functions: Option<Vec<HostFunctionDefinition>>,
+}
+
+impl TryFrom<&[u8]> for HostFunctionDetails {
+    type Error = Error;
+    #[cfg_attr(feature = "tracing", instrument(err(Debug), skip_all, parent = Span::current(), level= "Trace"))]
+    fn try_from(value: &[u8]) -> Result<Self> {
+        let host_function_details_fb = size_prefixed_root::<FbHostFunctionDetails>(value)
+            .map_err(|e| anyhow::anyhow!("Error while reading HostFunctionDetails: {:?}", e))?;
+
+        let host_function_definitions = match host_function_details_fb.functions() {
+            Some(hfd) => {
+                let len = hfd.len();
+                let mut vec_hfd: Vec<HostFunctionDefinition> = Vec::with_capacity(len);
+                for i in 0..len {
+                    let fb_host_function_definition = hfd.get(i);
+                    let hfdef = HostFunctionDefinition::try_from(&fb_host_function_definition)?;
+                    vec_hfd.push(hfdef);
+                }
+
+                Some(vec_hfd)
+            }
+
+            None => None,
+        };
+
+        Ok(Self {
+            host_functions: host_function_definitions,
+        })
+    }
+}
+
+impl TryFrom<&HostFunctionDetails> for Vec<u8> {
+    type Error = Error;
+    #[cfg_attr(feature = "tracing", instrument(err(Debug), skip_all, parent = Span::current(), level= "Trace"))]
+    fn try_from(value: &HostFunctionDetails) -> Result<Vec<u8>> {
+        let mut builder = flatbuffers::FlatBufferBuilder::new();
+        let vec_host_function_definitions = match &value.host_functions {
+            Some(vec_hfd) => {
+                let num_items = vec_hfd.len();
+                let mut host_function_definitions: Vec<WIPOffset<FbHostFunctionDefinition>> =
+                    Vec::with_capacity(num_items);
+
+                for hfd in vec_hfd {
+                    let host_function_definition = hfd.convert_to_flatbuffer_def(&mut builder)?;
+                    host_function_definitions.push(host_function_definition);
+                }
+
+                Some(host_function_definitions)
+            }
+            None => None,
+        };
+
+        let fb_host_function_definitions =
+            vec_host_function_definitions.map(|v| builder.create_vector(&v));
+
+        let host_function_details = FbHostFunctionDetails::create(
+            &mut builder,
+            &FbHostFunctionDetailsArgs {
+                functions: fb_host_function_definitions,
+            },
+        );
+        builder.finish_size_prefixed(host_function_details, None);
+        let res = builder.finished_data().to_vec();
+
+        Ok(res)
+    }
+}

src/hyperlight_common/src/flatbuffer_wrappers/mod.rs

@@ -21,4 +21,8 @@ pub mod guest_error;
 pub mod guest_log_data;
 /// cbindgen:ignore
 pub mod guest_log_level;
+/// cbindgen:ignore
+pub mod host_function_definition;
+/// cbindgen:ignore
+pub mod host_function_details;
 pub mod util;

src/hyperlight_common/src/flatbuffer_wrappers/util.rs

@@ -82,7 +82,7 @@ impl FlatbufferSerializable for &[u8] {
                 Fbhlsizeprefixedbuffer::create(
                     builder,
                     &FbhlsizeprefixedbufferArgs {
-                        size: self.len() as i32,
+                        size_: self.len() as i32,
                         value: Some(vec_offset),
                     },
                 )

src/hyperlight_common/src/flatbuffers/hyperlight/generated/hlsizeprefixedbuffer_generated.rs

@@ -30,7 +30,7 @@ impl<'a> flatbuffers::Follow<'a> for hlsizeprefixedbuffer<'a> {
 }
 
 impl<'a> hlsizeprefixedbuffer<'a> {
-    pub const VT_SIZE: flatbuffers::VOffsetT = 4;
+    pub const VT_SIZE_: flatbuffers::VOffsetT = 4;
     pub const VT_VALUE: flatbuffers::VOffsetT = 6;
 
     #[inline]
@@ -46,18 +46,18 @@ impl<'a> hlsizeprefixedbuffer<'a> {
         if let Some(x) = args.value {
             builder.add_value(x);
         }
-        builder.add_size(args.size);
+        builder.add_size_(args.size_);
         builder.finish()
     }
 
     #[inline]
-    pub fn size(&self) -> i32 {
+    pub fn size_(&self) -> i32 {
         // Safety:
         // Created from valid Table for this object
         // which contains a valid value in this slot
         unsafe {
             self._tab
-                .get::<i32>(hlsizeprefixedbuffer::VT_SIZE, Some(0))
+                .get::<i32>(hlsizeprefixedbuffer::VT_SIZE_, Some(0))
                 .unwrap()
         }
     }
@@ -84,7 +84,7 @@ impl flatbuffers::Verifiable for hlsizeprefixedbuffer<'_> {
     ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
         use self::flatbuffers::Verifiable;
         v.visit_table(pos)?
-            .visit_field::<i32>("size", Self::VT_SIZE, false)?
+            .visit_field::<i32>("size_", Self::VT_SIZE_, false)?
             .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
                 "value",
                 Self::VT_VALUE,
@@ -95,14 +95,14 @@ impl flatbuffers::Verifiable for hlsizeprefixedbuffer<'_> {
     }
 }
 pub struct hlsizeprefixedbufferArgs<'a> {
-    pub size: i32,
+    pub size_: i32,
     pub value: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
 }
 impl<'a> Default for hlsizeprefixedbufferArgs<'a> {
     #[inline]
     fn default() -> Self {
         hlsizeprefixedbufferArgs {
-            size: 0,
+            size_: 0,
             value: None,
         }
     }
@@ -114,9 +114,9 @@ pub struct hlsizeprefixedbufferBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + '
 }
 impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> hlsizeprefixedbufferBuilder<'a, 'b, A> {
     #[inline]
-    pub fn add_size(&mut self, size: i32) {
+    pub fn add_size_(&mut self, size_: i32) {
         self.fbb_
-            .push_slot::<i32>(hlsizeprefixedbuffer::VT_SIZE, size, 0);
+            .push_slot::<i32>(hlsizeprefixedbuffer::VT_SIZE_, size_, 0);
     }
     #[inline]
     pub fn add_value(&mut self, value: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>) {
@@ -143,7 +143,7 @@ impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> hlsizeprefixedbufferBuilder<'a,
 impl core::fmt::Debug for hlsizeprefixedbuffer<'_> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("hlsizeprefixedbuffer");
-        ds.field("size", &self.size());
+        ds.field("size_", &self.size_());
         ds.field("value", &self.value());
         ds.finish()
     }