Add fd UB tests

Author: lucic71

tests/ub/fd_close_invalid.c

@@ -0,0 +1,4 @@
+// panic-ub: refcount
+#include <unistd.h>
+
+int main(void) { return close(1234) == -1 ? 0 : 1; }

tests/ub/fd_double_close.c

@@ -0,0 +1,9 @@
+// panic-ub: refcount
+#include <fcntl.h>
+#include <unistd.h>
+
+int main(void) {
+  int fd = open("/dev/null", O_RDONLY);
+  close(fd);
+  return close(fd) == -1 ? 0 : 1;
+}

tests/ub/fd_use_after_close.c

@@ -0,0 +1,11 @@
+// panic-ub: refcount
+#include <fcntl.h>
+#include <unistd.h>
+
+int main(void) {
+  int fd = open("/dev/null", O_RDONLY);
+  close(fd);
+  char buf[4];
+  ssize_t n = read(fd, buf, sizeof(buf));
+  return n == -1 ? 0 : 1;
+}

tests/ub/out/refcount/fd_close_invalid.rs

@@ -0,0 +1,18 @@
+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 {
+    return if (((FdRegistry::close(1234) == -1_i32) as i32) != 0) {
+        0
+    } else {
+        1
+    };
+}

tests/ub/out/refcount/fd_double_close.rs

@@ -0,0 +1,38 @@
+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({
+        let __mode = match &[].first() {
+            Some(__m) => nix::sys::stat::Mode::from_bits_truncate(i32::get(__m) as ::libc::mode_t),
+            None => nix::sys::stat::Mode::empty(),
+        };
+        match nix::fcntl::open(
+            Ptr::from_string_literal(b"/dev/null")
+                .to_rust_string()
+                .as_str(),
+            nix::fcntl::OFlag::from_bits_retain(0),
+            __mode,
+        ) {
+            Ok(__ofd) => FdRegistry::register(__ofd),
+            Err(__e) => {
+                libcc2rs::cpp2rust_errno().write(__e as i32);
+                -1
+            }
+        }
+    }));
+    FdRegistry::close((*fd.borrow()));
+    return if (((FdRegistry::close((*fd.borrow())) == -1_i32) as i32) != 0) {
+        0
+    } else {
+        1
+    };
+}

tests/ub/out/refcount/fd_use_after_close.rs

@@ -0,0 +1,57 @@
+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({
+        let __mode = match &[].first() {
+            Some(__m) => nix::sys::stat::Mode::from_bits_truncate(i32::get(__m) as ::libc::mode_t),
+            None => nix::sys::stat::Mode::empty(),
+        };
+        match nix::fcntl::open(
+            Ptr::from_string_literal(b"/dev/null")
+                .to_rust_string()
+                .as_str(),
+            nix::fcntl::OFlag::from_bits_retain(0),
+            __mode,
+        ) {
+            Ok(__ofd) => FdRegistry::register(__ofd),
+            Err(__e) => {
+                libcc2rs::cpp2rust_errno().write(__e as i32);
+                -1
+            }
+        }
+    }));
+    FdRegistry::close((*fd.borrow()));
+    let buf: Value<Box<[u8]>> = Rc::new(RefCell::new(
+        (0..4).map(|_| <u8>::default()).collect::<Box<[u8]>>(),
+    ));
+    let n: Value<isize> = Rc::new(RefCell::new(
+        match FdRegistry::with_fd((*fd.borrow()), |__fd| {
+            ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>)
+                .to_any()
+                .reinterpret_cast::<u8>()
+                .with_slice_mut(::std::mem::size_of::<[u8; 4]>(), |__buf| {
+                    nix::unistd::read(__fd, __buf)
+                })
+        }) {
+            Ok(__n) => __n as isize,
+            Err(__e) => {
+                libcc2rs::cpp2rust_errno().write(__e as i32);
+                -1
+            }
+        },
+    ));
+    return if ((((*n.borrow()) == (-1_i32 as isize)) as i32) != 0) {
+        0
+    } else {
+        1
+    };
+}

tests/ub/out/unsafe/fd_close_invalid.rs

@@ -0,0 +1,20 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::collections::BTreeMap;
+use std::io::{Read, Seek, Write};
+use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
+use std::rc::Rc;
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    return if ((((libc::close(1234)) == (-1_i32)) as i32) != 0) {
+        0
+    } else {
+        1
+    };
+}

tests/ub/out/unsafe/fd_double_close.rs

@@ -0,0 +1,27 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::collections::BTreeMap;
+use std::io::{Read, Seek, Write};
+use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
+use std::rc::Rc;
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut fd: i32 = (unsafe {
+        libc::open(
+            (c"/dev/null".as_ptr().cast_mut()).cast_const() as *const i8,
+            0 as i32,
+        )
+    });
+    libc::close(fd);
+    return if ((((libc::close(fd)) == (-1_i32)) as i32) != 0) {
+        0
+    } else {
+        1
+    };
+}

tests/ub/out/unsafe/fd_use_after_close.rs

@@ -0,0 +1,33 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::collections::BTreeMap;
+use std::io::{Read, Seek, Write};
+use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
+use std::rc::Rc;
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut fd: i32 = (unsafe {
+        libc::open(
+            (c"/dev/null".as_ptr().cast_mut()).cast_const() as *const i8,
+            0 as i32,
+        )
+    });
+    libc::close(fd);
+    let mut buf: [libc::c_char; 4] = [(0 as libc::c_char); 4];
+    let mut n: isize = libc::read(
+        fd,
+        (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void),
+        ::std::mem::size_of::<[libc::c_char; 4]>(),
+    );
+    return if ((((n) == (-1_i32 as isize)) as i32) != 0) {
+        0
+    } else {
+        1
+    };
+}