jobjectArray InetAddress_getaddrinfo(JNIEnv* env, jobject obj, jstring javaName) {
if (javaName == NULL) {
jniThrowNullPointerException(env, NULL);
return NULL;
}
const char* name = env->GetStringUTFChars(javaName, NULL);
jobjectArray out = InetAddress_getaddrinfoImpl(env, name);
env->ReleaseStringUTFChars(javaName, name);
return out;
}
static jint android_content_StringBlock_nativeGetSize(JNIEnv* env, jobject clazz,
jlong token)
{
ResStringPool* osb = reinterpret_cast<ResStringPool*>(token);
if (osb == NULL) {
jniThrowNullPointerException(env, NULL);
return 0;
}
return osb->size();
}
static jint android_content_XmlBlock_nativeGetAttributeStringValue(JNIEnv* env, jobject clazz,
jint token, jint idx)
{
ResXMLParser* st = (ResXMLParser*)token;
if (st == NULL) {
jniThrowNullPointerException(env, NULL);
return 0;
}
return (jint)st->getAttributeValueStringID(idx);
}
static jint check(JNIEnv *env, jobject thiz, jstring jName)
{
const char *name = jName ? env->GetStringUTFChars(jName, NULL) : NULL;
if (!name) {
jniThrowNullPointerException(env, "name");
return 0;
}
int flags = check_interface(name);
env->ReleaseStringUTFChars(jName, name);
return flags;
}
static jint android_content_XmlBlock_nativeGetAttributeStringValue(JNIEnv* env, jobject clazz,
jlong token, jint idx)
{
ResXMLParser* st = reinterpret_cast<ResXMLParser*>(token);
if (st == NULL) {
jniThrowNullPointerException(env, NULL);
return 0;
}
return static_cast<jint>(st->getAttributeValueStringID(idx));
}
static jint android_content_XmlBlock_nativeGetLineNumber(JNIEnv* env, jobject clazz,
jlong token)
{
ResXMLParser* st = reinterpret_cast<ResXMLParser*>(token);
if (st == NULL) {
jniThrowNullPointerException(env, NULL);
return 0;
}
return static_cast<jint>(st->getLineNumber());
}
static void android_content_XmlBlock_nativeDestroyParseState(JNIEnv* env, jobject clazz,
jlong token)
{
ResXMLParser* st = reinterpret_cast<ResXMLParser*>(token);
if (st == NULL) {
jniThrowNullPointerException(env, NULL);
return;
}
delete st;
}
static jint android_content_XmlBlock_nativeGetLineNumber(JNIEnv* env, jobject clazz,
jint token)
{
ResXMLParser* st = (ResXMLParser*)token;
if (st == NULL) {
jniThrowNullPointerException(env, NULL);
return 0;
}
return (jint)st->getLineNumber();
}
static void android_content_XmlBlock_nativeDestroy(JNIEnv* env, jobject clazz,
jint token)
{
ResXMLTree* osb = (ResXMLTree*)token;
if (osb == NULL) {
jniThrowNullPointerException(env, NULL);
return;
}
delete osb;
}
static jlong android_content_XmlBlock_nativeGetStringBlock(JNIEnv* env, jobject clazz,
jlong token)
{
ResXMLTree* osb = reinterpret_cast<ResXMLTree*>(token);
if (osb == NULL) {
jniThrowNullPointerException(env, NULL);
return 0;
}
return reinterpret_cast<jlong>(&osb->getStrings());
}
static void android_os_Parcel_clearFileDescriptor(JNIEnv* env, jclass clazz, jobject object)
{
if (object == NULL) {
jniThrowNullPointerException(env, NULL);
return;
}
int fd = jniGetFDFromFileDescriptor(env, object);
if (fd >= 0) {
jniSetFileDescriptorOfFD(env, object, -1);
}
}
static void android_content_StringBlock_nativeDestroy(JNIEnv* env, jobject clazz,
jlong token)
{
ResStringPool* osb = reinterpret_cast<ResStringPool*>(token);
if (osb == NULL) {
jniThrowNullPointerException(env, NULL);
return;
}
delete osb;
}
static jint android_content_XmlBlock_nativeGetStringBlock(JNIEnv* env, jobject clazz,
jint token)
{
ResXMLTree* osb = (ResXMLTree*)token;
if (osb == NULL) {
jniThrowNullPointerException(env, NULL);
return 0;
}
return (jint)&osb->getStrings();
}
static void reset(JNIEnv *env, jobject thiz, jstring jName)
{
const char *name = jName ? env->GetStringUTFChars(jName, NULL) : NULL;
if (!name) {
jniThrowNullPointerException(env, "name");
return;
}
if (reset_interface(name) < 0) {
throwException(env, SYSTEM_ERROR, "Cannot reset interface");
}
env->ReleaseStringUTFChars(jName, name);
}
static jint android_content_XmlBlock_nativeGetClassAttribute(JNIEnv* env, jobject clazz,
jlong token)
{
ResXMLParser* st = reinterpret_cast<ResXMLParser*>(token);
if (st == NULL) {
jniThrowNullPointerException(env, NULL);
return 0;
}
ssize_t idx = st->indexOfClass();
return idx >= 0 ? static_cast<jint>(st->getAttributeValueStringID(idx)) : -1;
}
static jint android_content_XmlBlock_nativeGetClassAttribute(JNIEnv* env, jobject clazz,
jint token)
{
ResXMLParser* st = (ResXMLParser*)token;
if (st == NULL) {
jniThrowNullPointerException(env, NULL);
return 0;
}
ssize_t idx = st->indexOfClass();
return idx >= 0 ? (jint)st->getAttributeValueStringID(idx) : -1;
}
/**
* Converts an InetAddress object and port number to a native address structure.
*/
static bool inetAddressToSocketAddress(JNIEnv* env, jobject inetAddress,
int port, sockaddr_storage* ss) {
// Get the byte array that stores the IP address bytes in the InetAddress.
if (inetAddress == NULL) {
jniThrowNullPointerException(env, NULL);
return false;
}
jbyteArray addressBytes =
reinterpret_cast<jbyteArray>(env->GetObjectField(inetAddress,
gCachedFields.iaddr_ipaddress));
return byteArrayToSocketAddress(env, NULL, addressBytes, port, ss);
}
static jint android_view_MotionEvent_nativeInitialize(JNIEnv* env, jclass clazz,
jint nativePtr,
jint deviceId, jint source, jint action, jint flags, jint edgeFlags,
jint metaState, jint buttonState,
jfloat xOffset, jfloat yOffset, jfloat xPrecision, jfloat yPrecision,
jlong downTimeNanos, jlong eventTimeNanos,
jint pointerCount, jobjectArray pointerPropertiesObjArray,
jobjectArray pointerCoordsObjArray) {
if (!validatePointerCount(env, pointerCount)
|| !validatePointerPropertiesArray(env, pointerPropertiesObjArray, pointerCount)
|| !validatePointerCoordsObjArray(env, pointerCoordsObjArray, pointerCount)) {
return 0;
}
MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr);
if (!event) {
event = new MotionEvent();
}
PointerProperties pointerProperties[pointerCount];
PointerCoords rawPointerCoords[pointerCount];
for (jint i = 0; i < pointerCount; i++) {
jobject pointerPropertiesObj = env->GetObjectArrayElement(pointerPropertiesObjArray, i);
if (!pointerPropertiesObj) {
goto Error;
}
pointerPropertiesToNative(env, pointerPropertiesObj, &pointerProperties[i]);
env->DeleteLocalRef(pointerPropertiesObj);
jobject pointerCoordsObj = env->GetObjectArrayElement(pointerCoordsObjArray, i);
if (!pointerCoordsObj) {
jniThrowNullPointerException(env, "pointerCoords");
goto Error;
}
pointerCoordsToNative(env, pointerCoordsObj, xOffset, yOffset, &rawPointerCoords[i]);
env->DeleteLocalRef(pointerCoordsObj);
}
event->initialize(deviceId, source, action, flags, edgeFlags, metaState, buttonState,
xOffset, yOffset, xPrecision, yPrecision,
downTimeNanos, eventTimeNanos, pointerCount, pointerProperties, rawPointerCoords);
return reinterpret_cast<jint>(event);
Error:
if (!nativePtr) {
delete event;
}
return 0;
}
static void
acquireWakeLock(JNIEnv *env, jobject clazz, jint lock, jstring idObj)
{
if (idObj == NULL) {
jniThrowNullPointerException(env, "id is null");
return ;
}
const char *id = env->GetStringUTFChars(idObj, NULL);
acquire_wake_lock(lock, id);
env->ReleaseStringUTFChars(idObj, id);
}
static jobject android_os_Parcel_openFileDescriptor(JNIEnv* env, jclass clazz,
jstring name, jint mode)
{
if (name == NULL) {
jniThrowNullPointerException(env, NULL);
return NULL;
}
const jchar* str = env->GetStringCritical(name, 0);
if (str == NULL) {
// Whatever, whatever.
jniThrowException(env, "java/lang/IllegalStateException", NULL);
return NULL;
}
String8 name8((const char16_t*)str, env->GetStringLength(name));
env->ReleaseStringCritical(name, str);
int flags=0;
switch (mode&0x30000000) {
case 0:
case 0x10000000:
flags = O_RDONLY;
break;
case 0x20000000:
flags = O_WRONLY;
break;
case 0x30000000:
flags = O_RDWR;
break;
}
if (mode&0x08000000) flags |= O_CREAT;
if (mode&0x04000000) flags |= O_TRUNC;
if (mode&0x02000000) flags |= O_APPEND;
int realMode = S_IRWXU|S_IRWXG;
if (mode&0x00000001) realMode |= S_IROTH;
if (mode&0x00000002) realMode |= S_IWOTH;
int fd = open(name8.string(), flags, realMode);
if (fd < 0) {
jniThrowException(env, "java/io/FileNotFoundException", strerror(errno));
return NULL;
}
jobject object = jniCreateFileDescriptor(env, fd);
if (object == NULL) {
close(fd);
}
return object;
}
static jint writeSysfs(JNIEnv* env, jobject obj, jstring jPath, jint jVal)
{
int ret;
const char *path = NULL;
UNUSED(obj);
path = jPath ? env->GetStringUTFChars(jPath, NULL) : NULL;
if (!path) {
jniThrowNullPointerException(env, "path");
return -EINVAL;
}
ret = writeToFile(path, jVal);
env->ReleaseStringUTFChars(jPath, path);
return ret;
}
static jint getCoolingDeviceIndexContains(JNIEnv* env, jobject obj, jstring jType)
{
int ret;
const char *type = NULL;
UNUSED(obj);
type = jType ? env->GetStringUTFChars(jType, NULL) : NULL;
if (!type) {
jniThrowNullPointerException(env, "Type");
return -1;
}
ret = lookup_contains(COOLING_DEV_PATH, type);
env->ReleaseStringUTFChars(jType, type);
return ret;
}
static jint getThermalZoneIndex(JNIEnv* env, jobject obj, jstring jType)
{
int ret;
const char *type = NULL;
UNUSED(obj);
type = jType ? env->GetStringUTFChars(jType, NULL) : NULL;
if (!type) {
jniThrowNullPointerException(env, "Type");
return -1;
}
ret = lookup(THERMAL_ZONE_PATH, type);
env->ReleaseStringUTFChars(jType, type);
return ret;
}
//TODO change this to return an instance of LocalSocketAddress
static jobject socket_getSockName(JNIEnv *env,
jobject object, jobject fileDescriptor)
{
int err;
int fd;
if (fileDescriptor == NULL) {
jniThrowNullPointerException(env, NULL);
return NULL;
}
fd = jniGetFDFromFileDescriptor(env, fileDescriptor);
if (env->ExceptionOccurred() != NULL) {
return NULL;
}
union {
struct sockaddr address;
struct sockaddr_un un_address;
} sa;
memset(&sa, 0, sizeof(sa));
socklen_t namelen = sizeof(sa);
err = getsockname(fd, &(sa.address), &namelen);
if (err < 0) {
jniThrowIOException(env, errno);
return NULL;
}
if (sa.address.sa_family != AF_UNIX) {
// We think we're an impl only for AF_UNIX, so this should never happen.
jniThrowIOException(env, EINVAL);
return NULL;
}
if (sa.un_address.sun_path[0] == '\0') {
} else {
}
}
//static void NativeDecimalFormat_applyPatternImpl(JNIEnv* env, jclass, jint addr, jboolean localized, jstring pattern0) {
JNIEXPORT void JNICALL
Java_com_ibm_icu4jni_text_NativeDecimalFormat_applyPatternImpl(JNIEnv* env,
jclass, jint addr, jboolean localized, jstring pattern0) {
if (pattern0 == NULL) {
jniThrowNullPointerException(env, NULL);
return;
}
ScopedJavaUnicodeString pattern(env, pattern0);
DecimalFormat* fmt = toDecimalFormat(addr);
UErrorCode status = U_ZERO_ERROR;
if (localized) {
fmt->applyLocalizedPattern(pattern.unicodeString(), status);
} else {
fmt->applyPattern(pattern.unicodeString(), status);
}
icu4jni_error(env, status);
}
static jobject android_os_Parcel_openFileDescriptor(JNIEnv* env, jclass clazz,
jstring name, jint mode)
{
if (name == NULL) {
jniThrowNullPointerException(env, NULL);
return NULL;
}
ScopedUtfChars name8(env, name);
if (name8.c_str() == NULL) {
return NULL;
}
int flags=0;
switch (mode&0x30000000) {
case 0:
case 0x10000000:
flags = O_RDONLY;
break;
case 0x20000000:
flags = O_WRONLY;
break;
case 0x30000000:
flags = O_RDWR;
break;
}
if (mode&0x08000000) flags |= O_CREAT;
if (mode&0x04000000) flags |= O_TRUNC;
if (mode&0x02000000) flags |= O_APPEND;
int realMode = S_IRWXU|S_IRWXG;
if (mode&0x00000001) realMode |= S_IROTH;
if (mode&0x00000002) realMode |= S_IWOTH;
int fd = open(name8.c_str(), flags, realMode);
if (fd < 0) {
jniThrowException(env, "java/io/FileNotFoundException", strerror(errno));
return NULL;
}
jobject object = jniCreateFileDescriptor(env, fd);
if (object == NULL) {
close(fd);
}
return object;
}
static void android_server_am_DebugAnr_logToFile(JNIEnv* env, jobject obj, jstring idObj) {
//pass name from java
if (idObj == NULL) {
jniThrowNullPointerException(env, "id is null");
return ;
}
const char *name = env->GetStringUTFChars(idObj, NULL);
FILE *fp = fopen(name, "w");
if (fp == NULL) {
ALOGE("Create file failed %s:%s\n", name, strerror(errno));
return;
}
env->ReleaseStringUTFChars(idObj, name);
read_all_process_info(fp, 0, 0);
fclose(fp);
}
static jint socket_readba (JNIEnv *env, jobject object,
jbyteArray buffer, jint off, jint len, jobject fileDescriptor)
{
int fd;
jbyte* byteBuffer;
int ret;
if (fileDescriptor == NULL || buffer == NULL) {
jniThrowNullPointerException(env, NULL);
return (jint)-1;
}
if (off < 0 || len < 0 || (off + len) > env->GetArrayLength(buffer)) {
jniThrowException(env, "java/lang/ArrayIndexOutOfBoundsException", NULL);
return (jint)-1;
}
if (len == 0) {
// because socket_read_all returns 0 on EOF
return 0;
}
fd = jniGetFDFromFileDescriptor(env, fileDescriptor);
if (env->ExceptionCheck()) {
return (jint)-1;
}
byteBuffer = env->GetByteArrayElements(buffer, NULL);
if (NULL == byteBuffer) {
// an exception will have been thrown
return (jint)-1;
}
ret = socket_read_all(env, object,
fd, byteBuffer + off, len);
// A return of -1 above means an exception is pending
env->ReleaseByteArrayElements(buffer, byteBuffer, 0);
return (jint) ((ret == 0) ? -1 : ret);
}
/**
* Looks up the name corresponding to an IP address.
*
* @param javaAddress: a byte array containing the raw IP address bytes. Must be
* 4 or 16 bytes long.
* @return the hostname.
* @throws UnknownHostException: the IP address has no associated hostname.
*/
static jstring InetAddress_getnameinfo(JNIEnv* env, jobject obj,
jbyteArray javaAddress)
{
if (javaAddress == NULL) {
jniThrowNullPointerException(env, NULL);
return NULL;
}
// Convert the raw address bytes into a socket address structure.
struct sockaddr_storage ss;
memset(&ss, 0, sizeof(ss));
size_t socklen;
const size_t addressLength = env->GetArrayLength(javaAddress);
if (addressLength == 4) {
struct sockaddr_in* sin = reinterpret_cast<sockaddr_in*>(&ss);
sin->sin_family = AF_INET;
socklen = sizeof(struct sockaddr_in);
jbyte* dst = reinterpret_cast<jbyte*>(&sin->sin_addr.s_addr);
env->GetByteArrayRegion(javaAddress, 0, 4, dst);
} else if (addressLength == 16) {
struct sockaddr_in6 *sin6 = reinterpret_cast<sockaddr_in6*>(&ss);
sin6->sin6_family = AF_INET6;
socklen = sizeof(struct sockaddr_in6);
jbyte* dst = reinterpret_cast<jbyte*>(&sin6->sin6_addr.s6_addr);
env->GetByteArrayRegion(javaAddress, 0, 16, dst);
} else {
// The caller already throws an exception in this case. Don't worry
// about it here.
return NULL;
}
// Look up the host name from the IP address.
char name[NI_MAXHOST];
int ret = getnameinfo(reinterpret_cast<sockaddr*>(&ss), socklen,
name, sizeof(name), NULL, 0, NI_NAMEREQD);
if (ret != 0) {
jniThrowException(env, "java/net/UnknownHostException", gai_strerror(ret));
return NULL;
}
return env->NewStringUTF(name);
}
static jlong android_content_XmlBlock_nativeCreateParseState(JNIEnv* env, jobject clazz,
jlong token)
{
ResXMLTree* osb = reinterpret_cast<ResXMLTree*>(token);
if (osb == NULL) {
jniThrowNullPointerException(env, NULL);
return 0;
}
ResXMLParser* st = new ResXMLParser(*osb);
if (st == NULL) {
jniThrowException(env, "java/lang/OutOfMemoryError", NULL);
return 0;
}
st->restart();
return reinterpret_cast<jlong>(st);
}
