1 /*
2 * Copyright (C) 2013 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "android-base/file.h"
18
19 #include "android-base/utf8.h"
20
21 #include <gtest/gtest.h>
22
23 #include <errno.h>
24 #include <fcntl.h>
25 #include <unistd.h>
26 #include <wchar.h>
27
28 #include <string>
29
30 #if !defined(_WIN32)
31 #include <pwd.h>
32 #else
33 #include <windows.h>
34 #endif
35
36 #include "android-base/logging.h" // and must be after windows.h for ERROR
37
TEST(file,ReadFileToString_ENOENT)38 TEST(file, ReadFileToString_ENOENT) {
39 std::string s("hello");
40 errno = 0;
41 ASSERT_FALSE(android::base::ReadFileToString("/proc/does-not-exist", &s));
42 EXPECT_EQ(ENOENT, errno);
43 EXPECT_EQ("", s); // s was cleared.
44 }
45
TEST(file,ReadFileToString_WriteStringToFile)46 TEST(file, ReadFileToString_WriteStringToFile) {
47 TemporaryFile tf;
48 ASSERT_NE(tf.fd, -1) << tf.path;
49 ASSERT_TRUE(android::base::WriteStringToFile("abc", tf.path))
50 << strerror(errno);
51 std::string s;
52 ASSERT_TRUE(android::base::ReadFileToString(tf.path, &s))
53 << strerror(errno);
54 EXPECT_EQ("abc", s);
55 }
56
57 // symlinks require elevated privileges on Windows.
58 #if !defined(_WIN32)
TEST(file,ReadFileToString_WriteStringToFile_symlink)59 TEST(file, ReadFileToString_WriteStringToFile_symlink) {
60 TemporaryFile target, link;
61 ASSERT_EQ(0, unlink(link.path));
62 ASSERT_EQ(0, symlink(target.path, link.path));
63 ASSERT_FALSE(android::base::WriteStringToFile("foo", link.path, false));
64 ASSERT_EQ(ELOOP, errno);
65 ASSERT_TRUE(android::base::WriteStringToFile("foo", link.path, true));
66
67 std::string s;
68 ASSERT_FALSE(android::base::ReadFileToString(link.path, &s));
69 ASSERT_EQ(ELOOP, errno);
70 ASSERT_TRUE(android::base::ReadFileToString(link.path, &s, true));
71 ASSERT_EQ("foo", s);
72 }
73 #endif
74
75 // WriteStringToFile2 is explicitly for setting Unix permissions, which make no
76 // sense on Windows.
77 #if !defined(_WIN32)
TEST(file,WriteStringToFile2)78 TEST(file, WriteStringToFile2) {
79 TemporaryFile tf;
80 ASSERT_NE(tf.fd, -1) << tf.path;
81 ASSERT_TRUE(android::base::WriteStringToFile("abc", tf.path, 0660,
82 getuid(), getgid()))
83 << strerror(errno);
84 struct stat sb;
85 ASSERT_EQ(0, stat(tf.path, &sb));
86 ASSERT_EQ(0660U, static_cast<unsigned int>(sb.st_mode & ~S_IFMT));
87 ASSERT_EQ(getuid(), sb.st_uid);
88 ASSERT_EQ(getgid(), sb.st_gid);
89 std::string s;
90 ASSERT_TRUE(android::base::ReadFileToString(tf.path, &s))
91 << strerror(errno);
92 EXPECT_EQ("abc", s);
93 }
94 #endif
95
96 #if defined(_WIN32)
TEST(file,NonUnicodeCharsWindows)97 TEST(file, NonUnicodeCharsWindows) {
98 constexpr auto kMaxEnvVariableValueSize = 32767;
99 std::wstring old_tmp;
100 old_tmp.resize(kMaxEnvVariableValueSize);
101 old_tmp.resize(GetEnvironmentVariableW(L"TMP", old_tmp.data(), old_tmp.size()));
102 if (old_tmp.empty()) {
103 // Can't continue with empty TMP folder.
104 return;
105 }
106
107 std::wstring new_tmp = old_tmp;
108 if (new_tmp.back() != L'\\') {
109 new_tmp.push_back(L'\\');
110 }
111
112 {
113 auto path(new_tmp + L"锦绣成都\\");
114 _wmkdir(path.c_str());
115 ASSERT_TRUE(SetEnvironmentVariableW(L"TMP", path.c_str()));
116
117 TemporaryFile tf;
118 ASSERT_NE(tf.fd, -1) << tf.path;
119 ASSERT_TRUE(android::base::WriteStringToFd("abc", tf.fd));
120
121 ASSERT_EQ(0, lseek(tf.fd, 0, SEEK_SET)) << strerror(errno);
122
123 std::string s;
124 ASSERT_TRUE(android::base::ReadFdToString(tf.fd, &s)) << strerror(errno);
125 EXPECT_EQ("abc", s);
126 }
127 {
128 auto path(new_tmp + L"директория с длинным именем\\");
129 _wmkdir(path.c_str());
130 ASSERT_TRUE(SetEnvironmentVariableW(L"TMP", path.c_str()));
131
132 TemporaryFile tf;
133 ASSERT_NE(tf.fd, -1) << tf.path;
134 ASSERT_TRUE(android::base::WriteStringToFd("abc", tf.fd));
135
136 ASSERT_EQ(0, lseek(tf.fd, 0, SEEK_SET)) << strerror(errno);
137
138 std::string s;
139 ASSERT_TRUE(android::base::ReadFdToString(tf.fd, &s)) << strerror(errno);
140 EXPECT_EQ("abc", s);
141 }
142 {
143 auto path(new_tmp + L"äüöß weiß\\");
144 _wmkdir(path.c_str());
145 ASSERT_TRUE(SetEnvironmentVariableW(L"TMP", path.c_str()));
146
147 TemporaryFile tf;
148 ASSERT_NE(tf.fd, -1) << tf.path;
149 ASSERT_TRUE(android::base::WriteStringToFd("abc", tf.fd));
150
151 ASSERT_EQ(0, lseek(tf.fd, 0, SEEK_SET)) << strerror(errno);
152
153 std::string s;
154 ASSERT_TRUE(android::base::ReadFdToString(tf.fd, &s)) << strerror(errno);
155 EXPECT_EQ("abc", s);
156 }
157
158 SetEnvironmentVariableW(L"TMP", old_tmp.c_str());
159 }
160
TEST(file,RootDirectoryWindows)161 TEST(file, RootDirectoryWindows) {
162 constexpr auto kMaxEnvVariableValueSize = 32767;
163 std::wstring old_tmp;
164 bool tmp_is_empty = false;
165 old_tmp.resize(kMaxEnvVariableValueSize);
166 old_tmp.resize(GetEnvironmentVariableW(L"TMP", old_tmp.data(), old_tmp.size()));
167 if (old_tmp.empty()) {
168 tmp_is_empty = (GetLastError() == ERROR_ENVVAR_NOT_FOUND);
169 }
170 SetEnvironmentVariableW(L"TMP", L"C:");
171
172 TemporaryFile tf;
173 ASSERT_NE(tf.fd, -1) << tf.path;
174
175 SetEnvironmentVariableW(L"TMP", tmp_is_empty ? nullptr : old_tmp.c_str());
176 }
177 #endif
178
TEST(file,WriteStringToFd)179 TEST(file, WriteStringToFd) {
180 TemporaryFile tf;
181 ASSERT_NE(tf.fd, -1) << tf.path;
182 ASSERT_TRUE(android::base::WriteStringToFd("abc", tf.fd));
183
184 ASSERT_EQ(0, lseek(tf.fd, 0, SEEK_SET)) << strerror(errno);
185
186 std::string s;
187 ASSERT_TRUE(android::base::ReadFdToString(tf.fd, &s)) << strerror(errno);
188 EXPECT_EQ("abc", s);
189 }
190
TEST(file,WriteFully)191 TEST(file, WriteFully) {
192 TemporaryFile tf;
193 ASSERT_NE(tf.fd, -1) << tf.path;
194 ASSERT_TRUE(android::base::WriteFully(tf.fd, "abc", 3));
195
196 ASSERT_EQ(0, lseek(tf.fd, 0, SEEK_SET)) << strerror(errno);
197
198 std::string s;
199 s.resize(3);
200 ASSERT_TRUE(android::base::ReadFully(tf.fd, &s[0], s.size()))
201 << strerror(errno);
202 EXPECT_EQ("abc", s);
203
204 ASSERT_EQ(0, lseek(tf.fd, 0, SEEK_SET)) << strerror(errno);
205
206 s.resize(1024);
207 ASSERT_FALSE(android::base::ReadFully(tf.fd, &s[0], s.size()));
208 }
209
TEST(file,RemoveFileIfExists)210 TEST(file, RemoveFileIfExists) {
211 TemporaryFile tf;
212 ASSERT_NE(tf.fd, -1) << tf.path;
213 close(tf.fd);
214 tf.fd = -1;
215 std::string err;
216 ASSERT_TRUE(android::base::RemoveFileIfExists(tf.path, &err)) << err;
217 ASSERT_TRUE(android::base::RemoveFileIfExists(tf.path));
218 TemporaryDir td;
219 ASSERT_FALSE(android::base::RemoveFileIfExists(td.path));
220 ASSERT_FALSE(android::base::RemoveFileIfExists(td.path, &err));
221 ASSERT_EQ("is not a regular file or symbolic link", err);
222 }
223
TEST(file,RemoveFileIfExists_ENOTDIR)224 TEST(file, RemoveFileIfExists_ENOTDIR) {
225 TemporaryFile tf;
226 close(tf.fd);
227 tf.fd = -1;
228 std::string err{"xxx"};
229 ASSERT_TRUE(android::base::RemoveFileIfExists(std::string{tf.path} + "/abc", &err));
230 ASSERT_EQ("xxx", err);
231 }
232
233 #if !defined(_WIN32)
TEST(file,RemoveFileIfExists_EACCES)234 TEST(file, RemoveFileIfExists_EACCES) {
235 // EACCES -- one of the directories in the path has no search permission
236 // root can bypass permission restrictions, so drop root.
237 if (getuid() == 0) {
238 passwd* shell = getpwnam("shell");
239 setgid(shell->pw_gid);
240 setuid(shell->pw_uid);
241 }
242
243 TemporaryDir td;
244 TemporaryFile tf(td.path);
245 close(tf.fd);
246 tf.fd = -1;
247 std::string err{"xxx"};
248 // Remove dir's search permission.
249 ASSERT_TRUE(chmod(td.path, S_IRUSR | S_IWUSR) == 0);
250 ASSERT_FALSE(android::base::RemoveFileIfExists(tf.path, &err));
251 ASSERT_EQ("Permission denied", err);
252 // Set dir's search permission again.
253 ASSERT_TRUE(chmod(td.path, S_IRWXU) == 0);
254 ASSERT_TRUE(android::base::RemoveFileIfExists(tf.path, &err));
255 }
256 #endif
257
TEST(file,Readlink)258 TEST(file, Readlink) {
259 #if !defined(_WIN32)
260 // Linux doesn't allow empty symbolic links.
261 std::string min("x");
262 // ext2 and ext4 both have PAGE_SIZE limits.
263 // If file encryption is enabled, there's extra overhead to store the
264 // size of the encrypted symlink target. There's also an off-by-one
265 // in current kernels (and marlin/sailfish where we're seeing this
266 // failure are still on 3.18, far from current). http://b/33306057.
267 std::string max(static_cast<size_t>(4096 - 2 - 1 - 1), 'x');
268
269 TemporaryDir td;
270 std::string min_path{std::string(td.path) + "/" + "min"};
271 std::string max_path{std::string(td.path) + "/" + "max"};
272
273 ASSERT_EQ(0, symlink(min.c_str(), min_path.c_str()));
274 ASSERT_EQ(0, symlink(max.c_str(), max_path.c_str()));
275
276 std::string result;
277
278 result = "wrong";
279 ASSERT_TRUE(android::base::Readlink(min_path, &result));
280 ASSERT_EQ(min, result);
281
282 result = "wrong";
283 ASSERT_TRUE(android::base::Readlink(max_path, &result));
284 ASSERT_EQ(max, result);
285 #endif
286 }
287
TEST(file,Realpath)288 TEST(file, Realpath) {
289 #if !defined(_WIN32)
290 TemporaryDir td;
291 std::string basename = android::base::Basename(td.path);
292 std::string dir_name = android::base::Dirname(td.path);
293 std::string base_dir_name = android::base::Basename(dir_name);
294
295 {
296 std::string path = dir_name + "/../" + base_dir_name + "/" + basename;
297 std::string result;
298 ASSERT_TRUE(android::base::Realpath(path, &result));
299 ASSERT_EQ(td.path, result);
300 }
301
302 {
303 std::string path = std::string(td.path) + "/..";
304 std::string result;
305 ASSERT_TRUE(android::base::Realpath(path, &result));
306 ASSERT_EQ(dir_name, result);
307 }
308
309 {
310 errno = 0;
311 std::string path = std::string(td.path) + "/foo.noent";
312 std::string result = "wrong";
313 ASSERT_TRUE(!android::base::Realpath(path, &result));
314 ASSERT_TRUE(result.empty());
315 ASSERT_EQ(ENOENT, errno);
316 }
317 #endif
318 }
319
TEST(file,GetExecutableDirectory)320 TEST(file, GetExecutableDirectory) {
321 std::string path = android::base::GetExecutableDirectory();
322 ASSERT_NE("", path);
323 ASSERT_NE(android::base::GetExecutablePath(), path);
324 ASSERT_EQ('/', path[0]);
325 ASSERT_NE('/', path[path.size() - 1]);
326 }
327
TEST(file,GetExecutablePath)328 TEST(file, GetExecutablePath) {
329 ASSERT_NE("", android::base::GetExecutablePath());
330 }
331
TEST(file,Basename)332 TEST(file, Basename) {
333 EXPECT_EQ("sh", android::base::Basename("/system/bin/sh"));
334 EXPECT_EQ("sh", android::base::Basename("sh"));
335 EXPECT_EQ("sh", android::base::Basename("/system/bin/sh/"));
336 }
337
TEST(file,Dirname)338 TEST(file, Dirname) {
339 EXPECT_EQ("/system/bin", android::base::Dirname("/system/bin/sh"));
340 EXPECT_EQ(".", android::base::Dirname("sh"));
341 EXPECT_EQ("/system/bin", android::base::Dirname("/system/bin/sh/"));
342 }
343
TEST(file,ReadFileToString_capacity)344 TEST(file, ReadFileToString_capacity) {
345 TemporaryFile tf;
346 ASSERT_NE(tf.fd, -1) << tf.path;
347
348 // For a huge file, the overhead should still be small.
349 std::string s;
350 size_t size = 16 * 1024 * 1024;
351 ASSERT_TRUE(android::base::WriteStringToFile(std::string(size, 'x'), tf.path));
352 ASSERT_TRUE(android::base::ReadFileToString(tf.path, &s));
353 EXPECT_EQ(size, s.size());
354 EXPECT_LT(s.capacity(), size + 16);
355
356 // Even for weird badly-aligned sizes.
357 size += 12345;
358 ASSERT_TRUE(android::base::WriteStringToFile(std::string(size, 'x'), tf.path));
359 ASSERT_TRUE(android::base::ReadFileToString(tf.path, &s));
360 EXPECT_EQ(size, s.size());
361 EXPECT_LT(s.capacity(), size + 16);
362
363 // We'll shrink an enormous string if you read a small file into it.
364 size = 64;
365 ASSERT_TRUE(android::base::WriteStringToFile(std::string(size, 'x'), tf.path));
366 ASSERT_TRUE(android::base::ReadFileToString(tf.path, &s));
367 EXPECT_EQ(size, s.size());
368 EXPECT_LT(s.capacity(), size + 16);
369 }
370
TEST(file,ReadFileToString_capacity_0)371 TEST(file, ReadFileToString_capacity_0) {
372 TemporaryFile tf;
373 ASSERT_NE(tf.fd, -1) << tf.path;
374
375 // Because /proc reports its files as zero-length, we don't actually trust
376 // any file that claims to be zero-length. Rather than add increasingly
377 // complex heuristics for shrinking the passed-in string in that case, we
378 // currently leave it alone.
379 std::string s;
380 size_t initial_capacity = s.capacity();
381 ASSERT_TRUE(android::base::WriteStringToFile("", tf.path));
382 ASSERT_TRUE(android::base::ReadFileToString(tf.path, &s));
383 EXPECT_EQ(0U, s.size());
384 EXPECT_EQ(initial_capacity, s.capacity());
385 }
386