/* gnu_java_nio_channels_FileChannelImpl.c - Copyright (C) 2003, 2004 Free Software Foundation, Inc. This file is part of GNU Classpath. GNU Classpath is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GNU Classpath is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU Classpath; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. Linking this library statically or dynamically with other modules is making a combined work based on this library. Thus, the terms and conditions of the GNU General Public License cover the whole combination. As a special exception, the copyright holders of this library give you permission to link this library with independent modules to produce an executable, regardless of the license terms of these independent modules, and to copy and distribute the resulting executable under terms of your choice, provided that you also meet, for each linked independent module, the terms and conditions of the license of that module. An independent module is a module which is not derived from or based on this library. If you modify this library, you may extend this exception to your version of the library, but you are not obligated to do so. If you do not wish to do so, delete this exception statement from your version. */ /* do not move; needed here because of some macro definitions */ #include #include #include #include #include #include "target_native.h" #ifndef WITHOUT_FILESYSTEM #include "target_native_file.h" #endif #include "target_native_math_int.h" #include "gnu_java_nio_channels_FileChannelImpl.h" /* These values must be kept in sync with FileChannelImpl.java. */ #define FILECHANNELIMPL_READ 1 #define FILECHANNELIMPL_WRITE 2 #define FILECHANNELIMPL_APPEND 4 /* These values must be kept in sync with FileChannelImpl.java. */ /* #define FILECHANNELIMPL_FILESEEK_SET 0 */ /* #define FILECHANNELIMPL_FILESEEK_CUR 1 */ /* #define FILECHANNELIMPL_FILESEEK_END 2 */ #define FILECHANNELIMPL_FILEOPEN_FLAG_READ 1 #define FILECHANNELIMPL_FILEOPEN_FLAG_WRITE 2 #define FILECHANNELIMPL_FILEOPEN_FLAG_APPEND 4 #define FILECHANNELIMPL_FILEOPEN_FLAG_EXCL 8 #define FILECHANNELIMPL_FILEOPEN_FLAG_SYNC 16 #define FILECHANNELIMPL_FILEOPEN_FLAG_DSYNC 32 #define IO_EXCEPTION "java/io/IOException" /* FIXME: This can't be right. Need converter macros. */ #define CONVERT_JLONG_TO_INT(x) TARGET_NATIVE_MATH_INT_INT64_TO_INT32(x) #define CONVERT_INT_TO_JLONG(x) TARGET_NATIVE_MATH_INT_INT32_TO_INT64(x) /* FIXME: This can't be right. Need converter macros. */ #define CONVERT_JLONG_TO_OFF_T(x) TARGET_NATIVE_MATH_INT_INT64_TO_INT32(x) #define CONVERT_OFF_T_TO_JLONG(x) TARGET_NATIVE_MATH_INT_INT32_TO_INT64(x) /* FIXME: This can't be right. Need converter macros */ #define CONVERT_JINT_TO_INT(x) ((int)(x & 0xFFFFFFFF)) #define CONVERT_INT_TO_JINT(x) ((int)(x & 0xFFFFFFFF)) /* FIXME: This can't be right. Need converter macros. */ #define CONVERT_SSIZE_T_TO_JINT(x) ((jint)(x & 0xFFFFFFFF)) #define CONVERT_JINT_TO_SSIZE_T(x) (x) /* cached fieldID of gnu.java.nio.channels.FileChannelImpl.fd */ static jfieldID native_fd_fieldID; static jint get_native_fd (JNIEnv * env, jobject obj) { return (*env)->GetIntField (env, obj, native_fd_fieldID); } /* * Library initialization routine. Called as part of java.io.FileDescriptor * static initialization. */ JNIEXPORT void JNICALL Java_gnu_java_nio_channels_FileChannelImpl_init (JNIEnv * env, jclass clazz) { jclass clazz_fc; jfieldID field; jmethodID constructor; jobject obj; /* Initialize native_fd_fieldID so we only compute it once! */ clazz_fc = (*env)->FindClass (env, "gnu/java/nio/channels/FileChannelImpl"); if (!clazz_fc) { JCL_ThrowException (env, IO_EXCEPTION, "Internal error"); return; } field = (*env)->GetFieldID (env, clazz_fc, "fd", "I"); if (!field) { JCL_ThrowException (env, IO_EXCEPTION, "Internal error"); return; } native_fd_fieldID = field; constructor = (*env)->GetMethodID (env, clazz, "", "(II)V"); if (!constructor) return; #define INIT_FIELD(FIELDNAME, FDVALUE, MODE) \ field = (*env)->GetStaticFieldID (env, clazz, FIELDNAME, \ "Lgnu/java/nio/channels/FileChannelImpl;"); \ if (! field) \ return; \ obj = (*env)->NewObject (env, clazz, constructor, FDVALUE, MODE); \ if (! obj) \ return; \ (*env)->SetStaticObjectField (env, clazz, field, obj); \ if ((*env)->ExceptionOccurred (env)) \ return; INIT_FIELD ("in", 0, FILECHANNELIMPL_READ); INIT_FIELD ("out", 1, FILECHANNELIMPL_WRITE); INIT_FIELD ("err", 2, FILECHANNELIMPL_WRITE); #undef INIT_FIELD } /* * Open the specified file and return a native file descriptor */ JNIEXPORT jint JNICALL Java_gnu_java_nio_channels_FileChannelImpl_open (JNIEnv * env, jobject obj __attribute__ ((__unused__)), jstring name, jint mode) { const char *filename; int flags; int permissions; int native_fd; int result; filename = JCL_jstring_to_cstring (env, name); if (filename == NULL) return (-1); /* Exception will already have been thrown */ /* get file/permission flags for open() */ if ((mode & FILECHANNELIMPL_FILEOPEN_FLAG_READ) && (mode & FILECHANNELIMPL_FILEOPEN_FLAG_WRITE)) { /* read/write */ flags = TARGET_NATIVE_FILE_FILEFLAG_CREATE | TARGET_NATIVE_FILE_FILEFLAG_READWRITE; permissions = TARGET_NATIVE_FILE_FILEPERMISSION_NORMAL; } else if ((mode & FILECHANNELIMPL_FILEOPEN_FLAG_READ)) { /* read */ flags = TARGET_NATIVE_FILE_FILEFLAG_READ; permissions = TARGET_NATIVE_FILE_FILEPERMISSION_NORMAL; } else { /* write */ flags = TARGET_NATIVE_FILE_FILEFLAG_CREATE | TARGET_NATIVE_FILE_FILEFLAG_WRITE; if ((mode & FILECHANNELIMPL_FILEOPEN_FLAG_APPEND)) { flags |= TARGET_NATIVE_FILE_FILEFLAG_APPEND; } else { flags |= TARGET_NATIVE_FILE_FILEFLAG_TRUNCATE; } permissions = TARGET_NATIVE_FILE_FILEPERMISSION_NORMAL; } if ((mode & FILECHANNELIMPL_FILEOPEN_FLAG_SYNC)) { flags |= TARGET_NATIVE_FILE_FILEFLAG_SYNC; } if ((mode & FILECHANNELIMPL_FILEOPEN_FLAG_DSYNC)) { flags |= TARGET_NATIVE_FILE_FILEFLAG_DSYNC; } #ifdef O_BINARY flags |= TARGET_NATIVE_FILE_FILEFLAG_BINARY; #endif TARGET_NATIVE_FILE_OPEN (filename, native_fd, flags, permissions, result); JCL_free_cstring (env, name, filename); if (result != TARGET_NATIVE_OK) { /* We can only throw FileNotFoundException. */ JCL_ThrowException (env, "java/io/FileNotFoundException", TARGET_NATIVE_LAST_ERROR_STRING ()); return TARGET_NATIVE_MATH_INT_INT64_CONST_MINUS_1; } return native_fd; } /* * Closes the specified file descriptor and return status code. * Exception on error */ JNIEXPORT void JNICALL Java_gnu_java_nio_channels_FileChannelImpl_implCloseChannel (JNIEnv * env, jobject obj) { int native_fd; int result; native_fd = get_native_fd (env, obj); TARGET_NATIVE_FILE_CLOSE (native_fd, result); if (result != TARGET_NATIVE_OK) { JCL_ThrowException (env, IO_EXCEPTION, TARGET_NATIVE_LAST_ERROR_STRING ()); } } /* * Return number of bytes that can be read from the file w/o blocking. * Exception on error */ JNIEXPORT jint JNICALL Java_gnu_java_nio_channels_FileChannelImpl_available (JNIEnv * env, jobject obj) { int native_fd; jlong bytes_available; int result; native_fd = get_native_fd (env, obj); TARGET_NATIVE_FILE_AVAILABLE (native_fd, bytes_available, result); if (result != TARGET_NATIVE_OK) { JCL_ThrowException (env, IO_EXCEPTION, TARGET_NATIVE_LAST_ERROR_STRING ()); return 0; } /* FIXME NYI ??? why only jint and not jlong? */ return TARGET_NATIVE_MATH_INT_INT64_TO_INT32 (bytes_available); } JNIEXPORT jlong JNICALL Java_gnu_java_nio_channels_FileChannelImpl_size (JNIEnv * env, jobject obj) { int native_fd; jlong file_size; int result; native_fd = get_native_fd (env, obj); TARGET_NATIVE_FILE_SIZE (native_fd, file_size, result); if (result != TARGET_NATIVE_OK) { JCL_ThrowException (env, IO_EXCEPTION, TARGET_NATIVE_LAST_ERROR_STRING ()); return TARGET_NATIVE_MATH_INT_INT64_CONST_MINUS_1; } return file_size; } /* * Return the current position of the file pointer * Exception on error */ JNIEXPORT jlong JNICALL Java_gnu_java_nio_channels_FileChannelImpl_implPosition (JNIEnv * env, jobject obj) { int native_fd; jlong current_offset; int result; native_fd = get_native_fd (env, obj); TARGET_NATIVE_FILE_TELL (native_fd, current_offset, result); if (result != TARGET_NATIVE_OK) { JCL_ThrowException (env, IO_EXCEPTION, TARGET_NATIVE_LAST_ERROR_STRING ()); return TARGET_NATIVE_MATH_INT_INT64_CONST_MINUS_1; } return current_offset; } /* * Wrapper around lseek call. Return new file position * Exception on error */ JNIEXPORT void JNICALL Java_gnu_java_nio_channels_FileChannelImpl_seek (JNIEnv * env, jobject obj, jlong offset) { int native_fd; jlong new_offset; int result; native_fd = get_native_fd (env, obj); #if 0 /* Should there be such an exception? All native layer macros should be accepting 64bit-values if needed. It some target is not able to handle such values it should simply operate with 32bit-values and convert 64bit-values appriopated. In this case I assume problems should not occurre: if some specific target is not able to handle 64bit-values the system is limited to 32bit at all, thus the application can not do a seek() or something else beyond the 32bit limit. It this true? */ /* FIXME: What do we do if offset > the max value of off_t on this 32bit * system? How do we detect that and what do we do? */ if (CONVERT_OFF_T_TO_JLONG (native_offset) != offset) { JCL_ThrowException (env, IO_EXCEPTION, "Cannot represent position correctly on this system"); } #endif /* 0 */ result = TARGET_NATIVE_ERROR; new_offset = TARGET_NATIVE_MATH_INT_INT64_CONST_MINUS_1; TARGET_NATIVE_FILE_SEEK_BEGIN (native_fd, offset, new_offset, result); if (result != TARGET_NATIVE_OK) { JCL_ThrowException (env, IO_EXCEPTION, TARGET_NATIVE_LAST_ERROR_STRING ()); } } /* * Set the length of the file * Exception on error */ JNIEXPORT void JNICALL Java_gnu_java_nio_channels_FileChannelImpl_implTruncate (JNIEnv * env, jobject obj, jlong len) { int native_fd; jlong file_size; int bytes_written; jlong save_offset, new_offset; char data; int result; native_fd = get_native_fd (env, obj); #if 0 /* Should there be such an exception? All native layer macros should be accepting 64bit-values if needed. It some target is not able to handle such values it should simply operate with 32bit-values and convert 64bit-values appriopated. In this case I assume problems should not occurre: if some specific target is not able to handle 64bit-values the system is limited to 32bit at all, thus the application can not do a seek() or something else beyond the 32bit limit. It this true? */ /* FIXME: What do we do if len > the max value of off_t on this 32bit * system? How do we detect that and what do we do? */ if (CONVERT_OFF_T_TO_JLONG (native_len) != len) { JCL_ThrowException (env, IO_EXCEPTION, "Cannot represent position correctly on this system"); return; } #endif /* 0 */ /* get file size */ TARGET_NATIVE_FILE_SIZE (native_fd, file_size, result); if (result != TARGET_NATIVE_OK) { JCL_ThrowException (env, IO_EXCEPTION, TARGET_NATIVE_LAST_ERROR_STRING ()); return; } /* Save off current position */ TARGET_NATIVE_FILE_TELL (native_fd, save_offset, result); if (result != TARGET_NATIVE_OK) { JCL_ThrowException (env, IO_EXCEPTION, TARGET_NATIVE_LAST_ERROR_STRING ()); return; } if (TARGET_NATIVE_MATH_INT_INT64_LT (file_size, len)) { /* File is too short -- seek to one byte short of where we want, * then write a byte */ /* move to position n-1 */ TARGET_NATIVE_FILE_SEEK_BEGIN (native_fd, TARGET_NATIVE_MATH_INT_INT64_SUB (len, 1), new_offset, result); if (result != TARGET_NATIVE_OK) { JCL_ThrowException (env, IO_EXCEPTION, TARGET_NATIVE_LAST_ERROR_STRING ()); return; } /* write a byte Note: This will fail if we somehow get here in read only mode * That shouldn't happen */ data = '\0'; TARGET_NATIVE_FILE_WRITE (native_fd, &data, 1, bytes_written, result); if (result != TARGET_NATIVE_OK) { JCL_ThrowException (env, IO_EXCEPTION, TARGET_NATIVE_LAST_ERROR_STRING ()); return; } /* Reposition file pointer to where we started if not beyond new len. */ if (TARGET_NATIVE_MATH_INT_INT64_LT (save_offset, len)) { TARGET_NATIVE_FILE_SEEK_BEGIN (native_fd, save_offset, new_offset, result); if (result != TARGET_NATIVE_OK) { JCL_ThrowException (env, IO_EXCEPTION, TARGET_NATIVE_LAST_ERROR_STRING ()); return; } } } else if (TARGET_NATIVE_MATH_INT_INT64_GT (file_size, len)) { /* File is too long - use ftruncate if available */ #ifdef HAVE_FTRUNCATE TARGET_NATIVE_FILE_TRUNCATE (native_fd, len, result); if (result != TARGET_NATIVE_OK) { JCL_ThrowException (env, IO_EXCEPTION, TARGET_NATIVE_LAST_ERROR_STRING ()); return; } #else /* HAVE_FTRUNCATE */ /* FIXME: Probably operation isn't supported, but this exception * is too harsh as it will probably crash the program without need JCL_ThrowException(env, "java/lang/UnsupportedOperationException", "not implemented - can't shorten files on this platform"); */ JCL_ThrowException (env, IO_EXCEPTION, "Unable to shorten file length"); #endif /* HAVE_FTRUNCATE */ /* Reposition file pointer when it now is beyond the end of file. */ if (TARGET_NATIVE_MATH_INT_INT64_GT (save_offset, len)) { TARGET_NATIVE_FILE_SEEK_BEGIN (native_fd, len, new_offset, result); if (result != TARGET_NATIVE_OK) { JCL_ThrowException (env, IO_EXCEPTION, TARGET_NATIVE_LAST_ERROR_STRING ()); return; } } } } JNIEXPORT jobject JNICALL Java_gnu_java_nio_channels_FileChannelImpl_mapImpl (JNIEnv * env, jobject obj __attribute__ ((__unused__)), jchar mode __attribute__ ((__unused__)), jlong position __attribute__ ((__unused__)), jint size __attribute__ ((__unused__))) { JCL_ThrowException (env, IO_EXCEPTION, "java.nio.FileChannelImpl.nio_mmap_file(): not implemented"); return 0; } /* * Read a single byte from the file descriptor * Return byte read or -1 on eof, exception on error */ JNIEXPORT jint JNICALL Java_gnu_java_nio_channels_FileChannelImpl_read__ (JNIEnv * env, jobject obj) { int native_fd; char data; ssize_t bytes_read; int result; native_fd = get_native_fd (env, obj); bytes_read = 0; do { TARGET_NATIVE_FILE_READ (native_fd, &data, 1, bytes_read, result); if ((result == TARGET_NATIVE_OK) && (bytes_read == 0)) { return (-1); } if ((result != TARGET_NATIVE_OK) && (TARGET_NATIVE_LAST_ERROR () != TARGET_NATIVE_ERROR_INTERRUPT_FUNCTION_CALL)) { JCL_ThrowException (env, IO_EXCEPTION, TARGET_NATIVE_LAST_ERROR_STRING ()); return (-1); } } while (bytes_read != 1); return ((jint) (data & 0xFF)); } /* * Reads to a byte buffer from the specified file descriptor * Return number of bytes read or -1 on eof, exception on error */ JNIEXPORT jint JNICALL Java_gnu_java_nio_channels_FileChannelImpl_read___3BII (JNIEnv * env, jobject obj, jbyteArray buffer, jint offset, jint length) { int native_fd; jbyte *bufptr; ssize_t bytes_read; ssize_t n; int result; native_fd = get_native_fd (env, obj); /* Must return 0 if an attempt is made to read 0 bytes. */ if (length == 0) return 0; bufptr = (*env)->GetByteArrayElements (env, buffer, 0); if (!bufptr) { JCL_ThrowException (env, IO_EXCEPTION, "Unexpected JNI error"); return (-1); } bytes_read = 0; do { TARGET_NATIVE_FILE_READ (native_fd, (bufptr + offset + bytes_read), (length - bytes_read), n, result); if ((result == TARGET_NATIVE_OK) && (n == 0)) { (*env)->ReleaseByteArrayElements (env, buffer, bufptr, 0); if (bytes_read == 0) return -1; /* Signal end of file to Java */ else return CONVERT_SSIZE_T_TO_JINT (bytes_read); } if ((result != TARGET_NATIVE_OK) && (TARGET_NATIVE_LAST_ERROR () != TARGET_NATIVE_ERROR_INTERRUPT_FUNCTION_CALL)) { JCL_ThrowException (env, IO_EXCEPTION, TARGET_NATIVE_LAST_ERROR_STRING ()); (*env)->ReleaseByteArrayElements (env, buffer, bufptr, 0); return -1; } bytes_read += n; } while (bytes_read < 1); (*env)->ReleaseByteArrayElements (env, buffer, bufptr, 0); return CONVERT_SSIZE_T_TO_JINT (bytes_read); } /* * Writes a single byte to the specified file descriptor * Return status code, exception on error */ JNIEXPORT void JNICALL Java_gnu_java_nio_channels_FileChannelImpl_write__I (JNIEnv * env, jobject obj, jint b) { int native_fd; char native_data; ssize_t bytes_written; int result; native_fd = get_native_fd (env, obj); native_data = (char) (CONVERT_JINT_TO_INT (b) & 0xFF); do { TARGET_NATIVE_FILE_WRITE (native_fd, &native_data, 1, bytes_written, result); if ((result != TARGET_NATIVE_OK) && (TARGET_NATIVE_LAST_ERROR () != TARGET_NATIVE_ERROR_INTERRUPT_FUNCTION_CALL)) { JCL_ThrowException (env, IO_EXCEPTION, TARGET_NATIVE_LAST_ERROR_STRING ()); } } while (result != TARGET_NATIVE_OK); } /* * Writes a byte buffer to the specified file descriptor * Return status code, exception on error */ JNIEXPORT void JNICALL Java_gnu_java_nio_channels_FileChannelImpl_write___3BII (JNIEnv * env, jobject obj, jbyteArray buffer, jint offset, jint length) { int native_fd; jbyte *bufptr; ssize_t bytes_written; ssize_t n; int result; native_fd = get_native_fd (env, obj); /* Just return if an attempt is made to write 0 bytes. */ if (length == 0) return; bufptr = (*env)->GetByteArrayElements (env, buffer, 0); if (!bufptr) { JCL_ThrowException (env, IO_EXCEPTION, "Unexpected JNI error"); return; } bytes_written = 0; while (bytes_written < CONVERT_JINT_TO_SSIZE_T (length)) { TARGET_NATIVE_FILE_WRITE (native_fd, (bufptr + offset + bytes_written), (length - bytes_written), n, result); if ((result != TARGET_NATIVE_OK) && (TARGET_NATIVE_LAST_ERROR () != TARGET_NATIVE_ERROR_INTERRUPT_FUNCTION_CALL)) { JCL_ThrowException (env, IO_EXCEPTION, TARGET_NATIVE_LAST_ERROR_STRING ()); (*env)->ReleaseByteArrayElements (env, buffer, bufptr, 0); return; } bytes_written += n; } (*env)->ReleaseByteArrayElements (env, buffer, bufptr, 0); } JNIEXPORT jboolean JNICALL Java_gnu_java_nio_channels_FileChannelImpl_lock (JNIEnv * env, jobject obj __attribute__ ((__unused__)), jlong position __attribute__ ((__unused__)), jlong size __attribute__ ((__unused__)), jboolean shared __attribute__ ((__unused__)), jboolean wait __attribute__ ((__unused__))) { JCL_ThrowException (env, IO_EXCEPTION, "java.nio.FileChannelImpl.lock(): not implemented"); return 0; } JNIEXPORT void JNICALL Java_gnu_java_nio_channels_FileChannelImpl_unlock (JNIEnv * env, jobject obj __attribute__ ((__unused__)), jlong position __attribute__ ((__unused__)), jlong length __attribute__ ((__unused__))) { JCL_ThrowException (env, IO_EXCEPTION, "java.nio.FileChannelImpl.unlock(): not implemented"); }