Add rules for libc structs

lucic71 · lucic71 · commit 6d4722504e53 · 2026-07-14T23:49:54.000+01:00
diff --git a/rules/dirent/src.cpp b/rules/dirent/src.cpp
@@ -4,6 +4,7 @@
 #include <dirent.h>
 
 using t1 = DIR *;
+using t2 = struct dirent;
 
 DIR *f1(const char *name) { return opendir(name); }
 
diff --git a/rules/dirent/tgt_unsafe.rs b/rules/dirent/tgt_unsafe.rs
@@ -5,6 +5,10 @@ fn t1() -> *mut ::libc::DIR {
     std::ptr::null_mut()
 }
 
+fn t2() -> ::libc::dirent {
+    unsafe { std::mem::zeroed() }
+}
+
 unsafe fn f1(a0: *const libc::c_char) -> *mut ::libc::DIR {
     libc::opendir(a0)
 }
diff --git a/rules/ifaddrs/src.cpp b/rules/ifaddrs/src.cpp
@@ -1,6 +1,8 @@
 #include <sys/types.h>
 #include <ifaddrs.h>
 
+typedef struct ifaddrs t1;
+
 int f1(struct ifaddrs **ifap) {
   return getifaddrs(ifap);
 }
diff --git a/rules/ifaddrs/tgt_unsafe.rs b/rules/ifaddrs/tgt_unsafe.rs
@@ -1,3 +1,7 @@
+fn t1() -> libc::ifaddrs {
+    unsafe { std::mem::zeroed() }
+}
+
 unsafe fn f1(a0: *mut *mut libc::ifaddrs) -> i32 {
     libc::getifaddrs(a0)
 }
diff --git a/rules/ip/src.cpp b/rules/ip/src.cpp
@@ -1,5 +1,10 @@
 #include <netinet/in.h>
 
+typedef struct sockaddr_in t1;
+typedef struct in_addr t2;
+typedef struct sockaddr_in6 t3;
+typedef struct in6_addr t4;
+
 int f1() {
   return IPPROTO_TCP;
 }
diff --git a/rules/ip/tgt_unsafe.rs b/rules/ip/tgt_unsafe.rs
@@ -1,3 +1,19 @@
+fn t1() -> ::libc::sockaddr_in {
+    unsafe { std::mem::zeroed() }
+}
+
+fn t2() -> ::libc::in_addr {
+    unsafe { std::mem::zeroed() }
+}
+
+fn t3() -> ::libc::sockaddr_in6 {
+    unsafe { std::mem::zeroed() }
+}
+
+fn t4() -> ::libc::in6_addr {
+    unsafe { std::mem::zeroed() }
+}
+
 unsafe fn f1() -> i32 {
     libc::IPPROTO_TCP
 }
diff --git a/rules/netdb/src.cpp b/rules/netdb/src.cpp
@@ -3,6 +3,8 @@
 
 #include <netdb.h>
 
