fixes for linux system

Author: NICK

Cargo.toml

@@ -10,4 +10,5 @@ once_cell = "1.13.0"
 widestring = "1.0.2"
 native_macro = { path = "./macros" }
 derivative = "2.2.0"
-lazy_static = "1.4.0"
+lazy_static = "1.4.0"
+libc = "0.2.126"

macros/src/lib.rs

@@ -30,6 +30,8 @@ pub fn native_object(_args: TokenStream, input: TokenStream) -> TokenStream {
 
         #[allow(non_upper_case_globals)]
         static #base_done_vtable_name: IInitDoneBaseVTable<#ident> = IInitDoneBaseVTable {
+            #[cfg(target_os = "linux")]
+            offset_linux: 0,
             drop: {
                 unsafe extern "C" fn drop<T: IComponentBase>(_0: &mut T) {
 
@@ -64,6 +66,8 @@ pub fn native_object(_args: TokenStream, input: TokenStream) -> TokenStream {
 
         #[allow(non_upper_case_globals)]
         static #language_ext_vtable_name: ILanguageExtenderBaseVTable<#ident> = ILanguageExtenderBaseVTable {
+            #[cfg(target_os = "linux")]
+            offset_linux: 0,
             drop: {
                 unsafe extern "C" fn drop<T: IComponentBase>(_0: &mut T) {
 
@@ -203,6 +207,8 @@ pub fn native_object(_args: TokenStream, input: TokenStream) -> TokenStream {
 
         #[allow(non_upper_case_globals)]
         static #locale_vtable_name: LocaleBaseVTable<#ident> = LocaleBaseVTable {
+            #[cfg(target_os = "linux")]
+            offset_linux: 0,
             drop: {
                 unsafe extern "C" fn drop<T: IComponentBase>(_0: &mut T) {
 

src/component.rs

@@ -6,6 +6,8 @@ use crate::connector::IConnector;
 
 #[repr(C)]
 pub struct IInitDoneBaseVTable<T> {
+    #[cfg(target_os = "linux")]
+    pub offset_linux: u64,
     pub drop: unsafe extern "C" fn(&mut T),
     pub init: unsafe extern "C" fn(&mut T, *mut c_void) -> bool,
     pub set_mem_manager: unsafe extern "C" fn(&mut T, *mut c_void) -> bool,
@@ -15,6 +17,8 @@ pub struct IInitDoneBaseVTable<T> {
 
 #[repr(C)]
 pub struct ILanguageExtenderBaseVTable<T> {
+    #[cfg(target_os = "linux")]
+    pub offset_linux: u64,
     pub drop: unsafe extern "C" fn(&mut T),
     pub register_extension_as: unsafe extern "C" fn(&mut T, *mut *const u16) -> bool,
     pub get_n_props: unsafe extern "C" fn(&mut T) -> i64,
@@ -36,6 +40,8 @@ pub struct ILanguageExtenderBaseVTable<T> {
 
 #[repr(C)]
 pub struct LocaleBaseVTable<T> {
+    #[cfg(target_os = "linux")]
+    pub offset_linux: u64,
     pub drop: unsafe extern "C" fn(&mut T),
     pub set_locale: unsafe extern "C" fn(&mut T, *const u16)
 }

src/connector.rs

@@ -3,6 +3,7 @@ use std::ptr::NonNull;
 use widestring::U16CStr;
 use crate::memory::IMemoryManager;
 use crate::types::Variant;
+use crate::info::{AppInfo, IPlatformInfo};
 
 #[repr(u8)]
 enum Interface {
@@ -23,6 +24,8 @@ struct IMessageBox {
 
 #[repr(C)]
 struct IConnectorVTable {
+    #[cfg(target_os = "linux")]
+    pub offset_linux: u64,
     _drop: unsafe extern "C" fn(&mut IConnector),
     add_error: unsafe extern "C" fn(&mut IConnector, u16, *const u16, *const u16, i64) -> bool,
     read: unsafe extern "C" fn(&mut IConnector, *const u16, *const Variant, *mut u64, *const *const u16) -> bool,
@@ -139,4 +142,20 @@ impl IConnector {
             Err(())
         }
     }
+
+    #[must_use]
+    pub fn platform_info(&mut self) -> Result<AppInfo, ()> {
+        let interface = self.get_interface(Interface::IPlatformInfo);
+        if interface.is_null() {
+            return Err(())
+        }
+
+        let interface = unsafe { &mut *(interface as *mut IPlatformInfo) };
+        let result = unsafe { (interface.vtable.as_mut().get_platform_info)(interface) };
+        if result.is_null() {
+            return Err(())
+        }
+
+        Ok(AppInfo::from(unsafe { &*result }))
+    }
 }

src/info.rs

@@ -0,0 +1,72 @@
+use std::ptr::NonNull;
+use widestring::U16CStr;
+
+#[repr(C)]
+pub(crate) struct PlatformInfoVTable {
+    pub(crate) get_platform_info: unsafe extern "C" fn(&IPlatformInfo) -> *const AppInfoInner,
+}
+
+#[repr(C)]
+pub(crate) struct IPlatformInfo {
+    pub(crate) vtable: NonNull<PlatformInfoVTable>
+}
+
+#[repr(i8)]
+#[derive(Copy, Clone)]
+pub enum AppType {
+    AppUnknown = -1,
+    AppThinClient = 0,
+    AppThickClient = 1,
+    AppWebClient = 2,
+    AppServer = 3,
+    AppExtConn = 4,
+    AppMobileClient = 5,
+    AppMobileServer = 6,
+}
+
+#[repr(C)]
+pub(crate) struct AppInfoInner {
+    version: *const u16,
+    user_agent: *const u16,
+    application: AppType,
+}
+
+pub struct AppInfo {
+    version: String,
+    user_agent: String,
+    application: AppType,
+}
+
+impl AppInfo {
+    pub fn version(&self) -> &str {
+        self.version.as_str()
+    }
+
+    pub fn user_agent(&self) -> &str {
+        self.user_agent.as_str()
+    }
+
+    pub fn application(&self) -> AppType {
+        self.application
+    }
+}
+
+impl From<&AppInfoInner> for AppInfo {
+    fn from(value: &AppInfoInner) -> Self {
+        AppInfo {
+            version: {
+                match value.version.is_null() {
+                    true => String::new(),
+                    false => unsafe { U16CStr::from_ptr_str(value.version).to_string_lossy() }
+                }
+            },
+            user_agent: {
+                match value.user_agent.is_null() {
+                    true => String::new(),
+                    false => unsafe { U16CStr::from_ptr_str(value.user_agent).to_string_lossy() }
+                }
+            },
+            application: value.application
+        }
+    }
+}

src/lib.rs

@@ -1,4 +1,5 @@
 extern crate derivative;
+extern crate libc;
 
 pub use once_cell::sync::OnceCell;
 pub use derivative::Derivative;
@@ -10,4 +11,5 @@ pub mod component;
 pub mod types;
 pub mod memory;
 pub mod connector;
+pub mod info;
 

src/memory.rs

@@ -4,6 +4,8 @@ use std::ptr::NonNull;
 
 #[repr(C)]
 pub struct IMemoryManagerVTable {
+    #[cfg(target_os = "linux")]
+    offset_linux: u64,
     _drop: unsafe extern "C" fn(&mut IMemoryManager),
     _alloc_memory: unsafe extern "C" fn(&mut IMemoryManager, *mut *const c_void, usize) -> bool,
     _free_memory: unsafe extern "C" fn(&mut IMemoryManager, *mut *const c_void),

src/types.rs

@@ -1,6 +1,5 @@
-use core::ffi::c_char;
+use libc::{tm, c_char};
 use crate::component::IComponentInit;
-use crate::memory::IMemoryManager;
 
 #[allow(non_camel_case_types)]
 #[repr(u16)]
@@ -59,7 +58,8 @@ pub union VariantUnion {
     pvar_val: *const Variant,
     pwstr_val: (*const u16, u32),
     pstr_val: (*const c_char, u32),
-    nothing: [u8;34]
+    tm_val: tm,
+    //nothing: [u8;34]
 }
 
 #[repr(C)]
@@ -312,7 +312,7 @@ macro_rules! variant_from {
         impl From<$from> for Variant {
             fn from(value: $from) -> Self {
                 Self {
-                    value: VariantUnion { $field: value},
+                    value: VariantUnion { $field: value.into() },
                     cb_elements: 0,
                     vt: $vt
                 }
@@ -322,12 +322,12 @@ macro_rules! variant_from {
 }
 
 variant_from!(bool, b_val, VariableType::VTYPE_BOOL);
-variant_from!(u8, ui8val, VariableType::VTYPE_UI1);
-variant_from!(u16, ushort_val, VariableType::VTYPE_UI2);
-variant_from!(u32, ul_val, VariableType::VTYPE_UI4);
+variant_from!(u8, ull_val, VariableType::VTYPE_UI1);
+variant_from!(u16, ull_val, VariableType::VTYPE_UI2);
+variant_from!(u32, ull_val, VariableType::VTYPE_UI4);
 variant_from!(u64, ull_val, VariableType::VTYPE_UI8);
-variant_from!(i8, i8val, VariableType::VTYPE_I1);
-variant_from!(i16, short_val, VariableType::VTYPE_I2);
-variant_from!(i32, l_val, VariableType::VTYPE_I4);
+variant_from!(i8, ll_val, VariableType::VTYPE_I1);
+variant_from!(i16, ll_val, VariableType::VTYPE_I2);
+variant_from!(i32, ll_val, VariableType::VTYPE_I4);
 variant_from!(i64, ll_val, VariableType::VTYPE_I8);
 variant_from!(f64, dbl_val, VariableType::VTYPE_R8);