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