+typedef struct addrinfo t1;
+
 int f1(const char *node, const char *service, const struct addrinfo *hints,
        struct addrinfo **res) {
   return getaddrinfo(node, service, hints, res);
diff --git a/rules/netdb/tgt_unsafe.rs b/rules/netdb/tgt_unsafe.rs
@@ -1,6 +1,10 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
+fn t1() -> ::libc::addrinfo {
+    unsafe { std::mem::zeroed() }
+}
+
 unsafe fn f1(
     a0: *const libc::c_char,
     a1: *const libc::c_char,
diff --git a/rules/poll/src.cpp b/rules/poll/src.cpp
@@ -3,6 +3,8 @@
 
 #include <poll.h>
 
+typedef struct pollfd t1;
+
 int f1(struct pollfd *fds, nfds_t nfds, int timeout) {
   return poll(fds, nfds, timeout);
 }
diff --git a/rules/poll/tgt_unsafe.rs b/rules/poll/tgt_unsafe.rs
@@ -1,6 +1,10 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
+fn t1() -> ::libc::pollfd {
+    unsafe { std::mem::zeroed() }
+}
+
 unsafe fn f1(a0: *mut ::libc::pollfd, a1: u64, a2: i32) -> i32 {
     libc::poll(a0, a1 as ::libc::nfds_t, a2)
 }
diff --git a/rules/pwd/src.cpp b/rules/pwd/src.cpp
@@ -3,6 +3,8 @@
 
 #include <pwd.h>
 
+typedef struct passwd t1;
+
 struct passwd *f1(uid_t uid) { return getpwuid(uid); }
 
 int f2(uid_t uid, struct passwd *pwd, char *buf, size_t buflen,
diff --git a/rules/pwd/tgt_unsafe.rs b/rules/pwd/tgt_unsafe.rs
@@ -1,6 +1,10 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
+fn t1() -> ::libc::passwd {
+    unsafe { std::mem::zeroed() }
+}
+
 unsafe fn f1(a0: u32) -> *mut ::libc::passwd {
     libc::getpwuid(a0)
 }
diff --git a/rules/socket/src.c b/rules/socket/src.c
@@ -1,8 +1,11 @@
 #define _GNU_SOURCE
 #include <sys/types.h>
 #include <sys/socket.h>
+#include <sys/un.h>
 
 typedef struct sockaddr t1;
+typedef struct sockaddr_storage t2;
+typedef struct sockaddr_un t3;
 
 int f1() {
   return MSG_NOSIGNAL;
diff --git a/rules/socket/tgt_unsafe.rs b/rules/socket/tgt_unsafe.rs
@@ -2,6 +2,14 @@ fn t1() -> libc::sockaddr {
     unsafe { std::mem::zeroed() }
 }
 
+fn t2() -> libc::sockaddr_storage {
+    unsafe { std::mem::zeroed() }
+}
+
+fn t3() -> libc::sockaddr_un {
+    unsafe { std::mem::zeroed() }
+}
+
 unsafe fn f1() -> i32 {
     libc::MSG_NOSIGNAL
 }
diff --git a/rules/stat/src.cpp b/rules/stat/src.cpp
@@ -3,6 +3,8 @@
 
 #include <sys/stat.h>
 
+typedef struct stat t1;
+
 int f1(const char *pathname, struct stat *statbuf) {
   return stat(pathname, statbuf);
 }
diff --git a/rules/stat/tgt_unsafe.rs b/rules/stat/tgt_unsafe.rs
@@ -1,6 +1,10 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
+fn t1() -> ::libc::stat {
+    unsafe { std::mem::zeroed() }
+}
+
 unsafe fn f1(a0: *const libc::c_char, a1: *mut ::libc::stat) -> i32 {
     libc::stat(a0, a1)
 }
diff --git a/rules/termios/src.cpp b/rules/termios/src.cpp
@@ -2,6 +2,10 @@
 // Distributed under the MIT license that can be found in the LICENSE file.
 
 #include <termios.h>
+#include <sys/ioctl.h>
+
+typedef struct termios t1;
+typedef struct winsize t2;
 
 int f1(int fd, int optional_actions, const struct termios *termios_p) {
   return tcsetattr(fd, optional_actions, termios_p);
diff --git a/rules/termios/tgt_unsafe.rs b/rules/termios/tgt_unsafe.rs
@@ -1,6 +1,14 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
+fn t1() -> ::libc::termios {
+    unsafe { std::mem::zeroed() }
+}
+
+fn t2() -> ::libc::winsize {
+    unsafe { std::mem::zeroed() }
+}
+
 unsafe fn f1(a0: i32, a1: i32, a2: *const ::libc::termios) -> i32 {
     libc::tcsetattr(a0, a1, a2)
 }
diff --git a/rules/time/src.c b/rules/time/src.c
@@ -4,6 +4,10 @@
 #include <sys/time.h>
 #include <time.h>
 
+typedef struct tm t1;
+typedef struct timeval t2;
+typedef struct timespec t3;
+
 time_t f1(time_t *t) { return time(t); }
 
 int f2(clockid_t clk_id, struct timespec *tp) {
diff --git a/rules/time/tgt_unsafe.rs b/rules/time/tgt_unsafe.rs
@@ -1,6 +1,18 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
+fn t1() -> ::libc::tm {
+    unsafe { std::mem::zeroed() }
+}
+
+fn t2() -> ::libc::timeval {
+    unsafe { std::mem::zeroed() }
+}
+
+fn t3() -> ::libc::timespec {
+    unsafe { std::mem::zeroed() }
+}
+
 unsafe fn f1(a0: *mut ::libc::time_t) -> ::libc::time_t {
     libc::time(a0)
 }
diff --git a/tests/unit/out/refcount/socket_transparent_union.rs b/tests/unit/out/refcount/socket_transparent_union.rs
@@ -0,0 +1,33 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let fd: Value<i32> = Rc::new(RefCell::new(0));
+    let ssloc: Value<libc::sockaddr_storage> = Rc::new(RefCell::new(unsafe { std::mem::zeroed() }));
+    let slen: Value<u32> = Rc::new(RefCell::new((128usize as u32)));
+    assert!(
+        ((({
+            let result: i32 = todo!("getsockname is not implemented yet");
+            result
+        } == -1_i32) as i32)
+            != 0)
+    );
+    let sin: Value<::libc::sockaddr_in> = Rc::new(RefCell::new(unsafe { std::mem::zeroed() }));
+    let inlen: Value<u32> = Rc::new(RefCell::new((16usize as u32)));
+    assert!(
+        ((({
+            let result: i32 = todo!("getsockname is not implemented yet");
+            result
+        } == -1_i32) as i32)
+            != 0)
+    );
+    return 0;
+}
diff --git a/tests/unit/out/unsafe/libc_char_ptr_field.rs b/tests/unit/out/unsafe/libc_char_ptr_field.rs
@@ -12,12 +12,12 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut pw: *mut passwd = libc::getpwuid(libc::geteuid());
+    let mut pw: *mut ::libc::passwd = libc::getpwuid(libc::geteuid());
     if !!(pw).is_null() {
         return 0;
     }
     let mut home: *mut libc::c_char = (*pw).pw_dir;
-    let mut d: *mut dirent =
+    let mut d: *mut ::libc::dirent =
         libc::readdir(libc::opendir((c"/tmp".as_ptr().cast_mut()).cast_const()));
     let mut dname: *mut libc::c_char = (*d).d_name.as_mut_ptr();
     return 0;
diff --git a/tests/unit/out/unsafe/libc_struct_without_default.rs b/tests/unit/out/unsafe/libc_struct_without_default.rs
@@ -38,24 +38,24 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut p: pollfd = unsafe { std::mem::zeroed::<pollfd>() };
+    let mut p: ::libc::pollfd = unsafe { std::mem::zeroed() };
     p.fd = -1_i32;
     p.events = 0_i16;
     p.revents = 2_i16;
     assert!(((p.fd) == (-1_i32)));
     assert!(((p.events as i32) == (0)));
     assert!(((p.revents as i32) == (2)));
-    let mut ia: in_addr = unsafe { std::mem::zeroed::<in_addr>() };
+    let mut ia: ::libc::in_addr = unsafe { std::mem::zeroed() };
     ia.s_addr = 1_u32;
     assert!(((ia.s_addr) == (1_u32)));
-    let mut t: tm = unsafe { std::mem::zeroed::<tm>() };
+    let mut t: ::libc::tm = unsafe { std::mem::zeroed() };
     t.tm_year = 124;
     t.tm_mon = 5;
     t.tm_mday = 15;
     assert!(((t.tm_year) == (124)));
     assert!(((t.tm_mon) == (5)));
     assert!(((t.tm_mday) == (15)));
-    let mut st: stat = unsafe { std::mem::zeroed::<stat>() };
+    let mut st: ::libc::stat = unsafe { std::mem::zeroed() };
     st.st_size = 1024_i64;
     assert!(((st.st_size) == (1024_i64)));
     let mut ud: UserDefined = <UserDefined>::default();
diff --git a/tests/unit/out/unsafe/socket_transparent_union.rs b/tests/unit/out/unsafe/socket_transparent_union.rs
@@ -13,22 +13,22 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut fd: i32 = 0;
-    let mut ssloc: sockaddr_storage = unsafe { std::mem::zeroed::<sockaddr_storage>() };
-    let mut slen: u32 = (::std::mem::size_of::<sockaddr_storage>() as u32);
+    let mut ssloc: libc::sockaddr_storage = unsafe { std::mem::zeroed() };
+    let mut slen: u32 = (::std::mem::size_of::<libc::sockaddr_storage>() as u32);
     assert!(
         ((((libc::getsockname(
             fd,
-            ((&mut ssloc as *mut sockaddr_storage) as *mut libc::sockaddr),
+            ((&mut ssloc as *mut libc::sockaddr_storage) as *mut libc::sockaddr),
             (&mut slen as *mut u32)
         )) == (-1_i32)) as i32)
             != 0)
     );
-    let mut sin: sockaddr_in = unsafe { std::mem::zeroed::<sockaddr_in>() };
-    let mut inlen: u32 = (::std::mem::size_of::<sockaddr_in>() as u32);
+    let mut sin: ::libc::sockaddr_in = unsafe { std::mem::zeroed() };
+    let mut inlen: u32 = (::std::mem::size_of::<::libc::sockaddr_in>() as u32);
     assert!(
         ((((libc::getsockname(
             fd,
-            ((&mut sin as *mut sockaddr_in) as *mut libc::sockaddr),
+            ((&mut sin as *mut ::libc::sockaddr_in) as *mut libc::sockaddr),
             (&mut inlen as *mut u32)
         )) == (-1_i32)) as i32)
             != 0)
diff --git a/tests/unit/out/unsafe/sys_stat.rs b/tests/unit/out/unsafe/sys_stat.rs
@@ -13,8 +13,8 @@ pub unsafe fn test_stat_0() {
     assert!((((!((fp).is_null())) as i32) != 0));
     libc::fputs((c"hello".as_ptr().cast_mut()).cast_const(), fp);
     assert!(((((libc::fclose(fp)) == (0)) as i32) != 0));
-    let mut st: stat = unsafe { std::mem::zeroed::<stat>() };
-    assert!(((((libc::stat(path, (&mut st as *mut stat))) == (0)) as i32) != 0));
+    let mut st: ::libc::stat = unsafe { std::mem::zeroed() };
+    assert!(((((libc::stat(path, (&mut st as *mut ::libc::stat))) == (0)) as i32) != 0));
     assert!(((((st.st_size) == (5_i64)) as i32) != 0));
     assert!(((((st.st_mtime) > (0_i64)) as i32) != 0));
     libc::unlink(path);
@@ -27,8 +27,8 @@ pub unsafe fn test_fstat_1() {
     libc::fputs((c"hello world".as_ptr().cast_mut()).cast_const(), fp);
     libc::fflush(fp);
     let mut fd: i32 = libc::fileno(fp);
-    let mut st: stat = unsafe { std::mem::zeroed::<stat>() };
-    assert!(((((libc::fstat(fd, (&mut st as *mut stat))) == (0)) as i32) != 0));
+    let mut st: ::libc::stat = unsafe { std::mem::zeroed() };
+    assert!(((((libc::fstat(fd, (&mut st as *mut ::libc::stat))) == (0)) as i32) != 0));
     assert!(((((st.st_size) == (11_i64)) as i32) != 0));
     assert!(((((st.st_mtime) > (0_i64)) as i32) != 0));
     assert!(((((libc::fclose(fp)) == (0)) as i32) != 0));
diff --git a/tests/unit/socket_transparent_union.c b/tests/unit/socket_transparent_union.c
@@ -1,4 +1,4 @@
-// no-compile: refcount
+// panic: refcount
 #define _GNU_SOURCE
 #include <assert.h>
 #include <netinet/in.h>

Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,10 @@ fn t1() -> *mut ::libc::DIR {`
`5`	`5`	`std::ptr::null_mut()`
`6`	`6`	`}`
`7`	`7`
	`8`	`+fn t2() -> ::libc::dirent {`
	`9`	`+ unsafe { std::mem::zeroed() }`
	`10`	`+}`
	`11`	`+`
`8`	`12`	`unsafe fn f1(a0: const libc::c_char) -> mut ::libc::DIR {`
`9`	`13`	`libc::opendir(a0)`
`10`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,8 @@`
`1`	`1`	`#include <sys/types.h>`
`2`	`2`	`#include <ifaddrs.h>`
`3`	`3`
	`4`	`+typedef struct ifaddrs t1;`
	`5`	`+`
`4`	`6`	`int f1(struct ifaddrs **ifap) {`
`5`	`7`	`return getifaddrs(ifap);`
`6`	`8`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,7 @@`
	`1`	`+fn t1() -> libc::ifaddrs {`
	`2`	`+ unsafe { std::mem::zeroed() }`
	`3`	`+}`
	`4`	`+`
`1`	`5`	`unsafe fn f1(a0: mut mut libc::ifaddrs) -> i32 {`
`2`	`6`	`libc::getifaddrs(a0)`
`3`	`7`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,8 @@`
`3`	`3`
`4`	`4`	`#include <poll.h>`
`5`	`5`
	`6`	`+typedef struct pollfd t1;`
	`7`	`+`
`6`	`8`	`int f1(struct pollfd *fds, nfds_t nfds, int timeout) {`
`7`	`9`	`return poll(fds, nfds, timeout);`
`8`	`10`	`}`