Fix event struct alignment issues

3 files changed, 39 insertions, 17 deletions

diff --git a/Cargo.lock b/Cargo.lock
index ffe5a42940..a7a7ff27c4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1147,6 +1147,15 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0ee1c47aaa256ecabcaea351eae4a9b01ef39ed810004e298d2511ed284b1525"
 
 [[package]]
+name = "memoffset"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "157b4208e3059a8f9e78d559edc658e13df41410cb3ae03979c83130067fdd87"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
 name = "miniz_oxide"
 version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -2540,6 +2549,7 @@ dependencies = [
  "lazy_static",
  "libc",
  "log",
+ "memoffset",
  "mnl",
  "netlink-packet-core",
  "netlink-packet-route",
diff --git a/talpid-core/Cargo.toml b/talpid-core/Cargo.toml
index 0635b5bcf6..1c60b5b66e 100644
--- a/talpid-core/Cargo.toml
+++ b/talpid-core/Cargo.toml
@@ -81,6 +81,7 @@ winreg = { version = "0.7", features = ["transactions"] }
 winapi = { version = "0.3.6", features = ["combaseapi", "handleapi", "ifdef", "libloaderapi", "netioapi", "psapi", "stringapiset", "synchapi", "winbase", "winioctl", "winuser"] }
 socket2 = "0.3"
 talpid-platform-metadata = { path = "../talpid-platform-metadata" }
+memoffset = "0.6"
 
 [build-dependencies]
 tonic-build = { version = "0.3", default-features = false, features = ["transport", "prost"] }
diff --git a/talpid-core/src/split_tunnel/windows/driver.rs b/talpid-core/src/split_tunnel/windows/driver.rs
index f0d87164a0..5b1187d259 100644
--- a/talpid-core/src/split_tunnel/windows/driver.rs
+++ b/talpid-core/src/split_tunnel/windows/driver.rs
@@ -2,6 +2,7 @@ use super::windows::{
     get_final_path_name, get_process_creation_time, get_process_device_path, open_process,
     ProcessAccess, ProcessSnapshot,
 };
+use memoffset::offset_of;
 use std::{
     cell::RefCell,
     collections::HashMap,
@@ -99,12 +100,12 @@ pub enum EventId {
 
 pub enum EventBody {
     SplittingEvent {
-        process_id: u32,
+        process_id: usize,
         reason: SplittingChangeReason,
         image: OsString,
     },
     SplittingError {
-        process_id: u32,
+        process_id: usize,
         image: OsString,
     },
     ErrorMessage {
@@ -536,25 +537,29 @@ fn serialize_process_tree(processes: Vec<ProcessInfo>) -> Result<Vec<u8>, io::Er
 struct EventHeader {
     event_id: EventId,
     event_size: usize,
+    event_data: [u8; 1],
 }
 
 #[repr(C)]
 struct SplittingEventHeader {
-    process_id: u32,
+    process_id: usize,
     reason: SplittingChangeReason,
     image_name_length: u16,
+    image_name_data: [u16; 1],
 }
 
 #[repr(C)]
 struct SplittingErrorEventHeader {
-    process_id: u32,
+    process_id: usize,
     image_name_length: u16,
+    image_name_data: [u16; 1],
 }
 
 #[repr(C)]
 struct ErrorMessageEventHeader {
     status: NTSTATUS,
     error_message_length: u16,
+    error_message_data: [u16; 1],
 }
 
 pub fn parse_event_buffer(buffer: &Vec<u8>) -> Option<(EventId, EventBody)> {
@@ -575,7 +580,7 @@ pub fn parse_event_buffer(buffer: &Vec<u8>) -> Option<(EventId, EventBody)> {
         ptr::copy_nonoverlapping(
             &buffer[0],
             &mut event_header as *mut _ as *mut u8,
-            mem::size_of_val(&event_header),
+            offset_of!(EventHeader, event_data),
         )
     };
 
@@ -584,9 +589,9 @@ pub fn parse_event_buffer(buffer: &Vec<u8>) -> Option<(EventId, EventBody)> {
             let mut event: SplittingEventHeader = unsafe { mem::zeroed() };
             unsafe {
                 ptr::copy_nonoverlapping(
-                    &buffer[mem::size_of_val(&event_header)],
+                    &buffer[offset_of!(EventHeader, event_data)],
                     &mut event as *mut _ as *mut u8,
-                    mem::size_of_val(&event),
+                    offset_of!(SplittingEventHeader, image_name_data),
                 )
             };
 
@@ -596,10 +601,12 @@ pub fn parse_event_buffer(buffer: &Vec<u8>) -> Option<(EventId, EventBody)> {
                 0u16,
             );
 
+            let string_byte_offset = offset_of!(EventHeader, event_data)
+                + offset_of!(SplittingEventHeader, image_name_data);
+
             unsafe {
                 ptr::copy_nonoverlapping(
-                    &buffer[mem::size_of_val(&event_header) + mem::size_of_val(&event)] as *const _
-                        as *const u16,
+                    &buffer[string_byte_offset] as *const _ as *const u16,
                     image_name.as_mut_ptr(),
                     image_name.len(),
                 )
@@ -618,9 +625,9 @@ pub fn parse_event_buffer(buffer: &Vec<u8>) -> Option<(EventId, EventBody)> {
             let mut event: SplittingErrorEventHeader = unsafe { mem::zeroed() };
             unsafe {
                 ptr::copy_nonoverlapping(
-                    &buffer[mem::size_of_val(&event_header)],
+                    &buffer[offset_of!(EventHeader, event_data)],
                     &mut event as *mut _ as *mut u8,
-                    mem::size_of_val(&event),
+                    offset_of!(SplittingErrorEventHeader, image_name_data),
                 )
             };
 
@@ -630,10 +637,12 @@ pub fn parse_event_buffer(buffer: &Vec<u8>) -> Option<(EventId, EventBody)> {
                 0u16,
             );
 
+            let string_byte_offset = offset_of!(EventHeader, event_data)
+                + offset_of!(SplittingErrorEventHeader, image_name_data);
+
             unsafe {
                 ptr::copy_nonoverlapping(
-                    &buffer[mem::size_of_val(&event_header) + mem::size_of_val(&event)] as *const _
-                        as *const u16,
+                    &buffer[string_byte_offset] as *const _ as *const u16,
                     image_name.as_mut_ptr(),
                     image_name.len(),
                 )
@@ -651,9 +660,9 @@ pub fn parse_event_buffer(buffer: &Vec<u8>) -> Option<(EventId, EventBody)> {
             let mut event: ErrorMessageEventHeader = unsafe { mem::zeroed() };
             unsafe {
                 ptr::copy_nonoverlapping(
-                    &buffer[mem::size_of_val(&event_header)],
+                    &buffer[offset_of!(EventHeader, event_data)],
                     &mut event as *mut _ as *mut u8,
-                    mem::size_of_val(&event),
+                    offset_of!(ErrorMessageEventHeader, error_message_data),
                 )
             };
 
@@ -663,10 +672,12 @@ pub fn parse_event_buffer(buffer: &Vec<u8>) -> Option<(EventId, EventBody)> {
                 0u16,
             );
 
+            let string_byte_offset = offset_of!(EventHeader, event_data)
+                + offset_of!(ErrorMessageEventHeader, error_message_data);
+
             unsafe {
                 ptr::copy_nonoverlapping(
-                    &buffer[mem::size_of_val(&event_header) + mem::size_of_val(&event)] as *const _
-                        as *const u16,
+                    &buffer[string_byte_offset] as *const _ as *const u16,
                     error_message.as_mut_ptr(),
                     error_message.len(),
                 )