Add refcount shims for libc structs

Author: lucic71

libcc2rs/src/libc_shims/dirent.rs

@@ -0,0 +1,49 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use crate::{ByteRepr, Value};
+use std::cell::RefCell;
+use std::rc::Rc;
+
+pub struct dirent {
+    pub d_ino: Value<u64>,
+    pub d_off: Value<i64>,
+    pub d_reclen: Value<u16>,
+    pub d_type: Value<u8>,
+    pub d_name: Value<Box<[u8]>>,
+}
+
+impl Default for dirent {
+    fn default() -> Self {
+        Self {
+            d_ino: Rc::new(RefCell::new(0)),
+            d_off: Rc::new(RefCell::new(0)),
+            d_reclen: Rc::new(RefCell::new(0)),
+            d_type: Rc::new(RefCell::new(0)),
+            d_name: Rc::new(RefCell::new(vec![0u8; 256].into_boxed_slice())),
+        }
+    }
+}
+
+impl Clone for dirent {
+    fn clone(&self) -> Self {
+        Self {
+            d_ino: Rc::new(RefCell::new(*self.d_ino.borrow())),
+            d_off: Rc::new(RefCell::new(*self.d_off.borrow())),
+            d_reclen: Rc::new(RefCell::new(*self.d_reclen.borrow())),
+            d_type: Rc::new(RefCell::new(*self.d_type.borrow())),
+            d_name: Rc::new(RefCell::new(self.d_name.borrow().clone())),
+        }
+    }
+}
+
+impl ByteRepr for dirent {}
+
+pub struct CDir {
+    pub entries: Vec<(u64, Vec<u8>, u8)>,
+    pub pos: ::std::cell::Cell<usize>,
+}
+
+impl ByteRepr for CDir {}
+
+impl ByteRepr for ::libc::dirent {}

libcc2rs/src/libc_shims/ifaddrs.rs

@@ -0,0 +1,43 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use super::sockaddr;
+use crate::{ByteRepr, Ptr, Value};
+use std::cell::RefCell;
+use std::rc::Rc;
+
+pub struct ifaddrs {
+    pub ifa_next: Value<Ptr<ifaddrs>>,
+    pub ifa_name: Value<Ptr<u8>>,
+    pub ifa_flags: Value<u32>,
+    pub ifa_addr: Value<Ptr<sockaddr>>,
+    pub ifa_netmask: Value<Ptr<sockaddr>>,
+}
+
+impl Default for ifaddrs {
+    fn default() -> Self {
+        Self {
+            ifa_next: Rc::new(RefCell::new(Ptr::null())),
+            ifa_name: Rc::new(RefCell::new(Ptr::null())),
+            ifa_flags: Rc::new(RefCell::new(0)),
+            ifa_addr: Rc::new(RefCell::new(Ptr::null())),
+            ifa_netmask: Rc::new(RefCell::new(Ptr::null())),
+        }
+    }
+}
+
+impl Clone for ifaddrs {
+    fn clone(&self) -> Self {
+        Self {
+            ifa_next: Rc::new(RefCell::new(self.ifa_next.borrow().clone())),
+            ifa_name: Rc::new(RefCell::new(self.ifa_name.borrow().clone())),
+            ifa_flags: Rc::new(RefCell::new(*self.ifa_flags.borrow())),
+            ifa_addr: Rc::new(RefCell::new(self.ifa_addr.borrow().clone())),
+            ifa_netmask: Rc::new(RefCell::new(self.ifa_netmask.borrow().clone())),
+        }
+    }
+}
+
+impl ByteRepr for ifaddrs {}
+
+impl ByteRepr for ::libc::ifaddrs {}

libcc2rs/src/libc_shims/ip.rs

