1 /* 2 * Copyright (C) 2012 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 <gtest/gtest.h> 18 19 #include <dirent.h> 20 #include <errno.h> 21 #include <fcntl.h> 22 #include <limits.h> 23 #include <sys/stat.h> 24 #include <sys/types.h> 25 #include <unistd.h> 26 27 #include <algorithm> 28 #include <set> 29 #include <string> 30 31 static void CheckProcSelf(std::set<std::string>& names) { 32 // We have a good idea of what should be in /proc/self. 33 ASSERT_TRUE(names.find(".") != names.end()); 34 ASSERT_TRUE(names.find("..") != names.end()); 35 ASSERT_TRUE(names.find("cmdline") != names.end()); 36 ASSERT_TRUE(names.find("fd") != names.end()); 37 ASSERT_TRUE(names.find("stat") != names.end()); 38 } 39 40 template <typename DirEntT> 41 void ScanEntries(DirEntT** entries, int entry_count, 42 std::set<std::string>& name_set, std::vector<std::string>& name_list) { 43 for (size_t i = 0; i < static_cast<size_t>(entry_count); ++i) { 44 name_set.insert(entries[i]->d_name); 45 name_list.push_back(entries[i]->d_name); 46 free(entries[i]); 47 } 48 free(entries); 49 } 50 51 TEST(dirent, scandir_scandir64) { 52 // Get everything from /proc/self... 53 dirent** entries; 54 int entry_count = scandir("/proc/self", &entries, NULL, alphasort); 55 ASSERT_GE(entry_count, 0); 56 57 dirent64** entries64; 58 int entry_count64 = scandir64("/proc/self", &entries64, NULL, alphasort64); 59 ASSERT_EQ(entry_count, entry_count64); 60 61 // Turn the directory entries into a set and vector of the names. 62 std::set<std::string> name_set; 63 std::vector<std::string> unsorted_name_list; 64 ScanEntries(entries, entry_count, name_set, unsorted_name_list); 65 66 // No duplicates. 67 ASSERT_EQ(name_set.size(), unsorted_name_list.size()); 68 69 // All entries sorted. 70 std::vector<std::string> sorted_name_list(unsorted_name_list); 71 std::sort(sorted_name_list.begin(), sorted_name_list.end()); 72 ASSERT_EQ(sorted_name_list, unsorted_name_list); 73 74 // scandir64 returned the same results as scandir. 75 std::set<std::string> name_set64; 76 std::vector<std::string> unsorted_name_list64; 77 ScanEntries(entries64, entry_count64, name_set64, unsorted_name_list64); 78 ASSERT_EQ(name_set, name_set64); 79 ASSERT_EQ(unsorted_name_list, unsorted_name_list64); 80 81 CheckProcSelf(name_set); 82 } 83 84 TEST(dirent, scandirat_scandirat64) { 85 // Get everything from /proc/self... 86 dirent** entries; 87 int entry_count = scandir("/proc/self", &entries, NULL, alphasort); 88 ASSERT_GE(entry_count, 0); 89 90 int proc_fd = open("/proc", O_DIRECTORY); 91 ASSERT_NE(-1, proc_fd); 92 93 dirent** entries_at; 94 int entry_count_at = scandirat(proc_fd, "self", &entries_at, NULL, alphasort); 95 ASSERT_EQ(entry_count, entry_count_at); 96 97 dirent64** entries_at64; 98 int entry_count_at64 = scandirat64(proc_fd, "self", &entries_at64, NULL, alphasort64); 99 ASSERT_EQ(entry_count, entry_count_at64); 100 101 close(proc_fd); 102 103 // scandirat and scandirat64 should return the same results as scandir. 104 std::set<std::string> name_set, name_set_at, name_set_at64; 105 std::vector<std::string> unsorted_name_list, unsorted_name_list_at, unsorted_name_list_at64; 106 ScanEntries(entries, entry_count, name_set, unsorted_name_list); 107 ScanEntries(entries_at, entry_count_at, name_set_at, unsorted_name_list_at); 108 ScanEntries(entries_at64, entry_count_at64, name_set_at64, unsorted_name_list_at64); 109 110 ASSERT_EQ(name_set, name_set_at); 111 ASSERT_EQ(name_set, name_set_at64); 112 ASSERT_EQ(unsorted_name_list, unsorted_name_list_at); 113 ASSERT_EQ(unsorted_name_list, unsorted_name_list_at64); 114 } 115 116 TEST(dirent, scandir_ENOENT) { 117 dirent** entries; 118 errno = 0; 119 ASSERT_EQ(-1, scandir("/does-not-exist", &entries, nullptr, nullptr)); 120 ASSERT_EQ(ENOENT, errno); 121 } 122 123 TEST(dirent, scandir64_ENOENT) { 124 dirent64** entries; 125 errno = 0; 126 ASSERT_EQ(-1, scandir64("/does-not-exist", &entries, nullptr, nullptr)); 127 ASSERT_EQ(ENOENT, errno); 128 } 129 130 TEST(dirent, scandirat_ENOENT) { 131 int root_fd = open("/", O_DIRECTORY | O_RDONLY); 132 ASSERT_NE(-1, root_fd); 133 dirent** entries; 134 errno = 0; 135 ASSERT_EQ(-1, scandirat(root_fd, "does-not-exist", &entries, nullptr, nullptr)); 136 ASSERT_EQ(ENOENT, errno); 137 close(root_fd); 138 } 139 140 TEST(dirent, scandirat64_ENOENT) { 141 int root_fd = open("/", O_DIRECTORY | O_RDONLY); 142 ASSERT_NE(-1, root_fd); 143 dirent64** entries; 144 errno = 0; 145 ASSERT_EQ(-1, scandirat64(root_fd, "does-not-exist", &entries, nullptr, nullptr)); 146 ASSERT_EQ(ENOENT, errno); 147 close(root_fd); 148 } 149 150 TEST(dirent, fdopendir_invalid) { 151 ASSERT_TRUE(fdopendir(-1) == NULL); 152 ASSERT_EQ(EBADF, errno); 153 154 int fd = open("/dev/null", O_RDONLY); 155 ASSERT_NE(fd, -1); 156 ASSERT_TRUE(fdopendir(fd) == NULL); 157 ASSERT_EQ(ENOTDIR, errno); 158 close(fd); 159 } 160 161 TEST(dirent, fdopendir) { 162 int fd = open("/proc/self", O_RDONLY); 163 DIR* d = fdopendir(fd); 164 ASSERT_TRUE(d != NULL); 165 dirent* e = readdir(d); 166 ASSERT_STREQ(e->d_name, "."); 167 ASSERT_EQ(closedir(d), 0); 168 169 // fdopendir(3) took ownership, so closedir(3) closed our fd. 170 ASSERT_EQ(close(fd), -1); 171 ASSERT_EQ(EBADF, errno); 172 } 173 174 TEST(dirent, opendir_invalid) { 175 ASSERT_TRUE(opendir("/does/not/exist") == NULL); 176 ASSERT_EQ(ENOENT, errno); 177 178 ASSERT_TRUE(opendir("/dev/null") == NULL); 179 ASSERT_EQ(ENOTDIR, errno); 180 } 181 182 TEST(dirent, opendir) { 183 DIR* d = opendir("/proc/self"); 184 ASSERT_TRUE(d != NULL); 185 dirent* e = readdir(d); 186 ASSERT_STREQ(e->d_name, "."); 187 ASSERT_EQ(closedir(d), 0); 188 } 189 190 TEST(dirent, closedir_invalid) { 191 DIR* d = NULL; 192 ASSERT_EQ(closedir(d), -1); 193 ASSERT_EQ(EINVAL, errno); 194 } 195 196 TEST(dirent, closedir) { 197 DIR* d = opendir("/proc/self"); 198 ASSERT_TRUE(d != NULL); 199 ASSERT_EQ(closedir(d), 0); 200 } 201 202 TEST(dirent, readdir) { 203 DIR* d = opendir("/proc/self"); 204 ASSERT_TRUE(d != NULL); 205 std::set<std::string> name_set; 206 errno = 0; 207 dirent* e; 208 while ((e = readdir(d)) != NULL) { 209 name_set.insert(e->d_name); 210 } 211 // Reading to the end of the directory is not an error. 212 // readdir(3) returns NULL, but leaves errno as 0. 213 ASSERT_EQ(0, errno); 214 ASSERT_EQ(closedir(d), 0); 215 216 CheckProcSelf(name_set); 217 } 218 219 TEST(dirent, readdir64) { 220 DIR* d = opendir("/proc/self"); 221 ASSERT_TRUE(d != NULL); 222 std::set<std::string> name_set; 223 errno = 0; 224 dirent64* e; 225 while ((e = readdir64(d)) != NULL) { 226 name_set.insert(e->d_name); 227 } 228 // Reading to the end of the directory is not an error. 229 // readdir64(3) returns NULL, but leaves errno as 0. 230 ASSERT_EQ(0, errno); 231 ASSERT_EQ(closedir(d), 0); 232 233 CheckProcSelf(name_set); 234 } 235 236 TEST(dirent, readdir_r) { 237 DIR* d = opendir("/proc/self"); 238 ASSERT_TRUE(d != NULL); 239 std::set<std::string> name_set; 240 errno = 0; 241 dirent storage; 242 dirent* e = NULL; 243 while (readdir_r(d, &storage, &e) == 0 && e != NULL) { 244 name_set.insert(e->d_name); 245 } 246 // Reading to the end of the directory is not an error. 247 // readdir_r(3) returns NULL, but leaves errno as 0. 248 ASSERT_EQ(0, errno); 249 ASSERT_EQ(closedir(d), 0); 250 251 CheckProcSelf(name_set); 252 } 253 254 TEST(dirent, readdir64_r) { 255 DIR* d = opendir("/proc/self"); 256 ASSERT_TRUE(d != NULL); 257 std::set<std::string> name_set; 258 errno = 0; 259 dirent64 storage; 260 dirent64* e = NULL; 261 while (readdir64_r(d, &storage, &e) == 0 && e != NULL) { 262 name_set.insert(e->d_name); 263 } 264 // Reading to the end of the directory is not an error. 265 // readdir64_r(3) returns NULL, but leaves errno as 0. 266 ASSERT_EQ(0, errno); 267 ASSERT_EQ(closedir(d), 0); 268 269 CheckProcSelf(name_set); 270 } 271 272 TEST(dirent, rewinddir) { 273 DIR* d = opendir("/proc/self"); 274 ASSERT_TRUE(d != NULL); 275 276 // Get all the names once... 277 std::vector<std::string> pass1; 278 dirent* e; 279 while ((e = readdir(d)) != NULL) { 280 pass1.push_back(e->d_name); 281 } 282 283 // ...rewind... 284 rewinddir(d); 285 286 // ...and get all the names again. 287 std::vector<std::string> pass2; 288 while ((e = readdir(d)) != NULL) { 289 pass2.push_back(e->d_name); 290 } 291 292 ASSERT_EQ(closedir(d), 0); 293 294 // We should have seen the same names in the same order both times. 295 ASSERT_EQ(pass1.size(), pass2.size()); 296 for (size_t i = 0; i < pass1.size(); ++i) { 297 ASSERT_EQ(pass1[i], pass2[i]); 298 } 299 } 300 301 TEST(dirent, seekdir_telldir) { 302 DIR* d = opendir("/proc/self"); 303 ASSERT_TRUE(d != NULL); 304 std::vector<long> offset_list; 305 std::vector<std::string> name_list; 306 dirent* e = NULL; 307 308 offset_list.push_back(telldir(d)); 309 ASSERT_EQ(0L, offset_list.back()); 310 311 while ((e = readdir(d)) != NULL) { 312 name_list.push_back(e->d_name); 313 offset_list.push_back(telldir(d)); 314 // Make sure telldir() point to the next entry. 315 ASSERT_EQ(e->d_off, offset_list.back()); 316 } 317 318 long end_offset = telldir(d); 319 // telldir() should not pass the end of the file. 320 ASSERT_EQ(offset_list.back(), end_offset); 321 offset_list.pop_back(); 322 323 for (size_t i = 0; i < offset_list.size(); ++i) { 324 seekdir(d, offset_list[i]); 325 ASSERT_EQ(offset_list[i], telldir(d)); 326 e = readdir(d); 327 ASSERT_TRUE(e != NULL); 328 ASSERT_STREQ(name_list[i].c_str(), e->d_name); 329 } 330 for (int i = static_cast<int>(offset_list.size()) - 1; i >= 0; --i) { 331 seekdir(d, offset_list[i]); 332 ASSERT_EQ(offset_list[i], telldir(d)); 333 e = readdir(d); 334 ASSERT_TRUE(e != NULL); 335 ASSERT_STREQ(name_list[i].c_str(), e->d_name); 336 } 337 338 // Seek to the end, read NULL. 339 seekdir(d, end_offset); 340 ASSERT_EQ(end_offset, telldir(d)); 341 errno = 0; 342 ASSERT_EQ(NULL, readdir(d)); 343 ASSERT_EQ(0, errno); 344 345 ASSERT_EQ(0, closedir(d)); 346 } 347
