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));
}
