Ejemplo n.º 1
0
JNIEXPORT void JNICALL Java_com_intel_bluetooth_BluetoothStackBlueZ_l2Send
  (JNIEnv* env, jobject peer, jlong handle, jbyteArray data, jint transmitMTU) {
#ifdef BLUECOVE_L2CAP_MTU_TRUNCATE
    struct l2cap_options opt;
    if (!l2Get_options(env, handle, &opt)) {
        return;
    }
#endif //BLUECOVE_L2CAP_MTU_TRUNCATE

    if (data == NULL) {
        throwRuntimeException(env, "Invalid argument");
        return;
    }
    jbyte *bytes = (*env)->GetByteArrayElements(env, data, 0);
    if (bytes == NULL) {
        throwRuntimeException(env, "Invalid argument");
        return;
    }
    int len = (int)(*env)->GetArrayLength(env, data);
    if (len > transmitMTU) {
		len = transmitMTU;
	}

#ifdef BLUECOVE_L2CAP_MTU_TRUNCATE
    if (len > opt.omtu) {
        len = opt.omtu;
    }
#endif //BLUECOVE_L2CAP_MTU_TRUNCATE

    int count = send(handle, (char *)bytes, len, 0);
    if (count < 0) {
        throwIOException(env, "Failed to write. [%d] %s", errno, strerror(errno));
    }
    (*env)->ReleaseByteArrayElements(env, data, bytes, 0);
}
Ejemplo n.º 2
0
JNIEXPORT void JNICALL Java_com_intel_bluetooth_BluetoothStackBlueZDBus_connectionRfWrite__J_3BII
  (JNIEnv* env, jobject peer, jlong handle, jbyteArray b, jint off, jint len) {
    if (b == NULL) {
        throwRuntimeException(env, "Invalid argument");
        return;
    }
    jbyte *bytes = (*env)->GetByteArrayElements(env, b, 0);
    if (bytes == NULL) {
        throwRuntimeException(env, "Invalid argument");
        return;
    }
    int done = 0;
    while(done < len) {
        int count = send(handle, (char *)(bytes + off + done), len - done, 0);
        if (count < 0) {
            throwIOException(env, "Failed to write. [%d] %s", errno, strerror(errno));
            break;
        }
        if (isCurrentThreadInterrupted(env, peer)) {
            break;
        }
        done += count;
    }
    (*env)->ReleaseByteArrayElements(env, b, bytes, 0);
}
bool DeviceInquiryCallback_builDeviceInquiryCallbacks(JNIEnv * env, struct DeviceInquiryCallback* callback, jobject inquiryRunnable, jobject startedNotify) {
    jclass inquiryRunnableClass = (*env)->GetObjectClass(env, inquiryRunnable);

    if (inquiryRunnableClass == NULL) {
        throwRuntimeException(env, "Fail to get Object Class");
        return false;
    }

    jmethodID deviceDiscoveredCallbackMethod = (*env)->GetMethodID(env, inquiryRunnableClass, "deviceDiscoveredCallback", "(Ljavax/bluetooth/DiscoveryListener;JILjava/lang/String;Z)V");
    if (deviceDiscoveredCallbackMethod == NULL) {
        throwRuntimeException(env, "Fail to get MethodID deviceDiscoveredCallback");
        return false;
    }

    jclass notifyClass = (*env)->GetObjectClass(env, startedNotify);
    if (notifyClass == NULL) {
        throwRuntimeException(env, "Fail to get Object Class");
        return false;
    }
    jmethodID notifyMethod = (*env)->GetMethodID(env, notifyClass, "deviceInquiryStartedCallback", "()V");
    if (notifyMethod == NULL) {
        throwRuntimeException(env, "Fail to get MethodID deviceInquiryStartedCallback");
        return false;
    }

    callback->inquiryRunnable = inquiryRunnable;
    callback->deviceDiscoveredCallbackMethod = deviceDiscoveredCallbackMethod;
    callback->startedNotify = startedNotify;
    callback->startedNotifyNotifyMethod = notifyMethod;

    return true;
}
Ejemplo n.º 4
0
static void setText(JNIEnv* env, jclass clazz, RegExData* data, jstring text)
{
    UErrorCode status = U_ZERO_ERROR;

    uregex_setText(data->regex, &EMPTY_STRING, 0, &status);
    if (!U_SUCCESS(status)) {
        throwRuntimeException(env, status);
        return;
    }

    if (data->text != &EMPTY_STRING) {
        delete[] data->text;
        data->text = NULL;
    }

    int textLen = env->GetStringLength(text);
    if (textLen == 0) {
        data->text = &EMPTY_STRING;
    } else {
        data->text = new jchar[textLen + 1];
        env->GetStringRegion(text, 0, textLen, data->text);
        data->text[textLen] = 0;
    }

    uregex_setText(data->regex, data->text, textLen, &status);
    if (!U_SUCCESS(status)) {
        throwRuntimeException(env, status);
    }
}
JNIEXPORT jstring JNICALL Java_com_intel_bluetooth_BluetoothStackBlueZ_getRemoteDeviceVersionInfoImpl
(JNIEnv *env, jobject peer, jint deviceDescriptor, jlong remoteDeviceAddressLong) {
    struct hci_conn_info_req *conn_info;
    struct hci_version ver;
    char info[256];

    conn_info = (struct hci_conn_info_req*)malloc(sizeof(*conn_info) + sizeof(struct hci_conn_info));
    if (!conn_info) {
        throwRuntimeException(env, cOUT_OF_MEMORY);
        return NULL;
    }
    memset(conn_info, 0, sizeof(struct hci_conn_info));
    longToDeviceAddr(remoteDeviceAddressLong, &(conn_info->bdaddr));

    conn_info->type = ACL_LINK;
    if (ioctl((int)deviceDescriptor, HCIGETCONNINFO, (unsigned long) conn_info) < 0) {
        free(conn_info);
        throwRuntimeException(env, "Fail to get connection info");
        return NULL;
    }

    int error = hci_read_remote_version((int)deviceDescriptor, conn_info->conn_info->handle, &ver, READ_REMOTE_NAME_TIMEOUT);
    if (error < 0) {
        throwRuntimeException(env, "Can not get remote device info");
        free(conn_info);
        return NULL;
    }
    snprintf(info, 256, "manufacturer=%i,lmp_version=%i,lmp_sub_version=%i", ver.manufacturer, ver.lmp_ver, ver.lmp_subver);
    free(conn_info);
    return (*env)->NewStringUTF(env, info);
}
Ejemplo n.º 6
0
inline void convertException(JNIEnv* env, Func func) noexcept
{
    try {
        func();
    } catch (JavaException& e) {
        return;
    } catch (std::exception& e) {
        throwRuntimeException(env, e.what());
    } catch (...) {
        throwRuntimeException(env, "Unindentified exception thrown (not derived from std::exception)");
    }
}
jmethodID getGetMethodID(JNIEnv * env, jclass clazz, const char *name, const char *sig) {
    if (clazz == NULL) {
        throwRuntimeException(env, "Fail to get MethodID %s for NULL class", name);
        return NULL;
    }
    jmethodID methodID = (*env)->GetMethodID(env, clazz, name, sig);
    if (methodID == NULL) {
        throwRuntimeException(env, "Fail to get MethodID %s", name);
        return NULL;
    }
    return methodID;
}
jint epollCtl(JNIEnv * env, jint efd, int op, jint fd, jint flags, jint id) {
    uint32_t events = EPOLLET;

    if (flags & EPOLL_ACCEPT) {
        events |= EPOLLIN;
    }
    if (flags & EPOLL_READ) {
        events |= EPOLLIN | EPOLLRDHUP;
    }
    if (flags & EPOLL_WRITE) {
        events |= EPOLLOUT;
    }

    struct epoll_event ev = {
        .events = events,
        // encode the id into the events
        .data.u64 = (((uint64_t) id) << 32L)
    };

    return epoll_ctl(efd, op, fd, &ev);
}

