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/file.h>
33 #include <android-base/strings.h>
34 #include <private/android_filesystem_config.h>
35
36 #if defined(__BIONIC__)
37 #include <android/api-level.h>
38 #include <android-base/properties.h>
39 #endif
40
41 // Generated android_ids array
42 #include "generated_android_ids.h"
43
44 using android::base::Join;
45 using android::base::ReadFileToString;
46 using android::base::Split;
47 using android::base::StartsWith;
48
49 using namespace std::literals;
50
51 enum uid_type_t {
52 TYPE_APP,
53 TYPE_SYSTEM,
54 TYPE_VENDOR,
55 };
56
57 #if defined(__BIONIC__)
58
check_passwd(const passwd * pwd,const char * username,uid_t uid,uid_type_t uid_type,bool check_username)59 static void check_passwd(const passwd* pwd, const char* username, uid_t uid, uid_type_t uid_type,
60 bool check_username) {
61 ASSERT_TRUE(pwd != nullptr);
62 if (check_username) {
63 EXPECT_STREQ(username, pwd->pw_name);
64 }
65 EXPECT_EQ(uid, pwd->pw_uid);
66 EXPECT_EQ(uid, pwd->pw_gid);
67 EXPECT_EQ(nullptr, pwd->pw_passwd);
68 #ifdef __LP64__
69 EXPECT_EQ(nullptr, pwd->pw_gecos);
70 #endif
71
72 if (uid_type == TYPE_APP) {
73 EXPECT_STREQ("/data", pwd->pw_dir);
74 } else {
75 EXPECT_STREQ("/", pwd->pw_dir);
76 }
77
78 // This has changed over time and that causes new GSI + old vendor images testing to fail.
79 // This parameter doesn't matter on Android, so simply ignore its value for older vendor images.
80 if (android::base::GetIntProperty("ro.product.first_api_level", 0) >= 30) {
81 EXPECT_STREQ("/bin/sh", pwd->pw_shell);
82 }
83 }
84
check_getpwuid(const char * username,uid_t uid,uid_type_t uid_type,bool check_username)85 static void check_getpwuid(const char* username, uid_t uid, uid_type_t uid_type,
86 bool check_username) {
87 errno = 0;
88 passwd* pwd = getpwuid(uid);
89 ASSERT_EQ(0, errno);
90 SCOPED_TRACE("getpwuid");
91 check_passwd(pwd, username, uid, uid_type, check_username);
92 }
93
check_getpwnam(const char * username,uid_t uid,uid_type_t uid_type,bool check_username)94 static void check_getpwnam(const char* username, uid_t uid, uid_type_t uid_type,
95 bool check_username) {
96 errno = 0;
97 passwd* pwd = getpwnam(username);
98 ASSERT_EQ(0, errno);
99 SCOPED_TRACE("getpwnam");
100 check_passwd(pwd, username, uid, uid_type, check_username);
101 }
102
check_getpwuid_r(const char * username,uid_t uid,uid_type_t uid_type,bool check_username)103 static void check_getpwuid_r(const char* username, uid_t uid, uid_type_t uid_type,
104 bool check_username) {
105 passwd pwd_storage;
106 char buf[512];
107 int result;
108
109 errno = 0;
110 passwd* pwd = nullptr;
111 result = getpwuid_r(uid, &pwd_storage, buf, sizeof(buf), &pwd);
112 ASSERT_EQ(0, result);
113 ASSERT_EQ(0, errno);
114 SCOPED_TRACE("getpwuid_r");
115 check_passwd(pwd, username, uid, uid_type, check_username);
116 }
117
check_getpwnam_r(const char * username,uid_t uid,uid_type_t uid_type,bool check_username)118 static void check_getpwnam_r(const char* username, uid_t uid, uid_type_t uid_type,
119 bool check_username) {
120 passwd pwd_storage;
121 char buf[512];
122 int result;
123
124 errno = 0;
125 passwd* pwd = nullptr;
126 result = getpwnam_r(username, &pwd_storage, buf, sizeof(buf), &pwd);
127 ASSERT_EQ(0, result);
128 ASSERT_EQ(0, errno);
129 SCOPED_TRACE("getpwnam_r");
130 check_passwd(pwd, username, uid, uid_type, check_username);
131 }
132
check_get_passwd(const char * username,uid_t uid,uid_type_t uid_type,bool check_username=true)133 static void check_get_passwd(const char* username, uid_t uid, uid_type_t uid_type,
134 bool check_username = true) {
135 SCOPED_TRACE("username '"s + username + "'");
136 check_getpwuid(username, uid, uid_type, check_username);
137 check_getpwnam(username, uid, uid_type, check_username);
138 check_getpwuid_r(username, uid, uid_type, check_username);
139 check_getpwnam_r(username, uid, uid_type, check_username);
140 }
141
expect_no_passwd_id(uid_t uid)142 static void expect_no_passwd_id(uid_t uid) {
143 SCOPED_TRACE("uid '" + std::to_string(uid) + "'");
144 errno = 0;
145 passwd* passwd = nullptr;
146 passwd = getpwuid(uid);
147 EXPECT_EQ(nullptr, passwd) << "name = '" << passwd->pw_name << "'";
148 EXPECT_EQ(ENOENT, errno);
149
150 struct passwd passwd_storage;
151 char buf[512];
152 EXPECT_EQ(ENOENT, getpwuid_r(uid, &passwd_storage, buf, sizeof(buf), &passwd));
153 EXPECT_EQ(nullptr, passwd) << "name = '" << passwd->pw_name << "'";
154 }
155
expect_no_passwd_name(const char * username)156 static void expect_no_passwd_name(const char* username) {
157 SCOPED_TRACE("username '"s + username + "'");
158 errno = 0;
159 passwd* passwd = nullptr;
160 passwd = getpwnam(username);
161 EXPECT_EQ(nullptr, passwd) << "name = '" << passwd->pw_name << "'";
162 EXPECT_EQ(ENOENT, errno);
163
164 struct passwd passwd_storage;
165 char buf[512];
166 EXPECT_EQ(ENOENT, getpwnam_r(username, &passwd_storage, buf, sizeof(buf), &passwd));
167 EXPECT_EQ(nullptr, passwd) << "name = '" << passwd->pw_name << "'";
168 }
169
170 #else // !defined(__BIONIC__)
171
check_get_passwd(const char *,uid_t,uid_type_t,bool)172 static void check_get_passwd(const char* /* username */, uid_t /* uid */, uid_type_t /* uid_type */,
173 bool /* check_username */) {
174 GTEST_SKIP() << "bionic-only test";
175 }
176
check_get_passwd(const char *,uid_t,uid_type_t)177 static void check_get_passwd(const char* /* username */, uid_t /* uid */, uid_type_t /* uid_type */) {
178 GTEST_SKIP() << "bionic-only test";
179 }
180
expect_no_passwd_id(uid_t)181 static void expect_no_passwd_id(uid_t /* uid */) {
182 GTEST_SKIP() << "bionic-only test";
183 }
184
expect_no_passwd_name(const char *)185 static void expect_no_passwd_name(const char* /* username */) {
186 GTEST_SKIP() << "bionic-only test";
187 }
188
189 #endif
190
TEST(pwd,getpwnam_platform_ids)191 TEST(pwd, getpwnam_platform_ids) {
192 check_get_passwd("root", 0, TYPE_SYSTEM);
193 check_get_passwd("daemon", 1, TYPE_SYSTEM);
194 check_get_passwd("bin", 2, TYPE_SYSTEM);
195
196 check_get_passwd("system", 1000, TYPE_SYSTEM);
197 check_get_passwd("radio", 1001, TYPE_SYSTEM);
198
199 check_get_passwd("shell", 2000, TYPE_SYSTEM);
200
201 check_get_passwd("nobody", 9999, TYPE_SYSTEM);
202 }
203
TEST(pwd,getpwnam_oem_ids)204 TEST(pwd, getpwnam_oem_ids) {
205 check_get_passwd("oem_2900", 2900, TYPE_VENDOR, false);
206 check_get_passwd("oem_2945", 2945, TYPE_VENDOR, false);
207 check_get_passwd("oem_2999", 2999, TYPE_VENDOR, false);
208 check_get_passwd("oem_5000", 5000, TYPE_VENDOR, false);
209 check_get_passwd("oem_5454", 5454, TYPE_VENDOR, false);
210 check_get_passwd("oem_5999", 5999, TYPE_VENDOR, false);
211 }
212
TEST(pwd,getpwnam_non_exist)213 TEST(pwd, getpwnam_non_exist) {
214 expect_no_passwd_id(999); // End of the system reserved range, unallocated.
215 expect_no_passwd_id(1999); // End of the system reserved range, unallocated.
216 expect_no_passwd_id(2899); // End of the system reserved range, unallocated.
217
218 // These ranges are for GIDs only.
219 expect_no_passwd_id(20000);
220 expect_no_passwd_id(30000);
221 expect_no_passwd_id(40000);
222 expect_no_passwd_id(50000);
223
224 // These should not be parsed as users, only as groups.
225 expect_no_passwd_name("u0_a9999_cache");
226 expect_no_passwd_name("u0_a9999_ext");
227 expect_no_passwd_name("u0_a9999_ext_cache");
228 expect_no_passwd_name("all_a9999");
229 }
230
TEST(pwd,getpwnam_u0_app_ids)231 TEST(pwd, getpwnam_u0_app_ids) {
232 check_get_passwd("u0_a0", 10000, TYPE_APP);
233 check_get_passwd("u0_a1234", 11234, TYPE_APP);
234 check_get_passwd("u0_a9999", 19999, TYPE_APP);
235
236 check_get_passwd("u0_i1", 90001, TYPE_APP);
237 check_get_passwd("u0_i4545", 94545, TYPE_APP);
238 check_get_passwd("u0_i9999", 99999, TYPE_APP);
239 }
240
TEST(pwd,getpwnam_app_id_u1_ids)241 TEST(pwd, getpwnam_app_id_u1_ids) {
242 check_get_passwd("u1_system", 101000, TYPE_SYSTEM);
243 check_get_passwd("u1_radio", 101001, TYPE_SYSTEM);
244
245 check_get_passwd("u1_a0", 110000, TYPE_APP);
246 check_get_passwd("u1_a1234", 111234, TYPE_APP);
247 check_get_passwd("u1_a9999", 119999, TYPE_APP);
248
249 check_get_passwd("u1_i1", 190001, TYPE_APP);
250 check_get_passwd("u1_i4545", 194545, TYPE_APP);
251 check_get_passwd("u1_i9999", 199999, TYPE_APP);
252 }
253
TEST(pwd,getpwnam_app_id_u31_ids)254 TEST(pwd, getpwnam_app_id_u31_ids) {
255 check_get_passwd("u31_system", 3101000, TYPE_SYSTEM);
256 check_get_passwd("u31_radio", 3101001, TYPE_SYSTEM);
257
258 check_get_passwd("u31_a0", 3110000, TYPE_APP);
259 check_get_passwd("u31_a1234", 3111234, TYPE_APP);
260 check_get_passwd("u31_a9999", 3119999, TYPE_APP);
261
262 check_get_passwd("u31_i1", 3190001, TYPE_APP);
263 check_get_passwd("u31_i4545", 3194545, TYPE_APP);
264 check_get_passwd("u31_i9999", 3199999, TYPE_APP);
265 }
266
TEST(pwd,getpwnam_app_id_not_allowed_platform)267 TEST(pwd, getpwnam_app_id_not_allowed_platform) {
268 expect_no_passwd_name("u1_root");
269 expect_no_passwd_name("u1_debuggerd");
270
271 expect_no_passwd_name("u31_root");
272 expect_no_passwd_name("u31_debuggerd");
273 }
274
TEST(pwd,getpwuid_app_id_u1_non_exist)275 TEST(pwd, getpwuid_app_id_u1_non_exist) {
276 expect_no_passwd_id(100000); // There is no 'root' for secondary users.
277 expect_no_passwd_id(101999); // End of the system reserved range, unallocated.
278 expect_no_passwd_id(102900); // The OEM ranges were never allocated to secondary users.
279 expect_no_passwd_id(105000); // The OEM ranges were never allocated to secondary users.
280
281 // These ranges are for GIDs only.
282 expect_no_passwd_id(120000);
283 expect_no_passwd_id(130000);
284 expect_no_passwd_id(140000);
285 expect_no_passwd_id(150000);
286 }
287
TEST(pwd,getpwuid_app_id_u31_non_exist)288 TEST(pwd, getpwuid_app_id_u31_non_exist) {
289 expect_no_passwd_id(3100000); // There is no 'root' for secondary users.
290 expect_no_passwd_id(3101999); // End of the system reserved range, unallocated.
291 expect_no_passwd_id(3102900); // The OEM ranges were never allocated to secondary users.
292 expect_no_passwd_id(3105000); // The OEM ranges were never allocated to secondary users.
293
294 // These ranges are for GIDs only.
295 expect_no_passwd_id(3120000);
296 expect_no_passwd_id(3130000);
297 expect_no_passwd_id(3140000);
298 expect_no_passwd_id(3150000);
299 }
300
TEST(pwd,getpwnam_r_alignment)301 TEST(pwd, getpwnam_r_alignment) {
302 #if defined(__BIONIC__)
303 passwd pwd_storage;
304 alignas(16) char buf[512];
305 passwd* pwd;
306 int result = getpwnam_r("root", &pwd_storage, buf + 1, sizeof(buf) - 1, &pwd);
307 ASSERT_EQ(0, result);
308 check_passwd(pwd, "root", 0, TYPE_SYSTEM, true);
309 #else
310 GTEST_SKIP() << "bionic-only test";
311 #endif
312 }
313
TEST(pwd,getpwuid_r_alignment)314 TEST(pwd, getpwuid_r_alignment) {
315 #if defined(__BIONIC__)
316 passwd pwd_storage;
317 alignas(16) char buf[512];
318 passwd* pwd;
319 int result = getpwuid_r(0, &pwd_storage, buf + 1, sizeof(buf) - 1, &pwd);
320 ASSERT_EQ(0, result);
321 check_passwd(pwd, "root", 0, TYPE_SYSTEM, true);
322 #else
323 GTEST_SKIP() << "bionic-only test";
324 #endif
325 }
326
TEST(pwd,getpwnam_r_reentrancy)327 TEST(pwd, getpwnam_r_reentrancy) {
328 #if defined(__BIONIC__)
329 passwd pwd_storage[2];
330 char buf[2][512];
331 passwd* pwd[3];
332 int result = getpwnam_r("root", &pwd_storage[0], buf[0], sizeof(buf[0]), &pwd[0]);
333 ASSERT_EQ(0, result);
334 check_passwd(pwd[0], "root", 0, TYPE_SYSTEM, true);
335 pwd[1] = getpwnam("system");
336 ASSERT_NE(nullptr, pwd[1]);
337 check_passwd(pwd[1], "system", 1000, TYPE_SYSTEM, true);
338 result = getpwnam_r("radio", &pwd_storage[1], buf[1], sizeof(buf[1]), &pwd[2]);
339 ASSERT_EQ(0, result);
340 check_passwd(pwd[2], "radio", 1001, TYPE_SYSTEM, true);
341 check_passwd(pwd[0], "root", 0, TYPE_SYSTEM, true);
342 check_passwd(pwd[1], "system", 1000, TYPE_SYSTEM, true);
343 #else
344 GTEST_SKIP() << "bionic-only test";
345 #endif
346 }
347
TEST(pwd,getpwuid_r_reentrancy)348 TEST(pwd, getpwuid_r_reentrancy) {
349 #if defined(__BIONIC__)
350 passwd pwd_storage[2];
351 char buf[2][512];
352 passwd* pwd[3];
353 int result = getpwuid_r(0, &pwd_storage[0], buf[0], sizeof(buf[0]), &pwd[0]);
354 ASSERT_EQ(0, result);
355 check_passwd(pwd[0], "root", 0, TYPE_SYSTEM, true);
356 pwd[1] = getpwuid(1000);
357 ASSERT_NE(nullptr, pwd[1]);
358 check_passwd(pwd[1], "system", 1000, TYPE_SYSTEM, true);
359 result = getpwuid_r(1001, &pwd_storage[1], buf[1], sizeof(buf[1]), &pwd[2]);
360 ASSERT_EQ(0, result);
361 check_passwd(pwd[2], "radio", 1001, TYPE_SYSTEM, true);
362 check_passwd(pwd[0], "root", 0, TYPE_SYSTEM, true);
363 check_passwd(pwd[1], "system", 1000, TYPE_SYSTEM, true);
364 #else
365 GTEST_SKIP() << "bionic-only test";
366 #endif
367 }
368
TEST(pwd,getpwnam_r_large_enough_suggested_buffer_size)369 TEST(pwd, getpwnam_r_large_enough_suggested_buffer_size) {
370 #if defined(__BIONIC__)
371 long size = sysconf(_SC_GETPW_R_SIZE_MAX);
372 ASSERT_GT(size, 0);
373 char buf[size];
374 passwd pwd_storage;
375 passwd* pwd;
376 ASSERT_EQ(0, getpwnam_r("root", &pwd_storage, buf, size, &pwd));
377 check_passwd(pwd, "root", 0, TYPE_SYSTEM, true);
378 #else
379 GTEST_SKIP() << "bionic-only test";
380 #endif
381 }
382
383 #if defined(__BIONIC__)
384 template <typename T>
expect_ids(T ids,bool is_group)385 static void expect_ids(T ids, bool is_group) {
386 std::set<typename T::key_type> expected_ids;
387 // Ensure that all android_ids are iterated through.
388 for (size_t n = 0; n < android_id_count; ++n) {
389 EXPECT_EQ(1U, ids.count(android_ids[n].aid)) << "android_ids[n].aid: " << android_ids[n].aid;
390 expected_ids.emplace(android_ids[n].aid);
391 }
392
393 auto expect_range = [&ids, &expected_ids](uid_t start, uid_t end) {
394 for (size_t n = start; n <= end; ++n) {
395 EXPECT_EQ(1U, ids.count(n)) << "n: " << n;
396 expected_ids.emplace(n);
397 }
398 };
399
400 // Ensure that all reserved ranges are iterated through.
401 expect_range(AID_OEM_RESERVED_START, AID_OEM_RESERVED_END);
402 expect_range(AID_OEM_RESERVED_2_START, AID_OEM_RESERVED_2_END);
403 expect_range(AID_APP_START, AID_APP_END);
404 if (is_group) {
405 expect_range(AID_CACHE_GID_START, AID_CACHE_GID_END);
406 expect_range(AID_EXT_GID_START, AID_EXT_GID_END);
407 expect_range(AID_EXT_CACHE_GID_START, AID_EXT_CACHE_GID_END);
408 expect_range(AID_SHARED_GID_START, AID_SHARED_GID_END);
409 }
410 expect_range(AID_ISOLATED_START, AID_ISOLATED_END);
411
412 // Prior to R, we didn't have a mechanism to create vendor AIDs in the system or other non-vendor
413 // partitions, therefore we disabled the rest of these checks for older API levels.
414 if (android::base::GetIntProperty("ro.product.first_api_level", 0) <= 29) {
415 return;
416 }
417
418 auto allow_range = [&ids](uid_t start, uid_t end) {
419 for (size_t n = start; n <= end; ++n) {
420 ids.erase(n);
421 }
422 };
423
424 allow_range(AID_SYSTEM_RESERVED_START, AID_SYSTEM_EXT_RESERVED_END);
425
426 // Ensure that no other ids were returned.
427 auto return_differences = [&ids, &expected_ids] {
428 std::vector<typename T::key_type> missing_from_ids;
429 std::set_difference(expected_ids.begin(), expected_ids.end(), ids.begin(), ids.end(),
430 std::inserter(missing_from_ids, missing_from_ids.begin()));
431 std::vector<typename T::key_type> extra_in_ids;
432 std::set_difference(ids.begin(), ids.end(), expected_ids.begin(), expected_ids.end(),
433 std::inserter(extra_in_ids, extra_in_ids.begin()));
434 std::string result;
435 if (!missing_from_ids.empty()) {
436 result += "Missing ids from results: " + Join(missing_from_ids, " ");
437 }
438 if (!extra_in_ids.empty()) {
439 if (!result.empty()) result += ", ";
440 result += "Extra ids in results: " + Join(extra_in_ids, " ");
441 }
442 return result;
443 };
444 EXPECT_EQ(expected_ids, ids) << return_differences();
445 }
446 #endif
447
TEST(pwd,getpwent_iterate)448 TEST(pwd, getpwent_iterate) {
449 #if defined(__BIONIC__)
450 passwd* pwd;
451 std::set<uid_t> uids;
452
453 setpwent();
454 while ((pwd = getpwent()) != nullptr) {
455 ASSERT_TRUE(nullptr != pwd->pw_name);
456
457 EXPECT_EQ(pwd->pw_gid, pwd->pw_uid) << "pwd->pw_uid: " << pwd->pw_uid;
458 EXPECT_EQ(nullptr, pwd->pw_passwd) << "pwd->pw_uid: " << pwd->pw_uid;
459 #ifdef __LP64__
460 EXPECT_TRUE(nullptr == pwd->pw_gecos) << "pwd->pw_uid: " << pwd->pw_uid;
461 #endif
462 EXPECT_TRUE(nullptr != pwd->pw_shell);
463 if (pwd->pw_uid < AID_APP_START || pwd->pw_uid == AID_OVERFLOWUID) {
464 EXPECT_STREQ("/", pwd->pw_dir) << "pwd->pw_uid: " << pwd->pw_uid;
465 } else {
466 EXPECT_STREQ("/data", pwd->pw_dir) << "pwd->pw_uid: " << pwd->pw_uid;
467 }
468
469 EXPECT_EQ(0U, uids.count(pwd->pw_uid)) << "pwd->pw_uid: " << pwd->pw_uid;
470 uids.emplace(pwd->pw_uid);
471 }
472 endpwent();
473
474 expect_ids(uids, false);
475 #else
476 GTEST_SKIP() << "bionic-only test";
477 #endif
478 }
479
check_group(const group * grp,const char * group_name,gid_t gid,bool check_groupname=true)480 static void check_group(const group* grp, const char* group_name, gid_t gid,
481 bool check_groupname = true) {
482 ASSERT_TRUE(grp != nullptr);
483 if (check_groupname) {
484 EXPECT_STREQ(group_name, grp->gr_name);
485 }
486 EXPECT_EQ(gid, grp->gr_gid);
487 ASSERT_TRUE(grp->gr_mem != nullptr);
488 if (check_groupname) {
489 EXPECT_STREQ(group_name, grp->gr_mem[0]);
490 }
491 EXPECT_TRUE(grp->gr_mem[1] == nullptr);
492 }
493
494 #if defined(__BIONIC__)
495
check_getgrgid(const char * group_name,gid_t gid,bool check_groupname)496 static void check_getgrgid(const char* group_name, gid_t gid, bool check_groupname) {
497 errno = 0;
498 group* grp = getgrgid(gid);
499 ASSERT_EQ(0, errno);
500 SCOPED_TRACE("getgrgid");
501 check_group(grp, group_name, gid, check_groupname);
502 }
503
check_getgrnam(const char * group_name,gid_t gid,bool check_groupname)504 static void check_getgrnam(const char* group_name, gid_t gid, bool check_groupname) {
505 errno = 0;
506 group* grp = getgrnam(group_name);
507 ASSERT_EQ(0, errno);
508 SCOPED_TRACE("getgrnam");
509 check_group(grp, group_name, gid, check_groupname);
510 }
511
check_getgrgid_r(const char * group_name,gid_t gid,bool check_groupname)512 static void check_getgrgid_r(const char* group_name, gid_t gid, bool check_groupname) {
513 group grp_storage;
514 char buf[512];
515 group* grp;
516
517 errno = 0;
518 int result = getgrgid_r(gid, &grp_storage, buf, sizeof(buf), &grp);
519 ASSERT_EQ(0, result);
520 ASSERT_EQ(0, errno);
521 SCOPED_TRACE("getgrgid_r");
522 check_group(grp, group_name, gid, check_groupname);
523 }
524
check_getgrnam_r(const char * group_name,gid_t gid,bool check_groupname)525 static void check_getgrnam_r(const char* group_name, gid_t gid, bool check_groupname) {
526 group grp_storage;
527 char buf[512];
528 group* grp;
529
530 errno = 0;
531 int result = getgrnam_r(group_name, &grp_storage, buf, sizeof(buf), &grp);
532 ASSERT_EQ(0, result);
533 ASSERT_EQ(0, errno);
534 SCOPED_TRACE("getgrnam_r");
535 check_group(grp, group_name, gid, check_groupname);
536 }
537
check_get_group(const char * group_name,gid_t gid,bool check_groupname=true)538 static void check_get_group(const char* group_name, gid_t gid, bool check_groupname = true) {
539 SCOPED_TRACE("groupname '"s + group_name + "'");
540 check_getgrgid(group_name, gid, check_groupname);
541 check_getgrnam(group_name, gid, check_groupname);
542 check_getgrgid_r(group_name, gid, check_groupname);
543 check_getgrnam_r(group_name, gid, check_groupname);
544 }
545
expect_no_group_id(gid_t gid)546 static void expect_no_group_id(gid_t gid) {
547 SCOPED_TRACE("gid '" + std::to_string(gid) + "'");
548 errno = 0;
549 group* group = nullptr;
550 group = getgrgid(gid);
551 EXPECT_EQ(nullptr, group) << "name = '" << group->gr_name << "'";
552 EXPECT_EQ(ENOENT, errno);
553
554 struct group group_storage;
555 char buf[512];
556 EXPECT_EQ(ENOENT, getgrgid_r(gid, &group_storage, buf, sizeof(buf), &group));
557 EXPECT_EQ(nullptr, group) << "name = '" << group->gr_name << "'";
558 }
559
expect_no_group_name(const char * groupname)560 static void expect_no_group_name(const char* groupname) {
561 SCOPED_TRACE("groupname '"s + groupname + "'");
562 errno = 0;
563 group* group = nullptr;
564 group = getgrnam(groupname);
565 EXPECT_EQ(nullptr, group) << "name = '" << group->gr_name << "'";
566 EXPECT_EQ(ENOENT, errno);
567
568 struct group group_storage;
569 char buf[512];
570 EXPECT_EQ(ENOENT, getgrnam_r(groupname, &group_storage, buf, sizeof(buf), &group));
571 EXPECT_EQ(nullptr, group) << "name = '" << group->gr_name << "'";
572 }
573
574 #else // !defined(__BIONIC__)
575
check_get_group(const char *,gid_t,bool)576 static void check_get_group(const char*, gid_t, bool) {
577 GTEST_SKIP() << "bionic-only test";
578 }
579
check_get_group(const char *,gid_t)580 static void check_get_group(const char*, gid_t) {
581 GTEST_SKIP() << "bionic-only test";
582 }
583
expect_no_group_id(gid_t)584 static void expect_no_group_id(gid_t /* gid */) {
585 GTEST_SKIP() << "bionic-only test";
586 }
587
expect_no_group_name(const char *)588 static void expect_no_group_name(const char* /* groupname */) {
589 GTEST_SKIP() << "bionic-only test";
590 }
591
592 #endif
593
TEST(grp,getgrnam_platform_ids)594 TEST(grp, getgrnam_platform_ids) {
595 check_get_group("root", 0);
596 check_get_group("daemon", 1);
597 check_get_group("bin", 2);
598
599 check_get_group("system", 1000);
600 check_get_group("radio", 1001);
601
602 check_get_group("shell", 2000);
603
604 check_get_group("nobody", 9999);
605 }
606
TEST(grp,getgrnam_oem_ids)607 TEST(grp, getgrnam_oem_ids) {
608 check_get_group("oem_2900", 2900, false);
609 check_get_group("oem_2945", 2945, false);
610 check_get_group("oem_2999", 2999, false);
611 check_get_group("oem_5000", 5000, false);
612 check_get_group("oem_5454", 5454, false);
613 check_get_group("oem_5999", 5999, false);
614 }
615
TEST(grp,getgrnam_non_exist)616 TEST(grp, getgrnam_non_exist) {
617 expect_no_passwd_id(999); // End of the system reserved range, unallocated.
618 expect_no_passwd_id(1999); // End of the system reserved range, unallocated.
619 expect_no_passwd_id(2899); // End of the system reserved range, unallocated.
620 }
621
TEST(grp,getgrnam_u0_app_ids)622 TEST(grp, getgrnam_u0_app_ids) {
623 check_get_group("u0_a0", 10000);
624 check_get_group("u0_a1234", 11234);
625 check_get_group("u0_a9999", 19999);
626
627 check_get_group("u0_a0_cache", 20000);
628 check_get_group("u0_a1234_cache", 21234);
629 check_get_group("u0_a9999_cache", 29999);
630
631 check_get_group("u0_a0_ext", 30000);
632 check_get_group("u0_a4545_ext", 34545);
633 check_get_group("u0_a9999_ext", 39999);
634
635 check_get_group("u0_a0_ext_cache", 40000);
636 check_get_group("u0_a4545_ext_cache", 44545);
637 check_get_group("u0_a9999_ext_cache", 49999);
638
639 check_get_group("all_a0", 50000);
640 check_get_group("all_a4545", 54545);
641 check_get_group("all_a9999", 59999);
642
643 check_get_group("u0_i1", 90001);
644 }
645
TEST(grp,getgrnam_u1_app_ids)646 TEST(grp, getgrnam_u1_app_ids) {
647 check_get_group("u1_system", 101000);
648 check_get_group("u1_radio", 101001);
649
650 check_get_group("u1_a0", 110000);
651 check_get_group("u1_a1234", 111234);
652 check_get_group("u1_a9999", 119999);
653
654 check_get_group("u1_a0_cache", 120000);
655 check_get_group("u1_a1234_cache", 121234);
656 check_get_group("u1_a9999_cache", 129999);
657
658 check_get_group("u1_a0_ext", 130000);
659 check_get_group("u1_a4545_ext", 134545);
660 check_get_group("u1_a9999_ext", 139999);
661
662 check_get_group("u1_a0_ext_cache", 140000);
663 check_get_group("u1_a4545_ext_cache", 144545);
664 check_get_group("u1_a9999_ext_cache", 149999);
665
666 check_get_group("u1_i1", 190001);
667 }
668
TEST(grp,getgrnam_u31_app_ids)669 TEST(grp, getgrnam_u31_app_ids) {
670 check_get_group("u31_system", 3101000);
671 check_get_group("u31_radio", 3101001);
672
673 check_get_group("u31_a0", 3110000);
674 check_get_group("u31_a1234", 3111234);
675 check_get_group("u31_a9999", 3119999);
676
677 check_get_group("u31_a0_cache", 3120000);
678 check_get_group("u31_a1234_cache", 3121234);
679 check_get_group("u31_a9999_cache", 3129999);
680
681 check_get_group("u31_a0_cache", 3120000);
682 check_get_group("u31_a1234_cache", 3121234);
683 check_get_group("u31_a9999_cache", 3129999);
684
685 check_get_group("u31_a0_ext", 3130000);
686 check_get_group("u31_a4545_ext", 3134545);
687 check_get_group("u31_a9999_ext", 3139999);
688
689 check_get_group("u31_a0_ext_cache", 3140000);
690 check_get_group("u31_a4545_ext_cache", 3144545);
691 check_get_group("u31_a9999_ext_cache", 3149999);
692
693 check_get_group("u31_i1", 3190001);
694 }
695
TEST(grp,getpgram_app_id_not_allowed_platform)696 TEST(grp, getpgram_app_id_not_allowed_platform) {
697 expect_no_group_name("u1_root");
698 expect_no_group_name("u1_debuggerd");
699
700 expect_no_group_name("u31_root");
701 expect_no_group_name("u31_debuggerd");
702 }
703
TEST(grp,getgrgid_app_id_u1_non_exist)704 TEST(grp, getgrgid_app_id_u1_non_exist) {
705 expect_no_group_id(100000); // There is no 'root' for secondary users.
706 expect_no_group_id(101999); // End of the system reserved range, unallocated.
707 expect_no_group_id(102900); // The OEM ranges were never allocated to secondary users.
708 expect_no_group_id(105000); // The OEM ranges were never allocated to secondary users.
709
710 // The shared range is shared among users, and therefore doesn't exist for secondary users.
711 expect_no_group_id(150000);
712 }
713
TEST(grp,getgrgid_app_id_u31_non_exist)714 TEST(grp, getgrgid_app_id_u31_non_exist) {
715 expect_no_group_id(3100000); // There is no 'root' for secondary users.
716 expect_no_group_id(3101999); // End of the system reserved range, unallocated.
717 expect_no_group_id(3102900); // The OEM ranges were never allocated to secondary users.
718 expect_no_group_id(3105000); // The OEM ranges were never allocated to secondary users.
719
720 // The shared range is shared among users, and therefore doesn't exist for secondary users.
721 expect_no_group_id(3150000);
722 }
723
TEST(grp,getgrnam_r_alignment)724 TEST(grp, getgrnam_r_alignment) {
725 #if defined(__BIONIC__)
726 group grp_storage;
727 alignas(16) char buf[512];
728 group* grp;
729 int result = getgrnam_r("root", &grp_storage, buf + 1, sizeof(buf) - 1, &grp);
730 ASSERT_EQ(0, result);
731 check_group(grp, "root", 0);
732 #else
733 GTEST_SKIP() << "bionic-only test";
734 #endif
735 }
736
TEST(grp,getgrgid_r_alignment)737 TEST(grp, getgrgid_r_alignment) {
738 #if defined(__BIONIC__)
739 group grp_storage;
740 alignas(16) char buf[512];
741 group* grp;
742 int result = getgrgid_r(0, &grp_storage, buf + 1, sizeof(buf) - 1, &grp);
743 ASSERT_EQ(0, result);
744 check_group(grp, "root", 0);
745 #else
746 GTEST_SKIP() << "bionic-only test";
747 #endif
748 }
749
TEST(grp,getgrnam_r_reentrancy)750 TEST(grp, getgrnam_r_reentrancy) {
751 #if defined(__BIONIC__)
752 group grp_storage[2];
753 char buf[2][512];
754 group* grp[3];
755 int result = getgrnam_r("root", &grp_storage[0], buf[0], sizeof(buf[0]), &grp[0]);
756 ASSERT_EQ(0, result);
757 check_group(grp[0], "root", 0);
758 grp[1] = getgrnam("system");
759 check_group(grp[1], "system", 1000);
760 result = getgrnam_r("radio", &grp_storage[1], buf[1], sizeof(buf[1]), &grp[2]);
761 ASSERT_EQ(0, result);
762 check_group(grp[2], "radio", 1001);
763 check_group(grp[0], "root", 0);
764 check_group(grp[1], "system", 1000);
765 #else
766 GTEST_SKIP() << "bionic-only test";
767 #endif
768 }
769
TEST(grp,getgrgid_r_reentrancy)770 TEST(grp, getgrgid_r_reentrancy) {
771 #if defined(__BIONIC__)
772 group grp_storage[2];
773 char buf[2][512];
774 group* grp[3];
775 int result = getgrgid_r(0, &grp_storage[0], buf[0], sizeof(buf[0]), &grp[0]);
776 ASSERT_EQ(0, result);
777 check_group(grp[0], "root", 0);
778 grp[1] = getgrgid(1000);
779 check_group(grp[1], "system", 1000);
780 result = getgrgid_r(1001, &grp_storage[1], buf[1], sizeof(buf[1]), &grp[2]);
781 ASSERT_EQ(0, result);
782 check_group(grp[2], "radio", 1001);
783 check_group(grp[0], "root", 0);
784 check_group(grp[1], "system", 1000);
785 #else
786 GTEST_SKIP() << "bionic-only test";
787 #endif
788 }
789
TEST(grp,getgrnam_r_large_enough_suggested_buffer_size)790 TEST(grp, getgrnam_r_large_enough_suggested_buffer_size) {
791 long size = sysconf(_SC_GETGR_R_SIZE_MAX);
792 ASSERT_GT(size, 0);
793 char buf[size];
794 group grp_storage;
795 group* grp;
796 ASSERT_EQ(0, getgrnam_r("root", &grp_storage, buf, size, &grp));
797 check_group(grp, "root", 0);
798 }
799
TEST(grp,getgrent_iterate)800 TEST(grp, getgrent_iterate) {
801 #if defined(__BIONIC__)
802 group* grp;
803 std::set<gid_t> gids;
804
805 setgrent();
806 while ((grp = getgrent()) != nullptr) {
807 ASSERT_TRUE(grp->gr_name != nullptr) << "grp->gr_gid: " << grp->gr_gid;
808 ASSERT_TRUE(grp->gr_mem != nullptr) << "grp->gr_gid: " << grp->gr_gid;
809 EXPECT_STREQ(grp->gr_name, grp->gr_mem[0]) << "grp->gr_gid: " << grp->gr_gid;
810 EXPECT_TRUE(grp->gr_mem[1] == nullptr) << "grp->gr_gid: " << grp->gr_gid;
811
812 EXPECT_EQ(0U, gids.count(grp->gr_gid)) << "grp->gr_gid: " << grp->gr_gid;
813 gids.emplace(grp->gr_gid);
814 }
815 endgrent();
816
817 expect_ids(gids, true);
818 #else
819 GTEST_SKIP() << "bionic-only test";
820 #endif
821 }
822
823 #if defined(__BIONIC__)
TestAidNamePrefix(const std::string & file_path)824 static void TestAidNamePrefix(const std::string& file_path) {
825 std::string file_contents;
826 if (!ReadFileToString(file_path, &file_contents)) {
827 // If we cannot read this file, then there are no vendor defind AID names, in which case this
828 // test passes by default.
829 return;
830 }
831 auto lines = Split(file_contents, "\n");
832 for (const auto& line : lines) {
833 if (line.empty()) continue;
834 auto name = Split(line, ":")[0];
835 EXPECT_TRUE(StartsWith(name, "vendor_"));
836 }
837 }
838 #endif
839
TEST(pwd,vendor_prefix_users)840 TEST(pwd, vendor_prefix_users) {
841 #if defined(__BIONIC__)
842 if (android::base::GetIntProperty("ro.product.first_api_level", 0) <= 28) {
843 return;
844 }
845
846 TestAidNamePrefix("/vendor/etc/passwd");
847 #else
848 GTEST_SKIP() << "bionic-only test";
849 #endif
850 }
851
TEST(pwd,vendor_prefix_groups)852 TEST(pwd, vendor_prefix_groups) {
853 #if defined(__BIONIC__)
854 if (android::base::GetIntProperty("ro.product.first_api_level", 0) <= 28) {
855 return;
856 }
857
858 TestAidNamePrefix("/vendor/etc/group");
859 #else
860 GTEST_SKIP() << "bionic-only test";
861 #endif
862 }
863