@@ -0,0 +1,76 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use crate::{AsPointer, ByteRepr, Ptr, Value};
+use std::cell::RefCell;
+use std::rc::Rc;
+
+#[derive(Default)]
+pub struct in_addr {
+    pub s_addr: Value<u32>,
+}
+
+pub struct in6_addr {
+    pub s6_addr: Value<Box<[u8]>>,
+}
+
+impl in6_addr {
+    pub fn s6_addr(&self) -> Ptr<u8> {
+        self.s6_addr.as_pointer()
+    }
+}
+
+impl Default for in6_addr {
+    fn default() -> Self {
+        Self {
+            s6_addr: Rc::new(RefCell::new(vec![0u8; 16].into_boxed_slice())),
+        }
+    }
+}
+
+impl Clone for in_addr {
+    fn clone(&self) -> Self {
+        Self {
+            s_addr: Rc::new(RefCell::new(*self.s_addr.borrow())),
+        }
+    }
+}
+
+impl Clone for in6_addr {
+    fn clone(&self) -> Self {
+        Self {
+            s6_addr: Rc::new(RefCell::new(self.s6_addr.borrow().clone())),
+        }
+    }
+}
+
+impl ByteRepr for in_addr {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.s_addr.borrow()).to_bytes(&mut buf[0..4]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            s_addr: Rc::new(RefCell::new(<u32>::from_bytes(&buf[0..4]))),
+        }
+    }
+}
+
+impl ByteRepr for in6_addr {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        buf[0..16].copy_from_slice(&self.s6_addr.borrow());
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            s6_addr: Rc::new(RefCell::new(buf[0..16].to_vec().into_boxed_slice())),
+        }
+    }
+}
+
+impl ByteRepr for ::libc::in_addr {}
+impl ByteRepr for ::libc::in6_addr {}

libcc2rs/src/libc_shims/mod.rs

@@ -0,0 +1,26 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#![allow(non_camel_case_types)]
+
+mod dirent;
+mod ifaddrs;
+mod ip;
+mod netdb;
+mod poll;
+mod pwd;
+mod socket;
+mod stat;
+mod termios;
+mod time;
+
+pub use dirent::*;
+pub use ifaddrs::*;
+pub use ip::*;
+pub use netdb::*;
+pub use poll::*;
+pub use pwd::*;
+pub use socket::*;
+pub use stat::*;
+pub use termios::*;
+pub use time::*;

libcc2rs/src/libc_shims/netdb.rs

@@ -0,0 +1,52 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use super::sockaddr;
+use crate::{ByteRepr, Ptr, Value};
+use std::cell::RefCell;
+use std::rc::Rc;
+
+pub struct addrinfo {
+    pub ai_flags: Value<i32>,
+    pub ai_family: Value<i32>,
+    pub ai_socktype: Value<i32>,
+    pub ai_protocol: Value<i32>,
+    pub ai_addrlen: Value<u32>,
+    pub ai_addr: Value<Ptr<sockaddr>>,
+    pub ai_canonname: Value<Ptr<u8>>,
+    pub ai_next: Value<Ptr<addrinfo>>,
+}
+
+impl Default for addrinfo {
+    fn default() -> Self {
+        Self {
+            ai_flags: Rc::new(RefCell::new(0)),
+            ai_family: Rc::new(RefCell::new(0)),
+            ai_socktype: Rc::new(RefCell::new(0)),
+            ai_protocol: Rc::new(RefCell::new(0)),
+            ai_addrlen: Rc::new(RefCell::new(0)),
+            ai_addr: Rc::new(RefCell::new(Ptr::null())),
+            ai_canonname: Rc::new(RefCell::new(Ptr::null())),
+            ai_next: Rc::new(RefCell::new(Ptr::null())),
+        }
+    }
+}
+
+impl Clone for addrinfo {
+    fn clone(&self) -> Self {
+        Self {
+            ai_flags: Rc::new(RefCell::new(*self.ai_flags.borrow())),
+            ai_family: Rc::new(RefCell::new(*self.ai_family.borrow())),
+            ai_socktype: Rc::new(RefCell::new(*self.ai_socktype.borrow())),
+            ai_protocol: Rc::new(RefCell::new(*self.ai_protocol.borrow())),
+            ai_addrlen: Rc::new(RefCell::new(*self.ai_addrlen.borrow())),
+            ai_addr: Rc::new(RefCell::new(self.ai_addr.borrow().clone())),
+            ai_canonname: Rc::new(RefCell::new(self.ai_canonname.borrow().clone())),
+            ai_next: Rc::new(RefCell::new(self.ai_next.borrow().clone())),
+        }
+    }
+}
+
+impl ByteRepr for addrinfo {}
+
+impl ByteRepr for ::libc::addrinfo {}

