ByteArray* Java_java_net_NetworkInterface_getIpv6Addresses(Env* env, JClass* cls, Object* interfaceName) {
    const char* name = rvmGetStringUTFChars(env, interfaceName);
    if (!name) {
        return NULL;
    }
    jint count = 0;
    if (!iterateAddrInfo(env, name, countIpv6AddressesIterator, &count)) {
        return NULL;
    }

    if (count == 0) {
        return NULL;
    }

    ByteArray* result = rvmNewByteArray(env, 16 * 2 * count);
    if (!result) {
        return NULL;
    }

    GetIpv6AddressesData data = {result, 0};
    if (!iterateAddrInfo(env, name, getIpv6AddressesIterator, &data)) {
        return NULL;
    }
    return result;
}
示例#2
0
文件: aura_rt_VM.c 项目: Zubnix/aura
ByteArray* Java_aura_rt_VM_newByteArray(Env* env, Class* c, jlong address, jint size) {
    ByteArray* array = rvmNewByteArray(env, size);
    if (array) {
        memcpy(array->values, LONG_TO_PTR(address), size * sizeof(jbyte));
    }
    return array;
}
static jboolean getHardwareAddressIterator(Env* env, struct ifaddrs *ia, void* data) {
    ByteArray** resultPtr = (ByteArray**) data;
    if (ia->ifa_addr->sa_family == AF_LINK) {
        struct sockaddr_dl* addr = (struct sockaddr_dl*) ia->ifa_addr;
        if (addr->sdl_alen == 6) {
            char* bytes = (char*) LLADDR(addr);
            *resultPtr = rvmNewByteArray(env, 6);
            if (*resultPtr) {
                memcpy((*resultPtr)->values, bytes, 6);
            }
            return FALSE; // Stop iteration
        }
    }
    return TRUE; // Continue iteration
}
示例#4
0
文件: aura_rt_VM.c 项目: Zubnix/aura
ByteArray* Java_aura_rt_VM_getRuntimeData0(Env* env, Class* c) {
    Options* options = env->vm->options;
    if (!options->runtimeData) {
        return NULL;
    }
    void* p = options->runtimeData;
    jint length = *((jint*) p);
    if (length == 0) {
        return NULL;
    }
    p += sizeof(jint);
    ByteArray* data = rvmNewByteArray(env, length);
    if (!data) {
        return NULL;
    }
    memcpy(data->values, p, length);
    return data;
}
ByteArray* Java_java_net_NetworkInterface_getHardwareAddress(Env* env, JClass* cls, Object* interfaceName) {
    const char* name = rvmGetStringUTFChars(env, interfaceName);
    if (!name) {
        return NULL;
    }
    ByteArray* result = NULL;
#if defined(DARWIN)
    // Darwin doesn't have SIOCGIFHWADDR so we need to use getifaddrs() instead.
    iterateAddrInfo(env, name, getHardwareAddressIterator, &result);
#else
    struct ifreq ifreq;
    if (!ioctl_ifreq(env, interfaceName, &ifreq, SIOCGIFHWADDR)) {
        return NULL;
    }
    if (ifreq.ifr_hwaddr.sa_family == ARPHRD_ETHER) {
        result = rvmNewByteArray(env, 6);
        if (result) {
            memcpy(result->values, ifreq.ifr_hwaddr.sa_data, 6);
        }
    }
#endif
    return result;
}
示例#6
0
文件: bc.c 项目: SinoJerk/robovm
ByteArray* _bcNewByteArray(Env* env, jint length) {
    ENTER;
    ByteArray* array = rvmNewByteArray(env, length);
    LEAVE(array);
}
示例#7
0
文件: attribute.c 项目: Zubnix/aura
static jboolean parseArrayElementValue(Env* env, void** attributes, Class* arrayClass, Object* classLoader, jvalue* result) {
    jbyte tag = getByte(attributes);
    if (tag != '[') return throwFormatError(env, "Array");

    Class* componentType = arrayClass->componentType;

    jint length = getChar(attributes);
    Array* array = NULL;
    if (CLASS_IS_PRIMITIVE(componentType)) {
        switch (componentType->name[0]) {
        case 'Z':
            array = (Array*) rvmNewBooleanArray(env, length);
            break;
        case 'B':
            array = (Array*) rvmNewByteArray(env, length);
            break;
        case 'S':
            array = (Array*) rvmNewShortArray(env, length);
            break;
        case 'C':
            array = (Array*) rvmNewCharArray(env, length);
            break;
        case 'I':
            array = (Array*) rvmNewIntArray(env, length);
            break;
        case 'J':
            array = (Array*) rvmNewLongArray(env, length);
            break;
        case 'F':
            array = (Array*) rvmNewFloatArray(env, length);
            break;
        case 'D':
            array = (Array*) rvmNewDoubleArray(env, length);
            break;
        }
    } else {
        array = (Array*) rvmNewObjectArray(env, length, NULL, arrayClass, NULL);
    }
    if (!array) return FALSE;

    jint i = 0;
    for (i = 0; i < length; i++) {
        jvalue v;
        if (!parseElementValue(env, attributes, componentType, classLoader, &v)) return FALSE;
        if (CLASS_IS_PRIMITIVE(componentType)) {
            switch (componentType->name[0]) {
            case 'Z':
                ((BooleanArray*) array)->values[i] = v.z;
                break;
            case 'B':
                ((ByteArray*) array)->values[i] = v.b;
                break;
            case 'S':
                ((ShortArray*) array)->values[i] = v.s;
                break;
            case 'C':
                ((CharArray*) array)->values[i] = v.c;
                break;
            case 'I':
                ((IntArray*) array)->values[i] = v.i;
                break;
            case 'J':
                ((LongArray*) array)->values[i] = v.j;
                break;
            case 'F':
                ((FloatArray*) array)->values[i] = v.f;
                break;
            case 'D':
                ((DoubleArray*) array)->values[i] = v.d;
                break;
            }
        } else {
            ((ObjectArray*) array)->values[i] = (Object*) v.l;
        }
    }
    result->l = (jobject) array;
    return result->l ? TRUE : FALSE;
}
示例#8
0
static jbyteArray NewByteArray(JNIEnv* env, jsize len) {
    return (jbyteArray) rvmNewByteArray((Env*) env, len);
}