Add more string rules

Author: lucic71

rules/cstring/ir_unsafe.json

@@ -1,7 +1,9 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
+#define _GNU_SOURCE
 #include <string.h>
+#include <strings.h>
 
 void *f1(void *dst, const void *src, size_t n) { return memcpy(dst, src, n); }
 
@@ -24,3 +26,15 @@ void *f10(const void *a0, int a1, size_t a2) { return memchr(a0, a1, a2); }
 char *f11(const char *a0, int a1) { return strrchr(a0, a1); }
 
 char *f15(const char *a0) { return strdup(a0); }
+
+size_t f16(const char *a0, const char *a1) { return strcspn(a0, a1); }
+
+size_t f17(const char *a0, const char *a1) { return strspn(a0, a1); }
+
+char *f18(const char *a0, const char *a1) { return strstr(a0, a1); }
+
+char *f21(const char *a0, const char *a1) { return strpbrk(a0, a1); }
+
+void *f24(const void *a0, int a1, size_t a2) { return memrchr(a0, a1, a2); }
+
+int f27(const char *a0, const char *a1) { return strcasecmp(a0, a1); }

rules/cstring/src.c

@@ -1,6 +1,25 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
+#define _GNU_SOURCE
 #include <string.h>
 
 const char *f6(const char *a0, int a1) { return strchr(a0, a1); }
+
+const void *f12(const void *a0, int a1, size_t a2) { return memchr(a0, a1, a2); }
+
+const char *f13(const char *a0, int a1) { return strrchr(a0, a1); }
+
+char *f14(char *a0, int a1) { return strrchr(a0, a1); }
+
+const char *f19(const char *a0, const char *a1) { return strstr(a0, a1); }
+
+char *f20(char *a0, const char *a1) { return strstr(a0, a1); }
+
+const char *f22(const char *a0, const char *a1) { return strpbrk(a0, a1); }
+
+char *f23(char *a0, const char *a1) { return strpbrk(a0, a1); }
+
+const void *f25(const void *a0, int a1, size_t a2) { return memrchr(a0, a1, a2); }
+
+void *f26(void *a0, int a1, size_t a2) { return memrchr(a0, a1, a2); }

rules/cstring/src.cpp