jint getOption(JNIEnv *env, jint fd, int level, int optname, const void *optval, socklen_t optlen) {
    int code;
    code = getsockopt(fd, level, optname, optval, &optlen);
    if (code == 0) {
        return 0;
    }
    int err = errno;
    throwRuntimeException(env, exceptionMessage("Error during getsockopt(...): ", err));
    return code;
}
static inline struct io_control * getIOControl(JNIEnv* env, jobject pointer) {
    struct io_control * ioControl = (struct io_control *) (*env)->GetDirectBufferAddress(env, pointer);
    if (ioControl == NULL) {
       throwRuntimeException(env, "Controller not initialized");
    }
    return ioControl;
}
/**
 * private static native int EVP_PKEY_new_RSA(byte[] n, byte[] e, byte[] d, byte[] p, byte[] q);
 */
static EVP_PKEY* NativeCrypto_EVP_PKEY_new_RSA(JNIEnv* env, jclass clazz, jbyteArray n, jbyteArray e, jbyteArray d, jbyteArray p, jbyteArray q) {
    // LOGD("Entering EVP_PKEY_new_RSA()");

    RSA* rsa = RSA_new();

    rsa->n = arrayToBignum(env, n);
    rsa->e = arrayToBignum(env, e);

    if (d != NULL) {
        rsa->d = arrayToBignum(env, d);
    }

    if (p != NULL) {
        rsa->p = arrayToBignum(env, p);
    }

    if (q != NULL) {
        rsa->q = arrayToBignum(env, q);
    }

    // int check = RSA_check_key(rsa);
    // LOGI("RSA_check_key returns %d", check);

    if (rsa->n == NULL || rsa->e == NULL) {
        RSA_free(rsa);
        throwRuntimeException(env, "Unable to convert BigInteger to BIGNUM");
        return NULL;
    }

    EVP_PKEY* pkey = EVP_PKEY_new();
    EVP_PKEY_assign_RSA(pkey, rsa);

    return pkey;
}
/**
 * private static native int EVP_PKEY_new_DSA(byte[] p, byte[] q, byte[] g, byte[] pub_key, byte[] priv_key);
 */
