Merge "Clean up warnings in stubs.cpp."
This commit is contained in:
Elliott Hughes
android code review
commit
b66bc51423
@ -292,7 +292,7 @@ libc_common_src_files := \
|
||||
bionic/sched_cpucount.c \
|
||||
bionic/semaphore.c \
|
||||
bionic/sha1.c \
|
||||
bionic/stubs.c \
|
||||
bionic/stubs.cpp \
|
||||
bionic/system_properties.c \
|
||||
bionic/tdelete.c \
|
||||
bionic/tdestroy.c \
|
||||
|
||||
@ -1,525 +0,0 @@
|
||||
/*
|
||||
* Copyright (C) 2008 The Android Open Source Project
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||||
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
|
||||
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
||||
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
||||
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
|
||||
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <ctype.h>
|
||||
#include <errno.h>
|
||||
#include <grp.h>
|
||||
#include <mntent.h>
|
||||
#include <netdb.h>
|
||||
#include <private/android_filesystem_config.h>
|
||||
#include <private/logd.h>
|
||||
#include <pthread.h>
|
||||
#include <pwd.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
|
||||
static int do_getpw_r(int by_name, const char* name, uid_t uid,
|
||||
struct passwd* dst, char* buf, size_t byte_count, struct passwd** result)
|
||||
{
|
||||
/*
|
||||
* getpwnam_r and getpwuid_r don't modify errno, but library calls we
|
||||
* make might.
|
||||
*/
|
||||
int old_errno = errno;
|
||||
int rc = 0;
|
||||
*result = NULL;
|
||||
|
||||
const struct passwd* src = by_name ? getpwnam(name) : getpwuid(uid);
|
||||
|
||||
/*
|
||||
* POSIX allows failure to find a match to be considered a non-error.
|
||||
* Reporting success (0) but with *result NULL is glibc's behavior.
|
||||
*/
|
||||
if (src == NULL) {
|
||||
rc = (errno == ENOENT) ? 0 : errno;
|
||||
goto failure;
|
||||
}
|
||||
|
||||
/*
|
||||
* Work out where our strings will go in 'buf', and whether we've got
|
||||
* enough space.
|
||||
*/
|
||||
size_t required_byte_count = 0;
|
||||
dst->pw_name = buf;
|
||||
required_byte_count += strlen(src->pw_name) + 1;
|
||||
dst->pw_dir = buf + required_byte_count;
|
||||
required_byte_count += strlen(src->pw_dir) + 1;
|
||||
dst->pw_shell = buf + required_byte_count;
|
||||
required_byte_count += strlen(src->pw_shell) + 1;
|
||||
if (byte_count < required_byte_count) {
|
||||
rc = ERANGE;
|
||||
goto failure;
|
||||
}
|
||||
|
||||
/* Copy the strings. */
|
||||
snprintf(buf, byte_count, "%s%c%s%c%s",
|
||||
src->pw_name, 0, src->pw_dir, 0, src->pw_shell);
|
||||
|
||||
/*
|
||||
* pw_passwd is non-POSIX and unused (always NULL) in bionic.
|
||||
* pw_gecos is non-POSIX and missing in bionic.
|
||||
*/
|
||||
dst->pw_passwd = NULL;
|
||||
|
||||
/* Copy the integral fields. */
|
||||
dst->pw_gid = src->pw_gid;
|
||||
dst->pw_uid = src->pw_uid;
|
||||
|
||||
success:
|
||||
rc = 0;
|
||||
*result = dst;
|
||||
failure:
|
||||
errno = old_errno;
|
||||
return rc;
|
||||
}
|
||||
|
||||
int getpwnam_r(const char* name, struct passwd* pwd,
|
||||
char* buf, size_t byte_count, struct passwd** result)
|
||||
{
|
||||
return do_getpw_r(1, name, -1, pwd, buf, byte_count, result);
|
||||
}
|
||||
|
||||
int getpwuid_r(uid_t uid, struct passwd* pwd,
|
||||
char* buf, size_t byte_count, struct passwd** result)
|
||||
{
|
||||
return do_getpw_r(0, NULL, uid, pwd, buf, byte_count, result);
|
||||
}
|
||||
|
||||
/** Thread-specific state for the stubs functions
|
||||
**/
|
||||
|
||||
static pthread_once_t the_once = PTHREAD_ONCE_INIT;
|
||||
static pthread_key_t the_key;
|
||||
|
||||
typedef struct {
|
||||
struct passwd passwd;
|
||||
struct group group;
|
||||
char* group_members[2];
|
||||
char app_name_buffer[32];
|
||||
char group_name_buffer[32];
|
||||
} stubs_state_t;
|
||||
|
||||
static void
|
||||
stubs_state_free( void* _s )
|
||||
{
|
||||
stubs_state_t* s = _s;
|
||||
free(s);
|
||||
}
|
||||
|
||||
static stubs_state_t*
|
||||
stubs_state_alloc( void )
|
||||
{
|
||||
stubs_state_t* s = calloc(1, sizeof *s);
|
||||
|
||||
if (s != NULL) {
|
||||
s->group.gr_mem = s->group_members;
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
static void __stubs_key_init(void)
|
||||
{
|
||||
pthread_key_create( &the_key, stubs_state_free );
|
||||
}
|
||||
|
||||
static stubs_state_t*
|
||||
__stubs_state(void)
|
||||
{
|
||||
stubs_state_t* s;
|
||||
|
||||
pthread_once(&the_once, __stubs_key_init);
|
||||
s = pthread_getspecific(the_key);
|
||||
if (s == NULL) {
|
||||
s = stubs_state_alloc();
|
||||
if (s == NULL) {
|
||||
errno = ENOMEM; /* just in case */
|
||||
} else {
|
||||
if ( pthread_setspecific(the_key, s) != 0 ) {
|
||||
stubs_state_free(s);
|
||||
errno = ENOMEM;
|
||||
s = NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
static struct passwd*
|
||||
android_iinfo_to_passwd( struct passwd *pw,
|
||||
struct android_id_info *iinfo )
|
||||
{
|
||||
pw->pw_name = (char*)iinfo->name;
|
||||
pw->pw_uid = iinfo->aid;
|
||||
pw->pw_gid = iinfo->aid;
|
||||
pw->pw_dir = "/";
|
||||
pw->pw_shell = "/system/bin/sh";
|
||||
return pw;
|
||||
}
|
||||
|
||||
static struct group*
|
||||
android_iinfo_to_group( struct group *gr,
|
||||
struct android_id_info *iinfo )
|
||||
{
|
||||
gr->gr_name = (char*) iinfo->name;
|
||||
gr->gr_gid = iinfo->aid;
|
||||
gr->gr_mem[0] = gr->gr_name;
|
||||
gr->gr_mem[1] = NULL;
|
||||
return gr;
|
||||
}
|
||||
|
||||
static struct passwd *
|
||||
android_id_to_passwd( struct passwd *pw, unsigned id)
|
||||
{
|
||||
struct android_id_info *iinfo = android_ids;
|
||||
unsigned n;
|
||||
for (n = 0; n < android_id_count; n++) {
|
||||
if (iinfo[n].aid == id) {
|
||||
return android_iinfo_to_passwd(pw, iinfo + n);
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static struct passwd*
|
||||
android_name_to_passwd(struct passwd *pw, const char *name)
|
||||
{
|
||||
struct android_id_info *iinfo = android_ids;
|
||||
unsigned n;
|
||||
for (n = 0; n < android_id_count; n++) {
|
||||
if (!strcmp(iinfo[n].name, name)) {
|
||||
return android_iinfo_to_passwd(pw, iinfo + n);
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static struct group*
|
||||
android_id_to_group( struct group *gr, unsigned id )
|
||||
{
|
||||
struct android_id_info *iinfo = android_ids;
|
||||
unsigned n;
|
||||
for (n = 0; n < android_id_count; n++) {
|
||||
if (iinfo[n].aid == id) {
|
||||
return android_iinfo_to_group(gr, iinfo + n);
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static struct group*
|
||||
android_name_to_group( struct group *gr, const char *name )
|
||||
{
|
||||
struct android_id_info *iinfo = android_ids;
|
||||
unsigned n;
|
||||
for (n = 0; n < android_id_count; n++) {
|
||||
if (!strcmp(iinfo[n].name, name)) {
|
||||
return android_iinfo_to_group(gr, iinfo + n);
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* translate a user/group name to the corresponding user/group id.
|
||||
* u0_a1234 -> 0 * AID_USER + AID_APP + 1234
|
||||
* u2_i1000 -> 2 * AID_USER + AID_ISOLATED_START + 1000
|
||||
* u1_system -> 1 * AID_USER + android_ids['system']
|
||||
* returns 0 and sets errno to ENOENT in case of error
|
||||
*/
|
||||
static unsigned
|
||||
app_id_from_name( const char* name )
|
||||
{
|
||||
unsigned long userid;
|
||||
unsigned long appid = 0;
|
||||
char* end;
|
||||
|
||||
if (name[0] != 'u' || !isdigit(name[1]))
|
||||
goto FAIL;
|
||||
|
||||
userid = strtoul(name+1, &end, 10);
|
||||
if (end[0] != '_' || end[1] == 0)
|
||||
goto FAIL;
|
||||
|
||||
if (end[1] == 'a' && isdigit(end[2])) {
|
||||
/* end will point to \0 if the strtoul below succeeds. */
|
||||
appid = strtoul(end+2, &end, 10) + AID_APP;
|
||||
} else if (end[1] == 'i' && isdigit(end[2])) {
|
||||
/* end will point to \0 if the strtoul below succeeds. */
|
||||
appid = strtoul(end+2, &end, 10) + AID_ISOLATED_START;
|
||||
} else {
|
||||
for (size_t n = 0; n < android_id_count; n++) {
|
||||
if (!strcmp(android_ids[n].name, end + 1)) {
|
||||
appid = android_ids[n].aid;
|
||||
/* move the end pointer to the null terminator */
|
||||
end += 1 + strlen(android_ids[n].name);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* check if the entire string was consumed by the 3 cases above */
|
||||
if (end[0] != 0)
|
||||
goto FAIL;
|
||||
|
||||
/* check that user id won't overflow */
|
||||
if (userid > 1000)
|
||||
goto FAIL;
|
||||
|
||||
/* check that app id is within range */
|
||||
if (appid >= AID_USER)
|
||||
goto FAIL;
|
||||
|
||||
return (unsigned)(appid + userid*AID_USER);
|
||||
|
||||
FAIL:
|
||||
errno = ENOENT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void
|
||||
print_app_uid_name(uid_t uid, char* buffer, int bufferlen)
|
||||
{
|
||||
uid_t appid;
|
||||
uid_t userid;
|
||||
|
||||
appid = uid % AID_USER;
|
||||
userid = uid / AID_USER;
|
||||
|
||||
if (appid < AID_ISOLATED_START) {
|
||||
if (appid < AID_APP) {
|
||||
for (size_t n = 0; n < android_id_count; n++) {
|
||||
if (android_ids[n].aid == appid) {
|
||||
snprintf(buffer, bufferlen, "u%u_%s", userid, android_ids[n].name);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
snprintf(buffer, bufferlen, "u%u_a%u", userid, appid - AID_APP);
|
||||
} else {
|
||||
snprintf(buffer, bufferlen, "u%u_i%u", userid, appid - AID_ISOLATED_START);
|
||||
}
|
||||
}
|
||||
|
||||
/* translate a uid into the corresponding name.
|
||||
* 0 to AID_APP-1 -> "system", "radio", etc.
|
||||
* AID_APP to AID_ISOLATED_START-1 -> u0_a1234
|
||||
* AID_ISOLATED_START to AID_USER-1 -> u0_i1234
|
||||
* AID_USER+ -> u1_radio, u1_a1234, u2_i1234, etc.
|
||||
* returns a passwd structure (sets errno to ENOENT on failure)
|
||||
*/
|
||||
static struct passwd*
|
||||
app_id_to_passwd(uid_t uid, stubs_state_t* state)
|
||||
{
|
||||
struct passwd* pw = &state->passwd;
|
||||
|
||||
if (uid < AID_APP) {
|
||||
errno = ENOENT;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
print_app_uid_name(uid, state->app_name_buffer, sizeof state->app_name_buffer);
|
||||
|
||||
pw->pw_name = state->app_name_buffer;
|
||||
pw->pw_dir = "/data";
|
||||
pw->pw_shell = "/system/bin/sh";
|
||||
pw->pw_uid = uid;
|
||||
pw->pw_gid = uid;
|
||||
|
||||
return pw;
|
||||
}
|
||||
|
||||
/* translate a gid into the corresponding app_<gid>
|
||||
* group structure (sets errno to ENOENT on failure)
|
||||
*/
|
||||
static struct group*
|
||||
app_id_to_group(gid_t gid, stubs_state_t* state)
|
||||
{
|
||||
struct group* gr = &state->group;
|
||||
int appid;
|
||||
int userid;
|
||||
|
||||
if (gid < AID_APP) {
|
||||
errno = ENOENT;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
print_app_uid_name(gid, state->group_name_buffer, sizeof state->group_name_buffer);
|
||||
|
||||
gr->gr_name = state->group_name_buffer;
|
||||
gr->gr_gid = gid;
|
||||
gr->gr_mem[0] = gr->gr_name;
|
||||
gr->gr_mem[1] = NULL;
|
||||
|
||||
return gr;
|
||||
}
|
||||
|
||||
|
||||
struct passwd*
|
||||
getpwuid(uid_t uid)
|
||||
{
|
||||
stubs_state_t* state = __stubs_state();
|
||||
struct passwd* pw;
|
||||
|
||||
if (state == NULL)
|
||||
return NULL;
|
||||
|
||||
pw = &state->passwd;
|
||||
|
||||
if ( android_id_to_passwd(pw, uid) != NULL )
|
||||
return pw;
|
||||
|
||||
return app_id_to_passwd(uid, state);
|
||||
}
|
||||
|
||||
struct passwd*
|
||||
getpwnam(const char *login)
|
||||
{
|
||||
stubs_state_t* state = __stubs_state();
|
||||
|
||||
if (state == NULL)
|
||||
return NULL;
|
||||
|
||||
if (android_name_to_passwd(&state->passwd, login) != NULL)
|
||||
return &state->passwd;
|
||||
|
||||
return app_id_to_passwd( app_id_from_name(login), state );
|
||||
}
|
||||
|
||||
int
|
||||
getgrouplist (const char *user, gid_t group,
|
||||
gid_t *groups, int *ngroups)
|
||||
{
|
||||
if (*ngroups < 1) {
|
||||
*ngroups = 1;
|
||||
return -1;
|
||||
}
|
||||
groups[0] = group;
|
||||
return (*ngroups = 1);
|
||||
}
|
||||
|
||||
char*
|
||||
getlogin(void)
|
||||
{
|
||||
struct passwd *pw = getpwuid(getuid());
|
||||
|
||||
if(pw) {
|
||||
return pw->pw_name;
|
||||
} else {
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
struct group*
|
||||
getgrgid(gid_t gid)
|
||||
{
|
||||
stubs_state_t* state = __stubs_state();
|
||||
struct group* gr;
|
||||
|
||||
if (state == NULL)
|
||||
return NULL;
|
||||
|
||||
gr = android_id_to_group(&state->group, gid);
|
||||
if (gr != NULL)
|
||||
return gr;
|
||||
|
||||
return app_id_to_group(gid, state);
|
||||
}
|
||||
|
||||
struct group*
|
||||
getgrnam(const char *name)
|
||||
{
|
||||
stubs_state_t* state = __stubs_state();
|
||||
unsigned id;
|
||||
|
||||
if (state == NULL)
|
||||
return NULL;
|
||||
|
||||
if (android_name_to_group(&state->group, name) != 0)
|
||||
return &state->group;
|
||||
|
||||
return app_id_to_group( app_id_from_name(name), state );
|
||||
}
|
||||
|
||||
static void unimplemented_stub(const char* function) {
|
||||
const char* fmt = "%s(3) is not implemented on Android\n";
|
||||
__libc_android_log_print(ANDROID_LOG_WARN, "libc", fmt, function);
|
||||
fprintf(stderr, fmt, function);
|
||||
}
|
||||
|
||||
#define UNIMPLEMENTED unimplemented_stub(__PRETTY_FUNCTION__)
|
||||
|
||||
struct netent* getnetbyname(const char* name) {
|
||||
UNIMPLEMENTED;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void endpwent(void) {
|
||||
UNIMPLEMENTED;
|
||||
}
|
||||
|
||||
struct mntent* getmntent(FILE* f) {
|
||||
UNIMPLEMENTED;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
char* ttyname(int fd) {
|
||||
UNIMPLEMENTED;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int ttyname_r(int fd, char* buf, size_t buflen) {
|
||||
UNIMPLEMENTED;
|
||||
return -ERANGE;
|
||||
}
|
||||
|
||||
struct netent* getnetbyaddr(uint32_t net, int type) {
|
||||
UNIMPLEMENTED;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
struct protoent* getprotobyname(const char* name) {
|
||||
UNIMPLEMENTED;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
struct protoent* getprotobynumber(int proto) {
|
||||
UNIMPLEMENTED;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
char* getusershell(void) {
|
||||
UNIMPLEMENTED;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void setusershell(void) {
|
||||
UNIMPLEMENTED;
|
||||
}
|
||||
|
||||
void endusershell(void) {
|
||||
UNIMPLEMENTED;
|
||||
}
|
||||
461
libc/bionic/stubs.cpp
Normal file
461
libc/bionic/stubs.cpp
Normal file
@ -0,0 +1,461 @@
|
||||
/*
|
||||
* Copyright (C) 2008 The Android Open Source Project
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||||
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
|
||||
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
||||
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
||||
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
|
||||
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <ctype.h>
|
||||
#include <errno.h>
|
||||
#include <grp.h>
|
||||
#include <mntent.h>
|
||||
#include <netdb.h>
|
||||
#include <private/android_filesystem_config.h>
|
||||
#include <private/logd.h>
|
||||
#include <pthread.h>
|
||||
#include <pwd.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
|
||||
// Thread-specific state for the non-reentrant functions.
|
||||
static pthread_once_t stubs_once = PTHREAD_ONCE_INIT;
|
||||
static pthread_key_t stubs_key;
|
||||
struct stubs_state_t {
|
||||
passwd passwd_;
|
||||
group group_;
|
||||
char* group_members_[2];
|
||||
char app_name_buffer_[32];
|
||||
char group_name_buffer_[32];
|
||||
char dir_buffer_[32];
|
||||
char sh_buffer_[32];
|
||||
};
|
||||
|
||||
static int do_getpw_r(int by_name, const char* name, uid_t uid,
|
||||
passwd* dst, char* buf, size_t byte_count,
|
||||
passwd** result) {
|
||||
// getpwnam_r and getpwuid_r don't modify errno, but library calls we
|
||||
// make might.
|
||||
int old_errno = errno;
|
||||
*result = NULL;
|
||||
|
||||
// Our implementation of getpwnam(3) and getpwuid(3) use thread-local
|
||||
// storage, so we can call them as long as we copy everything out
|
||||
// before returning.
|
||||
const passwd* src = by_name ? getpwnam(name) : getpwuid(uid); // NOLINT: see above.
|
||||
|
||||
// POSIX allows failure to find a match to be considered a non-error.
|
||||
// Reporting success (0) but with *result NULL is glibc's behavior.
|
||||
if (src == NULL) {
|
||||
int rc = (errno == ENOENT) ? 0 : errno;
|
||||
errno = old_errno;
|
||||
return rc;
|
||||
}
|
||||
|
||||
// Work out where our strings will go in 'buf', and whether we've got
|
||||
// enough space.
|
||||
size_t required_byte_count = 0;
|
||||
dst->pw_name = buf;
|
||||
required_byte_count += strlen(src->pw_name) + 1;
|
||||
dst->pw_dir = buf + required_byte_count;
|
||||
required_byte_count += strlen(src->pw_dir) + 1;
|
||||
dst->pw_shell = buf + required_byte_count;
|
||||
required_byte_count += strlen(src->pw_shell) + 1;
|
||||
if (byte_count < required_byte_count) {
|
||||
errno = old_errno;
|
||||
return ERANGE;
|
||||
}
|
||||
|
||||
// Copy the strings.
|
||||
snprintf(buf, byte_count, "%s%c%s%c%s",
|
||||
src->pw_name, 0, src->pw_dir, 0, src->pw_shell);
|
||||
|
||||
// pw_passwd is non-POSIX and unused (always NULL) in bionic.
|
||||
// pw_gecos is non-POSIX and missing in bionic.
|
||||
dst->pw_passwd = NULL;
|
||||
|
||||
// Copy the integral fields.
|
||||
dst->pw_gid = src->pw_gid;
|
||||
dst->pw_uid = src->pw_uid;
|
||||
|
||||
*result = dst;
|
||||
errno = old_errno;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int getpwnam_r(const char* name, passwd* pwd,
|
||||
char* buf, size_t byte_count, passwd** result) {
|
||||
return do_getpw_r(1, name, -1, pwd, buf, byte_count, result);
|
||||
}
|
||||
|
||||
int getpwuid_r(uid_t uid, passwd* pwd,
|
||||
char* buf, size_t byte_count, passwd** result) {
|
||||
return do_getpw_r(0, NULL, uid, pwd, buf, byte_count, result);
|
||||
}
|
||||
|
||||
static stubs_state_t* stubs_state_alloc() {
|
||||
stubs_state_t* s = reinterpret_cast<stubs_state_t*>(calloc(1, sizeof(*s)));
|
||||
if (s != NULL) {
|
||||
s->group_.gr_mem = s->group_members_;
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
static void stubs_state_free(void* ptr) {
|
||||
stubs_state_t* state = reinterpret_cast<stubs_state_t*>(ptr);
|
||||
free(state);
|
||||
}
|
||||
|
||||
static void __stubs_key_init() {
|
||||
pthread_key_create(&stubs_key, stubs_state_free);
|
||||
}
|
||||
|
||||
static stubs_state_t* __stubs_state() {
|
||||
pthread_once(&stubs_once, __stubs_key_init);
|
||||
stubs_state_t* s =
|
||||
reinterpret_cast<stubs_state_t*>(pthread_getspecific(stubs_key));
|
||||
if (s == NULL) {
|
||||
s = stubs_state_alloc();
|
||||
if (s == NULL) {
|
||||
errno = ENOMEM; // Just in case.
|
||||
} else {
|
||||
if (pthread_setspecific(stubs_key, s) != 0) {
|
||||
stubs_state_free(s);
|
||||
errno = ENOMEM;
|
||||
s = NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
static passwd* android_iinfo_to_passwd(stubs_state_t* state,
|
||||
const android_id_info* iinfo) {
|
||||
snprintf(state->dir_buffer_, sizeof(state->dir_buffer_), "/");
|
||||
snprintf(state->sh_buffer_, sizeof(state->sh_buffer_), "/system/bin/sh");
|
||||
|
||||
passwd* pw = &state->passwd_;
|
||||
pw->pw_name = (char*) iinfo->name;
|
||||
pw->pw_uid = iinfo->aid;
|
||||
pw->pw_gid = iinfo->aid;
|
||||
pw->pw_dir = state->dir_buffer_;
|
||||
pw->pw_shell = state->sh_buffer_;
|
||||
return pw;
|
||||
}
|
||||
|
||||
static group* android_iinfo_to_group(group* gr,
|
||||
const android_id_info* iinfo) {
|
||||
gr->gr_name = (char*) iinfo->name;
|
||||
gr->gr_gid = iinfo->aid;
|
||||
gr->gr_mem[0] = gr->gr_name;
|
||||
gr->gr_mem[1] = NULL;
|
||||
return gr;
|
||||
}
|
||||
|
||||
static passwd* android_id_to_passwd(stubs_state_t* state, unsigned id) {
|
||||
for (size_t n = 0; n < android_id_count; ++n) {
|
||||
if (android_ids[n].aid == id) {
|
||||
return android_iinfo_to_passwd(state, android_ids + n);
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static passwd* android_name_to_passwd(stubs_state_t* state, const char* name) {
|
||||
for (size_t n = 0; n < android_id_count; ++n) {
|
||||
if (!strcmp(android_ids[n].name, name)) {
|
||||
return android_iinfo_to_passwd(state, android_ids + n);
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static group* android_id_to_group(group* gr, unsigned id) {
|
||||
for (size_t n = 0; n < android_id_count; ++n) {
|
||||
if (android_ids[n].aid == id) {
|
||||
return android_iinfo_to_group(gr, android_ids + n);
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static group* android_name_to_group(group* gr, const char* name) {
|
||||
for (size_t n = 0; n < android_id_count; ++n) {
|
||||
if (!strcmp(android_ids[n].name, name)) {
|
||||
return android_iinfo_to_group(gr, android_ids + n);
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Translate a user/group name to the corresponding user/group id.
|
||||
// u0_a1234 -> 0 * AID_USER + AID_APP + 1234
|
||||
// u2_i1000 -> 2 * AID_USER + AID_ISOLATED_START + 1000
|
||||
// u1_system -> 1 * AID_USER + android_ids['system']
|
||||
// returns 0 and sets errno to ENOENT in case of error
|
||||
static unsigned app_id_from_name(const char* name) {
|
||||
if (name[0] != 'u' || !isdigit(name[1])) {
|
||||
errno = ENOENT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
char* end;
|
||||
unsigned long userid = strtoul(name+1, &end, 10);
|
||||
if (end[0] != '_' || end[1] == 0) {
|
||||
errno = ENOENT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
unsigned long appid = 0;
|
||||
if (end[1] == 'a' && isdigit(end[2])) {
|
||||
// end will point to \0 if the strtoul below succeeds.
|
||||
appid = strtoul(end+2, &end, 10) + AID_APP;
|
||||
} else if (end[1] == 'i' && isdigit(end[2])) {
|
||||
// end will point to \0 if the strtoul below succeeds.
|
||||
appid = strtoul(end+2, &end, 10) + AID_ISOLATED_START;
|
||||
} else {
|
||||
for (size_t n = 0; n < android_id_count; n++) {
|
||||
if (!strcmp(android_ids[n].name, end + 1)) {
|
||||
appid = android_ids[n].aid;
|
||||
// Move the end pointer to the null terminator.
|
||||
end += strlen(android_ids[n].name) + 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Check that the entire string was consumed by one of the 3 cases above.
|
||||
if (end[0] != 0) {
|
||||
errno = ENOENT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Check that user id won't overflow.
|
||||
if (userid > 1000) {
|
||||
errno = ENOENT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Check that app id is within range.
|
||||
if (appid >= AID_USER) {
|
||||
errno = ENOENT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
return (unsigned)(appid + userid*AID_USER);
|
||||
}
|
||||
|
||||
static void print_app_uid_name(uid_t uid, char* buffer, int bufferlen) {
|
||||
uid_t appid = uid % AID_USER;
|
||||
uid_t userid = uid / AID_USER;
|
||||
|
||||
if (appid < AID_ISOLATED_START) {
|
||||
if (appid < AID_APP) {
|
||||
for (size_t n = 0; n < android_id_count; n++) {
|
||||
if (android_ids[n].aid == appid) {
|
||||
snprintf(buffer, bufferlen, "u%u_%s", userid, android_ids[n].name);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
snprintf(buffer, bufferlen, "u%u_a%u", userid, appid - AID_APP);
|
||||
} else {
|
||||
snprintf(buffer, bufferlen, "u%u_i%u", userid, appid - AID_ISOLATED_START);
|
||||
}
|
||||
}
|
||||
|
||||
// Translate a uid into the corresponding name.
|
||||
// 0 to AID_APP-1 -> "system", "radio", etc.
|
||||
// AID_APP to AID_ISOLATED_START-1 -> u0_a1234
|
||||
// AID_ISOLATED_START to AID_USER-1 -> u0_i1234
|
||||
// AID_USER+ -> u1_radio, u1_a1234, u2_i1234, etc.
|
||||
// returns a passwd structure (sets errno to ENOENT on failure).
|
||||
static passwd* app_id_to_passwd(uid_t uid, stubs_state_t* state) {
|
||||
passwd* pw = &state->passwd_;
|
||||
|
||||
if (uid < AID_APP) {
|
||||
errno = ENOENT;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
print_app_uid_name(uid, state->app_name_buffer_,
|
||||
sizeof(state->app_name_buffer_));
|
||||
|
||||
snprintf(state->dir_buffer_, sizeof(state->dir_buffer_), "/data");
|
||||
snprintf(state->sh_buffer_, sizeof(state->sh_buffer_), "/system/bin/sh");
|
||||
|
||||
pw->pw_name = state->app_name_buffer_;
|
||||
pw->pw_dir = state->dir_buffer_;
|
||||
pw->pw_shell = state->sh_buffer_;
|
||||
pw->pw_uid = uid;
|
||||
pw->pw_gid = uid;
|
||||
|
||||
return pw;
|
||||
}
|
||||
|
||||
// Translate a gid into the corresponding app_<gid>
|
||||
// group structure (sets errno to ENOENT on failure).
|
||||
static group* app_id_to_group(gid_t gid, stubs_state_t* state) {
|
||||
if (gid < AID_APP) {
|
||||
errno = ENOENT;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
print_app_uid_name(gid, state->group_name_buffer_,
|
||||
sizeof(state->group_name_buffer_));
|
||||
|
||||
group* gr = &state->group_;
|
||||
gr->gr_name = state->group_name_buffer_;
|
||||
gr->gr_gid = gid;
|
||||
gr->gr_mem[0] = gr->gr_name;
|
||||
gr->gr_mem[1] = NULL;
|
||||
return gr;
|
||||
}
|
||||
|
||||
|
||||
passwd* getpwuid(uid_t uid) { // NOLINT: implementing bad function.
|
||||
stubs_state_t* state = __stubs_state();
|
||||
if (state == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
passwd* pw = android_id_to_passwd(state, uid);
|
||||
if (pw != NULL) {
|
||||
return pw;
|
||||
}
|
||||
return app_id_to_passwd(uid, state);
|
||||
}
|
||||
|
||||
passwd* getpwnam(const char* login) { // NOLINT: implementing bad function.
|
||||
stubs_state_t* state = __stubs_state();
|
||||
if (state == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
passwd* pw = android_name_to_passwd(state, login);
|
||||
if (pw != NULL) {
|
||||
return pw;
|
||||
}
|
||||
return app_id_to_passwd(app_id_from_name(login), state);
|
||||
}
|
||||
|
||||
int getgrouplist(const char* user, gid_t group, gid_t* groups, int* ngroups) {
|
||||
if (*ngroups < 1) {
|
||||
*ngroups = 1;
|
||||
return -1;
|
||||
}
|
||||
groups[0] = group;
|
||||
return (*ngroups = 1);
|
||||
}
|
||||
|
||||
char* getlogin() { // NOLINT: implementing bad function.
|
||||
passwd *pw = getpwuid(getuid()); // NOLINT: implementing bad function in terms of bad function.
|
||||
return (pw != NULL) ? pw->pw_name : NULL;
|
||||
}
|
||||
|
||||
group* getgrgid(gid_t gid) { // NOLINT: implementing bad function.
|
||||
stubs_state_t* state = __stubs_state();
|
||||
if (state == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
group* gr = android_id_to_group(&state->group_, gid);
|
||||
if (gr != NULL) {
|
||||
return gr;
|
||||
}
|
||||
|
||||
return app_id_to_group(gid, state);
|
||||
}
|
||||
|
||||
group* getgrnam(const char* name) { // NOLINT: implementing bad function.
|
||||
stubs_state_t* state = __stubs_state();
|
||||
if (state == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (android_name_to_group(&state->group_, name) != 0) {
|
||||
return &state->group_;
|
||||
}
|
||||
|
||||
return app_id_to_group(app_id_from_name(name), state);
|
||||
}
|
||||
|
||||
static void unimplemented_stub(const char* function) {
|
||||
const char* fmt = "%s(3) is not implemented on Android\n";
|
||||
__libc_android_log_print(ANDROID_LOG_WARN, "libc", fmt, function);
|
||||
fprintf(stderr, fmt, function);
|
||||
}
|
||||
|
||||
#define UNIMPLEMENTED unimplemented_stub(__PRETTY_FUNCTION__)
|
||||
|
||||
netent* getnetbyname(const char* name) {
|
||||
UNIMPLEMENTED;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void endpwent() {
|
||||
UNIMPLEMENTED;
|
||||
}
|
||||
|
||||
mntent* getmntent(FILE* f) {
|
||||
UNIMPLEMENTED;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
char* ttyname(int fd) { // NOLINT: implementing bad function.
|
||||
UNIMPLEMENTED;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int ttyname_r(int fd, char* buf, size_t buflen) {
|
||||
UNIMPLEMENTED;
|
||||
return -ERANGE;
|
||||
}
|
||||
|
||||
netent* getnetbyaddr(uint32_t net, int type) {
|
||||
UNIMPLEMENTED;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
protoent* getprotobyname(const char* name) {
|
||||
UNIMPLEMENTED;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
protoent* getprotobynumber(int proto) {
|
||||
UNIMPLEMENTED;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
char* getusershell() {
|
||||
UNIMPLEMENTED;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void setusershell() {
|
||||
UNIMPLEMENTED;
|
||||
}
|
||||
|
||||
void endusershell() {
|
||||
UNIMPLEMENTED;
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user