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 // Below are the header files we want to test. 20 #include <grp.h> 21 #include <pwd.h> 22 23 #include <errno.h> 24 #include <limits.h> 25 #include <sys/cdefs.h> 26 #include <sys/types.h> 27 #include <unistd.h> 28 29 #include <set> 30 #include <vector> 31 32 #include <android-base/strings.h> 33 #include <private/android_filesystem_config.h> 34 35 // Generated android_ids array 36 #include "generated_android_ids.h" 37 38 using android::base::Join; 39 40 enum uid_type_t { 41 TYPE_SYSTEM, 42 TYPE_APP 43 }; 44 45 #if defined(__BIONIC__) 46 47 static void check_passwd(const passwd* pwd, const char* username, uid_t uid, uid_type_t uid_type, 48 bool check_username) { 49 ASSERT_TRUE(pwd != NULL); 50 if (check_username) { 51 EXPECT_STREQ(username, pwd->pw_name); 52 } 53 EXPECT_EQ(uid, pwd->pw_uid); 54 EXPECT_EQ(uid, pwd->pw_gid); 55 EXPECT_EQ(NULL, pwd->pw_passwd); 56 #ifdef __LP64__ 57 EXPECT_EQ(NULL, pwd->pw_gecos); 58 #endif 59 60 if (uid_type == TYPE_SYSTEM) { 61 EXPECT_STREQ("/", pwd->pw_dir); 62 } else { 63 EXPECT_STREQ("/data", pwd->pw_dir); 64 } 65 EXPECT_STREQ("/system/bin/sh", pwd->pw_shell); 66 } 67 68 static void check_getpwuid(const char* username, uid_t uid, uid_type_t uid_type, 69 bool check_username) { 70 errno = 0; 71 passwd* pwd = getpwuid(uid); 72 ASSERT_EQ(0, errno); 73 SCOPED_TRACE("getpwuid"); 74 check_passwd(pwd, username, uid, uid_type, check_username); 75 } 76 77 static void check_getpwnam(const char* username, uid_t uid, uid_type_t uid_type, 78 bool check_username) { 79 errno = 0; 80 passwd* pwd = getpwnam(username); 81 ASSERT_EQ(0, errno); 82 SCOPED_TRACE("getpwnam"); 83 check_passwd(pwd, username, uid, uid_type, check_username); 84 } 85 86 static void check_getpwuid_r(const char* username, uid_t uid, uid_type_t uid_type, 87 bool check_username) { 88 passwd pwd_storage; 89 char buf[512]; 90 int result; 91 92 errno = 0; 93 passwd* pwd = NULL; 94 result = getpwuid_r(uid, &pwd_storage, buf, sizeof(buf), &pwd); 95 ASSERT_EQ(0, result); 96 ASSERT_EQ(0, errno); 97 SCOPED_TRACE("getpwuid_r"); 98 check_passwd(pwd, username, uid, uid_type, check_username); 99 } 100 101 static void check_getpwnam_r(const char* username, uid_t uid, uid_type_t uid_type, 102 bool check_username) { 103 passwd pwd_storage; 104 char buf[512]; 105 int result; 106 107 errno = 0; 108 passwd* pwd = NULL; 109 result = getpwnam_r(username, &pwd_storage, buf, sizeof(buf), &pwd); 110 ASSERT_EQ(0, result); 111 ASSERT_EQ(0, errno); 112 SCOPED_TRACE("getpwnam_r"); 113 check_passwd(pwd, username, uid, uid_type, check_username); 114 } 115 116 static void check_get_passwd(const char* username, uid_t uid, uid_type_t uid_type, 117 bool check_username = true) { 118 check_getpwuid(username, uid, uid_type, check_username); 119 check_getpwnam(username, uid, uid_type, check_username); 120 check_getpwuid_r(username, uid, uid_type, check_username); 121 check_getpwnam_r(username, uid, uid_type, check_username); 122 } 123 124 #else // !defined(__BIONIC__) 125 126 static void print_no_getpwnam_test_info() { 127 GTEST_LOG_(INFO) << "This test is about uid/username translation for Android, which does nothing on libc other than bionic.\n"; 128 } 129 130 static void check_get_passwd(const char* /* username */, uid_t /* uid */, uid_type_t /* uid_type */, 131 bool /* check_username */) { 132 print_no_getpwnam_test_info(); 133 } 134 135 static void check_get_passwd(const char* /* username */, uid_t /* uid */, uid_type_t /* uid_type */) { 136 print_no_getpwnam_test_info(); 137 } 138 139 #endif 140 141 TEST(pwd, getpwnam_system_id_root) { 142 check_get_passwd("root", 0, TYPE_SYSTEM); 143 } 144 145 TEST(pwd, getpwnam_system_id_system) { 146 check_get_passwd("system", 1000, TYPE_SYSTEM); 147 } 148 149 TEST(pwd, getpwnam_app_id_radio) { 150 check_get_passwd("radio", 1001, TYPE_SYSTEM); 151 } 152 153 TEST(pwd, getpwnam_oem_id_5000) { 154 check_get_passwd("oem_5000", 5000, TYPE_SYSTEM, false); 155 } 156 157 TEST(pwd, getpwnam_oem_id_5999) { 158 check_get_passwd("oem_5999", 5999, TYPE_SYSTEM, false); 159 } 160 161 TEST(pwd, getpwnam_oem_id_2900) { 162 check_get_passwd("oem_2900", 2900, TYPE_SYSTEM, false); 163 } 164 165 TEST(pwd, getpwnam_oem_id_2999) { 166 check_get_passwd("oem_2999", 2999, TYPE_SYSTEM, false); 167 } 168 169 TEST(pwd, getpwnam_app_id_nobody) { 170 check_get_passwd("nobody", 9999, TYPE_SYSTEM); 171 } 172 173 TEST(pwd, getpwnam_app_id_u0_a0) { 174 check_get_passwd("u0_a0", 10000, TYPE_APP); 175 } 176 177 TEST(pwd, getpwnam_app_id_u0_a1234) { 178 check_get_passwd("u0_a1234", 11234, TYPE_APP); 179 } 180 181 // Test the difference between uid and shared gid. 182 TEST(pwd, getpwnam_app_id_u0_a49999) { 183 check_get_passwd("u0_a49999", 59999, TYPE_APP); 184 } 185 186 TEST(pwd, getpwnam_app_id_u0_i1) { 187 check_get_passwd("u0_i1", 99001, TYPE_APP); 188 } 189 190 TEST(pwd, getpwnam_app_id_u1_root) { 191 check_get_passwd("u1_root", 100000, TYPE_SYSTEM); 192 } 193 194 TEST(pwd, getpwnam_app_id_u1_radio) { 195 check_get_passwd("u1_radio", 101001, TYPE_SYSTEM); 196 } 197 198 TEST(pwd, getpwnam_app_id_u1_a0) { 199 check_get_passwd("u1_a0", 110000, TYPE_APP); 200 } 201 202 TEST(pwd, getpwnam_app_id_u1_a40000) { 203 check_get_passwd("u1_a40000", 150000, TYPE_APP); 204 } 205 206 TEST(pwd, getpwnam_app_id_u1_i0) { 207 check_get_passwd("u1_i0", 199000, TYPE_APP); 208 } 209 210 template <typename T> 211 static void expect_ids(const T& ids) { 212 std::set<typename T::key_type> expected_ids; 213 // Ensure that all android_ids are iterated through. 214 for (size_t n = 0; n < android_id_count; ++n) { 215 EXPECT_EQ(1U, ids.count(android_ids[n].aid)) << "android_ids[n].aid: " << android_ids[n].aid; 216 expected_ids.emplace(android_ids[n].aid); 217 } 218 219 auto expect_range = [&ids, &expected_ids](uid_t start, uid_t end) { 220 for (size_t n = start; n <= end; ++n) { 221 EXPECT_EQ(1U, ids.count(n)) << "n: " << n; 222 expected_ids.emplace(n); 223 } 224 }; 225 226 // Ensure that all reserved ranges are iterated through. 227 expect_range(AID_OEM_RESERVED_START, AID_OEM_RESERVED_END); 228 expect_range(AID_OEM_RESERVED_2_START, AID_OEM_RESERVED_2_END); 229 expect_range(AID_APP_START, AID_APP_END); 230 expect_range(AID_CACHE_GID_START, AID_CACHE_GID_END); 231 expect_range(AID_EXT_GID_START, AID_EXT_GID_END); 232 expect_range(AID_EXT_CACHE_GID_START, AID_EXT_CACHE_GID_END); 233 expect_range(AID_SHARED_GID_START, AID_SHARED_GID_END); 234 expect_range(AID_ISOLATED_START, AID_ISOLATED_END); 235 236 // Ensure that no other ids were returned. 237 auto return_differences = [&ids, &expected_ids] { 238 std::vector<typename T::key_type> missing_from_ids; 239 std::set_difference(expected_ids.begin(), expected_ids.end(), ids.begin(), ids.end(), 240 std::inserter(missing_from_ids, missing_from_ids.begin())); 241 std::vector<typename T::key_type> extra_in_ids; 242 std::set_difference(ids.begin(), ids.end(), expected_ids.begin(), expected_ids.end(), 243 std::inserter(extra_in_ids, extra_in_ids.begin())); 244 std::string result; 245 if (!missing_from_ids.empty()) { 246 result += "Missing ids from results: " + Join(missing_from_ids, " "); 247 } 248 if (!extra_in_ids.empty()) { 249 if (!result.empty()) result += ", "; 250 result += "Extra ids in results: " + Join(extra_in_ids, " "); 251 } 252 return result; 253 }; 254 EXPECT_EQ(expected_ids, ids) << return_differences(); 255 } 256 257 TEST(pwd, getpwent_iterate) { 258 #if defined(__BIONIC__) 259 passwd* pwd; 260 std::set<uid_t> uids; 261 262 setpwent(); 263 while ((pwd = getpwent()) != NULL) { 264 ASSERT_TRUE(NULL != pwd->pw_name); 265 266 EXPECT_EQ(pwd->pw_gid, pwd->pw_uid) << "pwd->pw_uid: " << pwd->pw_uid; 267 EXPECT_EQ(NULL, pwd->pw_passwd) << "pwd->pw_uid: " << pwd->pw_uid; 268 #ifdef __LP64__ 269 EXPECT_TRUE(NULL == pwd->pw_gecos) << "pwd->pw_uid: " << pwd->pw_uid; 270 #endif 271 EXPECT_TRUE(NULL != pwd->pw_shell); 272 if (pwd->pw_uid < AID_APP_START || pwd->pw_uid == AID_OVERFLOWUID) { 273 EXPECT_STREQ("/", pwd->pw_dir) << "pwd->pw_uid: " << pwd->pw_uid; 274 } else { 275 EXPECT_STREQ("/data", pwd->pw_dir) << "pwd->pw_uid: " << pwd->pw_uid; 276 } 277 278 EXPECT_EQ(0U, uids.count(pwd->pw_uid)) << "pwd->pw_uid: " << pwd->pw_uid; 279 uids.emplace(pwd->pw_uid); 280 } 281 endpwent(); 282 283 expect_ids(uids); 284 #else 285 print_no_getpwnam_test_info(); 286 #endif 287 } 288 289 static void check_group(const group* grp, const char* group_name, gid_t gid, 290 bool check_groupname = true) { 291 ASSERT_TRUE(grp != NULL); 292 if (check_groupname) { 293 EXPECT_STREQ(group_name, grp->gr_name); 294 } 295 EXPECT_EQ(gid, grp->gr_gid); 296 ASSERT_TRUE(grp->gr_mem != NULL); 297 if (check_groupname) { 298 EXPECT_STREQ(group_name, grp->gr_mem[0]); 299 } 300 EXPECT_TRUE(grp->gr_mem[1] == NULL); 301 } 302 303 #if defined(__BIONIC__) 304 305 static void check_getgrgid(const char* group_name, gid_t gid, bool check_groupname) { 306 errno = 0; 307 group* grp = getgrgid(gid); 308 ASSERT_EQ(0, errno); 309 SCOPED_TRACE("getgrgid"); 310 check_group(grp, group_name, gid, check_groupname); 311 } 312 313 static void check_getgrnam(const char* group_name, gid_t gid, bool check_groupname) { 314 errno = 0; 315 group* grp = getgrnam(group_name); 316 ASSERT_EQ(0, errno); 317 SCOPED_TRACE("getgrnam"); 318 check_group(grp, group_name, gid, check_groupname); 319 } 320 321 static void check_getgrgid_r(const char* group_name, gid_t gid, bool check_groupname) { 322 group grp_storage; 323 char buf[512]; 324 group* grp; 325 326 errno = 0; 327 int result = getgrgid_r(gid, &grp_storage, buf, sizeof(buf), &grp); 328 ASSERT_EQ(0, result); 329 ASSERT_EQ(0, errno); 330 SCOPED_TRACE("getgrgid_r"); 331 check_group(grp, group_name, gid, check_groupname); 332 } 333 334 static void check_getgrnam_r(const char* group_name, gid_t gid, bool check_groupname) { 335 group grp_storage; 336 char buf[512]; 337 group* grp; 338 339 errno = 0; 340 int result = getgrnam_r(group_name, &grp_storage, buf, sizeof(buf), &grp); 341 ASSERT_EQ(0, result); 342 ASSERT_EQ(0, errno); 343 SCOPED_TRACE("getgrnam_r"); 344 check_group(grp, group_name, gid, check_groupname); 345 } 346 347 static void check_get_group(const char* group_name, gid_t gid, bool check_groupname = true) { 348 check_getgrgid(group_name, gid, check_groupname); 349 check_getgrnam(group_name, gid, check_groupname); 350 check_getgrgid_r(group_name, gid, check_groupname); 351 check_getgrnam_r(group_name, gid, check_groupname); 352 } 353 354 #else // !defined(__BIONIC__) 355 356 static void print_no_getgrnam_test_info() { 357 GTEST_LOG_(INFO) << "This test is about gid/group_name translation for Android, which does nothing on libc other than bionic.\n"; 358 } 359 360 static void check_get_group(const char*, gid_t, bool) { 361 print_no_getgrnam_test_info(); 362 } 363 364 static void check_get_group(const char*, gid_t) { 365 print_no_getgrnam_test_info(); 366 } 367 368 #endif 369 370 TEST(grp, getgrnam_system_id_root) { 371 check_get_group("root", 0); 372 } 373 374 TEST(grp, getgrnam_system_id_system) { 375 check_get_group("system", 1000); 376 } 377 378 TEST(grp, getgrnam_app_id_radio) { 379 check_get_group("radio", 1001); 380 } 381 382 TEST(grp, getgrnam_oem_id_5000) { 383 check_get_group("oem_5000", 5000, false); 384 } 385 386 TEST(grp, getgrnam_oem_id_5999) { 387 check_get_group("oem_5999", 5999, false); 388 } 389 390 TEST(grp, getgrnam_oem_id_2900) { 391 check_get_group("oem_2900", 2900, false); 392 } 393 394 TEST(grp, getgrnam_oem_id_2999) { 395 check_get_group("oem_2999", 2999, false); 396 } 397 398 TEST(grp, getgrnam_app_id_nobody) { 399 check_get_group("nobody", 9999); 400 } 401 402 TEST(grp, getgrnam_app_id_u0_a0) { 403 check_get_group("u0_a0", 10000); 404 } 405 406 TEST(grp, getgrnam_app_id_u0_a1234) { 407 check_get_group("u0_a1234", 11234); 408 } 409 410 TEST(grp, getgrnam_app_id_u0_a9999) { 411 check_get_group("u0_a9999", 19999); 412 } 413 414 TEST(getgrnam, app_id_u0_a0_cache) { 415 check_get_group("u0_a0_cache", 20000); 416 } 417 418 TEST(getgrnam, app_id_u0_a1234_cache) { 419 check_get_group("u0_a1234_cache", 21234); 420 } 421 422 TEST(getgrnam, app_id_u0_a9999_cache) { 423 check_get_group("u0_a9999_cache", 29999); 424 } 425 426 TEST(getgrnam, app_id_u10_a1234_cache) { 427 check_get_group("u10_a1234_cache", 1021234); 428 } 429 430 // Test the difference between uid and shared gid. 431 TEST(grp, getgrnam_app_id_all_a9999) { 432 check_get_group("all_a9999", 59999); 433 } 434 435 TEST(grp, getgrnam_app_id_u0_i1) { 436 check_get_group("u0_i1", 99001); 437 } 438 439 TEST(grp, getgrnam_app_id_u1_root) { 440 check_get_group("u1_root", 100000); 441 } 442 443 TEST(grp, getgrnam_app_id_u1_radio) { 444 check_get_group("u1_radio", 101001); 445 } 446 447 TEST(grp, getgrnam_app_id_u1_a0) { 448 check_get_group("u1_a0", 110000); 449 } 450 451 TEST(grp, getgrnam_app_id_u1_a40000) { 452 check_get_group("u1_a40000", 150000); 453 } 454 455 TEST(grp, getgrnam_app_id_u1_i0) { 456 check_get_group("u1_i0", 199000); 457 } 458 459 TEST(grp, getgrnam_r_reentrancy) { 460 #if defined(__BIONIC__) 461 group grp_storage[2]; 462 char buf[2][512]; 463 group* grp[3]; 464 int result = getgrnam_r("root", &grp_storage[0], buf[0], sizeof(buf[0]), &grp[0]); 465 ASSERT_EQ(0, result); 466 check_group(grp[0], "root", 0); 467 grp[1] = getgrnam("system"); 468 check_group(grp[1], "system", 1000); 469 result = getgrnam_r("radio", &grp_storage[1], buf[1], sizeof(buf[1]), &grp[2]); 470 ASSERT_EQ(0, result); 471 check_group(grp[2], "radio", 1001); 472 check_group(grp[0], "root", 0); 473 check_group(grp[1], "system", 1000); 474 #else 475 print_no_getgrnam_test_info(); 476 #endif 477 } 478 479 TEST(grp, getgrgid_r_reentrancy) { 480 #if defined(__BIONIC__) 481 group grp_storage[2]; 482 char buf[2][512]; 483 group* grp[3]; 484 int result = getgrgid_r(0, &grp_storage[0], buf[0], sizeof(buf[0]), &grp[0]); 485 ASSERT_EQ(0, result); 486 check_group(grp[0], "root", 0); 487 grp[1] = getgrgid(1000); 488 check_group(grp[1], "system", 1000); 489 result = getgrgid_r(1001, &grp_storage[1], buf[1], sizeof(buf[1]), &grp[2]); 490 ASSERT_EQ(0, result); 491 check_group(grp[2], "radio", 1001); 492 check_group(grp[0], "root", 0); 493 check_group(grp[1], "system", 1000); 494 #else 495 print_no_getgrnam_test_info(); 496 #endif 497 } 498 499 TEST(grp, getgrnam_r_large_enough_suggested_buffer_size) { 500 long size = sysconf(_SC_GETGR_R_SIZE_MAX); 501 ASSERT_GT(size, 0); 502 char buf[size]; 503 group grp_storage; 504 group* grp; 505 ASSERT_EQ(0, getgrnam_r("root", &grp_storage, buf, size, &grp)); 506 check_group(grp, "root", 0); 507 } 508 509 TEST(grp, getgrent_iterate) { 510 #if defined(__BIONIC__) 511 group* grp; 512 std::set<gid_t> gids; 513 514 setgrent(); 515 while ((grp = getgrent()) != NULL) { 516 ASSERT_TRUE(grp->gr_name != NULL) << "grp->gr_gid: " << grp->gr_gid; 517 ASSERT_TRUE(grp->gr_mem != NULL) << "grp->gr_gid: " << grp->gr_gid; 518 EXPECT_STREQ(grp->gr_name, grp->gr_mem[0]) << "grp->gr_gid: " << grp->gr_gid; 519 EXPECT_TRUE(grp->gr_mem[1] == NULL) << "grp->gr_gid: " << grp->gr_gid; 520 521 EXPECT_EQ(0U, gids.count(grp->gr_gid)) << "grp->gr_gid: " << grp->gr_gid; 522 gids.emplace(grp->gr_gid); 523 } 524 endgrent(); 525 526 expect_ids(gids); 527 #else 528 print_no_getgrnam_test_info(); 529 #endif 530 } 531