static EVP_PKEY* NativeCrypto_EVP_PKEY_new_DSA(JNIEnv* env, jclass clazz, jbyteArray p, jbyteArray q, jbyteArray g, jbyteArray pub_key, jbyteArray priv_key) {
    // LOGD("Entering EVP_PKEY_new_DSA()");

    DSA* dsa = DSA_new();

    dsa->p = arrayToBignum(env, p);
    dsa->q = arrayToBignum(env, q);
    dsa->g = arrayToBignum(env, g);
    dsa->pub_key = arrayToBignum(env, pub_key);

    if (priv_key != NULL) {
        dsa->priv_key = arrayToBignum(env, priv_key);
    }

    if (dsa->p == NULL || dsa->q == NULL || dsa->g == NULL || dsa->pub_key == NULL) {
        DSA_free(dsa);
        throwRuntimeException(env, "Unable to convert BigInteger to BIGNUM");
        return NULL;
    }

    EVP_PKEY* pkey = EVP_PKEY_new();
    EVP_PKEY_assign_DSA(pkey, dsa);

    return pkey;
}
bool threadSleep(JNIEnv *env, jlong millis) {
    jclass clazz = (*env)->FindClass(env, "java/lang/Thread");
    if (clazz == NULL) {
        throwRuntimeException(env, "Fail to get Thread class");
        return false;
    }
    jmethodID methodID = (*env)->GetStaticMethodID(env, clazz, "sleep", "(J)V");
    if (methodID == NULL) {
        throwRuntimeException(env, "Fail to get MethodID Thread.sleep");
        return false;
    }
    (*env)->CallStaticVoidMethod(env, clazz, methodID, millis);
    if ((*env)->ExceptionCheck(env)) {
        return false;
    }
    return true;
}
Ejemplo n.º 13
0
JNIEXPORT jint JNICALL Java_io_netty_channel_epoll_Native_epollCreate(JNIEnv * env, jclass clazz) {
    jint efd = epoll_create1(EPOLL_CLOEXEC);
    if (efd < 0) {
        int err = errno;
        throwRuntimeException(env, exceptionMessage("Error during epoll_create(...): ", err));
    }
    return efd;
}
Ejemplo n.º 14
0
static void reset(JNIEnv* env, jclass clazz, RegExData* data, jint position)
{
    UErrorCode status = U_ZERO_ERROR;
    uregex_reset(data->regex, position, &status);
    if (!U_SUCCESS(status)) {
        throwRuntimeException(env, status);
    }
}
int setOption(JNIEnv *env, jint fd, int level, int optname, const void *optval, socklen_t len) {
    int rc = setsockopt(fd, level, optname, optval, len);
    if (rc < 0) {
        int err = errno;
        throwRuntimeException(env, exceptionMessage("Error during setsockopt(...): ", err));
    }
    return rc;
}
JNIEXPORT jint JNICALL Java_io_netty_channel_epoll_Native_read(JNIEnv * env, jclass clazz, jint fd, jobject jbuffer, jint pos, jint limit) {
    void *buffer = (*env)->GetDirectBufferAddress(env, jbuffer);
    if (buffer == NULL) {
        throwRuntimeException(env, "Unable to access address of buffer");
        return -1;
    }
    return read0(env, clazz, fd, buffer, pos, limit);
}
Ejemplo n.º 17
0
bool isCurrentThreadInterrupted(JNIEnv *env, jobject peer) {
    jclass peerClass = (*env)->GetObjectClass(env, peer);
    if (peerClass == NULL) {
        throwRuntimeException(env, "Fail to get Object Class");
        return true;
    }
    jmethodID aMethod = (*env)->GetMethodID(env, peerClass, "isCurrentThreadInterruptedCallback", "()Z");
    if (aMethod == NULL) {
        throwRuntimeException(env, "Fail to get MethodID isCurrentThreadInterruptedCallback");
        return true;
    }
    if ((*env)->CallBooleanMethod(env, peer, aMethod)) {
        throwInterruptedIOException(env, "thread interrupted");
        return true;
    }
    return (*env)->ExceptionCheck(env);
}
Ejemplo n.º 18
0
/*
 * Creates compatible GraphicsInfo structure for specified device context
 */
