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