@@ -79,3 +79,51 @@ unsafe fn f14(a0: *mut u8, a1: i32) -> *mut u8 {
 unsafe fn f15(a0: *const u8) -> *mut u8 {
     libc::strdup(a0 as *const i8) as *mut u8
 }
+
+unsafe fn f16(a0: *const u8, a1: *const u8) -> u64 {
+    libc::strcspn(a0 as *const i8, a1 as *const i8) as u64
+}
+
+unsafe fn f17(a0: *const u8, a1: *const u8) -> u64 {
+    libc::strspn(a0 as *const i8, a1 as *const i8) as u64
+}
+
+unsafe fn f18(a0: *const u8, a1: *const u8) -> *mut u8 {
+    libc::strstr(a0 as *const i8, a1 as *const i8) as *mut u8
+}
+
+unsafe fn f19(a0: *const u8, a1: *const u8) -> *const u8 {
+    libc::strstr(a0 as *const i8, a1 as *const i8) as *const u8
+}
+
+unsafe fn f20(a0: *mut u8, a1: *const u8) -> *mut u8 {
+    libc::strstr(a0 as *const i8, a1 as *const i8) as *mut u8
+}
+
+unsafe fn f21(a0: *const u8, a1: *const u8) -> *mut u8 {
+    libc::strpbrk(a0 as *const i8, a1 as *const i8) as *mut u8
+}
+
+unsafe fn f22(a0: *const u8, a1: *const u8) -> *const u8 {
+    libc::strpbrk(a0 as *const i8, a1 as *const i8) as *const u8
+}
+
+unsafe fn f23(a0: *mut u8, a1: *const u8) -> *mut u8 {
+    libc::strpbrk(a0 as *const i8, a1 as *const i8) as *mut u8
+}
+
+unsafe fn f24(a0: *const u8, a1: i32, a2: usize) -> *mut ::libc::c_void {
+    libc::memrchr(a0 as *const ::libc::c_void, a1, a2 as usize)
+}
+
+unsafe fn f25(a0: *const u8, a1: i32, a2: usize) -> *const ::libc::c_void {
+    libc::memrchr(a0 as *const ::libc::c_void, a1, a2 as usize) as *const ::libc::c_void
+}
+
+unsafe fn f26(a0: *mut u8, a1: i32, a2: usize) -> *mut ::libc::c_void {
+    libc::memrchr(a0 as *const ::libc::c_void, a1, a2 as usize)
+}
+
+unsafe fn f27(a0: *const u8, a1: *const u8) -> i32 {
+    libc::strcasecmp(a0 as *const i8, a1 as *const i8)
+}

rules/cstring/tgt_unsafe.rs

@@ -1,7 +1,9 @@
 // no-compile: refcount
+#define _GNU_SOURCE
 #include <cassert>
 #include <cstdlib>
 #include <cstring>
+#include <strings.h>
 
 static void test_memcpy() {
   const char src[] = "hello";
@@ -113,6 +115,63 @@ static void test_strdup() {
   std::free(d3);
 }
 
+static void test_strcspn() {
+  assert(std::strcspn("hello", "el") == 1);
+  assert(std::strcspn("abc", "xyz") == 3);
+  assert(std::strcspn("", "abc") == 0);
+  const char *s = "hello";
+  const char *rej = "el";
+  assert(std::strcspn(s, rej) == 1);
+}
+
+static void test_strspn() {
+  assert(std::strspn("hello", "hel") == 4);
+  assert(std::strspn("abc", "xyz") == 0);
+  assert(std::strspn("aaa", "a") == 3);
+  const char *s = "hello";
+  const char *acc = "hel";
+  assert(std::strspn(s, acc) == 4);
+}
+
+static void test_strstr() {
+  const char *h = "hello world";
+  const char *r = std::strstr(h, "world");
+  assert(r != nullptr);
+  assert(r == h + 6);
+  assert(std::strstr(h, "xyz") == nullptr);
+  char buf[] = {'h', 'e', 'l', 'l', 'o', '\0'};
+  assert(std::strstr(buf, "ll") == &buf[2]);
+}
+
+static void test_strpbrk() {
+  const char *s = "hello world";
+  const char *r = std::strpbrk(s, "wo");
+  assert(r != nullptr);
+  assert(r == s + 4);
+  assert(std::strpbrk(s, "xyz") == nullptr);
+  char buf[] = {'a', 'b', 'c', '\0'};
+  assert(std::strpbrk(buf, "b") == &buf[1]);
+}
+
+static void test_memrchr() {
+  const char data[] = {1, 2, 3, 2, 4};
+  const void *r = memrchr(data, 2, 5);
+  assert(r == &data[3]);
+  assert(memrchr(data, 99, 5) == nullptr);
+  const void *p = data;
+  std::size_t n = 5;
+  assert(memrchr(p, 1, n) == p);
+}
+
+static void test_strcasecmp() {
+  assert(strcasecmp("HELLO", "hello") == 0);
+  assert(strcasecmp("abc", "abd") < 0);
+  assert(strcasecmp("abd", "abc") > 0);
+  const char *p = "FOO";
+  const char *q = "foo";
+  assert(strcasecmp(p, q) == 0);
+}
+
 int main() {
   test_memcpy();
   test_memset();
@@ -125,5 +184,11 @@ int main() {
   test_memchr();
   test_strrchr();
   test_strdup();
+  test_strcspn();
+  test_strspn();
+  test_strstr();
+  test_strpbrk();
+  test_memrchr();
+  test_strcasecmp();
   return 0;
 }

tests/unit/cstring.cpp

@@ -292,6 +292,129 @@ pub unsafe fn test_strdup_10() {
     );
     libc::free((d3 as *mut u8 as *mut ::libc::c_void));
 }
+pub unsafe fn test_strcspn_11() {
+    assert!(
+        ((libc::strcspn(
+            b"hello\0".as_ptr() as *const i8,
+            b"el\0".as_ptr() as *const i8
+        ) as u64)
+            == (1_u64))
+    );
+    assert!(
+        ((libc::strcspn(
+            b"abc\0".as_ptr() as *const i8,
+            b"xyz\0".as_ptr() as *const i8
+        ) as u64)
+            == (3_u64))
+    );
+    assert!(
+        ((libc::strcspn(b"\0".as_ptr() as *const i8, b"abc\0".as_ptr() as *const i8) as u64)
+            == (0_u64))
+    );
+    let mut s: *const u8 = b"hello\0".as_ptr();
+    let mut rej: *const u8 = b"el\0".as_ptr();
+    assert!(((libc::strcspn(s as *const i8, rej as *const i8) as u64) == (1_u64)));
+}
+pub unsafe fn test_strspn_12() {
+    assert!(
+        ((libc::strspn(
+            b"hello\0".as_ptr() as *const i8,
+            b"hel\0".as_ptr() as *const i8
+        ) as u64)
+            == (4_u64))
+    );
+    assert!(
+        ((libc::strspn(
+            b"abc\0".as_ptr() as *const i8,
+            b"xyz\0".as_ptr() as *const i8
+        ) as u64)
+            == (0_u64))
+    );
+    assert!(
+        ((libc::strspn(b"aaa\0".as_ptr() as *const i8, b"a\0".as_ptr() as *const i8) as u64)
+            == (3_u64))
+    );
+    let mut s: *const u8 = b"hello\0".as_ptr();
+    let mut acc: *const u8 = b"hel\0".as_ptr();
+    assert!(((libc::strspn(s as *const i8, acc as *const i8) as u64) == (4_u64)));
+}
+pub unsafe fn test_strstr_13() {
+    let mut h: *const u8 = b"hello world\0".as_ptr();
+    let mut r: *const u8 =
+        libc::strstr(h as *const i8, b"world\0".as_ptr() as *const i8) as *const u8;
+    assert!(!((r).is_null()));
+    assert!(((r) == (h.offset((6) as isize))));
+    assert!((libc::strstr(h as *const i8, b"xyz\0".as_ptr() as *const i8) as *const u8).is_null());
+    let mut buf: [u8; 6] = [
+        ('h' as u8),
+        ('e' as u8),
+        ('l' as u8),
+        ('l' as u8),
+        ('o' as u8),
+        ('\0' as u8),
+    ];
+    assert!(
+        ((libc::strstr(buf.as_mut_ptr() as *const i8, b"ll\0".as_ptr() as *const i8) as *mut u8)
+            == (&mut buf[(2) as usize] as *mut u8))
+    );
+}
+pub unsafe fn test_strpbrk_14() {
+    let mut s: *const u8 = b"hello world\0".as_ptr();
+    let mut r: *const u8 =
+        libc::strpbrk(s as *const i8, b"wo\0".as_ptr() as *const i8) as *const u8;
+    assert!(!((r).is_null()));
+    assert!(((r) == (s.offset((4) as isize))));
+    assert!((libc::strpbrk(s as *const i8, b"xyz\0".as_ptr() as *const i8) as *const u8).is_null());
+    let mut buf: [u8; 4] = [('a' as u8), ('b' as u8), ('c' as u8), ('\0' as u8)];
+    assert!(
+        ((libc::strpbrk(buf.as_mut_ptr() as *const i8, b"b\0".as_ptr() as *const i8) as *mut u8)
+            == (&mut buf[(1) as usize] as *mut u8))
+    );
+}
+pub unsafe fn test_memrchr_15() {
+    let data: [u8; 5] = [1_u8, 2_u8, 3_u8, 2_u8, 4_u8];
+    let mut r: *const ::libc::c_void = libc::memrchr(
+        (data.as_ptr() as *const u8 as *const ::libc::c_void) as *const ::libc::c_void,
+        2,
+        5_u64 as usize,
+    ) as *const ::libc::c_void;
+    assert!(((r) == ((&data[(3) as usize] as *const u8) as *const u8 as *const ::libc::c_void)));
+    assert!((libc::memrchr(
+        (data.as_ptr() as *const u8 as *const ::libc::c_void) as *const ::libc::c_void,
+        99,
+        5_u64 as usize
+    ) as *const ::libc::c_void)
+        .is_null());
+    let mut p: *const ::libc::c_void = (data.as_ptr() as *const u8 as *const ::libc::c_void);
+    let mut n: u64 = 5_u64;
+    assert!(
+        ((libc::memrchr(p as *const ::libc::c_void, 1, n as usize) as *const ::libc::c_void)
+            == (p))
+    );
+}
+pub unsafe fn test_strcasecmp_16() {
+    assert!(
+        ((libc::strcasecmp(
+            b"HELLO\0".as_ptr() as *const i8,
+            b"hello\0".as_ptr() as *const i8
+        )) == (0))
+    );
+    assert!(
+        ((libc::strcasecmp(
+            b"abc\0".as_ptr() as *const i8,
+            b"abd\0".as_ptr() as *const i8
+        )) < (0))
+    );
+    assert!(
+        ((libc::strcasecmp(
+            b"abd\0".as_ptr() as *const i8,
+            b"abc\0".as_ptr() as *const i8
+        )) > (0))
+    );
+    let mut p: *const u8 = b"FOO\0".as_ptr();
+    let mut q: *const u8 = b"foo\0".as_ptr();
+    assert!(((libc::strcasecmp(p as *const i8, q as *const i8)) == (0)));
+}
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
@@ -309,5 +432,11 @@ unsafe fn main_0() -> i32 {
     (unsafe { test_memchr_8() });
     (unsafe { test_strrchr_9() });
     (unsafe { test_strdup_10() });
+    (unsafe { test_strcspn_11() });
+    (unsafe { test_strspn_12() });
+    (unsafe { test_strstr_13() });
+    (unsafe { test_strpbrk_14() });
+    (unsafe { test_memrchr_15() });
+    (unsafe { test_strcasecmp_16() });
     return 0;
 }