static inline GraphicsInfo *createCompatibleImageInfo(JNIEnv *env, HDC hdc, jint width, jint height) {
    GraphicsInfo *gi = (GraphicsInfo *) malloc(sizeof(GraphicsInfo));

       // To avoid issue of joint operation Windows NetMeeting and GL,
       // we create HDC and Bitmap for Volatile Image which will compatible 
       // HDC of the entire screen. It may leads to other issues on 
       // multimonitor systems in the future.
    
    gi->hwnd = 0;
       HDC dc = GetDC(NULL);
    //gi->hdc = CreateCompatibleDC(hdc);
    gi->hdc = CreateCompatibleDC(dc);
    if (gi->hdc == NULL) {
        // We are out of GDI resources
        runGC(env);
        //gi->hdc = CreateCompatibleDC(hdc);
        gi->hdc = CreateCompatibleDC(dc);
        if (gi->hdc == NULL)
            throwRuntimeException(env);
    }
        
    
    // Creating bitmap and setting it to DC
    //gi->bmp = CreateCompatibleBitmap(hdc, width, height);
    gi->bmp = CreateCompatibleBitmap(dc, width, height);
    if (gi->bmp == NULL) {
        // We are out of GDI resources
        runGC(env);
        //gi->bmp = CreateCompatibleBitmap(hdc, width, height);
        gi->bmp = CreateCompatibleBitmap(dc, width, height);
        if (gi->bmp == NULL)
            throwRuntimeException(env);
    }
    SelectObject(gi->hdc, gi->bmp);
       ReleaseDC(NULL, dc);
    
    gi->graphics = new Graphics(gi->hdc);
    gi->pen = 0;
    gi->brush = 0;   
    gi->matrix = 0;

    gi->clip = new Region(Rect(0, 0, width, height));
    gi->graphics->SetClip(gi->clip);
    
    return gi; 
}
JNIEXPORT void JNICALL Java_io_netty_channel_epoll_Native_epollCtlDel(JNIEnv * env, jclass clazz, jint efd, jint fd) {
    // Create an empty event to workaround a bug in older kernels which can not handle NULL.
    struct epoll_event event = { 0 };
    if (epoll_ctl(efd, EPOLL_CTL_DEL, fd, &event) < 0) {
        int err = errno;
        throwRuntimeException(env, exceptionMessage("Error during calling epoll_ctl(...): ", err));
    }
}
JNIEXPORT jint JNICALL Java_io_netty_channel_epoll_Native_sendTo(JNIEnv * env, jclass clazz, jint fd, jobject jbuffer, jint pos, jint limit, jbyteArray address, jint scopeId, jint port) {
    void *buffer = (*env)->GetDirectBufferAddress(env, jbuffer);
    if (buffer == NULL) {
        throwRuntimeException(env, "Unable to access address of buffer");
        return -1;
    }
    return sendTo0(env, fd, buffer, pos, limit, address, scopeId, port);
}
JNIEXPORT void JNICALL Java_io_netty_channel_epoll_Native_eventFdRead(JNIEnv * env, jclass clazz, jint fd) {
    uint64_t eventfd_t;

    if (eventfd_read(fd, &eventfd_t) != 0) {
        // something is serious wrong
        throwRuntimeException(env, "Error calling eventfd_read(...)");
    }
}
JNIEXPORT void JNICALL Java_io_netty_channel_epoll_Native_eventFdWrite(JNIEnv * env, jclass clazz, jint fd, jlong value) {
    jint eventFD = eventfd_write(fd, (eventfd_t)value);

    if (eventFD < 0) {
        int err = errno;
        throwRuntimeException(env, exceptionMessage("Error calling eventfd_write(...): ", err));
    }
}
Ejemplo n.º 23
0
static void setRegion(JNIEnv* env, jclass clazz, RegExData* data, jint start,
                      jint end)
{
    UErrorCode status = U_ZERO_ERROR;
    uregex_setRegion(data->regex, start, end, &status);
    if (!U_SUCCESS(status)) {
        throwRuntimeException(env, status);
    }
}
Ejemplo n.º 24
0
static jint regionStart(JNIEnv* env, jclass clazz, RegExData* data)
{
    UErrorCode status = U_ZERO_ERROR;
    int result = uregex_regionStart(data->regex, &status);
    if (!U_SUCCESS(status)) {
        throwRuntimeException(env, status);
    }
    return result;
}
Ejemplo n.º 25
0
static void useAnchoringBounds(JNIEnv* env, jclass clazz, RegExData* data,
                               jboolean value)
{
    UErrorCode status = U_ZERO_ERROR;
    uregex_useAnchoringBounds(data->regex, value, &status);
    if (!U_SUCCESS(status)) {
        throwRuntimeException(env, status);
    }
}
JNIEXPORT jint JNICALL Java_io_netty_channel_epoll_Native_eventFd(JNIEnv * env, jclass clazz) {
    jint eventFD =  eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);

    if (eventFD < 0) {
        int err = errno;
        throwRuntimeException(env, exceptionMessage("Error creating eventFD(...): ", err));
    }
    return eventFD;
}
Ejemplo n.º 27
0
static jboolean requireEnd(JNIEnv* env, jclass clazz, RegExData* data)
{
    UErrorCode status = U_ZERO_ERROR;
    jboolean result = uregex_requireEnd(data->regex, &status);
    if (!U_SUCCESS(status)) {
        throwRuntimeException(env, status);
    }
    return result;
}
JNIEXPORT void JNICALL Java_org_apache_activemq_artemis_jlibaio_LibaioContext_freeBuffer
  (JNIEnv * env, jclass clazz, jobject jbuffer) {
    if (jbuffer == NULL)
    {
       throwRuntimeException(env, "Null pointer");
       return;
    }
  	void *  buffer = (*env)->GetDirectBufferAddress(env, jbuffer);
  	free(buffer);
}
JNIEXPORT jstring JNICALL Java_io_netty_channel_epoll_Native_kernelVersion(JNIEnv *env, jclass clazz) {
    struct utsname name;

    int res = uname(&name);
    if (res == 0) {
        return (*env)->NewStringUTF(env, name.release);
    }
    int err = errno;
    throwRuntimeException(env, exceptionMessage("Error during uname(...): ", err));
    return NULL;
}
Ejemplo n.º 30
0
static jboolean lookingAt(JNIEnv* env, jclass clazz, RegExData* data,
                          jint startIndex)
{
    UErrorCode status = U_ZERO_ERROR;

    jboolean result = uregex_lookingAt(data->regex, startIndex, &status);
    if (!U_SUCCESS(status)) {
        throwRuntimeException(env, status);
    }

    return result;
}