1 //===-- sanitizer_libc_test.cc --------------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 // Tests for sanitizer_libc.h.
10 //===----------------------------------------------------------------------===//
11
12 #include "sanitizer_common/sanitizer_common.h"
13 #include "sanitizer_common/sanitizer_libc.h"
14 #include "sanitizer_common/sanitizer_platform.h"
15 #include "gtest/gtest.h"
16
17 #if SANITIZER_LINUX || SANITIZER_MAC
18 # define SANITIZER_TEST_HAS_STAT_H 1
19 # include <sys/stat.h>
20 # include "sanitizer_common/sanitizer_posix.h"
21 #else
22 # define SANITIZER_TEST_HAS_STAT_H 0
23 #endif
24
25 // A regression test for internal_memmove() implementation.
TEST(SanitizerCommon,InternalMemmoveRegression)26 TEST(SanitizerCommon, InternalMemmoveRegression) {
27 char src[] = "Hello World";
28 char *dest = src + 6;
29 __sanitizer::internal_memmove(dest, src, 5);
30 EXPECT_EQ(dest[0], src[0]);
31 EXPECT_EQ(dest[4], src[4]);
32 }
33
TEST(SanitizerCommon,mem_is_zero)34 TEST(SanitizerCommon, mem_is_zero) {
35 size_t size = 128;
36 char *x = new char[size];
37 memset(x, 0, size);
38 for (size_t pos = 0; pos < size; pos++) {
39 x[pos] = 1;
40 for (size_t beg = 0; beg < size; beg++) {
41 for (size_t end = beg; end < size; end++) {
42 // fprintf(stderr, "pos %zd beg %zd end %zd \n", pos, beg, end);
43 if (beg <= pos && pos < end)
44 EXPECT_FALSE(__sanitizer::mem_is_zero(x + beg, end - beg));
45 else
46 EXPECT_TRUE(__sanitizer::mem_is_zero(x + beg, end - beg));
47 }
48 }
49 x[pos] = 0;
50 }
51 delete [] x;
52 }
53
54 struct stat_and_more {
55 struct stat st;
56 unsigned char z;
57 };
58
temp_file_name(char * buf,size_t bufsize,const char * prefix)59 static void temp_file_name(char *buf, size_t bufsize, const char *prefix) {
60 const char *tmpdir = "/tmp";
61 #if SANITIZER_ANDROID
62 // I don't know a way to query temp directory location on Android without
63 // going through Java interfaces. The code below is not ideal, but should
64 // work. May require "adb root", but it is needed for almost any use of ASan
65 // on Android already.
66 tmpdir = GetEnv("EXTERNAL_STORAGE");
67 #endif
68 u32 uid = GetUid();
69 internal_snprintf(buf, bufsize, "%s/%s%d", tmpdir, prefix, uid);
70 }
71
72 // FIXME: File manipulations are not yet supported on Windows
73 #if !defined(_WIN32)
TEST(SanitizerCommon,FileOps)74 TEST(SanitizerCommon, FileOps) {
75 const char *str1 = "qwerty";
76 uptr len1 = internal_strlen(str1);
77 const char *str2 = "zxcv";
78 uptr len2 = internal_strlen(str2);
79
80 char tmpfile[128];
81 temp_file_name(tmpfile, sizeof(tmpfile), "sanitizer_common.fileops.tmp.");
82 fd_t fd = OpenFile(tmpfile, WrOnly);
83 ASSERT_NE(fd, kInvalidFd);
84 EXPECT_EQ(len1, internal_write(fd, str1, len1));
85 EXPECT_EQ(len2, internal_write(fd, str2, len2));
86 CloseFile(fd);
87
88 fd = OpenFile(tmpfile, RdOnly);
89 ASSERT_NE(fd, kInvalidFd);
90 uptr fsize = internal_filesize(fd);
91 EXPECT_EQ(len1 + len2, fsize);
92
93 #if SANITIZER_TEST_HAS_STAT_H
94 struct stat st1, st2, st3;
95 EXPECT_EQ(0u, internal_stat(tmpfile, &st1));
96 EXPECT_EQ(0u, internal_lstat(tmpfile, &st2));
97 EXPECT_EQ(0u, internal_fstat(fd, &st3));
98 EXPECT_EQ(fsize, (uptr)st3.st_size);
99
100 // Verify that internal_fstat does not write beyond the end of the supplied
101 // buffer.
102 struct stat_and_more sam;
103 memset(&sam, 0xAB, sizeof(sam));
104 EXPECT_EQ(0u, internal_fstat(fd, &sam.st));
105 EXPECT_EQ(0xAB, sam.z);
106 EXPECT_NE(0xAB, sam.st.st_size);
107 EXPECT_NE(0, sam.st.st_size);
108 #endif
109
110 char buf[64] = {};
111 EXPECT_EQ(len1, internal_read(fd, buf, len1));
112 EXPECT_EQ(0, internal_memcmp(buf, str1, len1));
113 EXPECT_EQ((char)0, buf[len1 + 1]);
114 internal_memset(buf, 0, len1);
115 EXPECT_EQ(len2, internal_read(fd, buf, len2));
116 EXPECT_EQ(0, internal_memcmp(buf, str2, len2));
117 CloseFile(fd);
118 internal_unlink(tmpfile);
119 }
120 #endif
121
TEST(SanitizerCommon,InternalStrFunctions)122 TEST(SanitizerCommon, InternalStrFunctions) {
123 const char *haystack = "haystack";
124 EXPECT_EQ(haystack + 2, internal_strchr(haystack, 'y'));
125 EXPECT_EQ(haystack + 2, internal_strchrnul(haystack, 'y'));
126 EXPECT_EQ(0, internal_strchr(haystack, 'z'));
127 EXPECT_EQ(haystack + 8, internal_strchrnul(haystack, 'z'));
128 }
129
130 // FIXME: File manipulations are not yet supported on Windows
131 #if !defined(_WIN32) && !SANITIZER_MAC
TEST(SanitizerCommon,InternalMmapWithOffset)132 TEST(SanitizerCommon, InternalMmapWithOffset) {
133 char tmpfile[128];
134 temp_file_name(tmpfile, sizeof(tmpfile),
135 "sanitizer_common.internalmmapwithoffset.tmp.");
136 fd_t fd = OpenFile(tmpfile, RdWr);
137 ASSERT_NE(fd, kInvalidFd);
138
139 uptr page_size = GetPageSizeCached();
140 uptr res = internal_ftruncate(fd, page_size * 2);
141 ASSERT_FALSE(internal_iserror(res));
142
143 res = internal_lseek(fd, page_size, SEEK_SET);
144 ASSERT_FALSE(internal_iserror(res));
145
146 res = internal_write(fd, "AB", 2);
147 ASSERT_FALSE(internal_iserror(res));
148
149 char *p = (char *)MapWritableFileToMemory(nullptr, page_size, fd, page_size);
150 ASSERT_NE(nullptr, p);
151
152 ASSERT_EQ('A', p[0]);
153 ASSERT_EQ('B', p[1]);
154
155 CloseFile(fd);
156 UnmapOrDie(p, page_size);
157 internal_unlink(tmpfile);
158 }
159 #endif
160