blob: ab6793556189b75f6b1ac6dada0ff4795536c8fc [file] [log] [blame]
Elliott Hughesde727ca2012-08-13 15:45:36 -07001/*
2 * Copyright (C) 2008 The Android Open Source Project
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * * Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in
12 * the documentation and/or other materials provided with the
13 * distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29#include <ctype.h>
30#include <errno.h>
31#include <grp.h>
32#include <mntent.h>
33#include <netdb.h>
Elliott Hughesde727ca2012-08-13 15:45:36 -070034#include <pthread.h>
35#include <pwd.h>
36#include <stdio.h>
37#include <stdlib.h>
38#include <unistd.h>
39
Elliott Hughes3e898472013-02-12 16:40:24 +000040#include "private/android_filesystem_config.h"
Elliott Hughes3e898472013-02-12 16:40:24 +000041#include "private/ErrnoRestorer.h"
Elliott Hughes8f2a5a02013-03-15 15:30:25 -070042#include "private/libc_logging.h"
Yabin Cuia04c79b2014-11-18 16:14:54 -080043#include "private/ThreadLocalBuffer.h"
Elliott Hughes3e898472013-02-12 16:40:24 +000044
Elliott Hughes7874f1d2014-12-18 13:36:25 -080045// POSIX seems to envisage an implementation where the <pwd.h> functions are
46// implemented by brute-force searching with getpwent(3), and the <grp.h>
47// functions are implemented similarly with getgrent(3). This means that it's
48// okay for all the <grp.h> functions to share state, and all the <passwd.h>
49// functions to share state, but <grp.h> functions can't clobber <passwd.h>
50// functions' state and vice versa.
Yabin Cuia04c79b2014-11-18 16:14:54 -080051
Elliott Hughes7874f1d2014-12-18 13:36:25 -080052GLOBAL_INIT_THREAD_LOCAL_BUFFER(group);
53
54struct group_state_t {
Elliott Hughesde727ca2012-08-13 15:45:36 -070055 group group_;
56 char* group_members_[2];
Elliott Hughesde727ca2012-08-13 15:45:36 -070057 char group_name_buffer_[32];
Elliott Hughes7874f1d2014-12-18 13:36:25 -080058};
59
60static group_state_t* __group_state() {
61 LOCAL_INIT_THREAD_LOCAL_BUFFER(group_state_t*, group, sizeof(group_state_t));
62 if (group_tls_buffer != NULL) {
63 memset(group_tls_buffer, 0, sizeof(group_state_t));
64 group_tls_buffer->group_.gr_mem = group_tls_buffer->group_members_;
65 }
66 return group_tls_buffer;
67}
68
69GLOBAL_INIT_THREAD_LOCAL_BUFFER(passwd);
70
71struct passwd_state_t {
72 passwd passwd_;
73 char app_name_buffer_[32];
Elliott Hughesde727ca2012-08-13 15:45:36 -070074 char dir_buffer_[32];
75 char sh_buffer_[32];
76};
77
Elliott Hughes7874f1d2014-12-18 13:36:25 -080078static passwd_state_t* __passwd_state() {
79 LOCAL_INIT_THREAD_LOCAL_BUFFER(passwd_state_t*, passwd, sizeof(passwd_state_t));
80 return passwd_tls_buffer;
81}
82
Elliott Hughesde727ca2012-08-13 15:45:36 -070083static int do_getpw_r(int by_name, const char* name, uid_t uid,
84 passwd* dst, char* buf, size_t byte_count,
85 passwd** result) {
86 // getpwnam_r and getpwuid_r don't modify errno, but library calls we
87 // make might.
Elliott Hughes3e898472013-02-12 16:40:24 +000088 ErrnoRestorer errno_restorer;
Elliott Hughesde727ca2012-08-13 15:45:36 -070089 *result = NULL;
90
91 // Our implementation of getpwnam(3) and getpwuid(3) use thread-local
92 // storage, so we can call them as long as we copy everything out
93 // before returning.
94 const passwd* src = by_name ? getpwnam(name) : getpwuid(uid); // NOLINT: see above.
95
96 // POSIX allows failure to find a match to be considered a non-error.
97 // Reporting success (0) but with *result NULL is glibc's behavior.
98 if (src == NULL) {
Elliott Hughes3e898472013-02-12 16:40:24 +000099 return (errno == ENOENT) ? 0 : errno;
Elliott Hughesde727ca2012-08-13 15:45:36 -0700100 }
101
102 // Work out where our strings will go in 'buf', and whether we've got
103 // enough space.
104 size_t required_byte_count = 0;
105 dst->pw_name = buf;
106 required_byte_count += strlen(src->pw_name) + 1;
107 dst->pw_dir = buf + required_byte_count;
108 required_byte_count += strlen(src->pw_dir) + 1;
109 dst->pw_shell = buf + required_byte_count;
110 required_byte_count += strlen(src->pw_shell) + 1;
111 if (byte_count < required_byte_count) {
Elliott Hughesde727ca2012-08-13 15:45:36 -0700112 return ERANGE;
113 }
114
115 // Copy the strings.
Elliott Hughes3e898472013-02-12 16:40:24 +0000116 snprintf(buf, byte_count, "%s%c%s%c%s", src->pw_name, 0, src->pw_dir, 0, src->pw_shell);
Elliott Hughesde727ca2012-08-13 15:45:36 -0700117
Calin Juravlec7688742014-05-09 21:50:53 +0100118 // pw_passwd and pw_gecos are non-POSIX and unused (always NULL) in bionic.
Elliott Hughesde727ca2012-08-13 15:45:36 -0700119 dst->pw_passwd = NULL;
Elliott Hughes7874f1d2014-12-18 13:36:25 -0800120#if defined(__LP64__)
Calin Juravlec7688742014-05-09 21:50:53 +0100121 dst->pw_gecos = NULL;
122#endif
Elliott Hughesde727ca2012-08-13 15:45:36 -0700123
124 // Copy the integral fields.
125 dst->pw_gid = src->pw_gid;
126 dst->pw_uid = src->pw_uid;
127
128 *result = dst;
Elliott Hughesde727ca2012-08-13 15:45:36 -0700129 return 0;
130}
131
132int getpwnam_r(const char* name, passwd* pwd,
133 char* buf, size_t byte_count, passwd** result) {
134 return do_getpw_r(1, name, -1, pwd, buf, byte_count, result);
135}
136
137int getpwuid_r(uid_t uid, passwd* pwd,
138 char* buf, size_t byte_count, passwd** result) {
139 return do_getpw_r(0, NULL, uid, pwd, buf, byte_count, result);
140}
141
Elliott Hughes7874f1d2014-12-18 13:36:25 -0800142static passwd* android_iinfo_to_passwd(passwd_state_t* state,
Elliott Hughesde727ca2012-08-13 15:45:36 -0700143 const android_id_info* iinfo) {
144 snprintf(state->dir_buffer_, sizeof(state->dir_buffer_), "/");
145 snprintf(state->sh_buffer_, sizeof(state->sh_buffer_), "/system/bin/sh");
146
147 passwd* pw = &state->passwd_;
148 pw->pw_name = (char*) iinfo->name;
149 pw->pw_uid = iinfo->aid;
150 pw->pw_gid = iinfo->aid;
151 pw->pw_dir = state->dir_buffer_;
152 pw->pw_shell = state->sh_buffer_;
153 return pw;
154}
155
156static group* android_iinfo_to_group(group* gr,
157 const android_id_info* iinfo) {
158 gr->gr_name = (char*) iinfo->name;
159 gr->gr_gid = iinfo->aid;
160 gr->gr_mem[0] = gr->gr_name;
Elliott Hughesde727ca2012-08-13 15:45:36 -0700161 return gr;
162}
163
Elliott Hughes7874f1d2014-12-18 13:36:25 -0800164static passwd* android_id_to_passwd(passwd_state_t* state, unsigned id) {
Elliott Hughesde727ca2012-08-13 15:45:36 -0700165 for (size_t n = 0; n < android_id_count; ++n) {
166 if (android_ids[n].aid == id) {
167 return android_iinfo_to_passwd(state, android_ids + n);
168 }
169 }
170 return NULL;
171}
172
Elliott Hughes7874f1d2014-12-18 13:36:25 -0800173static passwd* android_name_to_passwd(passwd_state_t* state, const char* name) {
Elliott Hughesde727ca2012-08-13 15:45:36 -0700174 for (size_t n = 0; n < android_id_count; ++n) {
175 if (!strcmp(android_ids[n].name, name)) {
176 return android_iinfo_to_passwd(state, android_ids + n);
177 }
178 }
179 return NULL;
180}
181
182static group* android_id_to_group(group* gr, unsigned id) {
183 for (size_t n = 0; n < android_id_count; ++n) {
184 if (android_ids[n].aid == id) {
185 return android_iinfo_to_group(gr, android_ids + n);
186 }
187 }
188 return NULL;
189}
190
191static group* android_name_to_group(group* gr, const char* name) {
192 for (size_t n = 0; n < android_id_count; ++n) {
193 if (!strcmp(android_ids[n].name, name)) {
194 return android_iinfo_to_group(gr, android_ids + n);
195 }
196 }
197 return NULL;
198}
199
200// Translate a user/group name to the corresponding user/group id.
Yabin Cuia04c79b2014-11-18 16:14:54 -0800201// all_a1234 -> 0 * AID_USER + AID_SHARED_GID_START + 1234 (group name only)
Elliott Hughesde727ca2012-08-13 15:45:36 -0700202// u0_a1234 -> 0 * AID_USER + AID_APP + 1234
203// u2_i1000 -> 2 * AID_USER + AID_ISOLATED_START + 1000
204// u1_system -> 1 * AID_USER + android_ids['system']
205// returns 0 and sets errno to ENOENT in case of error
Yabin Cuia04c79b2014-11-18 16:14:54 -0800206static unsigned app_id_from_name(const char* name, bool is_group) {
207 char* end;
208 unsigned long userid;
209 bool is_shared_gid = false;
210
211 if (is_group && name[0] == 'a' && name[1] == 'l' && name[2] == 'l') {
212 end = const_cast<char*>(name+3);
213 userid = 0;
214 is_shared_gid = true;
215 } else if (name[0] == 'u' && isdigit(name[1])) {
216 userid = strtoul(name+1, &end, 10);
217 } else {
Elliott Hughesde727ca2012-08-13 15:45:36 -0700218 errno = ENOENT;
219 return 0;
220 }
221
Elliott Hughesde727ca2012-08-13 15:45:36 -0700222 if (end[0] != '_' || end[1] == 0) {
223 errno = ENOENT;
224 return 0;
225 }
226
227 unsigned long appid = 0;
228 if (end[1] == 'a' && isdigit(end[2])) {
Yabin Cuia04c79b2014-11-18 16:14:54 -0800229 if (is_shared_gid) {
230 // end will point to \0 if the strtoul below succeeds.
231 appid = strtoul(end+2, &end, 10) + AID_SHARED_GID_START;
232 if (appid > AID_SHARED_GID_END) {
233 errno = ENOENT;
234 return 0;
235 }
236 } else {
237 // end will point to \0 if the strtoul below succeeds.
238 appid = strtoul(end+2, &end, 10) + AID_APP;
239 }
Elliott Hughesde727ca2012-08-13 15:45:36 -0700240 } else if (end[1] == 'i' && isdigit(end[2])) {
241 // end will point to \0 if the strtoul below succeeds.
242 appid = strtoul(end+2, &end, 10) + AID_ISOLATED_START;
243 } else {
244 for (size_t n = 0; n < android_id_count; n++) {
245 if (!strcmp(android_ids[n].name, end + 1)) {
246 appid = android_ids[n].aid;
247 // Move the end pointer to the null terminator.
248 end += strlen(android_ids[n].name) + 1;
249 }
250 }
251 }
252
253 // Check that the entire string was consumed by one of the 3 cases above.
254 if (end[0] != 0) {
255 errno = ENOENT;
256 return 0;
257 }
258
259 // Check that user id won't overflow.
260 if (userid > 1000) {
261 errno = ENOENT;
262 return 0;
263 }
264
265 // Check that app id is within range.
266 if (appid >= AID_USER) {
267 errno = ENOENT;
268 return 0;
269 }
270
271 return (unsigned)(appid + userid*AID_USER);
272}
273
Yabin Cuia04c79b2014-11-18 16:14:54 -0800274static void print_app_name_from_uid(const uid_t uid, char* buffer, const int bufferlen) {
275 const uid_t appid = uid % AID_USER;
276 const uid_t userid = uid / AID_USER;
Kenny Root8a05a012012-09-13 14:31:50 -0700277 if (appid >= AID_ISOLATED_START) {
278 snprintf(buffer, bufferlen, "u%u_i%u", userid, appid - AID_ISOLATED_START);
Kenny Root8a05a012012-09-13 14:31:50 -0700279 } else if (appid < AID_APP) {
280 for (size_t n = 0; n < android_id_count; n++) {
281 if (android_ids[n].aid == appid) {
282 snprintf(buffer, bufferlen, "u%u_%s", userid, android_ids[n].name);
283 return;
Elliott Hughesde727ca2012-08-13 15:45:36 -0700284 }
285 }
Elliott Hughesde727ca2012-08-13 15:45:36 -0700286 } else {
Kenny Root8a05a012012-09-13 14:31:50 -0700287 snprintf(buffer, bufferlen, "u%u_a%u", userid, appid - AID_APP);
Elliott Hughesde727ca2012-08-13 15:45:36 -0700288 }
289}
290
Yabin Cuia04c79b2014-11-18 16:14:54 -0800291static void print_app_name_from_gid(const gid_t gid, char* buffer, const int bufferlen) {
292 const uid_t appid = gid % AID_USER;
293 const uid_t userid = gid / AID_USER;
294 if (appid >= AID_ISOLATED_START) {
295 snprintf(buffer, bufferlen, "u%u_i%u", userid, appid - AID_ISOLATED_START);
296 } else if (userid == 0 && appid >= AID_SHARED_GID_START && appid <= AID_SHARED_GID_END) {
297 snprintf(buffer, bufferlen, "all_a%u", appid - AID_SHARED_GID_START);
298 } else if (appid < AID_APP) {
299 for (size_t n = 0; n < android_id_count; n++) {
300 if (android_ids[n].aid == appid) {
301 snprintf(buffer, bufferlen, "u%u_%s", userid, android_ids[n].name);
302 return;
303 }
304 }
305 } else {
306 snprintf(buffer, bufferlen, "u%u_a%u", userid, appid - AID_APP);
307 }
Kenny Root2a54e5e2012-09-13 10:52:52 -0700308}
309
Elliott Hughesde727ca2012-08-13 15:45:36 -0700310// Translate a uid into the corresponding name.
311// 0 to AID_APP-1 -> "system", "radio", etc.
312// AID_APP to AID_ISOLATED_START-1 -> u0_a1234
313// AID_ISOLATED_START to AID_USER-1 -> u0_i1234
314// AID_USER+ -> u1_radio, u1_a1234, u2_i1234, etc.
315// returns a passwd structure (sets errno to ENOENT on failure).
Elliott Hughes7874f1d2014-12-18 13:36:25 -0800316static passwd* app_id_to_passwd(uid_t uid, passwd_state_t* state) {
Elliott Hughesde727ca2012-08-13 15:45:36 -0700317 if (uid < AID_APP) {
318 errno = ENOENT;
319 return NULL;
320 }
321
Yabin Cuia04c79b2014-11-18 16:14:54 -0800322 print_app_name_from_uid(uid, state->app_name_buffer_, sizeof(state->app_name_buffer_));
323
Kenny Root2a54e5e2012-09-13 10:52:52 -0700324 const uid_t appid = uid % AID_USER;
Kenny Root2a54e5e2012-09-13 10:52:52 -0700325 if (appid < AID_APP) {
326 snprintf(state->dir_buffer_, sizeof(state->dir_buffer_), "/");
327 } else {
328 snprintf(state->dir_buffer_, sizeof(state->dir_buffer_), "/data");
329 }
330
Elliott Hughesde727ca2012-08-13 15:45:36 -0700331 snprintf(state->sh_buffer_, sizeof(state->sh_buffer_), "/system/bin/sh");
332
Elliott Hughes7874f1d2014-12-18 13:36:25 -0800333 passwd* pw = &state->passwd_;
Elliott Hughesde727ca2012-08-13 15:45:36 -0700334 pw->pw_name = state->app_name_buffer_;
335 pw->pw_dir = state->dir_buffer_;
336 pw->pw_shell = state->sh_buffer_;
337 pw->pw_uid = uid;
338 pw->pw_gid = uid;
Elliott Hughesde727ca2012-08-13 15:45:36 -0700339 return pw;
340}
341
342// Translate a gid into the corresponding app_<gid>
343// group structure (sets errno to ENOENT on failure).
Elliott Hughes7874f1d2014-12-18 13:36:25 -0800344static group* app_id_to_group(gid_t gid, group_state_t* state) {
Elliott Hughesde727ca2012-08-13 15:45:36 -0700345 if (gid < AID_APP) {
346 errno = ENOENT;
347 return NULL;
348 }
349
Yabin Cuia04c79b2014-11-18 16:14:54 -0800350 print_app_name_from_gid(gid, state->group_name_buffer_, sizeof(state->group_name_buffer_));
Elliott Hughesde727ca2012-08-13 15:45:36 -0700351
352 group* gr = &state->group_;
353 gr->gr_name = state->group_name_buffer_;
354 gr->gr_gid = gid;
355 gr->gr_mem[0] = gr->gr_name;
Elliott Hughesde727ca2012-08-13 15:45:36 -0700356 return gr;
357}
358
Elliott Hughesde727ca2012-08-13 15:45:36 -0700359passwd* getpwuid(uid_t uid) { // NOLINT: implementing bad function.
Elliott Hughes7874f1d2014-12-18 13:36:25 -0800360 passwd_state_t* state = __passwd_state();
Elliott Hughesde727ca2012-08-13 15:45:36 -0700361 if (state == NULL) {
362 return NULL;
363 }
364
365 passwd* pw = android_id_to_passwd(state, uid);
366 if (pw != NULL) {
367 return pw;
368 }
369 return app_id_to_passwd(uid, state);
370}
371
372passwd* getpwnam(const char* login) { // NOLINT: implementing bad function.
Elliott Hughes7874f1d2014-12-18 13:36:25 -0800373 passwd_state_t* state = __passwd_state();
Elliott Hughesde727ca2012-08-13 15:45:36 -0700374 if (state == NULL) {
375 return NULL;
376 }
377
378 passwd* pw = android_name_to_passwd(state, login);
379 if (pw != NULL) {
380 return pw;
381 }
Yabin Cuia04c79b2014-11-18 16:14:54 -0800382 return app_id_to_passwd(app_id_from_name(login, false), state);
Elliott Hughesde727ca2012-08-13 15:45:36 -0700383}
384
Elliott Hughes6fa26e22012-10-22 16:04:56 -0700385// All users are in just one group, the one passed in.
386int getgrouplist(const char* /*user*/, gid_t group, gid_t* groups, int* ngroups) {
Elliott Hughes7874f1d2014-12-18 13:36:25 -0800387 if (*ngroups < 1) {
388 *ngroups = 1;
389 return -1;
390 }
391 groups[0] = group;
392 return (*ngroups = 1);
Elliott Hughesde727ca2012-08-13 15:45:36 -0700393}
394
395char* getlogin() { // NOLINT: implementing bad function.
396 passwd *pw = getpwuid(getuid()); // NOLINT: implementing bad function in terms of bad function.
397 return (pw != NULL) ? pw->pw_name : NULL;
398}
399
400group* getgrgid(gid_t gid) { // NOLINT: implementing bad function.
Elliott Hughes7874f1d2014-12-18 13:36:25 -0800401 group_state_t* state = __group_state();
Elliott Hughesde727ca2012-08-13 15:45:36 -0700402 if (state == NULL) {
403 return NULL;
404 }
405
406 group* gr = android_id_to_group(&state->group_, gid);
407 if (gr != NULL) {
408 return gr;
409 }
Elliott Hughesde727ca2012-08-13 15:45:36 -0700410 return app_id_to_group(gid, state);
411}
412
413group* getgrnam(const char* name) { // NOLINT: implementing bad function.
Elliott Hughes7874f1d2014-12-18 13:36:25 -0800414 group_state_t* state = __group_state();
Elliott Hughesde727ca2012-08-13 15:45:36 -0700415 if (state == NULL) {
416 return NULL;
417 }
418
419 if (android_name_to_group(&state->group_, name) != 0) {
420 return &state->group_;
421 }
Yabin Cuia04c79b2014-11-18 16:14:54 -0800422 return app_id_to_group(app_id_from_name(name, true), state);
Elliott Hughesde727ca2012-08-13 15:45:36 -0700423}
424
Elliott Hughes6fa26e22012-10-22 16:04:56 -0700425// We don't have an /etc/networks, so all inputs return NULL.
426netent* getnetbyname(const char* /*name*/) {
427 return NULL;
428}
429
430// We don't have an /etc/networks, so all inputs return NULL.
431netent* getnetbyaddr(uint32_t /*net*/, int /*type*/) {
432 return NULL;
433}
434
435// We don't have an /etc/protocols, so all inputs return NULL.
436protoent* getprotobyname(const char* /*name*/) {
437 return NULL;
438}
439
440// We don't have an /etc/protocols, so all inputs return NULL.
441protoent* getprotobynumber(int /*proto*/) {
442 return NULL;
443}
444
Elliott Hughesde727ca2012-08-13 15:45:36 -0700445static void unimplemented_stub(const char* function) {
446 const char* fmt = "%s(3) is not implemented on Android\n";
Elliott Hughes1e980b62013-01-17 18:36:06 -0800447 __libc_format_log(ANDROID_LOG_WARN, "libc", fmt, function);
Elliott Hughesde727ca2012-08-13 15:45:36 -0700448 fprintf(stderr, fmt, function);
449}
450
451#define UNIMPLEMENTED unimplemented_stub(__PRETTY_FUNCTION__)
452
Elliott Hughesde727ca2012-08-13 15:45:36 -0700453void endpwent() {
454 UNIMPLEMENTED;
455}
456
Elliott Hughesde727ca2012-08-13 15:45:36 -0700457char* getusershell() {
458 UNIMPLEMENTED;
459 return NULL;
460}
461
462void setusershell() {
463 UNIMPLEMENTED;
464}
465
466void endusershell() {
467 UNIMPLEMENTED;
468}
Bernhard Rosenkraenzer9ae59c02013-09-18 23:29:08 +0200469
Elliott Hughes0e44bc32014-02-24 15:55:31 -0800470// Portable code should use sysconf(_SC_PAGE_SIZE) directly instead.
Bernhard Rosenkraenzer9ae59c02013-09-18 23:29:08 +0200471int getpagesize() {
Elliott Hughes91570ce2014-07-10 12:34:23 -0700472 // We dont use sysconf(3) here because that drags in stdio, which makes static binaries fat.
473 return PAGE_SIZE;
Bernhard Rosenkraenzer9ae59c02013-09-18 23:29:08 +0200474}