Merge branch 'unsafe_blocks-fcntl-fnmatch' into 'master'

Unsafe blocks: `fcntl.h`, `fnmatch.h`

See merge request redox-os/relibc!578

src/header/fcntl/mod.rs

@@ -1,5 +1,7 @@
 //! fcntl implementation for Redox, following http://pubs.opengroup.org/onlinepubs/7908799/xsh/fcntl.h.html
 
+#![deny(unsafe_op_in_unsafe_fn)]
+
 use crate::{
     c_str::CStr,
     error::ResultExt,
@@ -36,7 +38,7 @@ pub const F_TEST: c_int = 3;
 
 #[no_mangle]
 pub unsafe extern "C" fn creat(path: *const c_char, mode: mode_t) -> c_int {
-    open(path, O_WRONLY | O_CREAT | O_TRUNC, mode)
+    unsafe { open(path, O_WRONLY | O_CREAT | O_TRUNC, mode) }
 }
 #[repr(C)]
 #[derive(Clone, Copy, Default)]
@@ -51,7 +53,9 @@ pub struct flock {
 pub unsafe extern "C" fn fcntl(fildes: c_int, cmd: c_int, mut __valist: ...) -> c_int {
     // c_ulonglong
     let arg = match cmd {
-        F_DUPFD | F_SETFD | F_SETFL | F_SETLK | F_SETLKW | F_GETLK => __valist.arg::<c_ulonglong>(),
+        F_DUPFD | F_SETFD | F_SETFL | F_SETLK | F_SETLKW | F_GETLK => unsafe {
+            __valist.arg::<c_ulonglong>()
+        },
         _ => 0,
     };
 
@@ -63,12 +67,12 @@ pub unsafe extern "C" fn open(path: *const c_char, oflag: c_int, mut __valist: .
     let mode = if oflag & O_CREAT == O_CREAT
     /* || oflag & O_TMPFILE == O_TMPFILE */
     {
-        __valist.arg::<mode_t>()
+        unsafe { __valist.arg::<mode_t>() }
     } else {
         0
     };
 
-    let path = CStr::from_ptr(path);
+    let path = unsafe { CStr::from_ptr(path) };
     Sys::open(path, oflag, mode).or_minus_one_errno()
 }
 

src/header/fnmatch/mod.rs

@@ -1,5 +1,7 @@
 //! fnmatch implementation
 
+#![deny(unsafe_op_in_unsafe_fn)]
+
 use alloc::{borrow::Cow, vec::Vec};
 use core::slice;
 
@@ -41,21 +43,21 @@ unsafe fn tokenize(mut pattern: *const u8, flags: c_int) -> Vec<(Token, Range)>
     let mut tokens = Vec::new();
     let mut leading = true;
 
-    while *pattern != 0 {
+    while unsafe { *pattern != 0 } {
         let was_leading = leading;
         leading = false;
 
-        let c = *pattern;
-        pattern = pattern.offset(1);
+        let c = unsafe { *pattern };
+        pattern = unsafe { pattern.offset(1) };
 
         tokens.push(match c {
             b'\\' if flags & FNM_NOESCAPE == FNM_NOESCAPE => {
-                let c = *pattern;
+                let c = unsafe { *pattern };
                 if c == 0 {
                     // Trailing backslash. Maybe error here?
                     break;
                 }
-                pattern = pattern.offset(1);
+                pattern = unsafe { pattern.offset(1) };
                 leading = is_leading(flags, c);
                 (Token::Char(c), ONCE)
             }
@@ -63,24 +65,24 @@ unsafe fn tokenize(mut pattern: *const u8, flags: c_int) -> Vec<(Token, Range)>
             b'*' => (any(was_leading, flags), Range(0, None)),
             b'[' => {
                 let mut list: Vec<Collation> = Vec::new();
-                let invert = if *pattern == b'!' {
-                    pattern = pattern.offset(1);
+                let invert = if unsafe { *pattern == b'!' } {
+                    pattern = unsafe { pattern.offset(1) };
                     true
                 } else {
                     false
                 };
 
                 loop {
-                    let mut c = *pattern;
+                    let mut c = unsafe { *pattern };
                     if c == 0 {
                         break;
                     }
-                    pattern = pattern.offset(1);
+                    pattern = unsafe { pattern.offset(1) };
                     match c {
                         b']' => break,
                         b'\\' => {
-                            c = *pattern;
-                            pattern = pattern.offset(1);
+                            c = unsafe { *pattern };
+                            pattern = unsafe { pattern.offset(1) };
                             if c == 0 {
                                 // Trailing backslash. Maybe error?
                                 break;
@@ -88,9 +90,9 @@ unsafe fn tokenize(mut pattern: *const u8, flags: c_int) -> Vec<(Token, Range)>
                         }
                         _ => (),
                     }
-                    if *pattern == b'-' && *pattern.offset(1) != 0 {
-                        let end = *pattern.offset(1);
-                        pattern = pattern.offset(2);
+                    if unsafe { *pattern == b'-' && *pattern.offset(1) != 0 } {
+                        let end = unsafe { *pattern.offset(1) };
+                        pattern = unsafe { pattern.offset(2) };
                         for c in c..=end {
                             if can_push(was_leading, flags, c) {
                                 list.push(Collation::Char(c));
@@ -121,12 +123,12 @@ pub unsafe extern "C" fn fnmatch(
     flags: c_int,
 ) -> c_int {
     let mut len = 0;
-    while *input.offset(len) != 0 {
+    while unsafe { *input.offset(len) != 0 } {
         len += 1;
     }
-    let input = slice::from_raw_parts(input as *const u8, len as usize);
+    let input = unsafe { slice::from_raw_parts(input as *const u8, len as usize) };
 
-    let mut tokens = tokenize(pattern as *const u8, flags);
+    let mut tokens = unsafe { tokenize(pattern as *const u8, flags) };
     tokens.push((Token::End, ONCE));
 
     if PosixRegex::new(Cow::Owned(vec![tokens]))