namespace HOOK_BINDER { // src: IPCThreadState.cpp static void *g_sym_IPCThreadState_self; static void *g_sym_IPCThreadState_getCallingUid; static jmethodID g_methodid_onGetCallingUid; int getCallingUid(JNIEnv *env, jclass jclazz) { int (*org_getCallingUid)(int) = (int (*)(int)) g_sym_IPCThreadState_getCallingUid; int (*func_self)(void) = (int (*)(void)) g_sym_IPCThreadState_self; int uid = org_getCallingUid(func_self()); if (uid == getuid()) { uid = env->CallStaticIntMethod(g_jclass, g_methodid_onGetCallingUid, uid); return uid; } return uid; } static JNINativeMethod gMethods[] = { NATIVE_METHOD((void *) getCallingUid, "getCallingUid", "()I"), }; void hook() { LOGD("hook Binder..."); g_sym_IPCThreadState_self = dlsym(RTLD_DEFAULT, "_ZN7android14IPCThreadState4selfEv"); g_sym_IPCThreadState_getCallingUid = dlsym(RTLD_DEFAULT, "_ZNK7android14IPCThreadState13getCallingUidEv"); if (g_sym_IPCThreadState_getCallingUid == NULL) { g_sym_IPCThreadState_getCallingUid = dlsym(RTLD_DEFAULT, "_ZN7android14IPCThreadState13getCallingUidEv"); } if (g_sym_IPCThreadState_self == NULL || g_sym_IPCThreadState_getCallingUid == NULL) { LOGE("hook Binder failed!"); return; } LOGD("sym_IPCThreadState=%p, sym_getCallingUid=%p", g_sym_IPCThreadState_self, g_sym_IPCThreadState_getCallingUid); JNIEnv *env = NULL; g_vm->GetEnv((void **) &env, JNI_VERSION_1_4); g_vm->AttachCurrentThread(&env, NULL); g_methodid_onGetCallingUid = env->GetStaticMethodID(g_jclass, JAVA_CALLBACK__BINDER__ON_GET_CALLING_UID, JAVA_CALLBACK__BINDER__ON_GET_CALLING_UID_SIGNATURE); jclass jclass_Binder = env->FindClass("android/os/Binder"); if (env->RegisterNatives(jclass_Binder, gMethods, NELEM(gMethods)) < 0) { LOGE("hook Binder failed! because register methods FAILED!!!"); return; } LOGD("Done hook Binder"); } }
switch (res.getType()) { case Formattable::kDouble: return doubleValueOf(env, res.getDouble()); case Formattable::kLong: return longValueOf(env, res.getLong()); case Formattable::kInt64: return longValueOf(env, res.getInt64()); default: return NULL; } } static jlong NativeDecimalFormat_cloneImpl(JNIEnv*, jclass, jlong addr) { DecimalFormat* fmt = toDecimalFormat(addr); return reinterpret_cast<uintptr_t>(fmt->clone()); } static JNINativeMethod gMethods[] = { NATIVE_METHOD(NativeDecimalFormat, applyPatternImpl, "(JZLjava/lang/String;)V"), NATIVE_METHOD(NativeDecimalFormat, cloneImpl, "(J)J"), NATIVE_METHOD(NativeDecimalFormat, close, "(J)V"), NATIVE_METHOD(NativeDecimalFormat, formatDouble, "(JDLlibcore/icu/NativeDecimalFormat$FieldPositionIterator;)[C"), NATIVE_METHOD(NativeDecimalFormat, formatLong, "(JJLlibcore/icu/NativeDecimalFormat$FieldPositionIterator;)[C"), NATIVE_METHOD(NativeDecimalFormat, formatDigitList, "(JLjava/lang/String;Llibcore/icu/NativeDecimalFormat$FieldPositionIterator;)[C"), NATIVE_METHOD(NativeDecimalFormat, getAttribute, "(JI)I"), NATIVE_METHOD(NativeDecimalFormat, getTextAttribute, "(JI)Ljava/lang/String;"), NATIVE_METHOD(NativeDecimalFormat, open, "(Ljava/lang/String;Ljava/lang/String;CCLjava/lang/String;CLjava/lang/String;Ljava/lang/String;Ljava/lang/String;CLjava/lang/String;CLjava/lang/String;CC)J"), NATIVE_METHOD(NativeDecimalFormat, parse, "(JLjava/lang/String;Ljava/text/ParsePosition;Z)Ljava/lang/Number;"), NATIVE_METHOD(NativeDecimalFormat, setAttribute, "(JII)V"), NATIVE_METHOD(NativeDecimalFormat, setDecimalFormatSymbols, "(JLjava/lang/String;CCLjava/lang/String;CLjava/lang/String;Ljava/lang/String;Ljava/lang/String;CLjava/lang/String;CLjava/lang/String;CC)V"), NATIVE_METHOD(NativeDecimalFormat, setRoundingMode, "(JID)V"), NATIVE_METHOD(NativeDecimalFormat, setSymbol, "(JILjava/lang/String;)V"), NATIVE_METHOD(NativeDecimalFormat, setTextAttribute, "(JILjava/lang/String;)V"), NATIVE_METHOD(NativeDecimalFormat, toPatternImpl, "(JZ)Ljava/lang/String;"),
MatcherAccessor matcher(env, addr, javaText, true); matcher->region(start, end, matcher.status()); } static void Matcher_useAnchoringBoundsImpl(JNIEnv* env, jclass, jint addr, jboolean value) { MatcherAccessor matcher(env, addr); matcher->useAnchoringBounds(value); } static void Matcher_useTransparentBoundsImpl(JNIEnv* env, jclass, jint addr, jboolean value) { MatcherAccessor matcher(env, addr); matcher->useTransparentBounds(value); } static JNINativeMethod gMethods[] = { NATIVE_METHOD(Matcher, closeImpl, "(I)V"), NATIVE_METHOD(Matcher, findImpl, "(ILjava/lang/String;I[I)Z"), NATIVE_METHOD(Matcher, findNextImpl, "(ILjava/lang/String;[I)Z"), NATIVE_METHOD(Matcher, groupCountImpl, "(I)I"), NATIVE_METHOD(Matcher, hitEndImpl, "(I)Z"), NATIVE_METHOD(Matcher, lookingAtImpl, "(ILjava/lang/String;[I)Z"), NATIVE_METHOD(Matcher, matchesImpl, "(ILjava/lang/String;[I)Z"), NATIVE_METHOD(Matcher, openImpl, "(I)I"), NATIVE_METHOD(Matcher, requireEndImpl, "(I)Z"), NATIVE_METHOD(Matcher, setInputImpl, "(ILjava/lang/String;II)V"), NATIVE_METHOD(Matcher, useAnchoringBoundsImpl, "(IZ)V"), NATIVE_METHOD(Matcher, useTransparentBoundsImpl, "(IZ)V"), }; int register_java_util_regex_Matcher(JNIEnv* env) { return jniRegisterNativeMethods(env, "java/util/regex/Matcher", gMethods, NELEM(gMethods)); }
"(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V"); if (notationDeclMethod == NULL) return; unparsedEntityDeclMethod = env->GetMethodID(clazz, "unparsedEntityDecl", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V"); if (unparsedEntityDeclMethod == NULL) return; internMethod = env->GetMethodID(JniConstants::stringClass, "intern", "()Ljava/lang/String;"); if (internMethod == NULL) return; // Reference to "". emptyString = reinterpret_cast<jstring>(env->NewGlobalRef(empty)); } static JNINativeMethod parserMethods[] = { NATIVE_METHOD(ExpatParser, appendString, "(JLjava/lang/String;Z)V"), NATIVE_METHOD(ExpatParser, appendBytes, "(J[BII)V"), NATIVE_METHOD(ExpatParser, appendChars, "(J[CII)V"), NATIVE_METHOD(ExpatParser, cloneAttributes, "(JI)J"), NATIVE_METHOD(ExpatParser, column, "(J)I"), NATIVE_METHOD(ExpatParser, createEntityParser, "(JLjava/lang/String;)J"), NATIVE_METHOD(ExpatParser, initialize, "(Ljava/lang/String;Z)J"), NATIVE_METHOD(ExpatParser, line, "(J)I"), NATIVE_METHOD(ExpatParser, release, "(J)V"), NATIVE_METHOD(ExpatParser, releaseParser, "(J)V"), NATIVE_METHOD(ExpatParser, staticInitialize, "(Ljava/lang/String;)V"), }; static JNINativeMethod attributeMethods[] = { NATIVE_METHOD(ExpatAttributes, freeAttributes, "(J)V"), NATIVE_METHOD(ExpatAttributes, getIndexForQName, "(JLjava/lang/String;)I"),
PluralRules* result = PluralRules::forLocale(locale, status); icu4jni_error(env, status); return reinterpret_cast<uintptr_t>(result); } static jint NativePluralRules_quantityForIntImpl(JNIEnv*, jclass, jint address, jint value) { UnicodeString keyword = toPluralRules(address)->select(value); if (keyword == "zero") { return 0; } else if (keyword == "one") { return 1; } else if (keyword == "two") { return 2; } else if (keyword == "few") { return 3; } else if (keyword == "many") { return 4; } else { return 5; } } static JNINativeMethod gMethods[] = { NATIVE_METHOD(NativePluralRules, finalizeImpl, "(I)V"), NATIVE_METHOD(NativePluralRules, forLocaleImpl, "(Ljava/lang/String;)I"), NATIVE_METHOD(NativePluralRules, quantityForIntImpl, "(II)I"), }; int register_libcore_icu_NativePluralRules(JNIEnv* env) { return jniRegisterNativeMethods(env, "libcore/icu/NativePluralRules", gMethods, NELEM(gMethods)); }
} for (int i = 0; i < page_count; ++i) { if (vec[i] != 1) { return JNI_FALSE; } } return JNI_TRUE; } static void OSMemory_flush(JNIEnv*, jclass, jint address, jlong size) { msync(cast<void*>(address), size, MS_SYNC); } static JNINativeMethod gMethods[] = { NATIVE_METHOD(OSMemory, flush, "(IJ)V"), NATIVE_METHOD(OSMemory, free, "(I)V"), NATIVE_METHOD(OSMemory, getAddress, "(I)I"), NATIVE_METHOD(OSMemory, getByte, "(I)B"), NATIVE_METHOD(OSMemory, getByteArray, "(I[BII)V"), NATIVE_METHOD(OSMemory, getDouble, "(I)D"), NATIVE_METHOD(OSMemory, getFloat, "(I)F"), NATIVE_METHOD(OSMemory, getInt, "(I)I"), NATIVE_METHOD(OSMemory, getLong, "(I)J"), NATIVE_METHOD(OSMemory, getShort, "(I)S"), NATIVE_METHOD(OSMemory, isLoaded, "(IJ)Z"), NATIVE_METHOD(OSMemory, load, "(IJ)V"), NATIVE_METHOD(OSMemory, malloc, "(I)I"), NATIVE_METHOD(OSMemory, memmove, "(IIJ)V"), NATIVE_METHOD(OSMemory, memset, "(IBJ)V"), NATIVE_METHOD(OSMemory, mmapImpl, "(IJJI)I"),
} static int Character_forNameImpl(JNIEnv* env, jclass, jstring javaBlockName) { ScopedUtfChars blockName(env, javaBlockName); if (blockName.c_str() == NULL) { return 0; } return u_getPropertyValueEnum(UCHAR_BLOCK, blockName.c_str()); } static int Character_ofImpl(JNIEnv*, jclass, jint codePoint) { return ublock_getCode(codePoint); } static JNINativeMethod gMethods[] = { NATIVE_METHOD(Character, digitImpl, "!(II)I"), NATIVE_METHOD(Character, forNameImpl, "(Ljava/lang/String;)I"), NATIVE_METHOD(Character, getDirectionalityImpl, "!(I)B"), NATIVE_METHOD(Character, getNameImpl, "(I)Ljava/lang/String;"), NATIVE_METHOD(Character, getNumericValueImpl, "!(I)I"), NATIVE_METHOD(Character, getTypeImpl, "!(I)I"), NATIVE_METHOD(Character, isDefinedImpl, "!(I)Z"), NATIVE_METHOD(Character, isDigitImpl, "!(I)Z"), NATIVE_METHOD(Character, isIdentifierIgnorableImpl, "!(I)Z"), NATIVE_METHOD(Character, isLetterImpl, "!(I)Z"), NATIVE_METHOD(Character, isLetterOrDigitImpl, "!(I)Z"), NATIVE_METHOD(Character, isLowerCaseImpl, "!(I)Z"), NATIVE_METHOD(Character, isMirroredImpl, "!(I)Z"), NATIVE_METHOD(Character, isSpaceCharImpl, "!(I)Z"), NATIVE_METHOD(Character, isTitleCaseImpl, "!(I)Z"), NATIVE_METHOD(Character, isUnicodeIdentifierPartImpl, "!(I)Z"),
static jint NativeBreakIterator_precedingImpl(JNIEnv* env, jclass, jlong address, jstring javaInput, jint offset) { BreakIteratorAccessor it(env, address, javaInput, false); return it->preceding(offset); } static jint NativeBreakIterator_previousImpl(JNIEnv* env, jclass, jlong address, jstring javaInput) { BreakIteratorAccessor it(env, address, javaInput, false); return it->previous(); } static void NativeBreakIterator_setTextImpl(JNIEnv* env, jclass, jlong address, jstring javaInput) { BreakIteratorAccessor it(env, address, javaInput, true); } static JNINativeMethod gMethods[] = { NATIVE_METHOD(NativeBreakIterator, cloneImpl, "(J)J"), NATIVE_METHOD(NativeBreakIterator, closeImpl, "(J)V"), NATIVE_METHOD(NativeBreakIterator, currentImpl, "(JLjava/lang/String;)I"), NATIVE_METHOD(NativeBreakIterator, firstImpl, "(JLjava/lang/String;)I"), NATIVE_METHOD(NativeBreakIterator, followingImpl, "(JLjava/lang/String;I)I"), NATIVE_METHOD(NativeBreakIterator, getCharacterInstanceImpl, "(Ljava/lang/String;)J"), NATIVE_METHOD(NativeBreakIterator, getLineInstanceImpl, "(Ljava/lang/String;)J"), NATIVE_METHOD(NativeBreakIterator, getSentenceInstanceImpl, "(Ljava/lang/String;)J"), NATIVE_METHOD(NativeBreakIterator, getWordInstanceImpl, "(Ljava/lang/String;)J"), NATIVE_METHOD(NativeBreakIterator, isBoundaryImpl, "(JLjava/lang/String;I)Z"), NATIVE_METHOD(NativeBreakIterator, lastImpl, "(JLjava/lang/String;)I"), NATIVE_METHOD(NativeBreakIterator, nextImpl, "(JLjava/lang/String;I)I"), NATIVE_METHOD(NativeBreakIterator, precedingImpl, "(JLjava/lang/String;I)I"), NATIVE_METHOD(NativeBreakIterator, previousImpl, "(JLjava/lang/String;)I"), NATIVE_METHOD(NativeBreakIterator, setTextImpl, "(JLjava/lang/String;)V"), };
} static jdouble StrictMath_pow(JNIEnv*, jclass, jdouble a, jdouble b) { return ieee_pow(a,b); } static jdouble StrictMath_hypot(JNIEnv*, jclass, jdouble a, jdouble b) { return ieee_hypot(a, b); } static jdouble StrictMath_nextafter(JNIEnv*, jclass, jdouble a, jdouble b) { return ieee_nextafter(a, b); } static JNINativeMethod gMethods[] = { NATIVE_METHOD(StrictMath, IEEEremainder, "!(DD)D"), NATIVE_METHOD(StrictMath, ceil, "!(D)D"), NATIVE_METHOD(StrictMath, cos, "!(D)D"), NATIVE_METHOD(StrictMath, floor, "!(D)D"), NATIVE_METHOD(StrictMath, hypot, "!(DD)D"), NATIVE_METHOD(StrictMath, nextafter, "!(DD)D"), NATIVE_METHOD(StrictMath, pow, "!(DD)D"), NATIVE_METHOD(StrictMath, rint, "!(D)D"), NATIVE_METHOD(StrictMath, sin, "!(D)D"), NATIVE_METHOD(StrictMath, sqrt, "!(D)D"), NATIVE_METHOD(StrictMath, tan, "!(D)D"), }; void register_java_lang_StrictMath(JNIEnv* env) { jniRegisterNativeMethods(env, "java/lang/StrictMath", gMethods, NELEM(gMethods)); }
} static void OSNetworkSystem_close(JNIEnv* env, jobject, jobject fileDescriptor) { NetFd fd(env, fileDescriptor); if (fd.isClosed()) { return; } int oldFd = fd.get(); jniSetFileDescriptorOfFD(env, fileDescriptor, -1); AsynchronousSocketCloseMonitor::signalBlockedThreads(oldFd); close(oldFd); } static JNINativeMethod gMethods[] = { NATIVE_METHOD(OSNetworkSystem, accept, "(Ljava/io/FileDescriptor;Ljava/net/SocketImpl;Ljava/io/FileDescriptor;)V"), NATIVE_METHOD(OSNetworkSystem, bind, "(Ljava/io/FileDescriptor;Ljava/net/InetAddress;I)V"), NATIVE_METHOD(OSNetworkSystem, close, "(Ljava/io/FileDescriptor;)V"), NATIVE_METHOD(OSNetworkSystem, connectNonBlocking, "(Ljava/io/FileDescriptor;Ljava/net/InetAddress;I)Z"), NATIVE_METHOD(OSNetworkSystem, connect, "(Ljava/io/FileDescriptor;Ljava/net/InetAddress;II)V"), NATIVE_METHOD(OSNetworkSystem, disconnectDatagram, "(Ljava/io/FileDescriptor;)V"), NATIVE_METHOD(OSNetworkSystem, getSocketLocalAddress, "(Ljava/io/FileDescriptor;)Ljava/net/InetAddress;"), NATIVE_METHOD(OSNetworkSystem, getSocketLocalPort, "(Ljava/io/FileDescriptor;)I"), NATIVE_METHOD(OSNetworkSystem, getSocketOption, "(Ljava/io/FileDescriptor;I)Ljava/lang/Object;"), NATIVE_METHOD(OSNetworkSystem, isConnected, "(Ljava/io/FileDescriptor;I)Z"), NATIVE_METHOD(OSNetworkSystem, listen, "(Ljava/io/FileDescriptor;I)V"), NATIVE_METHOD(OSNetworkSystem, read, "(Ljava/io/FileDescriptor;[BII)I"), NATIVE_METHOD(OSNetworkSystem, readDirect, "(Ljava/io/FileDescriptor;II)I"), NATIVE_METHOD(OSNetworkSystem, recv, "(Ljava/io/FileDescriptor;Ljava/net/DatagramPacket;[BIIZZ)I"), NATIVE_METHOD(OSNetworkSystem, recvDirect, "(Ljava/io/FileDescriptor;Ljava/net/DatagramPacket;IIIZZ)I"), NATIVE_METHOD(OSNetworkSystem, selectImpl, "([Ljava/io/FileDescriptor;[Ljava/io/FileDescriptor;II[IJ)Z"),
env->Throw(reinterpret_cast<jthrowable>(exception)); } static void Pattern_closeImpl(JNIEnv*, jclass, jint addr) { delete toRegexPattern(addr); } static jint Pattern_compileImpl(JNIEnv* env, jclass, jstring javaRegex, jint flags) { flags |= UREGEX_ERROR_ON_UNKNOWN_ESCAPES; UErrorCode status = U_ZERO_ERROR; UParseError error; error.offset = -1; ScopedJavaUnicodeString regex(env, javaRegex); UnicodeString& regexString(regex.unicodeString()); RegexPattern* result = RegexPattern::compile(regexString, flags, error, status); if (!U_SUCCESS(status)) { throwPatternSyntaxException(env, status, javaRegex, error); } return static_cast<jint>(reinterpret_cast<uintptr_t>(result)); } static JNINativeMethod gMethods[] = { NATIVE_METHOD(Pattern, closeImpl, "(I)V"), NATIVE_METHOD(Pattern, compileImpl, "(Ljava/lang/String;I)I"), }; int register_java_util_regex_Pattern(JNIEnv* env) { return jniRegisterNativeMethods(env, "java/util/regex/Pattern", gMethods, NELEM(gMethods)); }
return NULL; } UChar dst[256]; UErrorCode status = U_ZERO_ERROR; size_t resultLength = toAscii ? uidna_IDNToASCII(src.get(), src.size(), &dst[0], sizeof(dst), flags, NULL, &status) : uidna_IDNToUnicode(src.get(), src.size(), &dst[0], sizeof(dst), flags, NULL, &status); if (U_FAILURE(status)) { jniThrowException(env, "java/lang/IllegalArgumentException", u_errorName(status)); return NULL; } if (!toAscii) { // ICU only translates separators to ASCII for toASCII. // Java expects the translation for toUnicode too. // We may as well do this here, while the string is still mutable. for (size_t i = 0; i < resultLength; ++i) { if (isLabelSeparator(dst[i])) { dst[i] = '.'; } } } return env->NewString(&dst[0], resultLength); } static JNINativeMethod gMethods[] = { NATIVE_METHOD(NativeIDN, convertImpl, "(Ljava/lang/String;IZ)Ljava/lang/String;"), }; int register_libcore_icu_NativeIDN(JNIEnv* env) { return jniRegisterNativeMethods(env, "libcore/icu/NativeIDN", gMethods, NELEM(gMethods)); }
static jint Console_setEchoImpl(JNIEnv* env, jclass, jboolean on, jint previousState) { #ifdef _WIN32 FASTIVA_DBREAK(); #else termios state; if (TEMP_FAILURE_RETRY(tcgetattr(STDIN_FILENO, &state)) == -1) { jniThrowIOException(env, errno); return 0; } if (on) { state.c_lflag = previousState; } else { previousState = state.c_lflag; state.c_lflag &= ~(ECHO | ECHOE | ECHOK | ECHONL); } if (TEMP_FAILURE_RETRY(tcsetattr(STDIN_FILENO, TCSAFLUSH, &state)) == -1){ jniThrowIOException(env, errno); return 0; } #endif return previousState; } static JNINativeMethod gMethods[] = { NATIVE_METHOD(Console, setEchoImpl, "(ZI)I"), }; void register_java_io_Console(JNIEnv* env) { jniRegisterNativeMethods(env, "java/io/Console", gMethods, NELEM(gMethods)); }
ucol_setOffset(toCollationElements(address), offset, &status); maybeThrowIcuException(env, "ucol_setOffset", status); } static void NativeCollation_setText(JNIEnv* env, jclass, jlong address, jstring javaSource) { ScopedStringChars source(env, javaSource); if (source.get() == NULL) { return; } UErrorCode status = U_ZERO_ERROR; ucol_setText(toCollationElements(address), source.get(), source.size(), &status); maybeThrowIcuException(env, "ucol_setText", status); } static JNINativeMethod gMethods[] = { NATIVE_METHOD(NativeCollation, closeCollator, "(J)V"), NATIVE_METHOD(NativeCollation, closeElements, "(J)V"), NATIVE_METHOD(NativeCollation, compare, "(JLjava/lang/String;Ljava/lang/String;)I"), NATIVE_METHOD(NativeCollation, getAttribute, "(JI)I"), NATIVE_METHOD(NativeCollation, getCollationElementIterator, "(JLjava/lang/String;)I"), NATIVE_METHOD(NativeCollation, getMaxExpansion, "(JI)I"), NATIVE_METHOD(NativeCollation, getOffset, "(J)I"), NATIVE_METHOD(NativeCollation, getRules, "(J)Ljava/lang/String;"), NATIVE_METHOD(NativeCollation, getSortKey, "(JLjava/lang/String;)[B"), NATIVE_METHOD(NativeCollation, next, "(J)I"), NATIVE_METHOD(NativeCollation, openCollator, "(Ljava/lang/String;)J"), NATIVE_METHOD(NativeCollation, openCollatorFromRules, "(Ljava/lang/String;II)J"), NATIVE_METHOD(NativeCollation, previous, "(J)I"), NATIVE_METHOD(NativeCollation, reset, "(J)V"), NATIVE_METHOD(NativeCollation, safeClone, "(J)J"), NATIVE_METHOD(NativeCollation, setAttribute, "(JII)V"),
--mplus_Length; while (mminus_Length > 1 && mminus[mminus_Length - 1] == 0) --mminus_Length; digits[digitCount++] = U; } while (1); simpleShiftLeftHighPrecision (R, ++RLength, 1); if (low && !high) digits[digitCount++] = U; else if (high && !low) digits[digitCount++] = U + 1; else if (compareHighPrecision (R, RLength, S, SLength) < 0) digits[digitCount++] = U; else digits[digitCount++] = U + 1; static jfieldID digitCountFid = env->GetFieldID(JniConstants::realToStringClass, "digitCount", "I"); env->SetIntField(obj, digitCountFid, digitCount); static jfieldID firstKFid = env->GetFieldID(JniConstants::realToStringClass, "firstK", "I"); env->SetIntField(obj, firstKFid, firstK); } static JNINativeMethod gMethods[] = { NATIVE_METHOD(RealToString, bigIntDigitGenerator, "(JIZI)V"), }; void register_java_lang_RealToString(JNIEnv* env) { jniRegisterNativeMethods(env, "java/lang/RealToString", gMethods, NELEM(gMethods)); }
ZipEntry data; const int32_t error = FindEntry(reinterpret_cast<ZipArchiveHandle>(nativeHandle), ZipString(entryNameChars.c_str()), &data); if (error) { return NULL; } return newZipEntry(env, data, entryName); } static void StrictJarFile_nativeClose(JNIEnv*, jobject, jlong nativeHandle) { CloseArchive(reinterpret_cast<ZipArchiveHandle>(nativeHandle)); } static JNINativeMethod gMethods[] = { NATIVE_METHOD(StrictJarFile, nativeOpenJarFile, "(Ljava/lang/String;)J"), NATIVE_METHOD(StrictJarFile, nativeStartIteration, "(JLjava/lang/String;)J"), NATIVE_METHOD(StrictJarFile, nativeNextEntry, "(J)Ljava/util/zip/ZipEntry;"), NATIVE_METHOD(StrictJarFile, nativeFindEntry, "(JLjava/lang/String;)Ljava/util/zip/ZipEntry;"), NATIVE_METHOD(StrictJarFile, nativeClose, "(J)V"), }; void register_java_util_jar_StrictJarFile(JNIEnv* env) { jniRegisterNativeMethods(env, "java/util/jar/StrictJarFile", gMethods, NELEM(gMethods)); zipEntryCtor = env->GetMethodID(JniConstants::zipEntryClass, "<init>", "(Ljava/lang/String;Ljava/lang/String;JJJIII[BJJ)V"); LOG_ALWAYS_FATAL_IF(zipEntryCtor == NULL, "Unable to find ZipEntry.<init>"); }
if (!ai->nextBucket(status)) { jniThrowExceptionFmt(env, "java/lang/IllegalArgumentException", "Invalid index: %d", index); return NULL; } if (maybeThrowIcuException(env, "AlphabeticIndex::nextBucket", status)) { return NULL; } } // Return "" for the underflow/inflow/overflow buckets. if (ai->getBucketLabelType() != U_ALPHAINDEX_NORMAL) { return env->NewStringUTF(""); } const UnicodeString& label(ai->getBucketLabel()); return env->NewString(label.getBuffer(), label.length()); } static JNINativeMethod gMethods[] = { NATIVE_METHOD(AlphabeticIndex, create, "(Ljava/lang/String;)J"), NATIVE_METHOD(AlphabeticIndex, destroy, "(J)V"), NATIVE_METHOD(AlphabeticIndex, addLabels, "(JLjava/lang/String;)V"), NATIVE_METHOD(AlphabeticIndex, addLabelRange, "(JII)V"), NATIVE_METHOD(AlphabeticIndex, getBucketCount, "(J)I"), NATIVE_METHOD(AlphabeticIndex, getBucketIndex, "(JLjava/lang/String;)I"), NATIVE_METHOD(AlphabeticIndex, getBucketLabel, "(JI)Ljava/lang/String;"), }; void register_libcore_icu_AlphabeticIndex(JNIEnv* env) { jniRegisterNativeMethods(env, "libcore/icu/AlphabeticIndex", gMethods, NELEM(gMethods)); }
env->ReleasePrimitiveArrayCritical(arr1, buffer, 0); if (env->ExceptionCheck()) return -1; return sum; } EXPORT jint Test_jni(JNIEnv* env, jobject java_this, jbyteArray array) { return calcsum(env, array); } EXPORT jint Test_fastjni(JNIEnv* env, jobject java_this, jbyteArray array) { return calcsum(env, array); } static JNINativeMethod methods[] = { NATIVE_METHOD(Test, jni, "([B)I", jni), NATIVE_METHOD(Test, fastjni, "!([B)I", fastjni), }; /* * Register several native methods for one class. */ static int registerNativeMethods(JNIEnv* env, const char* className, JNINativeMethod* gMethods, int numMethods) { jclass clazz; clazz = env->FindClass(className); if (clazz == NULL) { ALOGE("Native registration unable to find class '%s'", className); return JNI_FALSE; }
static void Transliterator_destroy(JNIEnv*, jclass, jlong peer) { delete fromPeer(peer); } static jobjectArray Transliterator_getAvailableIDs(JNIEnv* env, jclass) { UErrorCode status = U_ZERO_ERROR; return fromStringEnumeration(env, Transliterator::getAvailableIDs(status)); } static jstring Transliterator_transliterate(JNIEnv* env, jclass, jlong peer, jstring javaString) { Transliterator* t = fromPeer(peer); ScopedJavaUnicodeString string(env, javaString); if (!string.valid()) { return NULL; } UnicodeString& s(string.unicodeString()); t->transliterate(s); return env->NewString(s.getBuffer(), s.length()); } static JNINativeMethod gMethods[] = { NATIVE_METHOD(Transliterator, create, "(Ljava/lang/String;)J"), NATIVE_METHOD(Transliterator, destroy, "(J)V"), NATIVE_METHOD(Transliterator, getAvailableIDs, "()[Ljava/lang/String;"), NATIVE_METHOD(Transliterator, transliterate, "(JLjava/lang/String;)Ljava/lang/String;"), }; void register_libcore_icu_Transliterator(JNIEnv* env) { jniRegisterNativeMethods(env, "libcore/icu/Transliterator", gMethods, NELEM(gMethods)); }
if (env->ExceptionCheck()) { return NULL; } // Construct the CharsetICU object. static jmethodID charsetConstructor = env->GetMethodID(JniConstants::charsetICUClass, "<init>", "(Ljava/lang/String;Ljava/lang/String;[Ljava/lang/String;)V"); if (env->ExceptionCheck()) { return NULL; } return env->NewObject(JniConstants::charsetICUClass, charsetConstructor, javaCanonicalName, env->NewStringUTF(icuCanonicalName), javaAliases); } static JNINativeMethod gMethods[] = { NATIVE_METHOD(NativeConverter, charsetForName, "(Ljava/lang/String;)Ljava/nio/charset/Charset;"), NATIVE_METHOD(NativeConverter, closeConverter, "(J)V"), NATIVE_METHOD(NativeConverter, contains, "(Ljava/lang/String;Ljava/lang/String;)Z"), NATIVE_METHOD(NativeConverter, decode, "(J[BI[CI[IZ)I"), NATIVE_METHOD(NativeConverter, encode, "(J[CI[BI[IZ)I"), NATIVE_METHOD(NativeConverter, getAvailableCharsetNames, "()[Ljava/lang/String;"), NATIVE_METHOD(NativeConverter, getAveBytesPerChar, "(J)F"), NATIVE_METHOD(NativeConverter, getAveCharsPerByte, "(J)F"), NATIVE_METHOD(NativeConverter, getMaxBytesPerChar, "(J)I"), NATIVE_METHOD(NativeConverter, getMinBytesPerChar, "(J)I"), NATIVE_METHOD(NativeConverter, getSubstitutionBytes, "(J)[B"), NATIVE_METHOD(NativeConverter, openConverter, "(Ljava/lang/String;)J"), NATIVE_METHOD(NativeConverter, resetByteToChar, "(J)V"), NATIVE_METHOD(NativeConverter, resetCharToByte, "(J)V"), NATIVE_METHOD(NativeConverter, setCallbackDecode, "(JIILjava/lang/String;)V"), NATIVE_METHOD(NativeConverter, setCallbackEncode, "(JII[B)V"),
ScopedIcuLocale icuLocale(env, javaLanguageTag); if (!icuLocale.valid()) { return; } UErrorCode status = U_ZERO_ERROR; Locale::setDefault(icuLocale.locale(), status); maybeThrowIcuException(env, "Locale::setDefault", status); } static jstring ICU_getDefaultLocale(JNIEnv* env, jclass) { return env->NewStringUTF(Locale::getDefault().getName()); } static JNINativeMethod gMethods[] = { NATIVE_METHOD(ICU, addLikelySubtags, "(Ljava/lang/String;)Ljava/lang/String;"), NATIVE_METHOD(ICU, getAvailableBreakIteratorLocalesNative, "()[Ljava/lang/String;"), NATIVE_METHOD(ICU, getAvailableCalendarLocalesNative, "()[Ljava/lang/String;"), NATIVE_METHOD(ICU, getAvailableCollatorLocalesNative, "()[Ljava/lang/String;"), NATIVE_METHOD(ICU, getAvailableCurrencyCodes, "()[Ljava/lang/String;"), NATIVE_METHOD(ICU, getAvailableDateFormatLocalesNative, "()[Ljava/lang/String;"), NATIVE_METHOD(ICU, getAvailableLocalesNative, "()[Ljava/lang/String;"), NATIVE_METHOD(ICU, getAvailableNumberFormatLocalesNative, "()[Ljava/lang/String;"), NATIVE_METHOD(ICU, getBestDateTimePatternNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"), NATIVE_METHOD(ICU, getCldrVersion, "()Ljava/lang/String;"), NATIVE_METHOD(ICU, getCurrencyCode, "(Ljava/lang/String;)Ljava/lang/String;"), NATIVE_METHOD(ICU, getCurrencyDisplayName, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"), NATIVE_METHOD(ICU, getCurrencyFractionDigits, "(Ljava/lang/String;)I"), NATIVE_METHOD(ICU, getCurrencyNumericCode, "(Ljava/lang/String;)I"), NATIVE_METHOD(ICU, getCurrencySymbol, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"), NATIVE_METHOD(ICU, getDefaultLocale, "()Ljava/lang/String;"),
if (port != -1) { // quick check for UDP type & UDP port // the packet is an IP header, UDP header, and UDP payload if ((size < (sizeof(struct iphdr) + sizeof(struct udphdr)))) { return 0; // runt packet } u_int8_t ip_proto = ((iphdr *) packetData)->protocol; if (ip_proto != IPPROTO_UDP) { return 0; // something other than UDP } __be16 destPort = htons((reinterpret_cast<udphdr*>(packetData + sizeof(iphdr)))->dest); if (destPort != port) { return 0; // something other than requested port } } return size; } static JNINativeMethod gRawMethods[] = { NATIVE_METHOD(RawSocket, create, "(Ljava/io/FileDescriptor;SLjava/lang/String;)V"), NATIVE_METHOD(RawSocket, sendPacket, "(Ljava/io/FileDescriptor;Ljava/lang/String;S[B[BII)I"), NATIVE_METHOD(RawSocket, recvPacket, "(Ljava/io/FileDescriptor;[BIIII)I"), }; void register_libcore_net_RawSocket(JNIEnv* env) { jniRegisterNativeMethods(env, "libcore/net/RawSocket", gRawMethods, NELEM(gRawMethods)); } #endif
// Temporarily clear exception so we can clean up. jthrowable exception = env->ExceptionOccurred(); env->ExceptionClear(); freeStrings(env, javaEnvironment, environment); // Clean up working directory string. if (javaWorkingDirectory != NULL) { env->ReleaseStringUTFChars(javaWorkingDirectory, workingDirectory); } freeStrings(env, javaCommands, commands); // Re-throw exception if present. if (exception != NULL) { if (env->Throw(exception) < 0) { ALOGE("Error rethrowing exception!"); } } return result; } static JNINativeMethod methods[] = { NATIVE_METHOD(ProcessManager, exec, "([Ljava/lang/String;[Ljava/lang/String;Ljava/lang/String;Ljava/io/FileDescriptor;Ljava/io/FileDescriptor;Ljava/io/FileDescriptor;Z)I"), }; void register_java_lang_ProcessManager(JNIEnv* env) { jniRegisterNativeMethods(env, "java/lang/ProcessManager", methods, NELEM(methods)); }
} static jboolean NetworkInterface_isLoopbackImpl(JNIEnv* env, jclass, jstring name) { return hasFlag(env, name, IFF_LOOPBACK); } static jboolean NetworkInterface_isPointToPointImpl(JNIEnv* env, jclass, jstring name) { return hasFlag(env, name, IFF_POINTOPOINT); // Unix API typo! } static jboolean NetworkInterface_isUpImpl(JNIEnv* env, jclass, jstring name) { return hasFlag(env, name, IFF_UP); } static jboolean NetworkInterface_supportsMulticastImpl(JNIEnv* env, jclass, jstring name) { return hasFlag(env, name, IFF_MULTICAST); } static JNINativeMethod gMethods[] = { NATIVE_METHOD(NetworkInterface, getAllInterfaceAddressesImpl, "()[Ljava/net/InterfaceAddress;"), //NATIVE_METHOD(NetworkInterface, getHardwareAddressImpl, "(Ljava/lang/String;)[B"), NATIVE_METHOD(NetworkInterface, getMTUImpl, "(Ljava/lang/String;)I"), NATIVE_METHOD(NetworkInterface, isLoopbackImpl, "(Ljava/lang/String;)Z"), NATIVE_METHOD(NetworkInterface, isPointToPointImpl, "(Ljava/lang/String;)Z"), NATIVE_METHOD(NetworkInterface, isUpImpl, "(Ljava/lang/String;)Z"), NATIVE_METHOD(NetworkInterface, supportsMulticastImpl, "(Ljava/lang/String;)Z"), }; int register_java_net_NetworkInterface(JNIEnv* env) { return jniRegisterNativeMethods(env, "java/net/NetworkInterface", gMethods, NELEM(gMethods)); }
static jlong System_nanoTime(JNIEnv*, jclass) { timespec now; clock_gettime(CLOCK_MONOTONIC, &now); return now.tv_sec * 1000000000LL + now.tv_nsec; } static jstring System_mapLibraryName(JNIEnv* env, jclass, jstring javaName) { ScopedUtfChars name(env, javaName); if (name.c_str() == NULL) { return NULL; } char* mappedName = NULL; asprintf(&mappedName, OS_SHARED_LIB_FORMAT_STR, name.c_str()); jstring result = env->NewStringUTF(mappedName); free(mappedName); return result; } static JNINativeMethod gMethods[] = { NATIVE_METHOD(System, currentTimeMillis, "()J"), NATIVE_METHOD(System, log, "(CLjava/lang/String;Ljava/lang/Throwable;)V"), NATIVE_METHOD(System, mapLibraryName, "(Ljava/lang/String;)Ljava/lang/String;"), NATIVE_METHOD(System, nanoTime, "()J"), NATIVE_METHOD(System, setFieldImpl, "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/Object;)V"), NATIVE_METHOD(System, specialProperties, "()[Ljava/lang/String;"), }; void register_java_lang_System(JNIEnv* env) { jniRegisterNativeMethods(env, "java/lang/System", gMethods, NELEM(gMethods)); }
#include "JniException.h" #include "ScopedJavaUnicodeString.h" #include "unicode/normlzr.h" static jstring NativeNormalizer_normalizeImpl(JNIEnv* env, jclass, jstring s, jint intMode) { ScopedJavaUnicodeString src(env, s); UNormalizationMode mode = static_cast<UNormalizationMode>(intMode); UErrorCode status = U_ZERO_ERROR; UnicodeString dst; Normalizer::normalize(src.unicodeString(), mode, 0, dst, status); maybeThrowIcuException(env, status); return dst.isBogus() ? NULL : env->NewString(dst.getBuffer(), dst.length()); } static jboolean NativeNormalizer_isNormalizedImpl(JNIEnv* env, jclass, jstring s, jint intMode) { ScopedJavaUnicodeString src(env, s); UNormalizationMode mode = static_cast<UNormalizationMode>(intMode); UErrorCode status = U_ZERO_ERROR; UBool result = Normalizer::isNormalized(src.unicodeString(), mode, status); maybeThrowIcuException(env, status); return result; } static JNINativeMethod gMethods[] = { NATIVE_METHOD(NativeNormalizer, normalizeImpl, "(Ljava/lang/String;I)Ljava/lang/String;"), NATIVE_METHOD(NativeNormalizer, isNormalizedImpl, "(Ljava/lang/String;I)Z"), }; void register_libcore_icu_NativeNormalizer(JNIEnv* env) { jniRegisterNativeMethods(env, "libcore/icu/NativeNormalizer", gMethods, NELEM(gMethods)); }
*/ #define LOG_TAG "CRC32" #include "JNIHelp.h" #include "JniConstants.h" #include "ScopedPrimitiveArray.h" #include "jni.h" #include "zlib.h" static jlong CRC32_updateImpl(JNIEnv* env, jobject, jbyteArray byteArray, int off, int len, jlong crc) { ScopedByteArrayRO bytes(env, byteArray); if (bytes.get() == NULL) { return 0; } jlong result = crc32(crc, reinterpret_cast<const Bytef*>(bytes.get() + off), len); return result; } static jlong CRC32_updateByteImpl(JNIEnv*, jobject, jbyte val, jlong crc) { return crc32(crc, reinterpret_cast<const Bytef*>(&val), 1); } static JNINativeMethod gMethods[] = { NATIVE_METHOD(CRC32, updateImpl, "([BIIJ)J"), NATIVE_METHOD(CRC32, updateByteImpl, "(BJ)J"), }; int register_java_util_zip_CRC32(JNIEnv* env) { return jniRegisterNativeMethods(env, "java/util/zip/CRC32", gMethods, NELEM(gMethods)); }
* Copyright (C) 2013 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define LOG_TAG "Unsafe" #include <nativehelper/JNIHelp.h> #include <nativehelper/JniConstants.h> static jobject Unsafe_allocateInstance(JNIEnv* env, jclass, jclass c) { return env->AllocObject(c); } static JNINativeMethod gMethods[] = { NATIVE_METHOD(Unsafe, allocateInstance, "(Ljava/lang/Class;)Ljava/lang/Object;"), }; void register_sun_misc_Unsafe(JNIEnv* env) { jniRegisterNativeMethods(env, "sun/misc/Unsafe", gMethods, NELEM(gMethods)); }
return reinterpret_cast<uintptr_t>(formatter); } static void DateIntervalFormat_destroyDateIntervalFormat(JNIEnv*, jclass, jlong address) { delete reinterpret_cast<DateIntervalFormat*>(address); } static jstring DateIntervalFormat_formatDateInterval(JNIEnv* env, jclass, jlong address, jlong fromDate, jlong toDate) { DateIntervalFormat* formatter(reinterpret_cast<DateIntervalFormat*>(address)); DateInterval date_interval(fromDate, toDate); UnicodeString s; FieldPosition pos = 0; UErrorCode status = U_ZERO_ERROR; formatter->format(&date_interval, s, pos, status); if (maybeThrowIcuException(env, "DateIntervalFormat::format", status)) { return NULL; } return env->NewString(s.getBuffer(), s.length()); } static JNINativeMethod gMethods[] = { NATIVE_METHOD(DateIntervalFormat, createDateIntervalFormat, "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)J"), NATIVE_METHOD(DateIntervalFormat, destroyDateIntervalFormat, "(J)V"), NATIVE_METHOD(DateIntervalFormat, formatDateInterval, "(JJJ)Ljava/lang/String;"), }; void register_libcore_icu_DateIntervalFormat(JNIEnv* env) { jniRegisterNativeMethods(env, "libcore/icu/DateIntervalFormat", gMethods, NELEM(gMethods)); }
usedAbbreviations[row.shortStd] = &row.longStd; } it = usedAbbreviations.find(uncommonDst); if (it == usedAbbreviations.end() || *(it->second) == row.longDst) { row.shortDst = uncommonDst; usedAbbreviations[row.shortDst] = &row.longDst; } } // Fill in whatever we got. ScopedLocalRef<jobjectArray> javaRow(env, env->NewObjectArray(5, JniConstants::stringClass, NULL)); ScopedLocalRef<jstring> id(env, reinterpret_cast<jstring>(env->GetObjectArrayElement(timeZoneIds, i))); env->SetObjectArrayElement(javaRow.get(), 0, id.get()); setStringArrayElement(env, javaRow.get(), 1, row.longStd); setStringArrayElement(env, javaRow.get(), 2, row.shortStd); setStringArrayElement(env, javaRow.get(), 3, row.longDst); setStringArrayElement(env, javaRow.get(), 4, row.shortDst); env->SetObjectArrayElement(result, i, javaRow.get()); delete row.tz; } return result; } static JNINativeMethod gMethods[] = { NATIVE_METHOD(TimeZones, forCountryCode, "(Ljava/lang/String;)[Ljava/lang/String;"), NATIVE_METHOD(TimeZones, getZoneStringsImpl, "(Ljava/lang/String;[Ljava/lang/String;)[[Ljava/lang/String;"), }; void register_libcore_icu_TimeZones(JNIEnv* env) { jniRegisterNativeMethods(env, "libcore/icu/TimeZones", gMethods, NELEM(gMethods)); }