1 /* 2 * Copyright (C) 2011 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #define LOG_TAG "Posix" 18 19 #include "AsynchronousCloseMonitor.h" 20 #include "cutils/log.h" 21 #include "ExecStrings.h" 22 #include "JNIHelp.h" 23 #include "JniConstants.h" 24 #include "JniException.h" 25 #include "NetworkUtilities.h" 26 #include "Portability.h" 27 #include "readlink.h" 28 #include "../../bionic/libc/dns/include/resolv_netid.h" // For android_getaddrinfofornet. 29 #include "ScopedBytes.h" 30 #include "ScopedLocalRef.h" 31 #include "ScopedPrimitiveArray.h" 32 #include "ScopedUtfChars.h" 33 #include "toStringArray.h" 34 #include "UniquePtr.h" 35 36 #include <arpa/inet.h> 37 #include <errno.h> 38 #include <fcntl.h> 39 #include <net/if.h> 40 #include <netdb.h> 41 #include <netinet/in.h> 42 #include <poll.h> 43 #include <pwd.h> 44 #include <signal.h> 45 #include <stdlib.h> 46 #include <sys/ioctl.h> 47 #include <sys/mman.h> 48 #ifndef __APPLE__ 49 #include <sys/prctl.h> 50 #endif 51 #include <sys/socket.h> 52 #include <sys/stat.h> 53 #ifdef __APPLE__ 54 #include <sys/statvfs.h> 55 #endif 56 #include <sys/syscall.h> 57 #include <sys/time.h> 58 #include <sys/types.h> 59 #include <sys/uio.h> 60 #include <sys/utsname.h> 61 #include <sys/wait.h> 62 #include <termios.h> 63 #include <unistd.h> 64 65 66 #ifndef __unused 67 #define __unused __attribute__((__unused__)) 68 #endif 69 70 #define TO_JAVA_STRING(NAME, EXP) \ 71 jstring NAME = env->NewStringUTF(EXP); \ 72 if (NAME == NULL) return NULL; 73 74 struct addrinfo_deleter { 75 void operator()(addrinfo* p) const { 76 if (p != NULL) { // bionic's freeaddrinfo(3) crashes when passed NULL. 77 freeaddrinfo(p); 78 } 79 } 80 }; 81 82 /** 83 * Used to retry networking system calls that can be interrupted with a signal. Unlike 84 * TEMP_FAILURE_RETRY, this also handles the case where 85 * AsynchronousCloseMonitor::signalBlockedThreads(fd) is used to signal a close() or 86 * Thread.interrupt(). Other signals that result in an EINTR result are ignored and the system call 87 * is retried. 88 * 89 * Returns the result of the system call though a Java exception will be pending if the result is 90 * -1: a SocketException if signaled via AsynchronousCloseMonitor, or ErrnoException for other 91 * failures. 92 */ 93 #define NET_FAILURE_RETRY(jni_env, return_type, syscall_name, java_fd, ...) ({ \ 94 return_type _rc = -1; \ 95 do { \ 96 bool _wasSignaled; \ 97 int _syscallErrno; \ 98 { \ 99 int _fd = jniGetFDFromFileDescriptor(jni_env, java_fd); \ 100 AsynchronousCloseMonitor _monitor(_fd); \ 101 _rc = syscall_name(_fd, __VA_ARGS__); \ 102 _syscallErrno = errno; \ 103 _wasSignaled = _monitor.wasSignaled(); \ 104 } \ 105 if (_wasSignaled) { \ 106 jniThrowException(jni_env, "java/net/SocketException", "Socket closed"); \ 107 _rc = -1; \ 108 break; \ 109 } \ 110 if (_rc == -1 && _syscallErrno != EINTR) { \ 111 /* TODO: with a format string we could show the arguments too, like strace(1). */ \ 112 throwErrnoException(jni_env, # syscall_name); \ 113 break; \ 114 } \ 115 } while (_rc == -1); /* _syscallErrno == EINTR && !_wasSignaled */ \ 116 _rc; }) 117 118 /** 119 * Used to retry system calls that can be interrupted with a signal. Unlike TEMP_FAILURE_RETRY, this 120 * also handles the case where AsynchronousCloseMonitor::signalBlockedThreads(fd) is used to signal 121 * a close() or Thread.interrupt(). Other signals that result in an EINTR result are ignored and the 122 * system call is retried. 123 * 124 * Returns the result of the system call though a Java exception will be pending if the result is 125 * -1: an IOException if the file descriptor is already closed, a InterruptedIOException if signaled 126 * via AsynchronousCloseMonitor, or ErrnoException for other failures. 127 */ 128 #define IO_FAILURE_RETRY(jni_env, return_type, syscall_name, java_fd, ...) ({ \ 129 return_type _rc = -1; \ 130 int _fd = jniGetFDFromFileDescriptor(jni_env, java_fd); \ 131 if (_fd == -1) { \ 132 jniThrowException(jni_env, "java/io/IOException", "File descriptor closed"); \ 133 } else { \ 134 do { \ 135 bool _wasSignaled; \ 136 int _syscallErrno; \ 137 { \ 138 int _fd = jniGetFDFromFileDescriptor(jni_env, java_fd); \ 139 AsynchronousCloseMonitor _monitor(_fd); \ 140 _rc = syscall_name(_fd, __VA_ARGS__); \ 141 _syscallErrno = errno; \ 142 _wasSignaled = _monitor.wasSignaled(); \ 143 } \ 144 if (_wasSignaled) { \ 145 jniThrowException(jni_env, "java/io/InterruptedIOException", # syscall_name " interrupted"); \ 146 _rc = -1; \ 147 break; \ 148 } \ 149 if (_rc == -1 && _syscallErrno != EINTR) { \ 150 /* TODO: with a format string we could show the arguments too, like strace(1). */ \ 151 throwErrnoException(jni_env, # syscall_name); \ 152 break; \ 153 } \ 154 } while (_rc == -1); /* && _syscallErrno == EINTR && !_wasSignaled */ \ 155 } \ 156 _rc; }) 157 158 static void throwException(JNIEnv* env, jclass exceptionClass, jmethodID ctor3, jmethodID ctor2, 159 const char* functionName, int error) { 160 jthrowable cause = NULL; 161 if (env->ExceptionCheck()) { 162 cause = env->ExceptionOccurred(); 163 env->ExceptionClear(); 164 } 165 166 ScopedLocalRef<jstring> detailMessage(env, env->NewStringUTF(functionName)); 167 if (detailMessage.get() == NULL) { 168 // Not really much we can do here. We're probably dead in the water, 169 // but let's try to stumble on... 170 env->ExceptionClear(); 171 } 172 173 jobject exception; 174 if (cause != NULL) { 175 exception = env->NewObject(exceptionClass, ctor3, detailMessage.get(), error, cause); 176 } else { 177 exception = env->NewObject(exceptionClass, ctor2, detailMessage.get(), error); 178 } 179 env->Throw(reinterpret_cast<jthrowable>(exception)); 180 } 181 182 static void throwErrnoException(JNIEnv* env, const char* functionName) { 183 int error = errno; 184 static jmethodID ctor3 = env->GetMethodID(JniConstants::errnoExceptionClass, 185 "<init>", "(Ljava/lang/String;ILjava/lang/Throwable;)V"); 186 static jmethodID ctor2 = env->GetMethodID(JniConstants::errnoExceptionClass, 187 "<init>", "(Ljava/lang/String;I)V"); 188 throwException(env, JniConstants::errnoExceptionClass, ctor3, ctor2, functionName, error); 189 } 190 191 static void throwGaiException(JNIEnv* env, const char* functionName, int error) { 192 // Cache the methods ids before we throw, so we don't call GetMethodID with a pending exception. 193 static jmethodID ctor3 = env->GetMethodID(JniConstants::gaiExceptionClass, "<init>", 194 "(Ljava/lang/String;ILjava/lang/Throwable;)V"); 195 static jmethodID ctor2 = env->GetMethodID(JniConstants::gaiExceptionClass, "<init>", 196 "(Ljava/lang/String;I)V"); 197 if (errno != 0) { 198 // EAI_SYSTEM should mean "look at errno instead", but both glibc and bionic seem to 199 // mess this up. In particular, if you don't have INTERNET permission, errno will be EACCES 200 // but you'll get EAI_NONAME or EAI_NODATA. So we want our GaiException to have a 201 // potentially-relevant ErrnoException as its cause even if error != EAI_SYSTEM. 202 // http://code.google.com/p/android/issues/detail?id=15722 203 throwErrnoException(env, functionName); 204 // Deliberately fall through to throw another exception... 205 } 206 throwException(env, JniConstants::gaiExceptionClass, ctor3, ctor2, functionName, error); 207 } 208 209 template <typename rc_t> 210 static rc_t throwIfMinusOne(JNIEnv* env, const char* name, rc_t rc) { 211 if (rc == rc_t(-1)) { 212 throwErrnoException(env, name); 213 } 214 return rc; 215 } 216 217 template <typename ScopedT> 218 class IoVec { 219 public: 220 IoVec(JNIEnv* env, size_t bufferCount) : mEnv(env), mBufferCount(bufferCount) { 221 } 222 223 bool init(jobjectArray javaBuffers, jintArray javaOffsets, jintArray javaByteCounts) { 224 // We can't delete our local references until after the I/O, so make sure we have room. 225 if (mEnv->PushLocalFrame(mBufferCount + 16) < 0) { 226 return false; 227 } 228 ScopedIntArrayRO offsets(mEnv, javaOffsets); 229 if (offsets.get() == NULL) { 230 return false; 231 } 232 ScopedIntArrayRO byteCounts(mEnv, javaByteCounts); 233 if (byteCounts.get() == NULL) { 234 return false; 235 } 236 // TODO: Linux actually has a 1024 buffer limit. glibc works around this, and we should too. 237 // TODO: you can query the limit at runtime with sysconf(_SC_IOV_MAX). 238 for (size_t i = 0; i < mBufferCount; ++i) { 239 jobject buffer = mEnv->GetObjectArrayElement(javaBuffers, i); // We keep this local ref. 240 mScopedBuffers.push_back(new ScopedT(mEnv, buffer)); 241 jbyte* ptr = const_cast<jbyte*>(mScopedBuffers.back()->get()); 242 if (ptr == NULL) { 243 return false; 244 } 245 struct iovec iov; 246 iov.iov_base = reinterpret_cast<void*>(ptr + offsets[i]); 247 iov.iov_len = byteCounts[i]; 248 mIoVec.push_back(iov); 249 } 250 return true; 251 } 252 253 ~IoVec() { 254 for (size_t i = 0; i < mScopedBuffers.size(); ++i) { 255 delete mScopedBuffers[i]; 256 } 257 mEnv->PopLocalFrame(NULL); 258 } 259 260 iovec* get() { 261 return &mIoVec[0]; 262 } 263 264 size_t size() { 265 return mBufferCount; 266 } 267 268 private: 269 JNIEnv* mEnv; 270 size_t mBufferCount; 271 std::vector<iovec> mIoVec; 272 std::vector<ScopedT*> mScopedBuffers; 273 }; 274 275 static jobject makeSocketAddress(JNIEnv* env, const sockaddr_storage& ss) { 276 jint port; 277 jobject inetAddress = sockaddrToInetAddress(env, ss, &port); 278 if (inetAddress == NULL) { 279 return NULL; 280 } 281 static jmethodID ctor = env->GetMethodID(JniConstants::inetSocketAddressClass, "<init>", 282 "(Ljava/net/InetAddress;I)V"); 283 return env->NewObject(JniConstants::inetSocketAddressClass, ctor, inetAddress, port); 284 } 285 286 static jobject makeStructPasswd(JNIEnv* env, const struct passwd& pw) { 287 TO_JAVA_STRING(pw_name, pw.pw_name); 288 TO_JAVA_STRING(pw_dir, pw.pw_dir); 289 TO_JAVA_STRING(pw_shell, pw.pw_shell); 290 static jmethodID ctor = env->GetMethodID(JniConstants::structPasswdClass, "<init>", 291 "(Ljava/lang/String;IILjava/lang/String;Ljava/lang/String;)V"); 292 return env->NewObject(JniConstants::structPasswdClass, ctor, 293 pw_name, static_cast<jint>(pw.pw_uid), static_cast<jint>(pw.pw_gid), pw_dir, pw_shell); 294 } 295 296 static jobject makeStructStat(JNIEnv* env, const struct stat& sb) { 297 static jmethodID ctor = env->GetMethodID(JniConstants::structStatClass, "<init>", 298 "(JJIJIIJJJJJJJ)V"); 299 return env->NewObject(JniConstants::structStatClass, ctor, 300 static_cast<jlong>(sb.st_dev), static_cast<jlong>(sb.st_ino), 301 static_cast<jint>(sb.st_mode), static_cast<jlong>(sb.st_nlink), 302 static_cast<jint>(sb.st_uid), static_cast<jint>(sb.st_gid), 303 static_cast<jlong>(sb.st_rdev), static_cast<jlong>(sb.st_size), 304 static_cast<jlong>(sb.st_atime), static_cast<jlong>(sb.st_mtime), 305 static_cast<jlong>(sb.st_ctime), static_cast<jlong>(sb.st_blksize), 306 static_cast<jlong>(sb.st_blocks)); 307 } 308 309 static jobject makeStructStatVfs(JNIEnv* env, const struct statvfs& sb) { 310 #if defined(__APPLE__) 311 // Mac OS has no f_namelen field in struct statfs. 312 jlong max_name_length = 255; // __DARWIN_MAXNAMLEN 313 #else 314 jlong max_name_length = static_cast<jlong>(sb.f_namemax); 315 #endif 316 317 static jmethodID ctor = env->GetMethodID(JniConstants::structStatVfsClass, "<init>", 318 "(JJJJJJJJJJJ)V"); 319 return env->NewObject(JniConstants::structStatVfsClass, ctor, 320 static_cast<jlong>(sb.f_bsize), 321 static_cast<jlong>(sb.f_frsize), 322 static_cast<jlong>(sb.f_blocks), 323 static_cast<jlong>(sb.f_bfree), 324 static_cast<jlong>(sb.f_bavail), 325 static_cast<jlong>(sb.f_files), 326 static_cast<jlong>(sb.f_ffree), 327 static_cast<jlong>(sb.f_favail), 328 static_cast<jlong>(sb.f_fsid), 329 static_cast<jlong>(sb.f_flag), 330 max_name_length); 331 } 332 333 static jobject makeStructLinger(JNIEnv* env, const struct linger& l) { 334 static jmethodID ctor = env->GetMethodID(JniConstants::structLingerClass, "<init>", "(II)V"); 335 return env->NewObject(JniConstants::structLingerClass, ctor, l.l_onoff, l.l_linger); 336 } 337 338 static jobject makeStructTimeval(JNIEnv* env, const struct timeval& tv) { 339 static jmethodID ctor = env->GetMethodID(JniConstants::structTimevalClass, "<init>", "(JJ)V"); 340 return env->NewObject(JniConstants::structTimevalClass, ctor, 341 static_cast<jlong>(tv.tv_sec), static_cast<jlong>(tv.tv_usec)); 342 } 343 344 static jobject makeStructUcred(JNIEnv* env, const struct ucred& u __unused) { 345 #ifdef __APPLE__ 346 jniThrowException(env, "java/lang/UnsupportedOperationException", "unimplemented support for ucred on a Mac"); 347 return NULL; 348 #else 349 static jmethodID ctor = env->GetMethodID(JniConstants::structUcredClass, "<init>", "(III)V"); 350 return env->NewObject(JniConstants::structUcredClass, ctor, u.pid, u.uid, u.gid); 351 #endif 352 } 353 354 static jobject makeStructUtsname(JNIEnv* env, const struct utsname& buf) { 355 TO_JAVA_STRING(sysname, buf.sysname); 356 TO_JAVA_STRING(nodename, buf.nodename); 357 TO_JAVA_STRING(release, buf.release); 358 TO_JAVA_STRING(version, buf.version); 359 TO_JAVA_STRING(machine, buf.machine); 360 static jmethodID ctor = env->GetMethodID(JniConstants::structUtsnameClass, "<init>", 361 "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V"); 362 return env->NewObject(JniConstants::structUtsnameClass, ctor, 363 sysname, nodename, release, version, machine); 364 }; 365 366 static bool fillIfreq(JNIEnv* env, jstring javaInterfaceName, struct ifreq& req) { 367 ScopedUtfChars interfaceName(env, javaInterfaceName); 368 if (interfaceName.c_str() == NULL) { 369 return false; 370 } 371 memset(&req, 0, sizeof(req)); 372 strncpy(req.ifr_name, interfaceName.c_str(), sizeof(req.ifr_name)); 373 req.ifr_name[sizeof(req.ifr_name) - 1] = '\0'; 374 return true; 375 } 376 377 static bool fillInetSocketAddress(JNIEnv* env, jint rc, jobject javaInetSocketAddress, const sockaddr_storage& ss) { 378 if (rc == -1 || javaInetSocketAddress == NULL) { 379 return true; 380 } 381 // Fill out the passed-in InetSocketAddress with the sender's IP address and port number. 382 jint port; 383 jobject sender = sockaddrToInetAddress(env, ss, &port); 384 if (sender == NULL) { 385 return false; 386 } 387 static jfieldID addressFid = env->GetFieldID(JniConstants::inetSocketAddressClass, "addr", "Ljava/net/InetAddress;"); 388 static jfieldID portFid = env->GetFieldID(JniConstants::inetSocketAddressClass, "port", "I"); 389 env->SetObjectField(javaInetSocketAddress, addressFid, sender); 390 env->SetIntField(javaInetSocketAddress, portFid, port); 391 return true; 392 } 393 394 static jobject doStat(JNIEnv* env, jstring javaPath, bool isLstat) { 395 ScopedUtfChars path(env, javaPath); 396 if (path.c_str() == NULL) { 397 return NULL; 398 } 399 struct stat sb; 400 int rc = isLstat ? TEMP_FAILURE_RETRY(lstat(path.c_str(), &sb)) 401 : TEMP_FAILURE_RETRY(stat(path.c_str(), &sb)); 402 if (rc == -1) { 403 throwErrnoException(env, isLstat ? "lstat" : "stat"); 404 return NULL; 405 } 406 return makeStructStat(env, sb); 407 } 408 409 static jobject doGetSockName(JNIEnv* env, jobject javaFd, bool is_sockname) { 410 int fd = jniGetFDFromFileDescriptor(env, javaFd); 411 sockaddr_storage ss; 412 sockaddr* sa = reinterpret_cast<sockaddr*>(&ss); 413 socklen_t byteCount = sizeof(ss); 414 memset(&ss, 0, byteCount); 415 int rc = is_sockname ? TEMP_FAILURE_RETRY(getsockname(fd, sa, &byteCount)) 416 : TEMP_FAILURE_RETRY(getpeername(fd, sa, &byteCount)); 417 if (rc == -1) { 418 throwErrnoException(env, is_sockname ? "getsockname" : "getpeername"); 419 return NULL; 420 } 421 return makeSocketAddress(env, ss); 422 } 423 424 class Passwd { 425 public: 426 Passwd(JNIEnv* env) : mEnv(env), mResult(NULL) { 427 mBufferSize = sysconf(_SC_GETPW_R_SIZE_MAX); 428 mBuffer.reset(new char[mBufferSize]); 429 } 430 431 jobject getpwnam(const char* name) { 432 return process("getpwnam_r", getpwnam_r(name, &mPwd, mBuffer.get(), mBufferSize, &mResult)); 433 } 434 435 jobject getpwuid(uid_t uid) { 436 return process("getpwuid_r", getpwuid_r(uid, &mPwd, mBuffer.get(), mBufferSize, &mResult)); 437 } 438 439 struct passwd* get() { 440 return mResult; 441 } 442 443 private: 444 jobject process(const char* syscall, int error) { 445 if (mResult == NULL) { 446 errno = error; 447 throwErrnoException(mEnv, syscall); 448 return NULL; 449 } 450 return makeStructPasswd(mEnv, *mResult); 451 } 452 453 JNIEnv* mEnv; 454 UniquePtr<char[]> mBuffer; 455 size_t mBufferSize; 456 struct passwd mPwd; 457 struct passwd* mResult; 458 }; 459 460 static jobject Posix_accept(JNIEnv* env, jobject, jobject javaFd, jobject javaInetSocketAddress) { 461 sockaddr_storage ss; 462 socklen_t sl = sizeof(ss); 463 memset(&ss, 0, sizeof(ss)); 464 sockaddr* peer = (javaInetSocketAddress != NULL) ? reinterpret_cast<sockaddr*>(&ss) : NULL; 465 socklen_t* peerLength = (javaInetSocketAddress != NULL) ? &sl : 0; 466 jint clientFd = NET_FAILURE_RETRY(env, int, accept, javaFd, peer, peerLength); 467 if (clientFd == -1 || !fillInetSocketAddress(env, clientFd, javaInetSocketAddress, ss)) { 468 close(clientFd); 469 return NULL; 470 } 471 return (clientFd != -1) ? jniCreateFileDescriptor(env, clientFd) : NULL; 472 } 473 474 static jboolean Posix_access(JNIEnv* env, jobject, jstring javaPath, jint mode) { 475 ScopedUtfChars path(env, javaPath); 476 if (path.c_str() == NULL) { 477 return JNI_FALSE; 478 } 479 int rc = TEMP_FAILURE_RETRY(access(path.c_str(), mode)); 480 if (rc == -1) { 481 throwErrnoException(env, "access"); 482 } 483 return (rc == 0); 484 } 485 486 static void Posix_bind(JNIEnv* env, jobject, jobject javaFd, jobject javaAddress, jint port) { 487 sockaddr_storage ss; 488 socklen_t sa_len; 489 if (!inetAddressToSockaddr(env, javaAddress, port, ss, sa_len)) { 490 return; 491 } 492 const sockaddr* sa = reinterpret_cast<const sockaddr*>(&ss); 493 // We don't need the return value because we'll already have thrown. 494 (void) NET_FAILURE_RETRY(env, int, bind, javaFd, sa, sa_len); 495 } 496 497 static void Posix_chmod(JNIEnv* env, jobject, jstring javaPath, jint mode) { 498 ScopedUtfChars path(env, javaPath); 499 if (path.c_str() == NULL) { 500 return; 501 } 502 throwIfMinusOne(env, "chmod", TEMP_FAILURE_RETRY(chmod(path.c_str(), mode))); 503 } 504 505 static void Posix_chown(JNIEnv* env, jobject, jstring javaPath, jint uid, jint gid) { 506 ScopedUtfChars path(env, javaPath); 507 if (path.c_str() == NULL) { 508 return; 509 } 510 throwIfMinusOne(env, "chown", TEMP_FAILURE_RETRY(chown(path.c_str(), uid, gid))); 511 } 512 513 static void Posix_close(JNIEnv* env, jobject, jobject javaFd) { 514 // Get the FileDescriptor's 'fd' field and clear it. 515 // We need to do this before we can throw an IOException (http://b/3222087). 516 int fd = jniGetFDFromFileDescriptor(env, javaFd); 517 jniSetFileDescriptorOfFD(env, javaFd, -1); 518 519 // Even if close(2) fails with EINTR, the fd will have been closed. 520 // Using TEMP_FAILURE_RETRY will either lead to EBADF or closing someone else's fd. 521 // http://lkml.indiana.edu/hypermail/linux/kernel/0509.1/0877.html 522 throwIfMinusOne(env, "close", close(fd)); 523 } 524 525 static void Posix_connect(JNIEnv* env, jobject, jobject javaFd, jobject javaAddress, jint port) { 526 sockaddr_storage ss; 527 socklen_t sa_len; 528 if (!inetAddressToSockaddr(env, javaAddress, port, ss, sa_len)) { 529 return; 530 } 531 const sockaddr* sa = reinterpret_cast<const sockaddr*>(&ss); 532 // We don't need the return value because we'll already have thrown. 533 (void) NET_FAILURE_RETRY(env, int, connect, javaFd, sa, sa_len); 534 } 535 536 static jobject Posix_dup(JNIEnv* env, jobject, jobject javaOldFd) { 537 int oldFd = jniGetFDFromFileDescriptor(env, javaOldFd); 538 int newFd = throwIfMinusOne(env, "dup", TEMP_FAILURE_RETRY(dup(oldFd))); 539 return (newFd != -1) ? jniCreateFileDescriptor(env, newFd) : NULL; 540 } 541 542 static jobject Posix_dup2(JNIEnv* env, jobject, jobject javaOldFd, jint newFd) { 543 int oldFd = jniGetFDFromFileDescriptor(env, javaOldFd); 544 int fd = throwIfMinusOne(env, "dup2", TEMP_FAILURE_RETRY(dup2(oldFd, newFd))); 545 return (fd != -1) ? jniCreateFileDescriptor(env, fd) : NULL; 546 } 547 548 static jobjectArray Posix_environ(JNIEnv* env, jobject) { 549 extern char** environ; // Standard, but not in any header file. 550 return toStringArray(env, environ); 551 } 552 553 static void Posix_execve(JNIEnv* env, jobject, jstring javaFilename, jobjectArray javaArgv, jobjectArray javaEnvp) { 554 ScopedUtfChars path(env, javaFilename); 555 if (path.c_str() == NULL) { 556 return; 557 } 558 559 ExecStrings argv(env, javaArgv); 560 ExecStrings envp(env, javaEnvp); 561 execve(path.c_str(), argv.get(), envp.get()); 562 563 throwErrnoException(env, "execve"); 564 } 565 566 static void Posix_execv(JNIEnv* env, jobject, jstring javaFilename, jobjectArray javaArgv) { 567 ScopedUtfChars path(env, javaFilename); 568 if (path.c_str() == NULL) { 569 return; 570 } 571 572 ExecStrings argv(env, javaArgv); 573 execv(path.c_str(), argv.get()); 574 575 throwErrnoException(env, "execv"); 576 } 577 578 static void Posix_fchmod(JNIEnv* env, jobject, jobject javaFd, jint mode) { 579 int fd = jniGetFDFromFileDescriptor(env, javaFd); 580 throwIfMinusOne(env, "fchmod", TEMP_FAILURE_RETRY(fchmod(fd, mode))); 581 } 582 583 static void Posix_fchown(JNIEnv* env, jobject, jobject javaFd, jint uid, jint gid) { 584 int fd = jniGetFDFromFileDescriptor(env, javaFd); 585 throwIfMinusOne(env, "fchown", TEMP_FAILURE_RETRY(fchown(fd, uid, gid))); 586 } 587 588 static jint Posix_fcntlVoid(JNIEnv* env, jobject, jobject javaFd, jint cmd) { 589 int fd = jniGetFDFromFileDescriptor(env, javaFd); 590 return throwIfMinusOne(env, "fcntl", TEMP_FAILURE_RETRY(fcntl(fd, cmd))); 591 } 592 593 static jint Posix_fcntlLong(JNIEnv* env, jobject, jobject javaFd, jint cmd, jlong arg) { 594 int fd = jniGetFDFromFileDescriptor(env, javaFd); 595 return throwIfMinusOne(env, "fcntl", TEMP_FAILURE_RETRY(fcntl(fd, cmd, arg))); 596 } 597 598 static jint Posix_fcntlFlock(JNIEnv* env, jobject, jobject javaFd, jint cmd, jobject javaFlock) { 599 static jfieldID typeFid = env->GetFieldID(JniConstants::structFlockClass, "l_type", "S"); 600 static jfieldID whenceFid = env->GetFieldID(JniConstants::structFlockClass, "l_whence", "S"); 601 static jfieldID startFid = env->GetFieldID(JniConstants::structFlockClass, "l_start", "J"); 602 static jfieldID lenFid = env->GetFieldID(JniConstants::structFlockClass, "l_len", "J"); 603 static jfieldID pidFid = env->GetFieldID(JniConstants::structFlockClass, "l_pid", "I"); 604 605 struct flock64 lock; 606 memset(&lock, 0, sizeof(lock)); 607 lock.l_type = env->GetShortField(javaFlock, typeFid); 608 lock.l_whence = env->GetShortField(javaFlock, whenceFid); 609 lock.l_start = env->GetLongField(javaFlock, startFid); 610 lock.l_len = env->GetLongField(javaFlock, lenFid); 611 lock.l_pid = env->GetIntField(javaFlock, pidFid); 612 613 int rc = IO_FAILURE_RETRY(env, int, fcntl, javaFd, cmd, &lock); 614 if (rc != -1) { 615 env->SetShortField(javaFlock, typeFid, lock.l_type); 616 env->SetShortField(javaFlock, whenceFid, lock.l_whence); 617 env->SetLongField(javaFlock, startFid, lock.l_start); 618 env->SetLongField(javaFlock, lenFid, lock.l_len); 619 env->SetIntField(javaFlock, pidFid, lock.l_pid); 620 } 621 return rc; 622 } 623 624 static void Posix_fdatasync(JNIEnv* env, jobject, jobject javaFd) { 625 int fd = jniGetFDFromFileDescriptor(env, javaFd); 626 throwIfMinusOne(env, "fdatasync", TEMP_FAILURE_RETRY(fdatasync(fd))); 627 } 628 629 static jobject Posix_fstat(JNIEnv* env, jobject, jobject javaFd) { 630 int fd = jniGetFDFromFileDescriptor(env, javaFd); 631 struct stat sb; 632 int rc = TEMP_FAILURE_RETRY(fstat(fd, &sb)); 633 if (rc == -1) { 634 throwErrnoException(env, "fstat"); 635 return NULL; 636 } 637 return makeStructStat(env, sb); 638 } 639 640 static jobject Posix_fstatvfs(JNIEnv* env, jobject, jobject javaFd) { 641 int fd = jniGetFDFromFileDescriptor(env, javaFd); 642 struct statvfs sb; 643 int rc = TEMP_FAILURE_RETRY(fstatvfs(fd, &sb)); 644 if (rc == -1) { 645 throwErrnoException(env, "fstatvfs"); 646 return NULL; 647 } 648 return makeStructStatVfs(env, sb); 649 } 650 651 static void Posix_fsync(JNIEnv* env, jobject, jobject javaFd) { 652 int fd = jniGetFDFromFileDescriptor(env, javaFd); 653 throwIfMinusOne(env, "fsync", TEMP_FAILURE_RETRY(fsync(fd))); 654 } 655 656 static void Posix_ftruncate(JNIEnv* env, jobject, jobject javaFd, jlong length) { 657 int fd = jniGetFDFromFileDescriptor(env, javaFd); 658 throwIfMinusOne(env, "ftruncate", TEMP_FAILURE_RETRY(ftruncate64(fd, length))); 659 } 660 661 static jstring Posix_gai_strerror(JNIEnv* env, jobject, jint error) { 662 return env->NewStringUTF(gai_strerror(error)); 663 } 664 665 static jobjectArray Posix_android_getaddrinfo(JNIEnv* env, jobject, jstring javaNode, 666 jobject javaHints, jint netId) { 667 ScopedUtfChars node(env, javaNode); 668 if (node.c_str() == NULL) { 669 return NULL; 670 } 671 672 static jfieldID flagsFid = env->GetFieldID(JniConstants::structAddrinfoClass, "ai_flags", "I"); 673 static jfieldID familyFid = env->GetFieldID(JniConstants::structAddrinfoClass, "ai_family", "I"); 674 static jfieldID socktypeFid = env->GetFieldID(JniConstants::structAddrinfoClass, "ai_socktype", "I"); 675 static jfieldID protocolFid = env->GetFieldID(JniConstants::structAddrinfoClass, "ai_protocol", "I"); 676 677 addrinfo hints; 678 memset(&hints, 0, sizeof(hints)); 679 hints.ai_flags = env->GetIntField(javaHints, flagsFid); 680 hints.ai_family = env->GetIntField(javaHints, familyFid); 681 hints.ai_socktype = env->GetIntField(javaHints, socktypeFid); 682 hints.ai_protocol = env->GetIntField(javaHints, protocolFid); 683 684 addrinfo* addressList = NULL; 685 errno = 0; 686 int rc = android_getaddrinfofornet(node.c_str(), NULL, &hints, netId, 0, &addressList); 687 UniquePtr<addrinfo, addrinfo_deleter> addressListDeleter(addressList); 688 if (rc != 0) { 689 throwGaiException(env, "android_getaddrinfo", rc); 690 return NULL; 691 } 692 693 // Count results so we know how to size the output array. 694 int addressCount = 0; 695 for (addrinfo* ai = addressList; ai != NULL; ai = ai->ai_next) { 696 if (ai->ai_family == AF_INET || ai->ai_family == AF_INET6) { 697 ++addressCount; 698 } else { 699 ALOGE("android_getaddrinfo unexpected ai_family %i", ai->ai_family); 700 } 701 } 702 if (addressCount == 0) { 703 return NULL; 704 } 705 706 // Prepare output array. 707 jobjectArray result = env->NewObjectArray(addressCount, JniConstants::inetAddressClass, NULL); 708 if (result == NULL) { 709 return NULL; 710 } 711 712 // Examine returned addresses one by one, save them in the output array. 713 int index = 0; 714 for (addrinfo* ai = addressList; ai != NULL; ai = ai->ai_next) { 715 if (ai->ai_family != AF_INET && ai->ai_family != AF_INET6) { 716 // Unknown address family. Skip this address. 717 ALOGE("android_getaddrinfo unexpected ai_family %i", ai->ai_family); 718 continue; 719 } 720 721 // Convert each IP address into a Java byte array. 722 sockaddr_storage& address = *reinterpret_cast<sockaddr_storage*>(ai->ai_addr); 723 ScopedLocalRef<jobject> inetAddress(env, sockaddrToInetAddress(env, address, NULL)); 724 if (inetAddress.get() == NULL) { 725 return NULL; 726 } 727 env->SetObjectArrayElement(result, index, inetAddress.get()); 728 ++index; 729 } 730 return result; 731 } 732 733 static jint Posix_getegid(JNIEnv*, jobject) { 734 return getegid(); 735 } 736 737 static jint Posix_geteuid(JNIEnv*, jobject) { 738 return geteuid(); 739 } 740 741 static jint Posix_getgid(JNIEnv*, jobject) { 742 return getgid(); 743 } 744 745 static jstring Posix_getenv(JNIEnv* env, jobject, jstring javaName) { 746 ScopedUtfChars name(env, javaName); 747 if (name.c_str() == NULL) { 748 return NULL; 749 } 750 return env->NewStringUTF(getenv(name.c_str())); 751 } 752 753 static jstring Posix_getnameinfo(JNIEnv* env, jobject, jobject javaAddress, jint flags) { 754 sockaddr_storage ss; 755 socklen_t sa_len; 756 if (!inetAddressToSockaddrVerbatim(env, javaAddress, 0, ss, sa_len)) { 757 return NULL; 758 } 759 char buf[NI_MAXHOST]; // NI_MAXHOST is longer than INET6_ADDRSTRLEN. 760 errno = 0; 761 int rc = getnameinfo(reinterpret_cast<sockaddr*>(&ss), sa_len, buf, sizeof(buf), NULL, 0, flags); 762 if (rc != 0) { 763 throwGaiException(env, "getnameinfo", rc); 764 return NULL; 765 } 766 return env->NewStringUTF(buf); 767 } 768 769 static jobject Posix_getpeername(JNIEnv* env, jobject, jobject javaFd) { 770 return doGetSockName(env, javaFd, false); 771 } 772 773 static jint Posix_getpid(JNIEnv*, jobject) { 774 return getpid(); 775 } 776 777 static jint Posix_getppid(JNIEnv*, jobject) { 778 return getppid(); 779 } 780 781 static jobject Posix_getpwnam(JNIEnv* env, jobject, jstring javaName) { 782 ScopedUtfChars name(env, javaName); 783 if (name.c_str() == NULL) { 784 return NULL; 785 } 786 return Passwd(env).getpwnam(name.c_str()); 787 } 788 789 static jobject Posix_getpwuid(JNIEnv* env, jobject, jint uid) { 790 return Passwd(env).getpwuid(uid); 791 } 792 793 static jobject Posix_getsockname(JNIEnv* env, jobject, jobject javaFd) { 794 return doGetSockName(env, javaFd, true); 795 } 796 797 static jint Posix_getsockoptByte(JNIEnv* env, jobject, jobject javaFd, jint level, jint option) { 798 int fd = jniGetFDFromFileDescriptor(env, javaFd); 799 u_char result = 0; 800 socklen_t size = sizeof(result); 801 throwIfMinusOne(env, "getsockopt", TEMP_FAILURE_RETRY(getsockopt(fd, level, option, &result, &size))); 802 return result; 803 } 804 805 static jobject Posix_getsockoptInAddr(JNIEnv* env, jobject, jobject javaFd, jint level, jint option) { 806 int fd = jniGetFDFromFileDescriptor(env, javaFd); 807 sockaddr_storage ss; 808 memset(&ss, 0, sizeof(ss)); 809 ss.ss_family = AF_INET; // This is only for the IPv4-only IP_MULTICAST_IF. 810 sockaddr_in* sa = reinterpret_cast<sockaddr_in*>(&ss); 811 socklen_t size = sizeof(sa->sin_addr); 812 int rc = TEMP_FAILURE_RETRY(getsockopt(fd, level, option, &sa->sin_addr, &size)); 813 if (rc == -1) { 814 throwErrnoException(env, "getsockopt"); 815 return NULL; 816 } 817 return sockaddrToInetAddress(env, ss, NULL); 818 } 819 820 static jint Posix_getsockoptInt(JNIEnv* env, jobject, jobject javaFd, jint level, jint option) { 821 int fd = jniGetFDFromFileDescriptor(env, javaFd); 822 jint result = 0; 823 socklen_t size = sizeof(result); 824 throwIfMinusOne(env, "getsockopt", TEMP_FAILURE_RETRY(getsockopt(fd, level, option, &result, &size))); 825 return result; 826 } 827 828 static jobject Posix_getsockoptLinger(JNIEnv* env, jobject, jobject javaFd, jint level, jint option) { 829 int fd = jniGetFDFromFileDescriptor(env, javaFd); 830 struct linger l; 831 socklen_t size = sizeof(l); 832 memset(&l, 0, size); 833 int rc = TEMP_FAILURE_RETRY(getsockopt(fd, level, option, &l, &size)); 834 if (rc == -1) { 835 throwErrnoException(env, "getsockopt"); 836 return NULL; 837 } 838 return makeStructLinger(env, l); 839 } 840 841 static jobject Posix_getsockoptTimeval(JNIEnv* env, jobject, jobject javaFd, jint level, jint option) { 842 int fd = jniGetFDFromFileDescriptor(env, javaFd); 843 struct timeval tv; 844 socklen_t size = sizeof(tv); 845 memset(&tv, 0, size); 846 int rc = TEMP_FAILURE_RETRY(getsockopt(fd, level, option, &tv, &size)); 847 if (rc == -1) { 848 throwErrnoException(env, "getsockopt"); 849 return NULL; 850 } 851 return makeStructTimeval(env, tv); 852 } 853 854 static jobject Posix_getsockoptUcred(JNIEnv* env, jobject, jobject javaFd, jint level, jint option) { 855 int fd = jniGetFDFromFileDescriptor(env, javaFd); 856 struct ucred u; 857 socklen_t size = sizeof(u); 858 memset(&u, 0, size); 859 int rc = TEMP_FAILURE_RETRY(getsockopt(fd, level, option, &u, &size)); 860 if (rc == -1) { 861 throwErrnoException(env, "getsockopt"); 862 return NULL; 863 } 864 return makeStructUcred(env, u); 865 } 866 867 static jint Posix_gettid(JNIEnv* env __unused, jobject) { 868 #if defined(__APPLE__) 869 uint64_t owner; 870 int rc = pthread_threadid_np(NULL, &owner); // Requires Mac OS 10.6 871 if (rc != 0) { 872 throwErrnoException(env, "gettid"); 873 return 0; 874 } 875 return static_cast<jint>(owner); 876 #else 877 // Neither bionic nor glibc exposes gettid(2). 878 return syscall(__NR_gettid); 879 #endif 880 } 881 882 static jint Posix_getuid(JNIEnv*, jobject) { 883 return getuid(); 884 } 885 886 static jstring Posix_if_indextoname(JNIEnv* env, jobject, jint index) { 887 char buf[IF_NAMESIZE]; 888 char* name = if_indextoname(index, buf); 889 // if_indextoname(3) returns NULL on failure, which will come out of NewStringUTF unscathed. 890 // There's no useful information in errno, so we don't bother throwing. Callers can null-check. 891 return env->NewStringUTF(name); 892 } 893 894 static jobject Posix_inet_pton(JNIEnv* env, jobject, jint family, jstring javaName) { 895 ScopedUtfChars name(env, javaName); 896 if (name.c_str() == NULL) { 897 return NULL; 898 } 899 sockaddr_storage ss; 900 memset(&ss, 0, sizeof(ss)); 901 // sockaddr_in and sockaddr_in6 are at the same address, so we can use either here. 902 void* dst = &reinterpret_cast<sockaddr_in*>(&ss)->sin_addr; 903 if (inet_pton(family, name.c_str(), dst) != 1) { 904 return NULL; 905 } 906 ss.ss_family = family; 907 return sockaddrToInetAddress(env, ss, NULL); 908 } 909 910 static jobject Posix_ioctlInetAddress(JNIEnv* env, jobject, jobject javaFd, jint cmd, jstring javaInterfaceName) { 911 struct ifreq req; 912 if (!fillIfreq(env, javaInterfaceName, req)) { 913 return NULL; 914 } 915 int fd = jniGetFDFromFileDescriptor(env, javaFd); 916 int rc = throwIfMinusOne(env, "ioctl", TEMP_FAILURE_RETRY(ioctl(fd, cmd, &req))); 917 if (rc == -1) { 918 return NULL; 919 } 920 return sockaddrToInetAddress(env, reinterpret_cast<sockaddr_storage&>(req.ifr_addr), NULL); 921 } 922 923 static jint Posix_ioctlInt(JNIEnv* env, jobject, jobject javaFd, jint cmd, jobject javaArg) { 924 // This is complicated because ioctls may return their result by updating their argument 925 // or via their return value, so we need to support both. 926 int fd = jniGetFDFromFileDescriptor(env, javaFd); 927 static jfieldID valueFid = env->GetFieldID(JniConstants::mutableIntClass, "value", "I"); 928 jint arg = env->GetIntField(javaArg, valueFid); 929 int rc = throwIfMinusOne(env, "ioctl", TEMP_FAILURE_RETRY(ioctl(fd, cmd, &arg))); 930 if (!env->ExceptionCheck()) { 931 env->SetIntField(javaArg, valueFid, arg); 932 } 933 return rc; 934 } 935 936 static jboolean Posix_isatty(JNIEnv* env, jobject, jobject javaFd) { 937 int fd = jniGetFDFromFileDescriptor(env, javaFd); 938 return TEMP_FAILURE_RETRY(isatty(fd)) == 1; 939 } 940 941 static void Posix_kill(JNIEnv* env, jobject, jint pid, jint sig) { 942 throwIfMinusOne(env, "kill", TEMP_FAILURE_RETRY(kill(pid, sig))); 943 } 944 945 static void Posix_lchown(JNIEnv* env, jobject, jstring javaPath, jint uid, jint gid) { 946 ScopedUtfChars path(env, javaPath); 947 if (path.c_str() == NULL) { 948 return; 949 } 950 throwIfMinusOne(env, "lchown", TEMP_FAILURE_RETRY(lchown(path.c_str(), uid, gid))); 951 } 952 953 static void Posix_link(JNIEnv* env, jobject, jstring javaOldPath, jstring javaNewPath) { 954 ScopedUtfChars oldPath(env, javaOldPath); 955 if (oldPath.c_str() == NULL) { 956 return; 957 } 958 ScopedUtfChars newPath(env, javaNewPath); 959 if (newPath.c_str() == NULL) { 960 return; 961 } 962 throwIfMinusOne(env, "link", TEMP_FAILURE_RETRY(link(oldPath.c_str(), newPath.c_str()))); 963 } 964 965 static void Posix_listen(JNIEnv* env, jobject, jobject javaFd, jint backlog) { 966 int fd = jniGetFDFromFileDescriptor(env, javaFd); 967 throwIfMinusOne(env, "listen", TEMP_FAILURE_RETRY(listen(fd, backlog))); 968 } 969 970 static jlong Posix_lseek(JNIEnv* env, jobject, jobject javaFd, jlong offset, jint whence) { 971 int fd = jniGetFDFromFileDescriptor(env, javaFd); 972 return throwIfMinusOne(env, "lseek", TEMP_FAILURE_RETRY(lseek64(fd, offset, whence))); 973 } 974 975 static jobject Posix_lstat(JNIEnv* env, jobject, jstring javaPath) { 976 return doStat(env, javaPath, true); 977 } 978 979 static void Posix_mincore(JNIEnv* env, jobject, jlong address, jlong byteCount, jbyteArray javaVector) { 980 ScopedByteArrayRW vector(env, javaVector); 981 if (vector.get() == NULL) { 982 return; 983 } 984 void* ptr = reinterpret_cast<void*>(static_cast<uintptr_t>(address)); 985 unsigned char* vec = reinterpret_cast<unsigned char*>(vector.get()); 986 throwIfMinusOne(env, "mincore", TEMP_FAILURE_RETRY(mincore(ptr, byteCount, vec))); 987 } 988 989 static void Posix_mkdir(JNIEnv* env, jobject, jstring javaPath, jint mode) { 990 ScopedUtfChars path(env, javaPath); 991 if (path.c_str() == NULL) { 992 return; 993 } 994 throwIfMinusOne(env, "mkdir", TEMP_FAILURE_RETRY(mkdir(path.c_str(), mode))); 995 } 996 997 static void Posix_mkfifo(JNIEnv* env, jobject, jstring javaPath, jint mode) { 998 ScopedUtfChars path(env, javaPath); 999 if (path.c_str() == NULL) { 1000 return; 1001 } 1002 throwIfMinusOne(env, "mkfifo", TEMP_FAILURE_RETRY(mkfifo(path.c_str(), mode))); 1003 } 1004 1005 static void Posix_mlock(JNIEnv* env, jobject, jlong address, jlong byteCount) { 1006 void* ptr = reinterpret_cast<void*>(static_cast<uintptr_t>(address)); 1007 throwIfMinusOne(env, "mlock", TEMP_FAILURE_RETRY(mlock(ptr, byteCount))); 1008 } 1009 1010 static jlong Posix_mmap(JNIEnv* env, jobject, jlong address, jlong byteCount, jint prot, jint flags, jobject javaFd, jlong offset) { 1011 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1012 void* suggestedPtr = reinterpret_cast<void*>(static_cast<uintptr_t>(address)); 1013 void* ptr = mmap(suggestedPtr, byteCount, prot, flags, fd, offset); 1014 if (ptr == MAP_FAILED) { 1015 throwErrnoException(env, "mmap"); 1016 } 1017 return static_cast<jlong>(reinterpret_cast<uintptr_t>(ptr)); 1018 } 1019 1020 static void Posix_msync(JNIEnv* env, jobject, jlong address, jlong byteCount, jint flags) { 1021 void* ptr = reinterpret_cast<void*>(static_cast<uintptr_t>(address)); 1022 throwIfMinusOne(env, "msync", TEMP_FAILURE_RETRY(msync(ptr, byteCount, flags))); 1023 } 1024 1025 static void Posix_munlock(JNIEnv* env, jobject, jlong address, jlong byteCount) { 1026 void* ptr = reinterpret_cast<void*>(static_cast<uintptr_t>(address)); 1027 throwIfMinusOne(env, "munlock", TEMP_FAILURE_RETRY(munlock(ptr, byteCount))); 1028 } 1029 1030 static void Posix_munmap(JNIEnv* env, jobject, jlong address, jlong byteCount) { 1031 void* ptr = reinterpret_cast<void*>(static_cast<uintptr_t>(address)); 1032 throwIfMinusOne(env, "munmap", TEMP_FAILURE_RETRY(munmap(ptr, byteCount))); 1033 } 1034 1035 static jobject Posix_open(JNIEnv* env, jobject, jstring javaPath, jint flags, jint mode) { 1036 ScopedUtfChars path(env, javaPath); 1037 if (path.c_str() == NULL) { 1038 return NULL; 1039 } 1040 int fd = throwIfMinusOne(env, "open", TEMP_FAILURE_RETRY(open(path.c_str(), flags, mode))); 1041 return fd != -1 ? jniCreateFileDescriptor(env, fd) : NULL; 1042 } 1043 1044 static jobjectArray Posix_pipe(JNIEnv* env, jobject) { 1045 int fds[2]; 1046 throwIfMinusOne(env, "pipe", TEMP_FAILURE_RETRY(pipe(&fds[0]))); 1047 jobjectArray result = env->NewObjectArray(2, JniConstants::fileDescriptorClass, NULL); 1048 if (result == NULL) { 1049 return NULL; 1050 } 1051 for (int i = 0; i < 2; ++i) { 1052 ScopedLocalRef<jobject> fd(env, jniCreateFileDescriptor(env, fds[i])); 1053 if (fd.get() == NULL) { 1054 return NULL; 1055 } 1056 env->SetObjectArrayElement(result, i, fd.get()); 1057 if (env->ExceptionCheck()) { 1058 return NULL; 1059 } 1060 } 1061 return result; 1062 } 1063 1064 static jint Posix_poll(JNIEnv* env, jobject, jobjectArray javaStructs, jint timeoutMs) { 1065 static jfieldID fdFid = env->GetFieldID(JniConstants::structPollfdClass, "fd", "Ljava/io/FileDescriptor;"); 1066 static jfieldID eventsFid = env->GetFieldID(JniConstants::structPollfdClass, "events", "S"); 1067 static jfieldID reventsFid = env->GetFieldID(JniConstants::structPollfdClass, "revents", "S"); 1068 1069 // Turn the Java android.system.StructPollfd[] into a C++ struct pollfd[]. 1070 size_t arrayLength = env->GetArrayLength(javaStructs); 1071 UniquePtr<struct pollfd[]> fds(new struct pollfd[arrayLength]); 1072 memset(fds.get(), 0, sizeof(struct pollfd) * arrayLength); 1073 size_t count = 0; // Some trailing array elements may be irrelevant. (See below.) 1074 for (size_t i = 0; i < arrayLength; ++i) { 1075 ScopedLocalRef<jobject> javaStruct(env, env->GetObjectArrayElement(javaStructs, i)); 1076 if (javaStruct.get() == NULL) { 1077 break; // We allow trailing nulls in the array for caller convenience. 1078 } 1079 ScopedLocalRef<jobject> javaFd(env, env->GetObjectField(javaStruct.get(), fdFid)); 1080 if (javaFd.get() == NULL) { 1081 break; // We also allow callers to just clear the fd field (this is what Selector does). 1082 } 1083 fds[count].fd = jniGetFDFromFileDescriptor(env, javaFd.get()); 1084 fds[count].events = env->GetShortField(javaStruct.get(), eventsFid); 1085 ++count; 1086 } 1087 1088 std::vector<AsynchronousCloseMonitor*> monitors; 1089 for (size_t i = 0; i < count; ++i) { 1090 monitors.push_back(new AsynchronousCloseMonitor(fds[i].fd)); 1091 } 1092 int rc = poll(fds.get(), count, timeoutMs); 1093 for (size_t i = 0; i < monitors.size(); ++i) { 1094 delete monitors[i]; 1095 } 1096 if (rc == -1) { 1097 throwErrnoException(env, "poll"); 1098 return -1; 1099 } 1100 1101 // Update the revents fields in the Java android.system.StructPollfd[]. 1102 for (size_t i = 0; i < count; ++i) { 1103 ScopedLocalRef<jobject> javaStruct(env, env->GetObjectArrayElement(javaStructs, i)); 1104 if (javaStruct.get() == NULL) { 1105 return -1; 1106 } 1107 env->SetShortField(javaStruct.get(), reventsFid, fds[i].revents); 1108 } 1109 return rc; 1110 } 1111 1112 static void Posix_posix_fallocate(JNIEnv* env, jobject, jobject javaFd __unused, 1113 jlong offset __unused, jlong length __unused) { 1114 #ifdef __APPLE__ 1115 jniThrowException(env, "java/lang/UnsupportedOperationException", 1116 "fallocate doesn't exist on a Mac"); 1117 #else 1118 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1119 errno = TEMP_FAILURE_RETRY(posix_fallocate64(fd, offset, length)); 1120 if (errno != 0) { 1121 throwErrnoException(env, "posix_fallocate"); 1122 } 1123 #endif 1124 } 1125 1126 static jint Posix_prctl(JNIEnv* env, jobject, jint option __unused, jlong arg2 __unused, 1127 jlong arg3 __unused, jlong arg4 __unused, jlong arg5 __unused) { 1128 #ifdef __APPLE__ 1129 jniThrowException(env, "java/lang/UnsupportedOperationException", "prctl doesn't exist on a Mac"); 1130 return 0; 1131 #else 1132 int result = prctl(static_cast<int>(option), 1133 static_cast<unsigned long>(arg2), static_cast<unsigned long>(arg3), 1134 static_cast<unsigned long>(arg4), static_cast<unsigned long>(arg5)); 1135 return throwIfMinusOne(env, "prctl", result); 1136 #endif 1137 } 1138 1139 static jint Posix_preadBytes(JNIEnv* env, jobject, jobject javaFd, jobject javaBytes, jint byteOffset, jint byteCount, jlong offset) { 1140 ScopedBytesRW bytes(env, javaBytes); 1141 if (bytes.get() == NULL) { 1142 return -1; 1143 } 1144 return IO_FAILURE_RETRY(env, ssize_t, pread64, javaFd, bytes.get() + byteOffset, byteCount, offset); 1145 } 1146 1147 static jint Posix_pwriteBytes(JNIEnv* env, jobject, jobject javaFd, jbyteArray javaBytes, jint byteOffset, jint byteCount, jlong offset) { 1148 ScopedBytesRO bytes(env, javaBytes); 1149 if (bytes.get() == NULL) { 1150 return -1; 1151 } 1152 return IO_FAILURE_RETRY(env, ssize_t, pwrite64, javaFd, bytes.get() + byteOffset, byteCount, offset); 1153 } 1154 1155 static jint Posix_readBytes(JNIEnv* env, jobject, jobject javaFd, jobject javaBytes, jint byteOffset, jint byteCount) { 1156 ScopedBytesRW bytes(env, javaBytes); 1157 if (bytes.get() == NULL) { 1158 return -1; 1159 } 1160 return IO_FAILURE_RETRY(env, ssize_t, read, javaFd, bytes.get() + byteOffset, byteCount); 1161 } 1162 1163 static jstring Posix_readlink(JNIEnv* env, jobject, jstring javaPath) { 1164 ScopedUtfChars path(env, javaPath); 1165 if (path.c_str() == NULL) { 1166 return NULL; 1167 } 1168 1169 std::string result; 1170 if (!readlink(path.c_str(), result)) { 1171 throwErrnoException(env, "readlink"); 1172 return NULL; 1173 } 1174 return env->NewStringUTF(result.c_str()); 1175 } 1176 1177 static jint Posix_readv(JNIEnv* env, jobject, jobject javaFd, jobjectArray buffers, jintArray offsets, jintArray byteCounts) { 1178 IoVec<ScopedBytesRW> ioVec(env, env->GetArrayLength(buffers)); 1179 if (!ioVec.init(buffers, offsets, byteCounts)) { 1180 return -1; 1181 } 1182 return IO_FAILURE_RETRY(env, ssize_t, readv, javaFd, ioVec.get(), ioVec.size()); 1183 } 1184 1185 static jint Posix_recvfromBytes(JNIEnv* env, jobject, jobject javaFd, jobject javaBytes, jint byteOffset, jint byteCount, jint flags, jobject javaInetSocketAddress) { 1186 ScopedBytesRW bytes(env, javaBytes); 1187 if (bytes.get() == NULL) { 1188 return -1; 1189 } 1190 sockaddr_storage ss; 1191 socklen_t sl = sizeof(ss); 1192 memset(&ss, 0, sizeof(ss)); 1193 sockaddr* from = (javaInetSocketAddress != NULL) ? reinterpret_cast<sockaddr*>(&ss) : NULL; 1194 socklen_t* fromLength = (javaInetSocketAddress != NULL) ? &sl : 0; 1195 jint recvCount = NET_FAILURE_RETRY(env, ssize_t, recvfrom, javaFd, bytes.get() + byteOffset, byteCount, flags, from, fromLength); 1196 fillInetSocketAddress(env, recvCount, javaInetSocketAddress, ss); 1197 return recvCount; 1198 } 1199 1200 static void Posix_remove(JNIEnv* env, jobject, jstring javaPath) { 1201 ScopedUtfChars path(env, javaPath); 1202 if (path.c_str() == NULL) { 1203 return; 1204 } 1205 throwIfMinusOne(env, "remove", TEMP_FAILURE_RETRY(remove(path.c_str()))); 1206 } 1207 1208 static void Posix_rename(JNIEnv* env, jobject, jstring javaOldPath, jstring javaNewPath) { 1209 ScopedUtfChars oldPath(env, javaOldPath); 1210 if (oldPath.c_str() == NULL) { 1211 return; 1212 } 1213 ScopedUtfChars newPath(env, javaNewPath); 1214 if (newPath.c_str() == NULL) { 1215 return; 1216 } 1217 throwIfMinusOne(env, "rename", TEMP_FAILURE_RETRY(rename(oldPath.c_str(), newPath.c_str()))); 1218 } 1219 1220 static jlong Posix_sendfile(JNIEnv* env, jobject, jobject javaOutFd, jobject javaInFd, jobject javaOffset, jlong byteCount) { 1221 int outFd = jniGetFDFromFileDescriptor(env, javaOutFd); 1222 int inFd = jniGetFDFromFileDescriptor(env, javaInFd); 1223 static jfieldID valueFid = env->GetFieldID(JniConstants::mutableLongClass, "value", "J"); 1224 off_t offset = 0; 1225 off_t* offsetPtr = NULL; 1226 if (javaOffset != NULL) { 1227 // TODO: fix bionic so we can have a 64-bit off_t! 1228 offset = env->GetLongField(javaOffset, valueFid); 1229 offsetPtr = &offset; 1230 } 1231 jlong result = throwIfMinusOne(env, "sendfile", TEMP_FAILURE_RETRY(sendfile(outFd, inFd, offsetPtr, byteCount))); 1232 if (javaOffset != NULL) { 1233 env->SetLongField(javaOffset, valueFid, offset); 1234 } 1235 return result; 1236 } 1237 1238 static jint Posix_sendtoBytes(JNIEnv* env, jobject, jobject javaFd, jobject javaBytes, jint byteOffset, jint byteCount, jint flags, jobject javaInetAddress, jint port) { 1239 ScopedBytesRO bytes(env, javaBytes); 1240 if (bytes.get() == NULL) { 1241 return -1; 1242 } 1243 sockaddr_storage ss; 1244 socklen_t sa_len = 0; 1245 if (javaInetAddress != NULL && !inetAddressToSockaddr(env, javaInetAddress, port, ss, sa_len)) { 1246 return -1; 1247 } 1248 const sockaddr* to = (javaInetAddress != NULL) ? reinterpret_cast<const sockaddr*>(&ss) : NULL; 1249 return NET_FAILURE_RETRY(env, ssize_t, sendto, javaFd, bytes.get() + byteOffset, byteCount, flags, to, sa_len); 1250 } 1251 1252 static void Posix_setegid(JNIEnv* env, jobject, jint egid) { 1253 throwIfMinusOne(env, "setegid", TEMP_FAILURE_RETRY(setegid(egid))); 1254 } 1255 1256 static void Posix_setenv(JNIEnv* env, jobject, jstring javaName, jstring javaValue, jboolean overwrite) { 1257 ScopedUtfChars name(env, javaName); 1258 if (name.c_str() == NULL) { 1259 return; 1260 } 1261 ScopedUtfChars value(env, javaValue); 1262 if (value.c_str() == NULL) { 1263 return; 1264 } 1265 throwIfMinusOne(env, "setenv", setenv(name.c_str(), value.c_str(), overwrite)); 1266 } 1267 1268 static void Posix_seteuid(JNIEnv* env, jobject, jint euid) { 1269 throwIfMinusOne(env, "seteuid", TEMP_FAILURE_RETRY(seteuid(euid))); 1270 } 1271 1272 static void Posix_setgid(JNIEnv* env, jobject, jint gid) { 1273 throwIfMinusOne(env, "setgid", TEMP_FAILURE_RETRY(setgid(gid))); 1274 } 1275 1276 static jint Posix_setsid(JNIEnv* env, jobject) { 1277 return throwIfMinusOne(env, "setsid", TEMP_FAILURE_RETRY(setsid())); 1278 } 1279 1280 static void Posix_setsockoptByte(JNIEnv* env, jobject, jobject javaFd, jint level, jint option, jint value) { 1281 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1282 u_char byte = value; 1283 throwIfMinusOne(env, "setsockopt", TEMP_FAILURE_RETRY(setsockopt(fd, level, option, &byte, sizeof(byte)))); 1284 } 1285 1286 static void Posix_setsockoptIfreq(JNIEnv* env, jobject, jobject javaFd, jint level, jint option, jstring javaInterfaceName) { 1287 struct ifreq req; 1288 if (!fillIfreq(env, javaInterfaceName, req)) { 1289 return; 1290 } 1291 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1292 throwIfMinusOne(env, "setsockopt", TEMP_FAILURE_RETRY(setsockopt(fd, level, option, &req, sizeof(req)))); 1293 } 1294 1295 static void Posix_setsockoptInt(JNIEnv* env, jobject, jobject javaFd, jint level, jint option, jint value) { 1296 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1297 throwIfMinusOne(env, "setsockopt", TEMP_FAILURE_RETRY(setsockopt(fd, level, option, &value, sizeof(value)))); 1298 } 1299 1300 #if defined(__APPLE__) && MAC_OS_X_VERSION_MAX_ALLOWED < 1070 1301 // Mac OS didn't support modern multicast APIs until 10.7. 1302 static void Posix_setsockoptIpMreqn(JNIEnv*, jobject, jobject, jint, jint, jint) { abort(); } 1303 static void Posix_setsockoptGroupReq(JNIEnv*, jobject, jobject, jint, jint, jobject) { abort(); } 1304 static void Posix_setsockoptGroupSourceReq(JNIEnv*, jobject, jobject, jint, jint, jobject) { abort(); } 1305 #else 1306 static void Posix_setsockoptIpMreqn(JNIEnv* env, jobject, jobject javaFd, jint level, jint option, jint value) { 1307 ip_mreqn req; 1308 memset(&req, 0, sizeof(req)); 1309 req.imr_ifindex = value; 1310 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1311 throwIfMinusOne(env, "setsockopt", TEMP_FAILURE_RETRY(setsockopt(fd, level, option, &req, sizeof(req)))); 1312 } 1313 1314 static void Posix_setsockoptGroupReq(JNIEnv* env, jobject, jobject javaFd, jint level, jint option, jobject javaGroupReq) { 1315 struct group_req req; 1316 memset(&req, 0, sizeof(req)); 1317 1318 static jfieldID grInterfaceFid = env->GetFieldID(JniConstants::structGroupReqClass, "gr_interface", "I"); 1319 req.gr_interface = env->GetIntField(javaGroupReq, grInterfaceFid); 1320 // Get the IPv4 or IPv6 multicast address to join or leave. 1321 static jfieldID grGroupFid = env->GetFieldID(JniConstants::structGroupReqClass, "gr_group", "Ljava/net/InetAddress;"); 1322 ScopedLocalRef<jobject> javaGroup(env, env->GetObjectField(javaGroupReq, grGroupFid)); 1323 socklen_t sa_len; 1324 if (!inetAddressToSockaddrVerbatim(env, javaGroup.get(), 0, req.gr_group, sa_len)) { 1325 return; 1326 } 1327 1328 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1329 int rc = TEMP_FAILURE_RETRY(setsockopt(fd, level, option, &req, sizeof(req))); 1330 if (rc == -1 && errno == EINVAL) { 1331 // Maybe we're a 32-bit binary talking to a 64-bit kernel? 1332 // glibc doesn't automatically handle this. 1333 // http://sourceware.org/bugzilla/show_bug.cgi?id=12080 1334 struct group_req64 { 1335 uint32_t gr_interface; 1336 uint32_t my_padding; 1337 sockaddr_storage gr_group; 1338 }; 1339 group_req64 req64; 1340 req64.gr_interface = req.gr_interface; 1341 memcpy(&req64.gr_group, &req.gr_group, sizeof(req.gr_group)); 1342 rc = TEMP_FAILURE_RETRY(setsockopt(fd, level, option, &req64, sizeof(req64))); 1343 } 1344 throwIfMinusOne(env, "setsockopt", rc); 1345 } 1346 1347 static void Posix_setsockoptGroupSourceReq(JNIEnv* env, jobject, jobject javaFd, jint level, jint option, jobject javaGroupSourceReq) { 1348 socklen_t sa_len; 1349 struct group_source_req req; 1350 memset(&req, 0, sizeof(req)); 1351 1352 static jfieldID gsrInterfaceFid = env->GetFieldID(JniConstants::structGroupSourceReqClass, "gsr_interface", "I"); 1353 req.gsr_interface = env->GetIntField(javaGroupSourceReq, gsrInterfaceFid); 1354 // Get the IPv4 or IPv6 multicast address to join or leave. 1355 static jfieldID gsrGroupFid = env->GetFieldID(JniConstants::structGroupSourceReqClass, "gsr_group", "Ljava/net/InetAddress;"); 1356 ScopedLocalRef<jobject> javaGroup(env, env->GetObjectField(javaGroupSourceReq, gsrGroupFid)); 1357 if (!inetAddressToSockaddrVerbatim(env, javaGroup.get(), 0, req.gsr_group, sa_len)) { 1358 return; 1359 } 1360 1361 // Get the IPv4 or IPv6 multicast address to add to the filter. 1362 static jfieldID gsrSourceFid = env->GetFieldID(JniConstants::structGroupSourceReqClass, "gsr_source", "Ljava/net/InetAddress;"); 1363 ScopedLocalRef<jobject> javaSource(env, env->GetObjectField(javaGroupSourceReq, gsrSourceFid)); 1364 if (!inetAddressToSockaddrVerbatim(env, javaSource.get(), 0, req.gsr_source, sa_len)) { 1365 return; 1366 } 1367 1368 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1369 int rc = TEMP_FAILURE_RETRY(setsockopt(fd, level, option, &req, sizeof(req))); 1370 if (rc == -1 && errno == EINVAL) { 1371 // Maybe we're a 32-bit binary talking to a 64-bit kernel? 1372 // glibc doesn't automatically handle this. 1373 // http://sourceware.org/bugzilla/show_bug.cgi?id=12080 1374 struct group_source_req64 { 1375 uint32_t gsr_interface; 1376 uint32_t my_padding; 1377 sockaddr_storage gsr_group; 1378 sockaddr_storage gsr_source; 1379 }; 1380 group_source_req64 req64; 1381 req64.gsr_interface = req.gsr_interface; 1382 memcpy(&req64.gsr_group, &req.gsr_group, sizeof(req.gsr_group)); 1383 memcpy(&req64.gsr_source, &req.gsr_source, sizeof(req.gsr_source)); 1384 rc = TEMP_FAILURE_RETRY(setsockopt(fd, level, option, &req64, sizeof(req64))); 1385 } 1386 throwIfMinusOne(env, "setsockopt", rc); 1387 } 1388 #endif 1389 1390 static void Posix_setsockoptLinger(JNIEnv* env, jobject, jobject javaFd, jint level, jint option, jobject javaLinger) { 1391 static jfieldID lOnoffFid = env->GetFieldID(JniConstants::structLingerClass, "l_onoff", "I"); 1392 static jfieldID lLingerFid = env->GetFieldID(JniConstants::structLingerClass, "l_linger", "I"); 1393 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1394 struct linger value; 1395 value.l_onoff = env->GetIntField(javaLinger, lOnoffFid); 1396 value.l_linger = env->GetIntField(javaLinger, lLingerFid); 1397 throwIfMinusOne(env, "setsockopt", TEMP_FAILURE_RETRY(setsockopt(fd, level, option, &value, sizeof(value)))); 1398 } 1399 1400 static void Posix_setsockoptTimeval(JNIEnv* env, jobject, jobject javaFd, jint level, jint option, jobject javaTimeval) { 1401 static jfieldID tvSecFid = env->GetFieldID(JniConstants::structTimevalClass, "tv_sec", "J"); 1402 static jfieldID tvUsecFid = env->GetFieldID(JniConstants::structTimevalClass, "tv_usec", "J"); 1403 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1404 struct timeval value; 1405 value.tv_sec = env->GetLongField(javaTimeval, tvSecFid); 1406 value.tv_usec = env->GetLongField(javaTimeval, tvUsecFid); 1407 throwIfMinusOne(env, "setsockopt", TEMP_FAILURE_RETRY(setsockopt(fd, level, option, &value, sizeof(value)))); 1408 } 1409 1410 static void Posix_setuid(JNIEnv* env, jobject, jint uid) { 1411 throwIfMinusOne(env, "setuid", TEMP_FAILURE_RETRY(setuid(uid))); 1412 } 1413 1414 static void Posix_shutdown(JNIEnv* env, jobject, jobject javaFd, jint how) { 1415 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1416 throwIfMinusOne(env, "shutdown", TEMP_FAILURE_RETRY(shutdown(fd, how))); 1417 } 1418 1419 static jobject Posix_socket(JNIEnv* env, jobject, jint domain, jint type, jint protocol) { 1420 int fd = throwIfMinusOne(env, "socket", TEMP_FAILURE_RETRY(socket(domain, type, protocol))); 1421 return fd != -1 ? jniCreateFileDescriptor(env, fd) : NULL; 1422 } 1423 1424 static void Posix_socketpair(JNIEnv* env, jobject, jint domain, jint type, jint protocol, jobject javaFd1, jobject javaFd2) { 1425 int fds[2]; 1426 int rc = throwIfMinusOne(env, "socketpair", TEMP_FAILURE_RETRY(socketpair(domain, type, protocol, fds))); 1427 if (rc != -1) { 1428 jniSetFileDescriptorOfFD(env, javaFd1, fds[0]); 1429 jniSetFileDescriptorOfFD(env, javaFd2, fds[1]); 1430 } 1431 } 1432 1433 static jobject Posix_stat(JNIEnv* env, jobject, jstring javaPath) { 1434 return doStat(env, javaPath, false); 1435 } 1436 1437 static jobject Posix_statvfs(JNIEnv* env, jobject, jstring javaPath) { 1438 ScopedUtfChars path(env, javaPath); 1439 if (path.c_str() == NULL) { 1440 return NULL; 1441 } 1442 struct statvfs sb; 1443 int rc = TEMP_FAILURE_RETRY(statvfs(path.c_str(), &sb)); 1444 if (rc == -1) { 1445 throwErrnoException(env, "statvfs"); 1446 return NULL; 1447 } 1448 return makeStructStatVfs(env, sb); 1449 } 1450 1451 static jstring Posix_strerror(JNIEnv* env, jobject, jint errnum) { 1452 char buffer[BUFSIZ]; 1453 const char* message = jniStrError(errnum, buffer, sizeof(buffer)); 1454 return env->NewStringUTF(message); 1455 } 1456 1457 static jstring Posix_strsignal(JNIEnv* env, jobject, jint signal) { 1458 return env->NewStringUTF(strsignal(signal)); 1459 } 1460 1461 static void Posix_symlink(JNIEnv* env, jobject, jstring javaOldPath, jstring javaNewPath) { 1462 ScopedUtfChars oldPath(env, javaOldPath); 1463 if (oldPath.c_str() == NULL) { 1464 return; 1465 } 1466 ScopedUtfChars newPath(env, javaNewPath); 1467 if (newPath.c_str() == NULL) { 1468 return; 1469 } 1470 throwIfMinusOne(env, "symlink", TEMP_FAILURE_RETRY(symlink(oldPath.c_str(), newPath.c_str()))); 1471 } 1472 1473 static jlong Posix_sysconf(JNIEnv* env, jobject, jint name) { 1474 // Since -1 is a valid result from sysconf(3), detecting failure is a little more awkward. 1475 errno = 0; 1476 long result = sysconf(name); 1477 if (result == -1L && errno == EINVAL) { 1478 throwErrnoException(env, "sysconf"); 1479 } 1480 return result; 1481 } 1482 1483 static void Posix_tcdrain(JNIEnv* env, jobject, jobject javaFd) { 1484 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1485 throwIfMinusOne(env, "tcdrain", TEMP_FAILURE_RETRY(tcdrain(fd))); 1486 } 1487 1488 static void Posix_tcsendbreak(JNIEnv* env, jobject, jobject javaFd, jint duration) { 1489 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1490 throwIfMinusOne(env, "tcsendbreak", TEMP_FAILURE_RETRY(tcsendbreak(fd, duration))); 1491 } 1492 1493 static jint Posix_umaskImpl(JNIEnv*, jobject, jint mask) { 1494 return umask(mask); 1495 } 1496 1497 static jobject Posix_uname(JNIEnv* env, jobject) { 1498 struct utsname buf; 1499 if (TEMP_FAILURE_RETRY(uname(&buf)) == -1) { 1500 return NULL; // Can't happen. 1501 } 1502 return makeStructUtsname(env, buf); 1503 } 1504 1505 static void Posix_unsetenv(JNIEnv* env, jobject, jstring javaName) { 1506 ScopedUtfChars name(env, javaName); 1507 if (name.c_str() == NULL) { 1508 return; 1509 } 1510 throwIfMinusOne(env, "unsetenv", unsetenv(name.c_str())); 1511 } 1512 1513 static jint Posix_waitpid(JNIEnv* env, jobject, jint pid, jobject javaStatus, jint options) { 1514 int status; 1515 int rc = throwIfMinusOne(env, "waitpid", TEMP_FAILURE_RETRY(waitpid(pid, &status, options))); 1516 if (rc != -1) { 1517 static jfieldID valueFid = env->GetFieldID(JniConstants::mutableIntClass, "value", "I"); 1518 env->SetIntField(javaStatus, valueFid, status); 1519 } 1520 return rc; 1521 } 1522 1523 static jint Posix_writeBytes(JNIEnv* env, jobject, jobject javaFd, jbyteArray javaBytes, jint byteOffset, jint byteCount) { 1524 ScopedBytesRO bytes(env, javaBytes); 1525 if (bytes.get() == NULL) { 1526 return -1; 1527 } 1528 return IO_FAILURE_RETRY(env, ssize_t, write, javaFd, bytes.get() + byteOffset, byteCount); 1529 } 1530 1531 static jint Posix_writev(JNIEnv* env, jobject, jobject javaFd, jobjectArray buffers, jintArray offsets, jintArray byteCounts) { 1532 IoVec<ScopedBytesRO> ioVec(env, env->GetArrayLength(buffers)); 1533 if (!ioVec.init(buffers, offsets, byteCounts)) { 1534 return -1; 1535 } 1536 return IO_FAILURE_RETRY(env, ssize_t, writev, javaFd, ioVec.get(), ioVec.size()); 1537 } 1538 1539 static JNINativeMethod gMethods[] = { 1540 NATIVE_METHOD(Posix, accept, "(Ljava/io/FileDescriptor;Ljava/net/InetSocketAddress;)Ljava/io/FileDescriptor;"), 1541 NATIVE_METHOD(Posix, access, "(Ljava/lang/String;I)Z"), 1542 NATIVE_METHOD(Posix, android_getaddrinfo, "(Ljava/lang/String;Landroid/system/StructAddrinfo;I)[Ljava/net/InetAddress;"), 1543 NATIVE_METHOD(Posix, bind, "(Ljava/io/FileDescriptor;Ljava/net/InetAddress;I)V"), 1544 NATIVE_METHOD(Posix, chmod, "(Ljava/lang/String;I)V"), 1545 NATIVE_METHOD(Posix, chown, "(Ljava/lang/String;II)V"), 1546 NATIVE_METHOD(Posix, close, "(Ljava/io/FileDescriptor;)V"), 1547 NATIVE_METHOD(Posix, connect, "(Ljava/io/FileDescriptor;Ljava/net/InetAddress;I)V"), 1548 NATIVE_METHOD(Posix, dup, "(Ljava/io/FileDescriptor;)Ljava/io/FileDescriptor;"), 1549 NATIVE_METHOD(Posix, dup2, "(Ljava/io/FileDescriptor;I)Ljava/io/FileDescriptor;"), 1550 NATIVE_METHOD(Posix, environ, "()[Ljava/lang/String;"), 1551 NATIVE_METHOD(Posix, execv, "(Ljava/lang/String;[Ljava/lang/String;)V"), 1552 NATIVE_METHOD(Posix, execve, "(Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/String;)V"), 1553 NATIVE_METHOD(Posix, fchmod, "(Ljava/io/FileDescriptor;I)V"), 1554 NATIVE_METHOD(Posix, fchown, "(Ljava/io/FileDescriptor;II)V"), 1555 NATIVE_METHOD(Posix, fcntlVoid, "(Ljava/io/FileDescriptor;I)I"), 1556 NATIVE_METHOD(Posix, fcntlLong, "(Ljava/io/FileDescriptor;IJ)I"), 1557 NATIVE_METHOD(Posix, fcntlFlock, "(Ljava/io/FileDescriptor;ILandroid/system/StructFlock;)I"), 1558 NATIVE_METHOD(Posix, fdatasync, "(Ljava/io/FileDescriptor;)V"), 1559 NATIVE_METHOD(Posix, fstat, "(Ljava/io/FileDescriptor;)Landroid/system/StructStat;"), 1560 NATIVE_METHOD(Posix, fstatvfs, "(Ljava/io/FileDescriptor;)Landroid/system/StructStatVfs;"), 1561 NATIVE_METHOD(Posix, fsync, "(Ljava/io/FileDescriptor;)V"), 1562 NATIVE_METHOD(Posix, ftruncate, "(Ljava/io/FileDescriptor;J)V"), 1563 NATIVE_METHOD(Posix, gai_strerror, "(I)Ljava/lang/String;"), 1564 NATIVE_METHOD(Posix, getegid, "()I"), 1565 NATIVE_METHOD(Posix, geteuid, "()I"), 1566 NATIVE_METHOD(Posix, getgid, "()I"), 1567 NATIVE_METHOD(Posix, getenv, "(Ljava/lang/String;)Ljava/lang/String;"), 1568 NATIVE_METHOD(Posix, getnameinfo, "(Ljava/net/InetAddress;I)Ljava/lang/String;"), 1569 NATIVE_METHOD(Posix, getpeername, "(Ljava/io/FileDescriptor;)Ljava/net/SocketAddress;"), 1570 NATIVE_METHOD(Posix, getpid, "()I"), 1571 NATIVE_METHOD(Posix, getppid, "()I"), 1572 NATIVE_METHOD(Posix, getpwnam, "(Ljava/lang/String;)Landroid/system/StructPasswd;"), 1573 NATIVE_METHOD(Posix, getpwuid, "(I)Landroid/system/StructPasswd;"), 1574 NATIVE_METHOD(Posix, getsockname, "(Ljava/io/FileDescriptor;)Ljava/net/SocketAddress;"), 1575 NATIVE_METHOD(Posix, getsockoptByte, "(Ljava/io/FileDescriptor;II)I"), 1576 NATIVE_METHOD(Posix, getsockoptInAddr, "(Ljava/io/FileDescriptor;II)Ljava/net/InetAddress;"), 1577 NATIVE_METHOD(Posix, getsockoptInt, "(Ljava/io/FileDescriptor;II)I"), 1578 NATIVE_METHOD(Posix, getsockoptLinger, "(Ljava/io/FileDescriptor;II)Landroid/system/StructLinger;"), 1579 NATIVE_METHOD(Posix, getsockoptTimeval, "(Ljava/io/FileDescriptor;II)Landroid/system/StructTimeval;"), 1580 NATIVE_METHOD(Posix, getsockoptUcred, "(Ljava/io/FileDescriptor;II)Landroid/system/StructUcred;"), 1581 NATIVE_METHOD(Posix, gettid, "()I"), 1582 NATIVE_METHOD(Posix, getuid, "()I"), 1583 NATIVE_METHOD(Posix, if_indextoname, "(I)Ljava/lang/String;"), 1584 NATIVE_METHOD(Posix, inet_pton, "(ILjava/lang/String;)Ljava/net/InetAddress;"), 1585 NATIVE_METHOD(Posix, ioctlInetAddress, "(Ljava/io/FileDescriptor;ILjava/lang/String;)Ljava/net/InetAddress;"), 1586 NATIVE_METHOD(Posix, ioctlInt, "(Ljava/io/FileDescriptor;ILandroid/util/MutableInt;)I"), 1587 NATIVE_METHOD(Posix, isatty, "(Ljava/io/FileDescriptor;)Z"), 1588 NATIVE_METHOD(Posix, kill, "(II)V"), 1589 NATIVE_METHOD(Posix, lchown, "(Ljava/lang/String;II)V"), 1590 NATIVE_METHOD(Posix, link, "(Ljava/lang/String;Ljava/lang/String;)V"), 1591 NATIVE_METHOD(Posix, listen, "(Ljava/io/FileDescriptor;I)V"), 1592 NATIVE_METHOD(Posix, lseek, "(Ljava/io/FileDescriptor;JI)J"), 1593 NATIVE_METHOD(Posix, lstat, "(Ljava/lang/String;)Landroid/system/StructStat;"), 1594 NATIVE_METHOD(Posix, mincore, "(JJ[B)V"), 1595 NATIVE_METHOD(Posix, mkdir, "(Ljava/lang/String;I)V"), 1596 NATIVE_METHOD(Posix, mkfifo, "(Ljava/lang/String;I)V"), 1597 NATIVE_METHOD(Posix, mlock, "(JJ)V"), 1598 NATIVE_METHOD(Posix, mmap, "(JJIILjava/io/FileDescriptor;J)J"), 1599 NATIVE_METHOD(Posix, msync, "(JJI)V"), 1600 NATIVE_METHOD(Posix, munlock, "(JJ)V"), 1601 NATIVE_METHOD(Posix, munmap, "(JJ)V"), 1602 NATIVE_METHOD(Posix, open, "(Ljava/lang/String;II)Ljava/io/FileDescriptor;"), 1603 NATIVE_METHOD(Posix, pipe, "()[Ljava/io/FileDescriptor;"), 1604 NATIVE_METHOD(Posix, poll, "([Landroid/system/StructPollfd;I)I"), 1605 NATIVE_METHOD(Posix, posix_fallocate, "(Ljava/io/FileDescriptor;JJ)V"), 1606 NATIVE_METHOD(Posix, prctl, "(IJJJJ)I"), 1607 NATIVE_METHOD(Posix, preadBytes, "(Ljava/io/FileDescriptor;Ljava/lang/Object;IIJ)I"), 1608 NATIVE_METHOD(Posix, pwriteBytes, "(Ljava/io/FileDescriptor;Ljava/lang/Object;IIJ)I"), 1609 NATIVE_METHOD(Posix, readBytes, "(Ljava/io/FileDescriptor;Ljava/lang/Object;II)I"), 1610 NATIVE_METHOD(Posix, readlink, "(Ljava/lang/String;)Ljava/lang/String;"), 1611 NATIVE_METHOD(Posix, readv, "(Ljava/io/FileDescriptor;[Ljava/lang/Object;[I[I)I"), 1612 NATIVE_METHOD(Posix, recvfromBytes, "(Ljava/io/FileDescriptor;Ljava/lang/Object;IIILjava/net/InetSocketAddress;)I"), 1613 NATIVE_METHOD(Posix, remove, "(Ljava/lang/String;)V"), 1614 NATIVE_METHOD(Posix, rename, "(Ljava/lang/String;Ljava/lang/String;)V"), 1615 NATIVE_METHOD(Posix, sendfile, "(Ljava/io/FileDescriptor;Ljava/io/FileDescriptor;Landroid/util/MutableLong;J)J"), 1616 NATIVE_METHOD(Posix, sendtoBytes, "(Ljava/io/FileDescriptor;Ljava/lang/Object;IIILjava/net/InetAddress;I)I"), 1617 NATIVE_METHOD(Posix, setegid, "(I)V"), 1618 NATIVE_METHOD(Posix, setenv, "(Ljava/lang/String;Ljava/lang/String;Z)V"), 1619 NATIVE_METHOD(Posix, seteuid, "(I)V"), 1620 NATIVE_METHOD(Posix, setgid, "(I)V"), 1621 NATIVE_METHOD(Posix, setsid, "()I"), 1622 NATIVE_METHOD(Posix, setsockoptByte, "(Ljava/io/FileDescriptor;III)V"), 1623 NATIVE_METHOD(Posix, setsockoptIfreq, "(Ljava/io/FileDescriptor;IILjava/lang/String;)V"), 1624 NATIVE_METHOD(Posix, setsockoptInt, "(Ljava/io/FileDescriptor;III)V"), 1625 NATIVE_METHOD(Posix, setsockoptIpMreqn, "(Ljava/io/FileDescriptor;III)V"), 1626 NATIVE_METHOD(Posix, setsockoptGroupReq, "(Ljava/io/FileDescriptor;IILandroid/system/StructGroupReq;)V"), 1627 NATIVE_METHOD(Posix, setsockoptGroupSourceReq, "(Ljava/io/FileDescriptor;IILandroid/system/StructGroupSourceReq;)V"), 1628 NATIVE_METHOD(Posix, setsockoptLinger, "(Ljava/io/FileDescriptor;IILandroid/system/StructLinger;)V"), 1629 NATIVE_METHOD(Posix, setsockoptTimeval, "(Ljava/io/FileDescriptor;IILandroid/system/StructTimeval;)V"), 1630 NATIVE_METHOD(Posix, setuid, "(I)V"), 1631 NATIVE_METHOD(Posix, shutdown, "(Ljava/io/FileDescriptor;I)V"), 1632 NATIVE_METHOD(Posix, socket, "(III)Ljava/io/FileDescriptor;"), 1633 NATIVE_METHOD(Posix, socketpair, "(IIILjava/io/FileDescriptor;Ljava/io/FileDescriptor;)V"), 1634 NATIVE_METHOD(Posix, stat, "(Ljava/lang/String;)Landroid/system/StructStat;"), 1635 NATIVE_METHOD(Posix, statvfs, "(Ljava/lang/String;)Landroid/system/StructStatVfs;"), 1636 NATIVE_METHOD(Posix, strerror, "(I)Ljava/lang/String;"), 1637 NATIVE_METHOD(Posix, strsignal, "(I)Ljava/lang/String;"), 1638 NATIVE_METHOD(Posix, symlink, "(Ljava/lang/String;Ljava/lang/String;)V"), 1639 NATIVE_METHOD(Posix, sysconf, "(I)J"), 1640 NATIVE_METHOD(Posix, tcdrain, "(Ljava/io/FileDescriptor;)V"), 1641 NATIVE_METHOD(Posix, tcsendbreak, "(Ljava/io/FileDescriptor;I)V"), 1642 NATIVE_METHOD(Posix, umaskImpl, "(I)I"), 1643 NATIVE_METHOD(Posix, uname, "()Landroid/system/StructUtsname;"), 1644 NATIVE_METHOD(Posix, unsetenv, "(Ljava/lang/String;)V"), 1645 NATIVE_METHOD(Posix, waitpid, "(ILandroid/util/MutableInt;I)I"), 1646 NATIVE_METHOD(Posix, writeBytes, "(Ljava/io/FileDescriptor;Ljava/lang/Object;II)I"), 1647 NATIVE_METHOD(Posix, writev, "(Ljava/io/FileDescriptor;[Ljava/lang/Object;[I[I)I"), 1648 }; 1649 void register_libcore_io_Posix(JNIEnv* env) { 1650 jniRegisterNativeMethods(env, "libcore/io/Posix", gMethods, NELEM(gMethods)); 1651 } 1652
