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