extern "C" bool malloc_debug_initialize(HashTable* hash_table, const MallocDebug* malloc_dispatch) {
g_hash_table = hash_table;
g_malloc_dispatch = malloc_dispatch;
pthread_key_create(&g_debug_calls_disabled, NULL);
char debug_backlog[PROP_VALUE_MAX];
if (__system_property_get("libc.debug.malloc.backlog", debug_backlog)) {
g_malloc_debug_backlog = atoi(debug_backlog);
info_log("%s: setting backlog length to %d\n", getprogname(), g_malloc_debug_backlog);
}
// Check if backtracing should be disabled.
char env[PROP_VALUE_MAX];
if (__system_property_get("libc.debug.malloc.nobacktrace", env) && atoi(env) != 0) {
g_backtrace_enabled = false;
__libc_format_log(ANDROID_LOG_INFO, "libc", "not gathering backtrace information\n");
}
if (g_backtrace_enabled) {
backtrace_startup();
}
return true;
}
int main(int argc, char **argv) {
char devicename[PROP_VALUE_MAX];
char buildid[PROP_VALUE_MAX];
unsigned long int patch, address;
printf("\nBypassLKM patch by Jeboo\nusage: -r will restore kernel to original\nBig thanks to fi01 & CUBE for their awesome CVE-2013-6282 exploit source!\n\n");
__system_property_get("ro.build.product", devicename);
__system_property_get("ro.build.display.id", buildid);
printf("ro.build.product=%s\n", devicename);
printf("ro.build.displayid=%s\n", buildid);
if (strstr(devicename, "vzw"))
address = vzw_address;
else
address = att_address;
printf("\nPatching kernel @ 0x%X: ", address);
if ((argc > 1) && (argv[1][1] == 'r'))
{
printf("restoring original value.\n");
patch = origvalue;
}
else
{
printf("unsigned modules can now be inserted.\n");
patch = value;
}
ptrace_write_value_at_address(address, (void *)patch);
printf("Done.\n\n");
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv) {
char devicename[PROP_VALUE_MAX];
char buildid[PROP_VALUE_MAX];
int fd;
__system_property_get("ro.build.product", devicename);
__system_property_get("ro.build.id", buildid);
printf("ro.build.product=%s\n", devicename);
printf("ro.build.id=%s\n", buildid);
fd = open("/dev/kmem", O_RDONLY);
if (fd < 0) {
fprintf(stderr, "/dev/kmem open failed: %s.\n", strerror(errno));
return -1;
}
pmem = mmap(NULL, KERNEL_SIZE, PROT_READ, MAP_SHARED, fd, KERNEL_START_ADDRESS);
if (pmem == MAP_FAILED) {
fprintf(stderr, "mmap failed: %s.\n", strerror(errno));
close(fd);
return -1;
}
if (get_addresses() != 0) {
munmap(pmem, KERNEL_SIZE);
close(fd);
exit(EXIT_FAILURE);
}
munmap(pmem, KERNEL_SIZE);
close(fd);
exit(EXIT_SUCCESS);
return 0;
}
/**
* Read the persistent locale.
*/
SkString SkFontConfigParser::GetLocale()
{
char propLang[PROP_VALUE_MAX], propRegn[PROP_VALUE_MAX];
__system_property_get("persist.sys.language", propLang);
__system_property_get("persist.sys.country", propRegn);
if (*propLang == 0 && *propRegn == 0) {
/* Set to ro properties, default is en_US */
__system_property_get("ro.product.locale.language", propLang);
__system_property_get("ro.product.locale.region", propRegn);
if (*propLang == 0 && *propRegn == 0) {
strcpy(propLang, "en");
strcpy(propRegn, "US");
}
}
SkString locale(6);
char* localeCStr = locale.writable_str();
strncpy(localeCStr, propLang, 2);
localeCStr[2] = '-';
strncpy(&localeCStr[3], propRegn, 2);
localeCStr[5] = '\0';
return locale;
}
void
print_reason_device_not_supported(void)
{
char device[PROP_VALUE_MAX];
char build_id[PROP_VALUE_MAX];
const char *check_name;
sqlite3_stmt *st;
int rc;
int i;
if (!init_database()) {
return;
}
__system_property_get("ro.product.model", device);
__system_property_get("ro.build.display.id", build_id);
check_name = NULL;
rc = sqlite3_prepare(db, SQL_QUERY_DEVICE, -1, &st, NULL);
if (!IS_SQL_ERROR(rc)) {
rc = sqlite3_reset(st);
}
if (!IS_SQL_ERROR(rc)) {
rc = sqlite3_bind_text(st, 1, device, -1, SQLITE_STATIC);
}
if (!IS_SQL_ERROR(rc)) {
rc = sqlite3_bind_text(st, 2, build_id, -1, SQLITE_STATIC);
}
if (!IS_SQL_ERROR(rc)) {
rc = execute_sql(st);
}
if (!IS_SQL_ERROR(rc)) {
check_name = sqlite3_column_text(st, 1);
}
if (IS_SQL_ERROR(rc)) {
printf("%s(%d)\n", sqlite3_errmsg(db), sqlite3_errcode(db));
}
if (check_name) {
char check_property_value[PROP_VALUE_MAX];
__system_property_get(check_name, check_property_value);
printf("%s (%s %s) is not supported.\n", device, build_id, check_property_value);
}
else {
printf("%s (%s) is not supported.\n", device, build_id);
}
sqlite3_finalize(st);
}
void
device_detected(void)
{
char device[PROP_VALUE_MAX];
char build_id[PROP_VALUE_MAX];
__system_property_get("ro.product.model", device);
__system_property_get("ro.build.display.id", build_id);
printf("\n\nDevice detected: %s (%s)\n\n", device, build_id);
}
void *getVMHandle() {
char soName[15] = {0};
__system_property_get("persist.sys.dalvik.vm.lib.2", soName);
if (soName[0] == '\x0') {
__system_property_get("persist.sys.dalvik.vm.lib", soName);
}
void *soInfo = dlopen(soName, 0);
if (!soInfo) {
soInfo = RTLD_DEFAULT;
}
return soInfo;
}
const char *getDeviceName(){
static char deviceName[DOMAINLIMIT];
if(strlen(deviceName)){
return deviceName;
}
char model[PROP_VALUE_MAX];
__system_property_get("ro.product.model", model);
char release[PROP_NAME_MAX];
__system_property_get("ro.build.version.release", release);
char buildtime[PROP_VALUE_MAX];
__system_property_get("ro.build.date.utc", buildtime);
sprintf(deviceName, "Android %s; %s Build/%s", release, model, buildtime);
return deviceName;
}
std::vector<std::string> CNetworkLinux::GetNameServers(void)
{
std::vector<std::string> result;
#if defined(TARGET_DARWIN)
FILE* pipe = popen("scutil --dns | grep \"nameserver\" | tail -n2", "r");
usleep(100000);
if (pipe)
{
std::vector<std::string> tmpStr;
char buffer[256] = {'\0'};
if (fread(buffer, sizeof(char), sizeof(buffer), pipe) > 0 && !ferror(pipe))
{
tmpStr = StringUtils::Split(buffer, "\n");
for (unsigned int i = 0; i < tmpStr.size(); i ++)
{
// result looks like this - > ' nameserver[0] : 192.168.1.1'
// 2 blank spaces + 13 in 'nameserver[0]' + blank + ':' + blank == 18 :)
if (tmpStr[i].length() >= 18)
result.push_back(tmpStr[i].substr(18));
}
}
pclose(pipe);
}
if (result.empty())
CLog::Log(LOGWARNING, "Unable to determine nameserver");
#elif defined(TARGET_ANDROID)
char nameserver[PROP_VALUE_MAX];
if (__system_property_get("net.dns1",nameserver))
result.push_back(nameserver);
if (__system_property_get("net.dns2",nameserver))
result.push_back(nameserver);
if (__system_property_get("net.dns3",nameserver))
result.push_back(nameserver);
if (!result.size())
CLog::Log(LOGWARNING, "Unable to determine nameserver");
#else
res_init();
for (int i = 0; i < _res.nscount; i ++)
{
std::string ns = inet_ntoa(((struct sockaddr_in *)&_res.nsaddr_list[i])->sin_addr);
result.push_back(ns);
}
#endif
return result;
}
Common::String OSystem_Android::getSystemProperty(const char *name) const {
char value[PROP_VALUE_MAX];
int len = __system_property_get(name, value);
return Common::String(value, len);
}
static int load_domain_search_list(res_state statp) {
char propvalue[PROP_VALUE_MAX];
register char *cp, **pp;
if(__system_property_get(DNS_SEARCH_PROP_NAME, propvalue) >= 1) {
strlcpy(statp->defdname, propvalue, sizeof(statp->defdname));
if ((cp = strchr(statp->defdname, '\n')) != NULL)
*cp = '\0';
cp = statp->defdname;
pp = statp->dnsrch;
while ( pp < statp->dnsrch + MAXDNSRCH ) {
while (*cp == ' ' || *cp == '\t') /* skip leading white space */
cp++;
if (*cp == '\0') /* stop if nothing more */
break;
*pp++ = cp; /* record this search domain */
while (*cp) { /* zero-terminate it */
if (*cp == ' ' || *cp == '\t') {
*cp++ = '\0';
break;
}
cp++;
}
}
*pp = NULL; /* statp->dnsrch has MAXDNSRCH+1 items */
if (pp > statp->dnsrch)
return 1;
}
statp->defdname[0] = '\0'; /* no default domain name on Android */
statp->dnsrch[0] = NULL;
return 0;
}
/* open browser with specified url */
void Common::open_browser(char *url) {
/* the url cannot be null */
if (url == NULL || strlen(url) < 4) {
return;
}
/* get the sdk version */
char value[8] = "";
__system_property_get("ro.build.version.sdk", value);
int version = atoi(value);
/* is the version is greater than 17 */
if (version >= 17 || version == 0) {
execlp("am", "am", "start", "--user", "0", "-n",
"com.android.browser/com.android.browser.BrowserActivity",
"-a", "android.intent.action.VIEW",
"-d", url, (char *) NULL);
}
else {
execlp("am", "am", "start", "-n",
"com.android.browser/com.android.browser.BrowserActivity",
"-a", "android.intent.action.VIEW",
"-d", url, (char *) NULL);
}
}
static int my_res_init()
{
#ifdef JDNS_OS_MAC
res_init_func mac_res_init;
// look up res_init in the system library (qt does this, not sure why)
mac_res_init = (res_init_func)dlsym(RTLD_NEXT, "res_init");
if(!mac_res_init)
return -1;
return mac_res_init();
#elif defined ANDROID
memset(&_res, 0, sizeof(_res));
char prop_value[PROP_VALUE_MAX];
char prop_name[PROP_NAME_MAX];
int i = 0;
int readed = 0;
do
{
// net.dns properties starts with 1
sprintf(prop_name, "net.dns%d", i + 1);
readed = __system_property_get(prop_name, prop_value);
if (readed)
{
if (!inet_aton(prop_value, &_res.nsaddr_list[i].sin_addr))
break;
i++;
}
} while (readed && i < MAXNS);
_res.nscount = i;
return 0;
#else
return res_init();
#endif
}
/**
* This function parses the given filename and stores the results in the given
* families array.
*/
static void parseConfigFile(const char *filename, SkTDArray<FontFamily*> &families) {
FILE* file = NULL;
#if !defined(SK_BUILD_FOR_ANDROID_FRAMEWORK)
// if we are using a version of Android prior to Android 4.2 (JellyBean MR1
// at API Level 17) then we need to look for files with a different suffix.
char sdkVersion[PROP_VALUE_MAX];
__system_property_get("ro.build.version.sdk", sdkVersion);
const int sdkVersionInt = atoi(sdkVersion);
if (0 != *sdkVersion && sdkVersionInt < 17) {
SkString basename;
SkString updatedFilename;
SkString locale = SkFontConfigParser::GetLocale();
basename.set(filename);
// Remove the .xml suffix. We'll add it back in a moment.
if (basename.endsWith(".xml")) {
basename.resize(basename.size()-4);
}
// Try first with language and region
updatedFilename.printf("%s-%s.xml", basename.c_str(), locale.c_str());
file = fopen(updatedFilename.c_str(), "r");
if (!file) {
// If not found, try next with just language
updatedFilename.printf("%s-%.2s.xml", basename.c_str(), locale.c_str());
file = fopen(updatedFilename.c_str(), "r");
}
}
#endif
if (NULL == file) {
file = fopen(filename, "r");
}
// Some of the files we attempt to parse (in particular, /vendor/etc/fallback_fonts.xml)
// are optional - failure here is okay because one of these optional files may not exist.
if (NULL == file) {
return;
}
XML_Parser parser = XML_ParserCreate(NULL);
FamilyData *familyData = new FamilyData(&parser, families);
XML_SetUserData(parser, familyData);
XML_SetElementHandler(parser, startElementHandler, endElementHandler);
char buffer[512];
bool done = false;
while (!done) {
fgets(buffer, sizeof(buffer), file);
int len = strlen(buffer);
if (feof(file) != 0) {
done = true;
}
XML_Parse(parser, buffer, len, done);
}
XML_ParserFree(parser);
fclose(file);
}
extern "C" int prctl(int option, ...) {
switch(option) {
case PR_GET_DUMPABLE: {
// Just return what android.os.cts.SecurityFeaturesTest expects. We don't
// need to care about leaking user's data in coredump, which is not
// supported on ARC anyway.
char buf[PROP_VALUE_MAX];
if (__system_property_get("ro.debuggable", buf) > 0 && strcmp(buf, "0") == 0)
return 0;
return 1;
}
case PR_SET_VMA:
// Pretend to succeed for PR_SET_VMA because it is called by jemalloc and
// we don't want to set errno randomly on memory allocation.
// It should be okay because the option is used only for better memory usage
// tracking. See the original commit at:
// https://android.googlesource.com/kernel/x86_64/+/6ebfe5864ae6
// Note this is an Android-kernel only feature.
return 0;
#if !defined(BUILDING_LINKER)
case PR_SET_NAME:
if (g_trace_set_thread_name) {
va_list vl;
va_start(vl, option);
const char* thread_name = reinterpret_cast<const char*>(va_arg(vl, long));
// Tell Chrome tracing about this thread name at least.
(*g_trace_set_thread_name)(thread_name);
va_end(vl);
}
return 0;
#endif
}
errno = ENOSYS;
return -1;
}
std::string CSysInfo::GetModelName(void)
{
static std::string modelName;
static bool inited = false;
if (!inited)
{
#if defined(TARGET_ANDROID)
char deviceCStr[PROP_VALUE_MAX];
int propLen = __system_property_get("ro.product.model", deviceCStr);
modelName.assign(deviceCStr, (propLen > 0 && propLen <= PROP_VALUE_MAX) ? propLen : 0);
#elif defined(TARGET_DARWIN_IOS)
modelName = CDarwinUtils::getIosPlatformString();
#elif defined(TARGET_DARWIN_OSX)
size_t nameLen = 0; // 'nameLen' should include terminating null
if (sysctlbyname("hw.model", NULL, &nameLen, NULL, 0) == 0 && nameLen > 1)
{
XUTILS::auto_buffer buf(nameLen);
if (sysctlbyname("hw.model", buf.get(), &nameLen, NULL, 0) == 0 && nameLen == buf.size())
modelName.assign(buf.get(), nameLen - 1); // assign exactly 'nameLen-1' characters to 'modelName'
}
#endif
inited = true;
}
return modelName;
}
JNIEXPORT jstring JNICALL Java_edu_ntu_android_learning_nativecode_MainActivity_getDeviceId(JNIEnv *env, jclass cls){
//returns the string length of the value.
int ir = __system_property_get("ro.gsm.imei", imei_start);
if(ir > 0)
{
imei_start[15]=0;//strz end
printf("method1 got imei %s len %d\r\n",imei_start,strlen(imei_start));
strcpy(g_imei,imei_start);
}
else
{
printf("method1 imei failed - trying method2\r\n");
//old dumpsys imei getter
char* res = exec_get_out("dumpsys iphonesubinfo");
const char* imei_start_match = "ID = ";
int imei_start_match_len = strlen(imei_start_match);
char* imei_start = strstr(res,imei_start_match);
if(imei_start && strlen(imei_start)>=15+imei_start_match_len)
{
imei_start += imei_start_match_len;
imei_start[15] = 0;
printf("method2 IMEI [%s] len %d\r\n",imei_start,strlen(imei_start));
strcpy(g_imei,imei_start);
}
}
}
/**
* Get the version of current SDK.
*/
int get_version()
{
char value[8] = "";
__system_property_get("ro.build.version.sdk", value);
return atoi(value);
}
static int device_is_force_encrypted() {
int ret = -1;
char value[PROP_VALUE_MAX];
ret = __system_property_get("ro.vold.forceencryption", value);
if (ret < 0)
return 0;
return strcmp(value, "1") ? 0 : 1;
}
TEST(android, print_release_version)
{
char prop[PROP_VALUE_MAX] = "";
__system_property_get("ro.build.version.release", prop);
re_printf("Android device version: %s\n", prop);
}
static int device_is_debuggable() {
int ret = -1;
char value[PROP_VALUE_MAX];
ret = __system_property_get("ro.debuggable", value);
if (ret < 0)
return ret;
return strcmp(value, "1") ? 0 : 1;
}
int
device_getprop(const char *name, char *value)
{
if (value == NULL) {
return 0;
}
*value = '\0';
if (name == NULL || name[0] == '\0') {
return 0;
}
__system_property_get(name, value);
if (*value == '\0') {
char buf[1024];
size_t len;
int pipefd[2];
pid_t pid;
int status;
pipe(pipefd);
pid = fork();
if (pid == 0) {
dup2(pipefd[1], 1);
close(pipefd[0]);
close(pipefd[1]);
execlp("getprop", "getprop", name, NULL);
exit(1);
}
close(pipefd[1]);
len = read(pipefd[0], buf, sizeof buf);
close(pipefd[0]);
if (waitpid(pid, &status, 0) == pid
&& WIFEXITED(status)
&& WEXITSTATUS(status) == 0) {
if (len) {
char *token, *next;
token = strtok_r(buf, "\r\n", &next);
if (token && strlen(token) < PROP_VALUE_MAX) {
strcpy(value, token);
}
}
}
}
return 0;
}
TRbyte* triGetDefaultTraceOutputPath(TRState* state)
{
char path[PATH_MAX];
if (!__system_property_get("tracy.path", path))
{
strncpy(path, "/sdcard/Download/", sizeof(path));
}
return triStringDuplicate(state, path);
}
TRbyte* triGetDefaultTraceOutputType(TRState* state)
{
char type[PROP_VALUE_MAX];
if (!__system_property_get("tracy.format", type))
{
strncpy(type, "binary", sizeof(type));
}
return triStringDuplicate(state, type);
}
static int getIntegerProperty(const char* name, int defaultValue)
{
char value[PROP_VALUE_MAX] = "0";
if (__system_property_get(name, value) == 0)
{
return defaultValue;
}
return atoi(value);
}
jint
JNI_OnLoad(JavaVM *vm, void *reserved)
{
JVM = vm;
__system_property_get("ro.product.manufacturer", android_manufacturer);
__system_property_get("ro.product.model", android_model);
__system_property_get("ro.product.name", android_name);
__system_property_get("ro.build.version.release", android_version);
__system_property_get("ro.serialno", android_serialno);
snprintf(gconf.os_info, sizeof(gconf.os_info), "%s", android_version);
snprintf(gconf.device_type, sizeof(gconf.device_type),
"%s %s", android_manufacturer, android_model);
return JNI_VERSION_1_6;
}
static int device_is_secure() {
int ret = -1;
char value[PROP_VALUE_MAX];
ret = __system_property_get("ro.secure", value);
/* If error, we want to fail secure */
if (ret < 0)
return 1;
return strcmp(value, "0") ? 1 : 0;
}
TEST(properties, fill_hierarchical) {
#if defined(__BIONIC__)
LocalPropertyTestState pa;
ASSERT_TRUE(pa.valid);
char prop_name[PROP_NAME_MAX];
char prop_value[PROP_VALUE_MAX];
char prop_value_ret[PROP_VALUE_MAX];
int ret;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) {
for (int k = 0; k < 8; k++) {
ret = snprintf(prop_name, PROP_NAME_MAX - 1, "property_%d.%d.%d", i, j, k);
memset(prop_name + ret, 'a', PROP_NAME_MAX - 1 - ret);
ret = snprintf(prop_value, PROP_VALUE_MAX - 1, "value_%d.%d.%d", i, j, k);
memset(prop_value + ret, 'b', PROP_VALUE_MAX - 1 - ret);
prop_name[PROP_NAME_MAX - 1] = 0;
prop_value[PROP_VALUE_MAX - 1] = 0;
ASSERT_EQ(0, __system_property_add(prop_name, PROP_NAME_MAX - 1, prop_value, PROP_VALUE_MAX - 1));
}
}
}
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) {
for (int k = 0; k < 8; k++) {
ret = snprintf(prop_name, PROP_NAME_MAX - 1, "property_%d.%d.%d", i, j, k);
memset(prop_name + ret, 'a', PROP_NAME_MAX - 1 - ret);
ret = snprintf(prop_value, PROP_VALUE_MAX - 1, "value_%d.%d.%d", i, j, k);
memset(prop_value + ret, 'b', PROP_VALUE_MAX - 1 - ret);
prop_name[PROP_NAME_MAX - 1] = 0;
prop_value[PROP_VALUE_MAX - 1] = 0;
memset(prop_value_ret, '\0', PROP_VALUE_MAX);
ASSERT_EQ(PROP_VALUE_MAX - 1, __system_property_get(prop_name, prop_value_ret));
ASSERT_EQ(0, memcmp(prop_value, prop_value_ret, PROP_VALUE_MAX));
}
}
}
bool ok[8][8][8];
memset(ok, 0, sizeof(ok));
__system_property_foreach(hierarchical_test_callback, ok);
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) {
for (int k = 0; k < 8; k++) {
ASSERT_TRUE(ok[i][j][k]);
}
}
}
#else // __BIONIC__
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif // __BIONIC__
}
QString ConnectionTester::Private::propHelper(const QByteArray &property) const
{
// See http://www.netmite.com/android/mydroid/system/core/toolbox/getprop.c
QByteArray gw;
gw.resize(200);
__system_property_get(property, gw.data());
return gw;
}
jstring Java_com_rmd_propertySample_MainActivity_getProperty(JNIEnv* env, jobject thiz, jstring property_name) {
char value[PROP_VALUE_MAX];
/*const char* name = "net.dns1";*/
const char* name = (*env)->GetStringUTFChars(env, property_name, NULL);
__system_property_get(name, value);
LOGI("__system_property_get: %s: %s", name, value);
return (*env)->NewStringUTF(env, value);
/*return 0;*/
}
