1 /* 2 * Copyright (c) 2000, 2018, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 #include <sys/types.h> 27 #include <string.h> 28 #include <sys/resource.h> 29 30 #include "jni.h" 31 #include "jni_util.h" 32 #include "jvm.h" 33 #include "jlong.h" 34 #include "sun_nio_ch_IOUtil.h" 35 #include "java_lang_Integer.h" 36 #include "nio.h" 37 #include "nio_util.h" 38 39 static jfieldID fd_fdID; /* for jint 'fd' in java.io.FileDescriptor */ 40 41 42 JNIEXPORT void JNICALL 43 Java_sun_nio_ch_IOUtil_initIDs(JNIEnv *env, jclass clazz) 44 { 45 CHECK_NULL(clazz = (*env)->FindClass(env, "java/io/FileDescriptor")); 46 CHECK_NULL(fd_fdID = (*env)->GetFieldID(env, clazz, "fd", "I")); 47 } 48 49 JNIEXPORT jboolean JNICALL 50 Java_sun_nio_ch_IOUtil_randomBytes(JNIEnv *env, jclass clazz, 51 jbyteArray randArray) 52 { 53 JNU_ThrowByName(env, "java/lang/UnsupportedOperationException", NULL); 54 return JNI_FALSE; 55 } 56 57 JNIEXPORT jint JNICALL 58 Java_sun_nio_ch_IOUtil_fdVal(JNIEnv *env, jclass clazz, jobject fdo) 59 { 60 return (*env)->GetIntField(env, fdo, fd_fdID); 61 } 62 63 JNIEXPORT void JNICALL 64 Java_sun_nio_ch_IOUtil_setfdVal(JNIEnv *env, jclass clazz, jobject fdo, jint val) 65 { 66 (*env)->SetIntField(env, fdo, fd_fdID, val); 67 } 68 69 static int 70 configureBlocking(int fd, jboolean blocking) 71 { 72 int flags = fcntl(fd, F_GETFL); 73 int newflags = blocking ? (flags & ~O_NONBLOCK) : (flags | O_NONBLOCK); 74 75 return (flags == newflags) ? 0 : fcntl(fd, F_SETFL, newflags); 76 } 77 78 JNIEXPORT void JNICALL 79 Java_sun_nio_ch_IOUtil_configureBlocking(JNIEnv *env, jclass clazz, 80 jobject fdo, jboolean blocking) 81 { 82 if (configureBlocking(fdval(env, fdo), blocking) < 0) 83 JNU_ThrowIOExceptionWithLastError(env, "Configure blocking failed"); 84 } 85 86 JNIEXPORT jlong JNICALL 87 Java_sun_nio_ch_IOUtil_makePipe(JNIEnv *env, jobject this, jboolean blocking) 88 { 89 int fd[2]; 90 91 if (pipe(fd) < 0) { 92 JNU_ThrowIOExceptionWithLastError(env, "Pipe failed"); 93 return 0; 94 } 95 if (blocking == JNI_FALSE) { 96 if ((configureBlocking(fd[0], JNI_FALSE) < 0) 97 || (configureBlocking(fd[1], JNI_FALSE) < 0)) { 98 JNU_ThrowIOExceptionWithLastError(env, "Configure blocking failed"); 99 close(fd[0]); 100 close(fd[1]); 101 return 0; 102 } 103 } 104 return ((jlong) fd[0] << 32) | (jlong) fd[1]; 105 } 106 107 108 JNIEXPORT jint JNICALL 109 Java_sun_nio_ch_IOUtil_write1(JNIEnv *env, jclass cl, jint fd, jbyte b) 110 { 111 char c = (char)b; 112 return convertReturnVal(env, write(fd, &c, 1), JNI_FALSE); 113 } 114 115 116 JNIEXPORT jboolean JNICALL 117 Java_sun_nio_ch_IOUtil_drain(JNIEnv *env, jclass cl, jint fd) 118 { 119 char buf[16]; 120 int tn = 0; 121 122 for (;;) { 123 int n = read(fd, buf, sizeof(buf)); 124 tn += n; 125 if ((n < 0) && (errno != EAGAIN)) 126 JNU_ThrowIOExceptionWithLastError(env, "Drain"); 127 if (n == (int)sizeof(buf)) 128 continue; 129 return (tn > 0) ? JNI_TRUE : JNI_FALSE; 130 } 131 } 132 133 JNIEXPORT jint JNICALL 134 Java_sun_nio_ch_IOUtil_fdLimit(JNIEnv *env, jclass this) 135 { 136 struct rlimit rlp; 137 if (getrlimit(RLIMIT_NOFILE, &rlp) < 0) { 138 JNU_ThrowIOExceptionWithLastError(env, "getrlimit failed"); 139 return -1; 140 } 141 if (rlp.rlim_max == RLIM_INFINITY || 142 rlp.rlim_max > (rlim_t)java_lang_Integer_MAX_VALUE) { 143 return java_lang_Integer_MAX_VALUE; 144 } else { 145 return (jint)rlp.rlim_max; 146 } 147 } 148 149 JNIEXPORT jint JNICALL 150 Java_sun_nio_ch_IOUtil_iovMax(JNIEnv *env, jclass this) 151 { 152 jlong iov_max = sysconf(_SC_IOV_MAX); 153 if (iov_max == -1) 154 iov_max = 16; 155 return (jint)iov_max; 156 } 157 158 /* Declared in nio_util.h for use elsewhere in NIO */ 159 160 jint 161 convertReturnVal(JNIEnv *env, jint n, jboolean reading) 162 { 163 if (n > 0) /* Number of bytes written */ 164 return n; 165 else if (n == 0) { 166 if (reading) { 167 return IOS_EOF; /* EOF is -1 in javaland */ 168 } else { 169 return 0; 170 } 171 } 172 else if (errno == EAGAIN) 173 return IOS_UNAVAILABLE; 174 else if (errno == EINTR) 175 return IOS_INTERRUPTED; 176 else { 177 const char *msg = reading ? "Read failed" : "Write failed"; 178 JNU_ThrowIOExceptionWithLastError(env, msg); 179 return IOS_THROWN; 180 } 181 } 182 183 /* Declared in nio_util.h for use elsewhere in NIO */ 184 185 jlong 186 convertLongReturnVal(JNIEnv *env, jlong n, jboolean reading) 187 { 188 if (n > 0) /* Number of bytes written */ 189 return n; 190 else if (n == 0) { 191 if (reading) { 192 return IOS_EOF; /* EOF is -1 in javaland */ 193 } else { 194 return 0; 195 } 196 } 197 else if (errno == EAGAIN) 198 return IOS_UNAVAILABLE; 199 else if (errno == EINTR) 200 return IOS_INTERRUPTED; 201 else { 202 const char *msg = reading ? "Read failed" : "Write failed"; 203 JNU_ThrowIOExceptionWithLastError(env, msg); 204 return IOS_THROWN; 205 } 206 } 207 208 jint 209 fdval(JNIEnv *env, jobject fdo) 210 { 211 return (*env)->GetIntField(env, fdo, fd_fdID); 212 }