libcc2rs/src/libc_shims/poll.rs

@@ -0,0 +1,36 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use crate::{ByteRepr, Value};
+use std::cell::RefCell;
+use std::rc::Rc;
+
+pub struct pollfd {
+    pub fd: Value<i32>,
+    pub events: Value<i16>,
+    pub revents: Value<i16>,
+}
+
+impl Default for pollfd {
+    fn default() -> Self {
+        Self {
+            fd: Rc::new(RefCell::new(0)),
+            events: Rc::new(RefCell::new(0)),
+            revents: Rc::new(RefCell::new(0)),
+        }
+    }
+}
+
+impl Clone for pollfd {
+    fn clone(&self) -> Self {
+        Self {
+            fd: Rc::new(RefCell::new(*self.fd.borrow())),
+            events: Rc::new(RefCell::new(*self.events.borrow())),
+            revents: Rc::new(RefCell::new(*self.revents.borrow())),
+        }
+    }
+}
+
+impl ByteRepr for pollfd {}
+
+impl ByteRepr for ::libc::pollfd {}

libcc2rs/src/libc_shims/pwd.rs

@@ -0,0 +1,48 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use crate::{ByteRepr, Ptr, Value};
+use std::cell::RefCell;
+use std::rc::Rc;
+
+pub struct passwd {
+    pub pw_name: Value<Ptr<u8>>,
+    pub pw_passwd: Value<Ptr<u8>>,
+    pub pw_uid: Value<u32>,
+    pub pw_gid: Value<u32>,
+    pub pw_gecos: Value<Ptr<u8>>,
+    pub pw_dir: Value<Ptr<u8>>,
+    pub pw_shell: Value<Ptr<u8>>,
+}
+
+impl Default for passwd {
+    fn default() -> Self {
+        Self {
+            pw_name: Rc::new(RefCell::new(Ptr::null())),
+            pw_passwd: Rc::new(RefCell::new(Ptr::null())),
+            pw_uid: Rc::new(RefCell::new(0)),
+            pw_gid: Rc::new(RefCell::new(0)),
+            pw_gecos: Rc::new(RefCell::new(Ptr::null())),
+            pw_dir: Rc::new(RefCell::new(Ptr::null())),
+            pw_shell: Rc::new(RefCell::new(Ptr::null())),
+        }
+    }
+}
+
+impl Clone for passwd {
+    fn clone(&self) -> Self {
+        Self {
+            pw_name: Rc::new(RefCell::new(self.pw_name.borrow().clone())),
+            pw_passwd: Rc::new(RefCell::new(self.pw_passwd.borrow().clone())),
+            pw_uid: Rc::new(RefCell::new(*self.pw_uid.borrow())),
+            pw_gid: Rc::new(RefCell::new(*self.pw_gid.borrow())),
+            pw_gecos: Rc::new(RefCell::new(self.pw_gecos.borrow().clone())),
+            pw_dir: Rc::new(RefCell::new(self.pw_dir.borrow().clone())),
+            pw_shell: Rc::new(RefCell::new(self.pw_shell.borrow().clone())),
+        }
+    }
+}
+
+impl ByteRepr for passwd {}
+
+impl ByteRepr for ::libc::passwd {}