JNIEXPORT jdouble JNICALL PRIMLIB_UnwrapDouble(JNIEnv * env, jobject obj) { if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_DOUBLE))) { return PRIMLIB_GetDoubleObjectValue(env, obj); } else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_FLOAT))) { return (jdouble)PRIMLIB_GetFloatObjectValue(env, obj); } else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_LONG))) { return (jdouble)PRIMLIB_GetLongObjectValue(env, obj); } else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_INT))) { return (jdouble)PRIMLIB_GetIntObjectValue(env, obj); } else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_SHORT))) { return (jdouble)PRIMLIB_GetShortObjectValue(env, obj); } else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_CHAR))) { return (jdouble)PRIMLIB_GetCharObjectValue(env, obj); } else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_BYTE))) { return (jdouble)PRIMLIB_GetByteObjectValue(env, obj); } else { JCL_ThrowException(env, "java/lang/IllegalArgumentException", "Argument not of correct type."); return 0; } }
jlong _javaio_get_file_length (JNIEnv * env, jint fd) { #ifndef WITHOUT_FILESYSTEM jlong length; int result; TARGET_NATIVE_FILE_SIZE (fd, length, result); if (result != TARGET_NATIVE_OK) { JCL_ThrowException (env, "java/io/IOException", TARGET_NATIVE_LAST_ERROR_STRING ()); return (TARGET_NATIVE_MATH_INT_INT64_CONST_MINUS_1); } return (length); #else /* not WITHOUT_FILESYSTEM */ return (TARGET_NATIVE_MATH_INT_INT64_CONST_0); #endif /* not WITHOUT_FILESYSTEM */ }
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkScreenGraphicsDevice_nativeSetDisplayMode (JNIEnv *env, jobject obj __attribute__((unused)), jobject gdkGraphicsEnv __attribute__((unused)), jint index __attribute__((unused)), jshort rate __attribute__((unused))) { #ifdef HAVE_XRANDR GdkDisplay *display; XRRScreenConfiguration *config; Rotation rotation; display = (GdkDisplay *) NSA_GET_DISPLAY_PTR(env, gdkGraphicsEnv); gdk_threads_enter(); config = XRRGetScreenInfo (GDK_DISPLAY_XDISPLAY(display), GDK_ROOT_WINDOW()); /* The rotation is not exposed to the Java API. So we retrieve its current * value and set it to the same when switching resolution. */ XRRConfigCurrentConfiguration (config, &rotation); XRRSetScreenConfigAndRate (GDK_DISPLAY_XDISPLAY(display), config, GDK_ROOT_WINDOW(), index, rotation, rate, CurrentTime); XRRFreeScreenConfigInfo(config); gdk_threads_leave(); #else JCL_ThrowException(env, "java/lang/InternalError", "Method should not have been invoked."); #endif }
JNIEXPORT jobjectArray JNICALL Java_gnu_java_awt_peer_gtk_GdkScreenGraphicsDevice_nativeGetDisplayModes (JNIEnv *env, jobject obj __attribute__((unused)), jobject gdkGraphicsEnv __attribute__((unused))) { #ifdef HAVE_XRANDR GdkDisplay *display; XRRScreenConfiguration *config; XRRScreenSize *screenSizes; int nsizes = 0, nrates = 0, i = 0; jclass x11DisplayMode_class; jmethodID x11DisplayMode_ctor; jobjectArray array; jobject instance; short *rates; jshortArray shortArray; display = (GdkDisplay *) NSA_GET_DISPLAY_PTR(env, gdkGraphicsEnv); gdk_threads_enter(); config = XRRGetScreenInfo (GDK_DISPLAY_XDISPLAY(display), GDK_ROOT_WINDOW()); screenSizes = XRRConfigSizes(config, &nsizes); x11DisplayMode_class = (*env)->FindClass(env, "gnu/java/awt/peer/gtk/GdkScreenGraphicsDevice$X11DisplayMode"); x11DisplayMode_ctor = (*env)->GetMethodID(env, x11DisplayMode_class, "<init>", "(II[S)V"); array = (*env)->NewObjectArray(env, nsizes, x11DisplayMode_class, NULL); for (; i < nsizes ; i++) { /* Retrieves refresh rate information. */ rates = XRRConfigRates(config, i, &nrates); /* Create a Java short array and put them in. */ shortArray = (*env)->NewShortArray(env, nrates); (*env)->SetShortArrayRegion(env, shortArray, 0, nrates, (jshort *) rates); /* Create a GdkScreenGraphicsDevice.X11DisplayMode instance. */ instance = (*env)->NewObject(env, x11DisplayMode_class, x11DisplayMode_ctor, screenSizes[i].width, screenSizes[i].height, shortArray); /* Put it into the result array. */ (*env)->SetObjectArrayElement(env, array, i, instance); } /* Free everything acquired by xlib. */ XRRFreeScreenConfigInfo (config); gdk_threads_leave(); return array; #else JCL_ThrowException(env, "java/lang/InternalError", "Method should not have been invoked."); return NULL; #endif }
JNIEXPORT void JNICALL Java_gnu_javax_sound_sampled_gstreamer_lines_GstPipeline_init_1instance (JNIEnv *env, jobject pipeline) { GstNativePipeline *_pipeline = NULL; jclass localGstPipelineClass = NULL; jclass localPointerClass = NULL; jobject _pointer = NULL; _pipeline = (GstNativePipeline *) JCL_malloc (env, sizeof (GstNativePipeline)); if (_pipeline == NULL) return; _pipeline->priv = (GstNativePipelinePrivate *) JCL_malloc (env, sizeof (GstNativePipelinePrivate)); if (_pipeline->priv == NULL) { JCL_free (env, _pipeline); return; } #if SIZEOF_VOID_P == 8 localPointerClass = JCL_FindClass (env, "gnu/classpath/Pointer64"); #else # if SIZEOF_VOID_P == 4 localPointerClass = JCL_FindClass (env, "gnu/classpath/Pointer32"); # else # error "Pointer size is not supported." # endif /* SIZEOF_VOID_P == 4 */ #endif /* SIZEOF_VOID_P == 8 */ localGstPipelineClass = (*env)->GetObjectClass(env, pipeline); if (localGstPipelineClass == NULL || localGstPipelineClass == NULL) { JCL_free (env, _pipeline->priv); JCL_free (env, _pipeline); JCL_ThrowException (env, "java/lang/InternalError", "Class Initialization failed."); return; } GST_DETECTED_PIPE_CAPACITY = (long) (*env)->GetLongField(env, pipeline, capacityFID); /* fill the object */ (*env)->GetJavaVM(env, &_pipeline->priv->vm); _pipeline->priv->jni_pipeline = (*env)->NewGlobalRef(env, pipeline); _pipeline->priv->GstPipelineClass = (*env)->NewGlobalRef(env, localGstPipelineClass); _pipeline->priv->PointerClass = (*env)->NewGlobalRef(env, localPointerClass); _pipeline->priv->pipeline = NULL; _pointer = (*env)->GetObjectField(env, pipeline, pipelineFID); if (_pointer == NULL) { #if SIZEOF_VOID_P == 8 _pointer = (*env)->NewObject(env, _pipeline->priv->PointerClass, pointerConstructorMID, (jlong) _pipeline); #else _pointer = (*env)->NewObject(env, _pipeline->priv->PointerClass, pointerConstructorMID, (jint) _pipeline); #endif } else { #if SIZEOF_VOID_P == 8 (*env)->SetLongField(env, pipeline, pipelineFID, (jlong) _pipeline); #else (*env)->SetIntField(env, pipeline, pipelineFID, (jint) _pipeline); #endif } /* store back our pointer into the calling class */ (*env)->SetObjectField(env, pipeline, pipelineFID, _pointer); }
/* * Returns all local network interfaces as an array. */ JNIEXPORT jobjectArray JNICALL Java_java_net_VMNetworkInterface_getVMInterfaces (JNIEnv * env, jclass clazz UNUSED) { #if defined (HAVE_IFADDRS_H) && defined (HAVE_GETIFADDRS) struct ifaddrs *ifaddrs, *i; struct netif_entry *iflist = NULL, *e; jobjectArray netifs; int numifs = 0; int k; if (getifaddrs (&ifaddrs) == -1) { JCL_ThrowException (env, "java/net/SocketException", strerror (errno)); return NULL; } for (i = ifaddrs; i != NULL; i = i->ifa_next) { if (iflist == NULL) { iflist = JCL_malloc (env, sizeof (struct netif_entry)); if (iflist == NULL) { freeifaddrs (ifaddrs); return NULL; } iflist->name = i->ifa_name; iflist->numaddrs = 0; iflist->next = NULL; iflist->netif = (*env)->NewObject (env, clazz, java_net_VMNetworkInterface_init, (*env)->NewStringUTF (env, i->ifa_name)); if (iflist->netif == NULL) { freeifaddrs (ifaddrs); JCL_free (env, iflist); return NULL; } e = iflist; } else { struct netif_entry *p = NULL; for (e = iflist; e != NULL; e = e->next) { if (strcmp (e->name, i->ifa_name) == 0) break; p = e; } if (e == NULL) { p->next = (struct netif_entry *) JCL_malloc (env, sizeof (struct netif_entry)); if (p->next == NULL) { free_netif_list (env, iflist); freeifaddrs (ifaddrs); return NULL; } e = p->next; e->name = i->ifa_name; e->numaddrs = 0; e->next = NULL; e->netif = (*env)->NewObject (env, clazz, java_net_VMNetworkInterface_init, (*env)->NewStringUTF (env, i->ifa_name)); if (e->netif == NULL) { free_netif_list (env, iflist); freeifaddrs (ifaddrs); return NULL; } } } if (i->ifa_addr == NULL) continue; if (i->ifa_addr->sa_family == AF_INET) { struct sockaddr_in *sin = (struct sockaddr_in *) i->ifa_addr; jobject buffer = (*env)->NewDirectByteBuffer (env, &(sin->sin_addr.s_addr), 4); (*env)->CallVoidMethod (env, e->netif, java_net_VMNetworkInterface_addAddress, buffer); if ((*env)->ExceptionCheck (env)) { free_netif_list (env, iflist); freeifaddrs (ifaddrs); return NULL; } (*env)->DeleteLocalRef (env, buffer); e->numaddrs++; } #ifdef HAVE_INET6 else if (i->ifa_addr->sa_family == AF_INET6) { struct sockaddr_in6 *sin = (struct sockaddr_in6 *) i->ifa_addr; jobject buffer = (*env)->NewDirectByteBuffer (env, &(sin->sin6_addr.s6_addr), 16); (*env)->CallVoidMethod (env, e->netif, java_net_VMNetworkInterface_addAddress, buffer); if ((*env)->ExceptionCheck (env)) { free_netif_list (env, iflist); freeifaddrs (ifaddrs); return NULL; } (*env)->DeleteLocalRef (env, buffer); e->numaddrs++; } #endif /* HAVE_INET6 */ } /* Count how many interfaces we have that have addresses. */ for (e = iflist; e != NULL; e = e->next) { if (e->numaddrs != 0) numifs++; } netifs = (*env)->NewObjectArray (env, numifs, clazz, NULL); k = 0; for (e = iflist; e != NULL && k < numifs; e = e->next) { if (e->numaddrs != 0) { (*env)->SetObjectArrayElement (env, netifs, k, e->netif); (*env)->DeleteLocalRef (env, e->netif); k++; } } free_netif_list (env, iflist); freeifaddrs (ifaddrs); return netifs; #else JCL_ThrowException (env, "java/net/SocketException", "getifaddrs not supported"); return NULL; #endif /* HAVE_IFADDRS_H && HAVE_GETIFADDRS */ }
/* * Implementation of a gathering write. Will use the appropriate * vector based read call (currently readv on Linux). * * This has a limit to the number of buffers that will be read. It * will not make muliple readv calls. This is to ensure that operations * are atomic. Currently it is limited to 16 buffers. This is for * compatibiliy with Sun. */ JNIEXPORT jlong JNICALL Java_gnu_java_nio_VMChannel_writeGathering (JNIEnv *env, jobject o __attribute__ ((__unused__)), jint fd, jobjectArray bbufs, jint offset, jint length) { int i; /* jboolean is_error = JNI_FALSE; */ /* char *error_msg; */ struct iovec buffers[JCL_IOV_MAX]; struct JCL_buffer bi_list[JCL_IOV_MAX]; ssize_t result; jint vec_len = length < JCL_IOV_MAX ? length : JCL_IOV_MAX; jlong bytes_written; /* Build the vector of buffers to read into */ for (i = 0; i < vec_len; i++) { struct JCL_buffer* buf; jobject bbuf; buf = &bi_list[i]; bbuf = (*env)->GetObjectArrayElement(env, bbufs, offset + i); JCL_init_buffer(env, buf, bbuf); buffers[i].iov_base = &(buf->ptr[buf->position + buf->offset]); buffers[i].iov_len = buf->limit - buf->position; (*env)->DeleteLocalRef(env, bbuf); } /* Work the gathering magic */ result = writev(fd, buffers, vec_len); bytes_written = (jlong) result; if (result < 0) { bytes_written = 0; if (errno == EAGAIN) /* Non blocking */ result = 0; else if (errno == EBADF) /* Bad fd */ { JCL_cleanup_buffers(env, bi_list, vec_len, bbufs, offset, bytes_written); JCL_ThrowException (env, NON_WRITABLE_CHANNEL_EXCEPTION, strerror(errno)); return -1; } else { JCL_cleanup_buffers(env, bi_list, vec_len, bbufs, offset, bytes_written); JCL_ThrowException (env, IO_EXCEPTION, strerror(errno)); return -1; } } else if (result == 0) /* EOF?? Does this happen on a write */ result = -1; JCL_cleanup_buffers(env, bi_list, vec_len, bbufs, offset, bytes_written); return (jlong) result; }
static void throw_exception_by_name (JNIEnv *env, const char *name, const char *msg) { JCL_ThrowException (env, name, msg); }
JNIEXPORT jint JNICALL Java_gnu_java_nio_VMSelector_select (JNIEnv * env, jclass obj __attribute__ ((__unused__)), jintArray read, jintArray write, jintArray except, jlong timeout) { jint result; jclass thread_class = (*env)->FindClass (env, "java/lang/Thread"); jmethodID thread_current_thread = (*env)->GetStaticMethodID (env, thread_class, "currentThread", "()Ljava/lang/Thread;"); jmethodID thread_interrupt = (*env)->GetMethodID (env, thread_class, "interrupt", "()V"); jmethodID thread_interrupted = (*env)->GetStaticMethodID (env, thread_class, "interrupted", "()Z"); jobject current_thread; int max_fd = 0; fd_set read_fds; fd_set write_fds; fd_set except_fds; struct timeval real_time_data; struct timeval *time_data = NULL; char *message; /* If a legal timeout value isn't given, use NULL. * This means an infinite timeout. The specification * also says that a zero timeout should be treated * as infinite. Otherwise (if the timeout value is legal), * fill our timeval struct and use it for the select. */ if (timeout > 0) { real_time_data.tv_sec = timeout / 1000; real_time_data.tv_usec = (timeout % 1000) * 1000; time_data = &real_time_data; } /* Reset all fd_set structures */ FD_ZERO (&read_fds); FD_ZERO (&write_fds); FD_ZERO (&except_fds); /* Fill the fd_set data structures for the _Jv_select() call. */ helper_put_filedescriptors (env, read, &read_fds, &max_fd); helper_put_filedescriptors (env, write, &write_fds, &max_fd); helper_put_filedescriptors (env, except, &except_fds, &max_fd); /* Actually do the select */ result = helper_select (env, thread_class, thread_interrupted, max_fd + 1, &read_fds, &write_fds, &except_fds, time_data); if (result == -EINTR) { /* The behavior of JRE 1.4.1 is that no exception is thrown * when the thread is interrupted, but the thread's interrupt * status is set. Clear all of our select sets and return 0, * indicating that nothing was selected. */ current_thread = (*env)->CallStaticObjectMethod (env, thread_class, thread_current_thread); (*env)->CallVoidMethod (env, current_thread, thread_interrupt); helper_reset (env, read); helper_reset (env, write); helper_reset (env, except); return 0; } if (result < 0) { #if defined(HAVE_STRERROR_R) char message_buf[BUF_SIZE+1]; int errorcode = -result; if (strerror_r (errorcode, message_buf, BUF_SIZE)) { /* This would mean that message_buf was to small * to hold the error message. */ JCL_ThrowException (env, "java/lang/InternalError", "Not enough space in message buffer."); return 0; } message = message_buf; #else message = strerror(errno); #endif JCL_ThrowException (env, "java/io/IOException", message); return 0; } /* Set the file descriptors according to the values returned from select(). */ helper_get_filedescriptors (env, read, &read_fds); helper_get_filedescriptors (env, write, &write_fds); helper_get_filedescriptors (env, except, &except_fds); return result; }
jint _javaio_write (JNIEnv * env, jint fd, jarray buf, jint offset, jint len) { #ifndef WITHOUT_FILESYSTEM jbyte *bufptr; int bytes_written; int result; if (len == 0) return 0; /* Nothing todo, and GetByteArrayElements() seems undefined. */ bufptr = (*env)->GetByteArrayElements (env, buf, 0); if (bufptr == NULL) { JCL_ThrowException (env, "java/io/IOException", "Internal Error: get byte array"); return (-1); } TARGET_NATIVE_FILE_WRITE (fd, (bufptr + offset), len, bytes_written, result); (*env)->ReleaseByteArrayElements (env, buf, bufptr, 0); if (result != TARGET_NATIVE_OK) JCL_ThrowException (env, "java/io/IOException", TARGET_NATIVE_LAST_ERROR_STRING ()); if (bytes_written == 0) return (-1); return (bytes_written); #else /* not WITHOUT_FILESYSTEM */ jbyte *bufptr; int bytesWritten; if ((fd == 0) || (fd == 1) || (fd == 2)) { if (len == 0) return 0; /* Nothing todo, and GetByteArrayElements() seems undefined. */ bufptr = (*env)->GetByteArrayElements (env, buf, 0); if (bufptr == NULL) { JCL_ThrowException (env, "java/io/IOException", "Internal Error"); return (-1); } TARGET_NATIVE_FILE_WRITE (fd, (bufptr + offset), len, bytes_written, result); (*env)->ReleaseByteArrayElements (env, buf, bufptr, 0); if (bytes_written == -1) JCL_ThrowException (env, "java/io/IOException", TARGET_NATIVE_LAST_ERROR_STRING ()); if (bytes_written == 0) return (-1); return (bytes_written); } else { return (-1); } #endif /* not WITHOUT_FILESYSTEM */ }