libcore_io_Linux.cpp revision 3c3ee8a421312ee7507ba3f07c3e1b1ba50cc4d7
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 "Linux" 18 19#include <arpa/inet.h> 20#include <errno.h> 21#include <fcntl.h> 22#include <ifaddrs.h> 23#include <linux/rtnetlink.h> 24#include <net/if.h> 25#include <netdb.h> 26#include <netinet/in.h> 27#include <netpacket/packet.h> 28#include <poll.h> 29#include <pwd.h> 30#include <signal.h> 31#include <stdlib.h> 32#include <sys/capability.h> 33#include <sys/ioctl.h> 34#include <sys/mman.h> 35#include <sys/prctl.h> 36#include <sys/resource.h> 37#include <sys/socket.h> 38#include <sys/stat.h> 39#include <sys/syscall.h> 40#include <sys/time.h> 41#include <sys/types.h> 42#include <sys/uio.h> 43#include <sys/un.h> 44#include <sys/utsname.h> 45#include <sys/wait.h> 46#include <sys/xattr.h> 47#include <termios.h> 48#include <unistd.h> 49 50#include <memory> 51 52#include <android-base/file.h> 53#include <android-base/strings.h> 54#include <log/log.h> 55#include <nativehelper/AsynchronousCloseMonitor.h> 56#include <nativehelper/JNIHelp.h> 57#include <nativehelper/JniConstants.h> 58#include <nativehelper/ScopedBytes.h> 59#include <nativehelper/ScopedLocalRef.h> 60#include <nativehelper/ScopedPrimitiveArray.h> 61#include <nativehelper/ScopedUtfChars.h> 62#include <nativehelper/toStringArray.h> 63 64#include "ExecStrings.h" 65#include "JniException.h" 66#include "NetworkUtilities.h" 67#include "Portability.h" 68 69#ifndef __unused 70#define __unused __attribute__((__unused__)) 71#endif 72 73#define TO_JAVA_STRING(NAME, EXP) \ 74 jstring NAME = env->NewStringUTF(EXP); \ 75 if ((NAME) == NULL) return NULL; 76 77struct addrinfo_deleter { 78 void operator()(addrinfo* p) const { 79 if (p != NULL) { // bionic's freeaddrinfo(3) crashes when passed NULL. 80 freeaddrinfo(p); 81 } 82 } 83}; 84 85struct c_deleter { 86 void operator()(void* p) const { 87 free(p); 88 } 89}; 90 91static bool isIPv4MappedAddress(const sockaddr *sa) { 92 const sockaddr_in6 *sin6 = reinterpret_cast<const sockaddr_in6*>(sa); 93 return sa != NULL && sa->sa_family == AF_INET6 && 94 (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr) || 95 IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)); // We map 0.0.0.0 to ::, so :: is mapped. 96} 97 98/** 99 * Perform a socket operation that specifies an IP address, possibly falling back from specifying 100 * the address as an IPv4-mapped IPv6 address in a struct sockaddr_in6 to specifying it as an IPv4 101 * address in a struct sockaddr_in. 102 * 103 * This is needed because all sockets created by the java.net APIs are IPv6 sockets, and on those 104 * sockets, IPv4 operations use IPv4-mapped addresses stored in a struct sockaddr_in6. But sockets 105 * created using Linux.socket(AF_INET, ...) are IPv4 sockets and only support operations using IPv4 106 * socket addresses structures. 107 */ 108#define NET_IPV4_FALLBACK(jni_env, return_type, syscall_name, java_fd, java_addr, port, null_addr_ok, args...) ({ \ 109 return_type _rc = -1; \ 110 do { \ 111 sockaddr_storage _ss; \ 112 socklen_t _salen; \ 113 if ((java_addr) == NULL && (null_addr_ok)) { \ 114 /* No IP address specified (e.g., sendto() on a connected socket). */ \ 115 _salen = 0; \ 116 } else if (!inetAddressToSockaddr(jni_env, java_addr, port, _ss, _salen)) { \ 117 /* Invalid socket address, return -1. inetAddressToSockaddr has already thrown. */ \ 118 break; \ 119 } \ 120 sockaddr* _sa = _salen ? reinterpret_cast<sockaddr*>(&_ss) : NULL; \ 121 /* inetAddressToSockaddr always returns an IPv6 sockaddr. Assume that java_fd was created \ 122 * by Java API calls, which always create IPv6 socket fds, and pass it in as is. */ \ 123 _rc = NET_FAILURE_RETRY(jni_env, return_type, syscall_name, java_fd, ##args, _sa, _salen); \ 124 if (_rc == -1 && errno == EAFNOSUPPORT && _salen && isIPv4MappedAddress(_sa)) { \ 125 /* We passed in an IPv4 address in an IPv6 sockaddr and the kernel told us that we got \ 126 * the address family wrong. Pass in the same address in an IPv4 sockaddr. */ \ 127 (jni_env)->ExceptionClear(); \ 128 if (!inetAddressToSockaddrVerbatim(jni_env, java_addr, port, _ss, _salen)) { \ 129 break; \ 130 } \ 131 _sa = reinterpret_cast<sockaddr*>(&_ss); \ 132 _rc = NET_FAILURE_RETRY(jni_env, return_type, syscall_name, java_fd, ##args, _sa, _salen); \ 133 } \ 134 } while (0); \ 135 _rc; }) \ 136 137/** 138 * Used to retry networking system calls that can be interrupted with a signal. Unlike 139 * TEMP_FAILURE_RETRY, this also handles the case where 140 * AsynchronousCloseMonitor::signalBlockedThreads(fd) is used to signal a close() or 141 * Thread.interrupt(). Other signals that result in an EINTR result are ignored and the system call 142 * is retried. 143 * 144 * Returns the result of the system call though a Java exception will be pending if the result is 145 * -1: a SocketException if signaled via AsynchronousCloseMonitor, or ErrnoException for other 146 * failures. 147 */ 148#define NET_FAILURE_RETRY(jni_env, return_type, syscall_name, java_fd, ...) ({ \ 149 return_type _rc = -1; \ 150 int _syscallErrno; \ 151 do { \ 152 bool _wasSignaled; \ 153 { \ 154 int _fd = jniGetFDFromFileDescriptor(jni_env, java_fd); \ 155 AsynchronousCloseMonitor _monitor(_fd); \ 156 _rc = syscall_name(_fd, __VA_ARGS__); \ 157 _syscallErrno = errno; \ 158 _wasSignaled = _monitor.wasSignaled(); \ 159 } \ 160 if (_wasSignaled) { \ 161 jniThrowException(jni_env, "java/net/SocketException", "Socket closed"); \ 162 _rc = -1; \ 163 break; \ 164 } \ 165 if (_rc == -1 && _syscallErrno != EINTR) { \ 166 /* TODO: with a format string we could show the arguments too, like strace(1). */ \ 167 throwErrnoException(jni_env, # syscall_name); \ 168 break; \ 169 } \ 170 } while (_rc == -1); /* _syscallErrno == EINTR && !_wasSignaled */ \ 171 if (_rc == -1) { \ 172 /* If the syscall failed, re-set errno: throwing an exception might have modified it. */ \ 173 errno = _syscallErrno; \ 174 } \ 175 _rc; }) 176 177/** 178 * Used to retry system calls that can be interrupted with a signal. Unlike TEMP_FAILURE_RETRY, this 179 * also handles the case where AsynchronousCloseMonitor::signalBlockedThreads(fd) is used to signal 180 * a close() or Thread.interrupt(). Other signals that result in an EINTR result are ignored and the 181 * system call is retried. 182 * 183 * Returns the result of the system call though a Java exception will be pending if the result is 184 * -1: an IOException if the file descriptor is already closed, a InterruptedIOException if signaled 185 * via AsynchronousCloseMonitor, or ErrnoException for other failures. 186 */ 187#define IO_FAILURE_RETRY(jni_env, return_type, syscall_name, java_fd, ...) ({ \ 188 return_type _rc = -1; \ 189 int _syscallErrno; \ 190 do { \ 191 bool _wasSignaled; \ 192 { \ 193 int _fd = jniGetFDFromFileDescriptor(jni_env, java_fd); \ 194 AsynchronousCloseMonitor _monitor(_fd); \ 195 _rc = syscall_name(_fd, __VA_ARGS__); \ 196 _syscallErrno = errno; \ 197 _wasSignaled = _monitor.wasSignaled(); \ 198 } \ 199 if (_wasSignaled) { \ 200 jniThrowException(jni_env, "java/io/InterruptedIOException", # syscall_name " interrupted"); \ 201 _rc = -1; \ 202 break; \ 203 } \ 204 if (_rc == -1 && _syscallErrno != EINTR) { \ 205 /* TODO: with a format string we could show the arguments too, like strace(1). */ \ 206 throwErrnoException(jni_env, # syscall_name); \ 207 break; \ 208 } \ 209 } while (_rc == -1); /* && _syscallErrno == EINTR && !_wasSignaled */ \ 210 if (_rc == -1) { \ 211 /* If the syscall failed, re-set errno: throwing an exception might have modified it. */ \ 212 errno = _syscallErrno; \ 213 } \ 214 _rc; }) 215 216#define NULL_ADDR_OK true 217#define NULL_ADDR_FORBIDDEN false 218 219static void throwException(JNIEnv* env, jclass exceptionClass, jmethodID ctor3, jmethodID ctor2, 220 const char* functionName, int error) { 221 jthrowable cause = NULL; 222 if (env->ExceptionCheck()) { 223 cause = env->ExceptionOccurred(); 224 env->ExceptionClear(); 225 } 226 227 ScopedLocalRef<jstring> detailMessage(env, env->NewStringUTF(functionName)); 228 if (detailMessage.get() == NULL) { 229 // Not really much we can do here. We're probably dead in the water, 230 // but let's try to stumble on... 231 env->ExceptionClear(); 232 } 233 234 jobject exception; 235 if (cause != NULL) { 236 exception = env->NewObject(exceptionClass, ctor3, detailMessage.get(), error, cause); 237 } else { 238 exception = env->NewObject(exceptionClass, ctor2, detailMessage.get(), error); 239 } 240 env->Throw(reinterpret_cast<jthrowable>(exception)); 241} 242 243static void throwErrnoException(JNIEnv* env, const char* functionName) { 244 int error = errno; 245 static jmethodID ctor3 = env->GetMethodID(JniConstants::errnoExceptionClass, 246 "<init>", "(Ljava/lang/String;ILjava/lang/Throwable;)V"); 247 static jmethodID ctor2 = env->GetMethodID(JniConstants::errnoExceptionClass, 248 "<init>", "(Ljava/lang/String;I)V"); 249 throwException(env, JniConstants::errnoExceptionClass, ctor3, ctor2, functionName, error); 250} 251 252static void throwGaiException(JNIEnv* env, const char* functionName, int error) { 253 // Cache the methods ids before we throw, so we don't call GetMethodID with a pending exception. 254 static jmethodID ctor3 = env->GetMethodID(JniConstants::gaiExceptionClass, "<init>", 255 "(Ljava/lang/String;ILjava/lang/Throwable;)V"); 256 static jmethodID ctor2 = env->GetMethodID(JniConstants::gaiExceptionClass, "<init>", 257 "(Ljava/lang/String;I)V"); 258 if (errno != 0) { 259 // EAI_SYSTEM should mean "look at errno instead", but both glibc and bionic seem to 260 // mess this up. In particular, if you don't have INTERNET permission, errno will be EACCES 261 // but you'll get EAI_NONAME or EAI_NODATA. So we want our GaiException to have a 262 // potentially-relevant ErrnoException as its cause even if error != EAI_SYSTEM. 263 // http://code.google.com/p/android/issues/detail?id=15722 264 throwErrnoException(env, functionName); 265 // Deliberately fall through to throw another exception... 266 } 267 throwException(env, JniConstants::gaiExceptionClass, ctor3, ctor2, functionName, error); 268} 269 270template <typename rc_t> 271static rc_t throwIfMinusOne(JNIEnv* env, const char* name, rc_t rc) { 272 if (rc == rc_t(-1)) { 273 throwErrnoException(env, name); 274 } 275 return rc; 276} 277 278template <typename ScopedT> 279class IoVec { 280public: 281 IoVec(JNIEnv* env, size_t bufferCount) : mEnv(env), mBufferCount(bufferCount) { 282 } 283 284 bool init(jobjectArray javaBuffers, jintArray javaOffsets, jintArray javaByteCounts) { 285 // We can't delete our local references until after the I/O, so make sure we have room. 286 if (mEnv->PushLocalFrame(mBufferCount + 16) < 0) { 287 return false; 288 } 289 ScopedIntArrayRO offsets(mEnv, javaOffsets); 290 if (offsets.get() == NULL) { 291 return false; 292 } 293 ScopedIntArrayRO byteCounts(mEnv, javaByteCounts); 294 if (byteCounts.get() == NULL) { 295 return false; 296 } 297 // TODO: Linux actually has a 1024 buffer limit. glibc works around this, and we should too. 298 // TODO: you can query the limit at runtime with sysconf(_SC_IOV_MAX). 299 for (size_t i = 0; i < mBufferCount; ++i) { 300 jobject buffer = mEnv->GetObjectArrayElement(javaBuffers, i); // We keep this local ref. 301 mScopedBuffers.push_back(new ScopedT(mEnv, buffer)); 302 jbyte* ptr = const_cast<jbyte*>(mScopedBuffers.back()->get()); 303 if (ptr == NULL) { 304 return false; 305 } 306 struct iovec iov; 307 iov.iov_base = reinterpret_cast<void*>(ptr + offsets[i]); 308 iov.iov_len = byteCounts[i]; 309 mIoVec.push_back(iov); 310 } 311 return true; 312 } 313 314 ~IoVec() { 315 for (size_t i = 0; i < mScopedBuffers.size(); ++i) { 316 delete mScopedBuffers[i]; 317 } 318 mEnv->PopLocalFrame(NULL); 319 } 320 321 iovec* get() { 322 return &mIoVec[0]; 323 } 324 325 size_t size() { 326 return mBufferCount; 327 } 328 329private: 330 JNIEnv* mEnv; 331 size_t mBufferCount; 332 std::vector<iovec> mIoVec; 333 std::vector<ScopedT*> mScopedBuffers; 334}; 335 336/** 337 * Returns a jbyteArray containing the sockaddr_un.sun_path from ss. As per unix(7) sa_len should be 338 * the length of ss as returned by getsockname(2), getpeername(2), or accept(2). 339 * If the returned array is of length 0 the sockaddr_un refers to an unnamed socket. 340 * A null pointer is returned in the event of an error. See unix(7) for more information. 341 */ 342static jbyteArray getUnixSocketPath(JNIEnv* env, const sockaddr_storage& ss, 343 const socklen_t& sa_len) { 344 if (ss.ss_family != AF_UNIX) { 345 jniThrowExceptionFmt(env, "java/lang/IllegalArgumentException", 346 "getUnixSocketPath unsupported ss_family: %i", ss.ss_family); 347 return NULL; 348 } 349 350 const struct sockaddr_un* un_addr = reinterpret_cast<const struct sockaddr_un*>(&ss); 351 // The length of sun_path is sa_len minus the length of the overhead (ss_family). 352 // See unix(7) for details. This calculation must match that of socket_make_sockaddr_un() in 353 // socket_local_client.c and javaUnixSocketAddressToSockaddr() to interoperate. 354 size_t pathLength = sa_len - offsetof(struct sockaddr_un, sun_path); 355 356 jbyteArray javaSunPath = env->NewByteArray(pathLength); 357 if (javaSunPath == NULL) { 358 return NULL; 359 } 360 361 if (pathLength > 0) { 362 env->SetByteArrayRegion(javaSunPath, 0, pathLength, 363 reinterpret_cast<const jbyte*>(&un_addr->sun_path)); 364 } 365 return javaSunPath; 366} 367 368static jobject makeSocketAddress(JNIEnv* env, const sockaddr_storage& ss, const socklen_t sa_len) { 369 if (ss.ss_family == AF_INET || ss.ss_family == AF_INET6) { 370 jint port; 371 jobject inetAddress = sockaddrToInetAddress(env, ss, &port); 372 if (inetAddress == NULL) { 373 return NULL; // Exception already thrown. 374 } 375 static jmethodID ctor = env->GetMethodID(JniConstants::inetSocketAddressClass, 376 "<init>", "(Ljava/net/InetAddress;I)V"); 377 return env->NewObject(JniConstants::inetSocketAddressClass, ctor, inetAddress, port); 378 } else if (ss.ss_family == AF_UNIX) { 379 static jmethodID ctor = env->GetMethodID(JniConstants::unixSocketAddressClass, 380 "<init>", "([B)V"); 381 382 jbyteArray javaSunPath = getUnixSocketPath(env, ss, sa_len); 383 if (!javaSunPath) { 384 return NULL; 385 } 386 return env->NewObject(JniConstants::unixSocketAddressClass, ctor, javaSunPath); 387 } else if (ss.ss_family == AF_NETLINK) { 388 const struct sockaddr_nl* nl_addr = reinterpret_cast<const struct sockaddr_nl*>(&ss); 389 static jmethodID ctor = env->GetMethodID(JniConstants::netlinkSocketAddressClass, 390 "<init>", "(II)V"); 391 return env->NewObject(JniConstants::netlinkSocketAddressClass, ctor, 392 static_cast<jint>(nl_addr->nl_pid), 393 static_cast<jint>(nl_addr->nl_groups)); 394 } else if (ss.ss_family == AF_PACKET) { 395 const struct sockaddr_ll* sll = reinterpret_cast<const struct sockaddr_ll*>(&ss); 396 static jmethodID ctor = env->GetMethodID(JniConstants::packetSocketAddressClass, 397 "<init>", "(SISB[B)V"); 398 ScopedLocalRef<jbyteArray> byteArray(env, env->NewByteArray(sll->sll_halen)); 399 if (byteArray.get() == NULL) { 400 return NULL; 401 } 402 env->SetByteArrayRegion(byteArray.get(), 0, sll->sll_halen, 403 reinterpret_cast<const jbyte*>(sll->sll_addr)); 404 jobject packetSocketAddress = env->NewObject(JniConstants::packetSocketAddressClass, ctor, 405 static_cast<jshort>(ntohs(sll->sll_protocol)), 406 static_cast<jint>(sll->sll_ifindex), 407 static_cast<jshort>(sll->sll_hatype), 408 static_cast<jbyte>(sll->sll_pkttype), 409 byteArray.get()); 410 return packetSocketAddress; 411 } 412 jniThrowExceptionFmt(env, "java/lang/IllegalArgumentException", "unsupported ss_family: %d", 413 ss.ss_family); 414 return NULL; 415} 416 417static jobject makeStructPasswd(JNIEnv* env, const struct passwd& pw) { 418 TO_JAVA_STRING(pw_name, pw.pw_name); 419 TO_JAVA_STRING(pw_dir, pw.pw_dir); 420 TO_JAVA_STRING(pw_shell, pw.pw_shell); 421 static jmethodID ctor = env->GetMethodID(JniConstants::structPasswdClass, "<init>", 422 "(Ljava/lang/String;IILjava/lang/String;Ljava/lang/String;)V"); 423 return env->NewObject(JniConstants::structPasswdClass, ctor, 424 pw_name, static_cast<jint>(pw.pw_uid), static_cast<jint>(pw.pw_gid), pw_dir, pw_shell); 425} 426 427static jobject makeStructTimespec(JNIEnv* env, const struct timespec& ts) { 428 static jmethodID ctor = env->GetMethodID(JniConstants::structTimespecClass, "<init>", 429 "(JJ)V"); 430 return env->NewObject(JniConstants::structTimespecClass, ctor, 431 static_cast<jlong>(ts.tv_sec), static_cast<jlong>(ts.tv_nsec)); 432} 433 434static jobject makeStructStat(JNIEnv* env, const struct stat64& sb) { 435 static jmethodID ctor = env->GetMethodID(JniConstants::structStatClass, "<init>", 436 "(JJIJIIJJLandroid/system/StructTimespec;Landroid/system/StructTimespec;Landroid/system/StructTimespec;JJ)V"); 437 return env->NewObject(JniConstants::structStatClass, ctor, 438 static_cast<jlong>(sb.st_dev), static_cast<jlong>(sb.st_ino), 439 static_cast<jint>(sb.st_mode), static_cast<jlong>(sb.st_nlink), 440 static_cast<jint>(sb.st_uid), static_cast<jint>(sb.st_gid), 441 static_cast<jlong>(sb.st_rdev), static_cast<jlong>(sb.st_size), 442 makeStructTimespec(env, sb.st_atim), makeStructTimespec(env, sb.st_mtim), 443 makeStructTimespec(env, sb.st_ctim), static_cast<jlong>(sb.st_blksize), 444 static_cast<jlong>(sb.st_blocks)); 445} 446 447static jobject makeStructStatVfs(JNIEnv* env, const struct statvfs& sb) { 448 static jmethodID ctor = env->GetMethodID(JniConstants::structStatVfsClass, "<init>", 449 "(JJJJJJJJJJJ)V"); 450 return env->NewObject(JniConstants::structStatVfsClass, ctor, 451 static_cast<jlong>(sb.f_bsize), 452 static_cast<jlong>(sb.f_frsize), 453 static_cast<jlong>(sb.f_blocks), 454 static_cast<jlong>(sb.f_bfree), 455 static_cast<jlong>(sb.f_bavail), 456 static_cast<jlong>(sb.f_files), 457 static_cast<jlong>(sb.f_ffree), 458 static_cast<jlong>(sb.f_favail), 459 static_cast<jlong>(sb.f_fsid), 460 static_cast<jlong>(sb.f_flag), 461 static_cast<jlong>(sb.f_namemax)); 462} 463 464static jobject makeStructLinger(JNIEnv* env, const struct linger& l) { 465 static jmethodID ctor = env->GetMethodID(JniConstants::structLingerClass, "<init>", "(II)V"); 466 return env->NewObject(JniConstants::structLingerClass, ctor, l.l_onoff, l.l_linger); 467} 468 469static jobject makeStructTimeval(JNIEnv* env, const struct timeval& tv) { 470 static jmethodID ctor = env->GetMethodID(JniConstants::structTimevalClass, "<init>", "(JJ)V"); 471 return env->NewObject(JniConstants::structTimevalClass, ctor, 472 static_cast<jlong>(tv.tv_sec), static_cast<jlong>(tv.tv_usec)); 473} 474 475static jobject makeStructUcred(JNIEnv* env, const struct ucred& u __unused) { 476 static jmethodID ctor = env->GetMethodID(JniConstants::structUcredClass, "<init>", "(III)V"); 477 return env->NewObject(JniConstants::structUcredClass, ctor, u.pid, u.uid, u.gid); 478} 479 480static jobject makeStructUtsname(JNIEnv* env, const struct utsname& buf) { 481 TO_JAVA_STRING(sysname, buf.sysname); 482 TO_JAVA_STRING(nodename, buf.nodename); 483 TO_JAVA_STRING(release, buf.release); 484 TO_JAVA_STRING(version, buf.version); 485 TO_JAVA_STRING(machine, buf.machine); 486 static jmethodID ctor = env->GetMethodID(JniConstants::structUtsnameClass, "<init>", 487 "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V"); 488 return env->NewObject(JniConstants::structUtsnameClass, ctor, 489 sysname, nodename, release, version, machine); 490}; 491 492static bool fillIfreq(JNIEnv* env, jstring javaInterfaceName, struct ifreq& req) { 493 ScopedUtfChars interfaceName(env, javaInterfaceName); 494 if (interfaceName.c_str() == NULL) { 495 return false; 496 } 497 memset(&req, 0, sizeof(req)); 498 strncpy(req.ifr_name, interfaceName.c_str(), sizeof(req.ifr_name)); 499 req.ifr_name[sizeof(req.ifr_name) - 1] = '\0'; 500 return true; 501} 502 503static bool fillUnixSocketAddress(JNIEnv* env, jobject javaUnixSocketAddress, 504 const sockaddr_storage& ss, const socklen_t& sa_len) { 505 if (javaUnixSocketAddress == NULL) { 506 return true; 507 } 508 jbyteArray javaSunPath = getUnixSocketPath(env, ss, sa_len); 509 if (!javaSunPath) { 510 return false; 511 } 512 513 static jfieldID sunPathFid = 514 env->GetFieldID(JniConstants::unixSocketAddressClass, "sun_path", "[B"); 515 env->SetObjectField(javaUnixSocketAddress, sunPathFid, javaSunPath); 516 return true; 517} 518 519static bool fillInetSocketAddress(JNIEnv* env, jobject javaInetSocketAddress, 520 const sockaddr_storage& ss) { 521 if (javaInetSocketAddress == NULL) { 522 return true; 523 } 524 // Fill out the passed-in InetSocketAddress with the sender's IP address and port number. 525 jint port; 526 jobject sender = sockaddrToInetAddress(env, ss, &port); 527 if (sender == NULL) { 528 return false; 529 } 530 static jfieldID holderFid = env->GetFieldID(JniConstants::inetSocketAddressClass, "holder", 531 "Ljava/net/InetSocketAddress$InetSocketAddressHolder;"); 532 jobject holder = env->GetObjectField(javaInetSocketAddress, holderFid); 533 534 static jfieldID addressFid = env->GetFieldID(JniConstants::inetSocketAddressHolderClass, 535 "addr", "Ljava/net/InetAddress;"); 536 static jfieldID portFid = env->GetFieldID(JniConstants::inetSocketAddressHolderClass, "port", "I"); 537 env->SetObjectField(holder, addressFid, sender); 538 env->SetIntField(holder, portFid, port); 539 return true; 540} 541 542static bool fillSocketAddress(JNIEnv* env, jobject javaSocketAddress, const sockaddr_storage& ss, 543 const socklen_t& sa_len) { 544 if (javaSocketAddress == NULL) { 545 return true; 546 } 547 548 if (env->IsInstanceOf(javaSocketAddress, JniConstants::inetSocketAddressClass)) { 549 return fillInetSocketAddress(env, javaSocketAddress, ss); 550 } else if (env->IsInstanceOf(javaSocketAddress, JniConstants::unixSocketAddressClass)) { 551 return fillUnixSocketAddress(env, javaSocketAddress, ss, sa_len); 552 } 553 jniThrowException(env, "java/lang/UnsupportedOperationException", 554 "unsupported SocketAddress subclass"); 555 return false; 556 557} 558 559static void javaInetSocketAddressToInetAddressAndPort( 560 JNIEnv* env, jobject javaInetSocketAddress, jobject& javaInetAddress, jint& port) { 561 static jfieldID holderFid = env->GetFieldID(JniConstants::inetSocketAddressClass, "holder", 562 "Ljava/net/InetSocketAddress$InetSocketAddressHolder;"); 563 jobject holder = env->GetObjectField(javaInetSocketAddress, holderFid); 564 565 static jfieldID addressFid = env->GetFieldID( 566 JniConstants::inetSocketAddressHolderClass, "addr", "Ljava/net/InetAddress;"); 567 static jfieldID portFid = env->GetFieldID(JniConstants::inetSocketAddressHolderClass, "port", "I"); 568 569 javaInetAddress = env->GetObjectField(holder, addressFid); 570 port = env->GetIntField(holder, portFid); 571} 572 573static bool javaInetSocketAddressToSockaddr( 574 JNIEnv* env, jobject javaSocketAddress, sockaddr_storage& ss, socklen_t& sa_len) { 575 jobject javaInetAddress; 576 jint port; 577 javaInetSocketAddressToInetAddressAndPort(env, javaSocketAddress, javaInetAddress, port); 578 return inetAddressToSockaddr(env, javaInetAddress, port, ss, sa_len); 579} 580 581static bool javaNetlinkSocketAddressToSockaddr( 582 JNIEnv* env, jobject javaSocketAddress, sockaddr_storage& ss, socklen_t& sa_len) { 583 static jfieldID nlPidFid = env->GetFieldID( 584 JniConstants::netlinkSocketAddressClass, "nlPortId", "I"); 585 static jfieldID nlGroupsFid = env->GetFieldID( 586 JniConstants::netlinkSocketAddressClass, "nlGroupsMask", "I"); 587 588 sockaddr_nl *nlAddr = reinterpret_cast<sockaddr_nl *>(&ss); 589 nlAddr->nl_family = AF_NETLINK; 590 nlAddr->nl_pid = env->GetIntField(javaSocketAddress, nlPidFid); 591 nlAddr->nl_groups = env->GetIntField(javaSocketAddress, nlGroupsFid); 592 sa_len = sizeof(sockaddr_nl); 593 return true; 594} 595 596static bool javaUnixSocketAddressToSockaddr( 597 JNIEnv* env, jobject javaUnixSocketAddress, sockaddr_storage& ss, socklen_t& sa_len) { 598 static jfieldID sunPathFid = env->GetFieldID( 599 JniConstants::unixSocketAddressClass, "sun_path", "[B"); 600 601 struct sockaddr_un* un_addr = reinterpret_cast<struct sockaddr_un*>(&ss); 602 memset (un_addr, 0, sizeof(sockaddr_un)); 603 un_addr->sun_family = AF_UNIX; 604 605 jbyteArray javaSunPath = (jbyteArray) env->GetObjectField(javaUnixSocketAddress, sunPathFid); 606 jsize pathLength = env->GetArrayLength(javaSunPath); 607 if ((size_t) pathLength > sizeof(sockaddr_un::sun_path)) { 608 jniThrowExceptionFmt(env, "java/lang/IllegalArgumentException", 609 "sun_path too long: max=%i, is=%i", 610 sizeof(sockaddr_un::sun_path), pathLength); 611 return false; 612 } 613 env->GetByteArrayRegion(javaSunPath, 0, pathLength, (jbyte*) un_addr->sun_path); 614 // sa_len is sun_path plus the length of the overhead (ss_family_t). See unix(7) for 615 // details. This calculation must match that of socket_make_sockaddr_un() in 616 // socket_local_client.c and getUnixSocketPath() to interoperate. 617 sa_len = offsetof(struct sockaddr_un, sun_path) + pathLength; 618 return true; 619} 620 621static bool javaPacketSocketAddressToSockaddr( 622 JNIEnv* env, jobject javaSocketAddress, sockaddr_storage& ss, socklen_t& sa_len) { 623 static jfieldID protocolFid = env->GetFieldID( 624 JniConstants::packetSocketAddressClass, "sll_protocol", "S"); 625 static jfieldID ifindexFid = env->GetFieldID( 626 JniConstants::packetSocketAddressClass, "sll_ifindex", "I"); 627 static jfieldID hatypeFid = env->GetFieldID( 628 JniConstants::packetSocketAddressClass, "sll_hatype", "S"); 629 static jfieldID pkttypeFid = env->GetFieldID( 630 JniConstants::packetSocketAddressClass, "sll_pkttype", "B"); 631 static jfieldID addrFid = env->GetFieldID( 632 JniConstants::packetSocketAddressClass, "sll_addr", "[B"); 633 634 sockaddr_ll *sll = reinterpret_cast<sockaddr_ll *>(&ss); 635 sll->sll_family = AF_PACKET; 636 sll->sll_protocol = htons(env->GetShortField(javaSocketAddress, protocolFid)); 637 sll->sll_ifindex = env->GetIntField(javaSocketAddress, ifindexFid); 638 sll->sll_hatype = env->GetShortField(javaSocketAddress, hatypeFid); 639 sll->sll_pkttype = env->GetByteField(javaSocketAddress, pkttypeFid); 640 641 jbyteArray sllAddr = (jbyteArray) env->GetObjectField(javaSocketAddress, addrFid); 642 if (sllAddr == NULL) { 643 sll->sll_halen = 0; 644 memset(&sll->sll_addr, 0, sizeof(sll->sll_addr)); 645 } else { 646 jsize len = env->GetArrayLength(sllAddr); 647 if ((size_t) len > sizeof(sll->sll_addr)) { 648 len = sizeof(sll->sll_addr); 649 } 650 sll->sll_halen = len; 651 env->GetByteArrayRegion(sllAddr, 0, len, (jbyte*) sll->sll_addr); 652 } 653 sa_len = sizeof(sockaddr_ll); 654 return true; 655} 656 657static bool javaSocketAddressToSockaddr( 658 JNIEnv* env, jobject javaSocketAddress, sockaddr_storage& ss, socklen_t& sa_len) { 659 if (javaSocketAddress == NULL) { 660 jniThrowNullPointerException(env, NULL); 661 return false; 662 } 663 664 if (env->IsInstanceOf(javaSocketAddress, JniConstants::netlinkSocketAddressClass)) { 665 return javaNetlinkSocketAddressToSockaddr(env, javaSocketAddress, ss, sa_len); 666 } else if (env->IsInstanceOf(javaSocketAddress, JniConstants::inetSocketAddressClass)) { 667 return javaInetSocketAddressToSockaddr(env, javaSocketAddress, ss, sa_len); 668 } else if (env->IsInstanceOf(javaSocketAddress, JniConstants::packetSocketAddressClass)) { 669 return javaPacketSocketAddressToSockaddr(env, javaSocketAddress, ss, sa_len); 670 } else if (env->IsInstanceOf(javaSocketAddress, JniConstants::unixSocketAddressClass)) { 671 return javaUnixSocketAddressToSockaddr(env, javaSocketAddress, ss, sa_len); 672 } 673 jniThrowException(env, "java/lang/UnsupportedOperationException", 674 "unsupported SocketAddress subclass"); 675 return false; 676} 677 678static jobject doStat(JNIEnv* env, jstring javaPath, bool isLstat) { 679 ScopedUtfChars path(env, javaPath); 680 if (path.c_str() == NULL) { 681 return NULL; 682 } 683 struct stat64 sb; 684 int rc = isLstat ? TEMP_FAILURE_RETRY(lstat64(path.c_str(), &sb)) 685 : TEMP_FAILURE_RETRY(stat64(path.c_str(), &sb)); 686 if (rc == -1) { 687 throwErrnoException(env, isLstat ? "lstat" : "stat"); 688 return NULL; 689 } 690 return makeStructStat(env, sb); 691} 692 693static jobject doGetSockName(JNIEnv* env, jobject javaFd, bool is_sockname) { 694 int fd = jniGetFDFromFileDescriptor(env, javaFd); 695 sockaddr_storage ss; 696 sockaddr* sa = reinterpret_cast<sockaddr*>(&ss); 697 socklen_t byteCount = sizeof(ss); 698 memset(&ss, 0, byteCount); 699 int rc = is_sockname ? TEMP_FAILURE_RETRY(getsockname(fd, sa, &byteCount)) 700 : TEMP_FAILURE_RETRY(getpeername(fd, sa, &byteCount)); 701 if (rc == -1) { 702 throwErrnoException(env, is_sockname ? "getsockname" : "getpeername"); 703 return NULL; 704 } 705 return makeSocketAddress(env, ss, byteCount); 706} 707 708class Passwd { 709public: 710 explicit Passwd(JNIEnv* env) : mEnv(env), mResult(NULL) { 711 mBufferSize = sysconf(_SC_GETPW_R_SIZE_MAX); 712 mBuffer.reset(new char[mBufferSize]); 713 } 714 715 jobject getpwnam(const char* name) { 716 return process("getpwnam_r", getpwnam_r(name, &mPwd, mBuffer.get(), mBufferSize, &mResult)); 717 } 718 719 jobject getpwuid(uid_t uid) { 720 return process("getpwuid_r", getpwuid_r(uid, &mPwd, mBuffer.get(), mBufferSize, &mResult)); 721 } 722 723 struct passwd* get() { 724 return mResult; 725 } 726 727private: 728 jobject process(const char* syscall, int error) { 729 if (mResult == NULL) { 730 errno = error; 731 throwErrnoException(mEnv, syscall); 732 return NULL; 733 } 734 return makeStructPasswd(mEnv, *mResult); 735 } 736 737 JNIEnv* mEnv; 738 std::unique_ptr<char[]> mBuffer; 739 size_t mBufferSize; 740 struct passwd mPwd; 741 struct passwd* mResult; 742}; 743 744static void AssertException(JNIEnv* env) { 745 if (env->ExceptionCheck() == JNI_FALSE) { 746 env->FatalError("Expected exception"); 747 } 748} 749 750// Note for capabilities functions: 751// We assume the calls are rare enough that it does not make sense to cache class objects. The 752// advantage is lower maintenance burden. 753 754static bool ReadStructCapUserHeader( 755 JNIEnv* env, jobject java_header, __user_cap_header_struct* c_header) { 756 if (java_header == nullptr) { 757 jniThrowNullPointerException(env, "header is null"); 758 return false; 759 } 760 761 ScopedLocalRef<jclass> header_class(env, env->FindClass("android/system/StructCapUserHeader")); 762 if (header_class.get() == nullptr) { 763 return false; 764 } 765 766 { 767 static jfieldID version_fid = env->GetFieldID(header_class.get(), "version", "I"); 768 if (version_fid == nullptr) { 769 return false; 770 } 771 c_header->version = env->GetIntField(java_header, version_fid); 772 } 773 774 { 775 static jfieldID pid_fid = env->GetFieldID(header_class.get(), "pid", "I"); 776 if (pid_fid == nullptr) { 777 return false; 778 } 779 c_header->pid = env->GetIntField(java_header, pid_fid); 780 } 781 782 return true; 783} 784 785static void SetStructCapUserHeaderVersion( 786 JNIEnv* env, jobject java_header, __user_cap_header_struct* c_header) { 787 ScopedLocalRef<jclass> header_class(env, env->FindClass("android/system/StructCapUserHeader")); 788 if (header_class.get() == nullptr) { 789 env->ExceptionClear(); 790 return; 791 } 792 793 static jfieldID version_fid = env->GetFieldID(header_class.get(), "version", "I"); 794 if (version_fid == nullptr) { 795 env->ExceptionClear(); 796 return; 797 } 798 env->SetIntField(java_header, version_fid, c_header->version); 799} 800 801static jobject CreateStructCapUserData( 802 JNIEnv* env, jclass data_class, __user_cap_data_struct* c_data) { 803 if (c_data == nullptr) { 804 // Should not happen. 805 jniThrowNullPointerException(env, "data is null"); 806 return nullptr; 807 } 808 809 static jmethodID data_cons = env->GetMethodID(data_class, "<init>", "(III)V"); 810 if (data_cons == nullptr) { 811 return nullptr; 812 } 813 814 jint e = static_cast<jint>(c_data->effective); 815 jint p = static_cast<jint>(c_data->permitted); 816 jint i = static_cast<jint>(c_data->inheritable); 817 return env->NewObject(data_class, data_cons, e, p, i); 818} 819 820static bool ReadStructCapUserData(JNIEnv* env, jobject java_data, __user_cap_data_struct* c_data) { 821 if (java_data == nullptr) { 822 jniThrowNullPointerException(env, "data is null"); 823 return false; 824 } 825 826 ScopedLocalRef<jclass> data_class(env, env->FindClass("android/system/StructCapUserData")); 827 if (data_class.get() == nullptr) { 828 return false; 829 } 830 831 { 832 static jfieldID effective_fid = env->GetFieldID(data_class.get(), "effective", "I"); 833 if (effective_fid == nullptr) { 834 return false; 835 } 836 c_data->effective = env->GetIntField(java_data, effective_fid); 837 } 838 839 { 840 static jfieldID permitted_fid = env->GetFieldID(data_class.get(), "permitted", "I"); 841 if (permitted_fid == nullptr) { 842 return false; 843 } 844 c_data->permitted = env->GetIntField(java_data, permitted_fid); 845 } 846 847 848 { 849 static jfieldID inheritable_fid = env->GetFieldID(data_class.get(), "inheritable", "I"); 850 if (inheritable_fid == nullptr) { 851 return false; 852 } 853 c_data->inheritable = env->GetIntField(java_data, inheritable_fid); 854 } 855 856 return true; 857} 858 859static constexpr size_t kMaxCapUserDataLength = 2U; 860#ifdef _LINUX_CAPABILITY_VERSION_1 861static_assert(kMaxCapUserDataLength >= _LINUX_CAPABILITY_U32S_1, "Length too small."); 862#endif 863#ifdef _LINUX_CAPABILITY_VERSION_2 864static_assert(kMaxCapUserDataLength >= _LINUX_CAPABILITY_U32S_2, "Length too small."); 865#endif 866#ifdef _LINUX_CAPABILITY_VERSION_3 867static_assert(kMaxCapUserDataLength >= _LINUX_CAPABILITY_U32S_3, "Length too small."); 868#endif 869#ifdef _LINUX_CAPABILITY_VERSION_4 870static_assert(false, "Unsupported capability version, please update."); 871#endif 872 873static size_t GetCapUserDataLength(uint32_t version) { 874#ifdef _LINUX_CAPABILITY_VERSION_1 875 if (version == _LINUX_CAPABILITY_VERSION_1) { 876 return _LINUX_CAPABILITY_U32S_1; 877 } 878#endif 879#ifdef _LINUX_CAPABILITY_VERSION_2 880 if (version == _LINUX_CAPABILITY_VERSION_2) { 881 return _LINUX_CAPABILITY_U32S_2; 882 } 883#endif 884#ifdef _LINUX_CAPABILITY_VERSION_3 885 if (version == _LINUX_CAPABILITY_VERSION_3) { 886 return _LINUX_CAPABILITY_U32S_3; 887 } 888#endif 889 return 0; 890} 891 892static jobject Linux_accept(JNIEnv* env, jobject, jobject javaFd, jobject javaSocketAddress) { 893 sockaddr_storage ss; 894 socklen_t sl = sizeof(ss); 895 memset(&ss, 0, sizeof(ss)); 896 sockaddr* peer = (javaSocketAddress != NULL) ? reinterpret_cast<sockaddr*>(&ss) : NULL; 897 socklen_t* peerLength = (javaSocketAddress != NULL) ? &sl : 0; 898 jint clientFd = NET_FAILURE_RETRY(env, int, accept, javaFd, peer, peerLength); 899 if (clientFd == -1 || !fillSocketAddress(env, javaSocketAddress, ss, *peerLength)) { 900 close(clientFd); 901 return NULL; 902 } 903 return (clientFd != -1) ? jniCreateFileDescriptor(env, clientFd) : NULL; 904} 905 906static jboolean Linux_access(JNIEnv* env, jobject, jstring javaPath, jint mode) { 907 ScopedUtfChars path(env, javaPath); 908 if (path.c_str() == NULL) { 909 return JNI_FALSE; 910 } 911 int rc = TEMP_FAILURE_RETRY(access(path.c_str(), mode)); 912 if (rc == -1) { 913 throwErrnoException(env, "access"); 914 } 915 return (rc == 0); 916} 917 918static void Linux_bind(JNIEnv* env, jobject, jobject javaFd, jobject javaAddress, jint port) { 919 // We don't need the return value because we'll already have thrown. 920 (void) NET_IPV4_FALLBACK(env, int, bind, javaFd, javaAddress, port, NULL_ADDR_FORBIDDEN); 921} 922 923static void Linux_bindSocketAddress( 924 JNIEnv* env, jobject, jobject javaFd, jobject javaSocketAddress) { 925 sockaddr_storage ss; 926 socklen_t sa_len; 927 if (!javaSocketAddressToSockaddr(env, javaSocketAddress, ss, sa_len)) { 928 return; // Exception already thrown. 929 } 930 931 const sockaddr* sa = reinterpret_cast<const sockaddr*>(&ss); 932 // We don't need the return value because we'll already have thrown. 933 (void) NET_FAILURE_RETRY(env, int, bind, javaFd, sa, sa_len); 934} 935 936static jobjectArray Linux_capget(JNIEnv* env, jobject, jobject header) { 937 // Convert Java header struct to kernel datastructure. 938 __user_cap_header_struct cap_header; 939 if (!ReadStructCapUserHeader(env, header, &cap_header)) { 940 AssertException(env); 941 return nullptr; 942 } 943 944 // Call capget. 945 __user_cap_data_struct cap_data[kMaxCapUserDataLength]; 946 if (capget(&cap_header, &cap_data[0]) == -1) { 947 // Check for EINVAL. In that case, mutate the header. 948 if (errno == EINVAL) { 949 int saved_errno = errno; 950 SetStructCapUserHeaderVersion(env, header, &cap_header); 951 errno = saved_errno; 952 } 953 throwErrnoException(env, "capget"); 954 return nullptr; 955 } 956 957 // Create the result array. 958 ScopedLocalRef<jclass> data_class(env, env->FindClass("android/system/StructCapUserData")); 959 if (data_class.get() == nullptr) { 960 return nullptr; 961 } 962 size_t result_size = GetCapUserDataLength(cap_header.version); 963 ScopedLocalRef<jobjectArray> result( 964 env, env->NewObjectArray(result_size, data_class.get(), nullptr)); 965 if (result.get() == nullptr) { 966 return nullptr; 967 } 968 // Translate the values we got. 969 for (size_t i = 0; i < result_size; ++i) { 970 ScopedLocalRef<jobject> value( 971 env, CreateStructCapUserData(env, data_class.get(), &cap_data[i])); 972 if (value.get() == nullptr) { 973 AssertException(env); 974 return nullptr; 975 } 976 env->SetObjectArrayElement(result.get(), i, value.get()); 977 } 978 return result.release(); 979} 980 981static void Linux_capset( 982 JNIEnv* env, jobject, jobject header, jobjectArray data) { 983 // Convert Java header struct to kernel datastructure. 984 __user_cap_header_struct cap_header; 985 if (!ReadStructCapUserHeader(env, header, &cap_header)) { 986 AssertException(env); 987 return; 988 } 989 size_t result_size = GetCapUserDataLength(cap_header.version); 990 // Ensure that the array has the expected length. 991 if (env->GetArrayLength(data) != static_cast<jint>(result_size)) { 992 jniThrowExceptionFmt(env, 993 "java/lang/IllegalArgumentException", 994 "Unsupported input length %d (expected %zu)", 995 env->GetArrayLength(data), 996 result_size); 997 return; 998 } 999 1000 __user_cap_data_struct cap_data[kMaxCapUserDataLength]; 1001 // Translate the values we got. 1002 for (size_t i = 0; i < result_size; ++i) { 1003 ScopedLocalRef<jobject> value(env, env->GetObjectArrayElement(data, i)); 1004 if (!ReadStructCapUserData(env, value.get(), &cap_data[i])) { 1005 AssertException(env); 1006 return; 1007 } 1008 } 1009 1010 throwIfMinusOne(env, "capset", capset(&cap_header, &cap_data[0])); 1011} 1012 1013static void Linux_chmod(JNIEnv* env, jobject, jstring javaPath, jint mode) { 1014 ScopedUtfChars path(env, javaPath); 1015 if (path.c_str() == NULL) { 1016 return; 1017 } 1018 throwIfMinusOne(env, "chmod", TEMP_FAILURE_RETRY(chmod(path.c_str(), mode))); 1019} 1020 1021static void Linux_chown(JNIEnv* env, jobject, jstring javaPath, jint uid, jint gid) { 1022 ScopedUtfChars path(env, javaPath); 1023 if (path.c_str() == NULL) { 1024 return; 1025 } 1026 throwIfMinusOne(env, "chown", TEMP_FAILURE_RETRY(chown(path.c_str(), uid, gid))); 1027} 1028 1029static void Linux_close(JNIEnv* env, jobject, jobject javaFd) { 1030 // Get the FileDescriptor's 'fd' field and clear it. 1031 // We need to do this before we can throw an IOException (http://b/3222087). 1032 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1033 jniSetFileDescriptorOfFD(env, javaFd, -1); 1034 1035 // Even if close(2) fails with EINTR, the fd will have been closed. 1036 // Using TEMP_FAILURE_RETRY will either lead to EBADF or closing someone else's fd. 1037 // http://lkml.indiana.edu/hypermail/linux/kernel/0509.1/0877.html 1038 throwIfMinusOne(env, "close", close(fd)); 1039} 1040 1041static void Linux_connect(JNIEnv* env, jobject, jobject javaFd, jobject javaAddress, jint port) { 1042 (void) NET_IPV4_FALLBACK(env, int, connect, javaFd, javaAddress, port, NULL_ADDR_FORBIDDEN); 1043} 1044 1045static void Linux_connectSocketAddress( 1046 JNIEnv* env, jobject, jobject javaFd, jobject javaSocketAddress) { 1047 sockaddr_storage ss; 1048 socklen_t sa_len; 1049 if (!javaSocketAddressToSockaddr(env, javaSocketAddress, ss, sa_len)) { 1050 return; // Exception already thrown. 1051 } 1052 1053 const sockaddr* sa = reinterpret_cast<const sockaddr*>(&ss); 1054 // We don't need the return value because we'll already have thrown. 1055 (void) NET_FAILURE_RETRY(env, int, connect, javaFd, sa, sa_len); 1056} 1057 1058static jobject Linux_dup(JNIEnv* env, jobject, jobject javaOldFd) { 1059 int oldFd = jniGetFDFromFileDescriptor(env, javaOldFd); 1060 int newFd = throwIfMinusOne(env, "dup", TEMP_FAILURE_RETRY(dup(oldFd))); 1061 return (newFd != -1) ? jniCreateFileDescriptor(env, newFd) : NULL; 1062} 1063 1064static jobject Linux_dup2(JNIEnv* env, jobject, jobject javaOldFd, jint newFd) { 1065 int oldFd = jniGetFDFromFileDescriptor(env, javaOldFd); 1066 int fd = throwIfMinusOne(env, "dup2", TEMP_FAILURE_RETRY(dup2(oldFd, newFd))); 1067 return (fd != -1) ? jniCreateFileDescriptor(env, fd) : NULL; 1068} 1069 1070static jobjectArray Linux_environ(JNIEnv* env, jobject) { 1071 extern char** environ; // Standard, but not in any header file. 1072 return toStringArray(env, environ); 1073} 1074 1075static void Linux_execve(JNIEnv* env, jobject, jstring javaFilename, jobjectArray javaArgv, jobjectArray javaEnvp) { 1076 ScopedUtfChars path(env, javaFilename); 1077 if (path.c_str() == NULL) { 1078 return; 1079 } 1080 1081 ExecStrings argv(env, javaArgv); 1082 ExecStrings envp(env, javaEnvp); 1083 TEMP_FAILURE_RETRY(execve(path.c_str(), argv.get(), envp.get())); 1084 1085 throwErrnoException(env, "execve"); 1086} 1087 1088static void Linux_execv(JNIEnv* env, jobject, jstring javaFilename, jobjectArray javaArgv) { 1089 ScopedUtfChars path(env, javaFilename); 1090 if (path.c_str() == NULL) { 1091 return; 1092 } 1093 1094 ExecStrings argv(env, javaArgv); 1095 TEMP_FAILURE_RETRY(execv(path.c_str(), argv.get())); 1096 1097 throwErrnoException(env, "execv"); 1098} 1099 1100static void Linux_fchmod(JNIEnv* env, jobject, jobject javaFd, jint mode) { 1101 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1102 throwIfMinusOne(env, "fchmod", TEMP_FAILURE_RETRY(fchmod(fd, mode))); 1103} 1104 1105static void Linux_fchown(JNIEnv* env, jobject, jobject javaFd, jint uid, jint gid) { 1106 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1107 throwIfMinusOne(env, "fchown", TEMP_FAILURE_RETRY(fchown(fd, uid, gid))); 1108} 1109 1110static jint Linux_fcntlFlock(JNIEnv* env, jobject, jobject javaFd, jint cmd, jobject javaFlock) { 1111 static jfieldID typeFid = env->GetFieldID(JniConstants::structFlockClass, "l_type", "S"); 1112 static jfieldID whenceFid = env->GetFieldID(JniConstants::structFlockClass, "l_whence", "S"); 1113 static jfieldID startFid = env->GetFieldID(JniConstants::structFlockClass, "l_start", "J"); 1114 static jfieldID lenFid = env->GetFieldID(JniConstants::structFlockClass, "l_len", "J"); 1115 static jfieldID pidFid = env->GetFieldID(JniConstants::structFlockClass, "l_pid", "I"); 1116 1117 struct flock64 lock; 1118 memset(&lock, 0, sizeof(lock)); 1119 lock.l_type = env->GetShortField(javaFlock, typeFid); 1120 lock.l_whence = env->GetShortField(javaFlock, whenceFid); 1121 lock.l_start = env->GetLongField(javaFlock, startFid); 1122 lock.l_len = env->GetLongField(javaFlock, lenFid); 1123 lock.l_pid = env->GetIntField(javaFlock, pidFid); 1124 1125 int rc = IO_FAILURE_RETRY(env, int, fcntl, javaFd, cmd, &lock); 1126 if (rc != -1) { 1127 env->SetShortField(javaFlock, typeFid, lock.l_type); 1128 env->SetShortField(javaFlock, whenceFid, lock.l_whence); 1129 env->SetLongField(javaFlock, startFid, lock.l_start); 1130 env->SetLongField(javaFlock, lenFid, lock.l_len); 1131 env->SetIntField(javaFlock, pidFid, lock.l_pid); 1132 } 1133 return rc; 1134} 1135 1136static jint Linux_fcntlInt(JNIEnv* env, jobject, jobject javaFd, jint cmd, jint arg) { 1137 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1138 return throwIfMinusOne(env, "fcntl", TEMP_FAILURE_RETRY(fcntl(fd, cmd, arg))); 1139} 1140 1141static jint Linux_fcntlVoid(JNIEnv* env, jobject, jobject javaFd, jint cmd) { 1142 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1143 return throwIfMinusOne(env, "fcntl", TEMP_FAILURE_RETRY(fcntl(fd, cmd))); 1144} 1145 1146static void Linux_fdatasync(JNIEnv* env, jobject, jobject javaFd) { 1147 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1148 throwIfMinusOne(env, "fdatasync", TEMP_FAILURE_RETRY(fdatasync(fd))); 1149} 1150 1151static jobject Linux_fstat(JNIEnv* env, jobject, jobject javaFd) { 1152 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1153 struct stat64 sb; 1154 int rc = TEMP_FAILURE_RETRY(fstat64(fd, &sb)); 1155 if (rc == -1) { 1156 throwErrnoException(env, "fstat"); 1157 return NULL; 1158 } 1159 return makeStructStat(env, sb); 1160} 1161 1162static jobject Linux_fstatvfs(JNIEnv* env, jobject, jobject javaFd) { 1163 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1164 struct statvfs sb; 1165 int rc = TEMP_FAILURE_RETRY(fstatvfs(fd, &sb)); 1166 if (rc == -1) { 1167 throwErrnoException(env, "fstatvfs"); 1168 return NULL; 1169 } 1170 return makeStructStatVfs(env, sb); 1171} 1172 1173static void Linux_fsync(JNIEnv* env, jobject, jobject javaFd) { 1174 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1175 throwIfMinusOne(env, "fsync", TEMP_FAILURE_RETRY(fsync(fd))); 1176} 1177 1178static void Linux_ftruncate(JNIEnv* env, jobject, jobject javaFd, jlong length) { 1179 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1180 throwIfMinusOne(env, "ftruncate", TEMP_FAILURE_RETRY(ftruncate64(fd, length))); 1181} 1182 1183static jstring Linux_gai_strerror(JNIEnv* env, jobject, jint error) { 1184 return env->NewStringUTF(gai_strerror(error)); 1185} 1186 1187static jobjectArray Linux_android_getaddrinfo(JNIEnv* env, jobject, jstring javaNode, 1188 jobject javaHints, jint netId) { 1189 ScopedUtfChars node(env, javaNode); 1190 if (node.c_str() == NULL) { 1191 return NULL; 1192 } 1193 1194 static jfieldID flagsFid = env->GetFieldID(JniConstants::structAddrinfoClass, "ai_flags", "I"); 1195 static jfieldID familyFid = env->GetFieldID(JniConstants::structAddrinfoClass, "ai_family", "I"); 1196 static jfieldID socktypeFid = env->GetFieldID(JniConstants::structAddrinfoClass, "ai_socktype", "I"); 1197 static jfieldID protocolFid = env->GetFieldID(JniConstants::structAddrinfoClass, "ai_protocol", "I"); 1198 1199 addrinfo hints; 1200 memset(&hints, 0, sizeof(hints)); 1201 hints.ai_flags = env->GetIntField(javaHints, flagsFid); 1202 hints.ai_family = env->GetIntField(javaHints, familyFid); 1203 hints.ai_socktype = env->GetIntField(javaHints, socktypeFid); 1204 hints.ai_protocol = env->GetIntField(javaHints, protocolFid); 1205 1206 addrinfo* addressList = NULL; 1207 errno = 0; 1208 int rc = android_getaddrinfofornet(node.c_str(), NULL, &hints, netId, 0, &addressList); 1209 std::unique_ptr<addrinfo, addrinfo_deleter> addressListDeleter(addressList); 1210 if (rc != 0) { 1211 throwGaiException(env, "android_getaddrinfo", rc); 1212 return NULL; 1213 } 1214 1215 // Count results so we know how to size the output array. 1216 int addressCount = 0; 1217 for (addrinfo* ai = addressList; ai != NULL; ai = ai->ai_next) { 1218 if (ai->ai_family == AF_INET || ai->ai_family == AF_INET6) { 1219 ++addressCount; 1220 } else { 1221 ALOGE("android_getaddrinfo unexpected ai_family %i", ai->ai_family); 1222 } 1223 } 1224 if (addressCount == 0) { 1225 return NULL; 1226 } 1227 1228 // Prepare output array. 1229 jobjectArray result = env->NewObjectArray(addressCount, JniConstants::inetAddressClass, NULL); 1230 if (result == NULL) { 1231 return NULL; 1232 } 1233 1234 // Examine returned addresses one by one, save them in the output array. 1235 int index = 0; 1236 for (addrinfo* ai = addressList; ai != NULL; ai = ai->ai_next) { 1237 if (ai->ai_family != AF_INET && ai->ai_family != AF_INET6) { 1238 // Unknown address family. Skip this address. 1239 ALOGE("android_getaddrinfo unexpected ai_family %i", ai->ai_family); 1240 continue; 1241 } 1242 1243 // Convert each IP address into a Java byte array. 1244 sockaddr_storage& address = *reinterpret_cast<sockaddr_storage*>(ai->ai_addr); 1245 ScopedLocalRef<jobject> inetAddress(env, sockaddrToInetAddress(env, address, NULL)); 1246 if (inetAddress.get() == NULL) { 1247 return NULL; 1248 } 1249 env->SetObjectArrayElement(result, index, inetAddress.get()); 1250 ++index; 1251 } 1252 return result; 1253} 1254 1255static jint Linux_getegid(JNIEnv*, jobject) { 1256 return getegid(); 1257} 1258 1259static jint Linux_geteuid(JNIEnv*, jobject) { 1260 return geteuid(); 1261} 1262 1263static jint Linux_getgid(JNIEnv*, jobject) { 1264 return getgid(); 1265} 1266 1267static jstring Linux_getenv(JNIEnv* env, jobject, jstring javaName) { 1268 ScopedUtfChars name(env, javaName); 1269 if (name.c_str() == NULL) { 1270 return NULL; 1271 } 1272 return env->NewStringUTF(getenv(name.c_str())); 1273} 1274 1275static jstring Linux_getnameinfo(JNIEnv* env, jobject, jobject javaAddress, jint flags) { 1276 sockaddr_storage ss; 1277 socklen_t sa_len; 1278 if (!inetAddressToSockaddrVerbatim(env, javaAddress, 0, ss, sa_len)) { 1279 return NULL; 1280 } 1281 char buf[NI_MAXHOST]; // NI_MAXHOST is longer than INET6_ADDRSTRLEN. 1282 errno = 0; 1283 int rc = getnameinfo(reinterpret_cast<sockaddr*>(&ss), sa_len, buf, sizeof(buf), NULL, 0, flags); 1284 if (rc != 0) { 1285 throwGaiException(env, "getnameinfo", rc); 1286 return NULL; 1287 } 1288 return env->NewStringUTF(buf); 1289} 1290 1291static jobject Linux_getpeername(JNIEnv* env, jobject, jobject javaFd) { 1292 return doGetSockName(env, javaFd, false); 1293} 1294 1295static jint Linux_getpgid(JNIEnv* env, jobject, jint pid) { 1296 return throwIfMinusOne(env, "getpgid", TEMP_FAILURE_RETRY(getpgid(pid))); 1297} 1298 1299static jint Linux_getpid(JNIEnv*, jobject) { 1300 return TEMP_FAILURE_RETRY(getpid()); 1301} 1302 1303static jint Linux_getppid(JNIEnv*, jobject) { 1304 return TEMP_FAILURE_RETRY(getppid()); 1305} 1306 1307static jobject Linux_getpwnam(JNIEnv* env, jobject, jstring javaName) { 1308 ScopedUtfChars name(env, javaName); 1309 if (name.c_str() == NULL) { 1310 return NULL; 1311 } 1312 return Passwd(env).getpwnam(name.c_str()); 1313} 1314 1315static jobject Linux_getpwuid(JNIEnv* env, jobject, jint uid) { 1316 return Passwd(env).getpwuid(uid); 1317} 1318 1319static jobject Linux_getrlimit(JNIEnv* env, jobject, jint resource) { 1320 struct rlimit r; 1321 if (throwIfMinusOne(env, "getrlimit", TEMP_FAILURE_RETRY(getrlimit(resource, &r))) == -1) { 1322 return nullptr; 1323 } 1324 1325 ScopedLocalRef<jclass> rlimit_class(env, env->FindClass("android/system/StructRlimit")); 1326 jmethodID ctor = env->GetMethodID(rlimit_class.get(), "<init>", "(JJ)V"); 1327 return env->NewObject(rlimit_class.get(), ctor, 1328 static_cast<jlong>(r.rlim_cur), 1329 static_cast<jlong>(r.rlim_max)); 1330} 1331 1332static jobject Linux_getsockname(JNIEnv* env, jobject, jobject javaFd) { 1333 return doGetSockName(env, javaFd, true); 1334} 1335 1336static jint Linux_getsockoptByte(JNIEnv* env, jobject, jobject javaFd, jint level, jint option) { 1337 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1338 u_char result = 0; 1339 socklen_t size = sizeof(result); 1340 throwIfMinusOne(env, "getsockopt", TEMP_FAILURE_RETRY(getsockopt(fd, level, option, &result, &size))); 1341 return result; 1342} 1343 1344static jobject Linux_getsockoptInAddr(JNIEnv* env, jobject, jobject javaFd, jint level, jint option) { 1345 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1346 sockaddr_storage ss; 1347 memset(&ss, 0, sizeof(ss)); 1348 ss.ss_family = AF_INET; // This is only for the IPv4-only IP_MULTICAST_IF. 1349 sockaddr_in* sa = reinterpret_cast<sockaddr_in*>(&ss); 1350 socklen_t size = sizeof(sa->sin_addr); 1351 int rc = TEMP_FAILURE_RETRY(getsockopt(fd, level, option, &sa->sin_addr, &size)); 1352 if (rc == -1) { 1353 throwErrnoException(env, "getsockopt"); 1354 return NULL; 1355 } 1356 return sockaddrToInetAddress(env, ss, NULL); 1357} 1358 1359static jint Linux_getsockoptInt(JNIEnv* env, jobject, jobject javaFd, jint level, jint option) { 1360 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1361 jint result = 0; 1362 socklen_t size = sizeof(result); 1363 throwIfMinusOne(env, "getsockopt", TEMP_FAILURE_RETRY(getsockopt(fd, level, option, &result, &size))); 1364 return result; 1365} 1366 1367static jobject Linux_getsockoptLinger(JNIEnv* env, jobject, jobject javaFd, jint level, jint option) { 1368 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1369 struct linger l; 1370 socklen_t size = sizeof(l); 1371 memset(&l, 0, size); 1372 int rc = TEMP_FAILURE_RETRY(getsockopt(fd, level, option, &l, &size)); 1373 if (rc == -1) { 1374 throwErrnoException(env, "getsockopt"); 1375 return NULL; 1376 } 1377 return makeStructLinger(env, l); 1378} 1379 1380static jobject Linux_getsockoptTimeval(JNIEnv* env, jobject, jobject javaFd, jint level, jint option) { 1381 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1382 struct timeval tv; 1383 socklen_t size = sizeof(tv); 1384 memset(&tv, 0, size); 1385 int rc = TEMP_FAILURE_RETRY(getsockopt(fd, level, option, &tv, &size)); 1386 if (rc == -1) { 1387 throwErrnoException(env, "getsockopt"); 1388 return NULL; 1389 } 1390 return makeStructTimeval(env, tv); 1391} 1392 1393static jobject Linux_getsockoptUcred(JNIEnv* env, jobject, jobject javaFd, jint level, jint option) { 1394 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1395 struct ucred u; 1396 socklen_t size = sizeof(u); 1397 memset(&u, 0, size); 1398 int rc = TEMP_FAILURE_RETRY(getsockopt(fd, level, option, &u, &size)); 1399 if (rc == -1) { 1400 throwErrnoException(env, "getsockopt"); 1401 return NULL; 1402 } 1403 return makeStructUcred(env, u); 1404} 1405 1406static jint Linux_gettid(JNIEnv* env __unused, jobject) { 1407#if defined(__BIONIC__) 1408 return TEMP_FAILURE_RETRY(gettid()); 1409#else 1410 return syscall(__NR_gettid); 1411#endif 1412} 1413 1414static jint Linux_getuid(JNIEnv*, jobject) { 1415 return getuid(); 1416} 1417 1418static jbyteArray Linux_getxattr(JNIEnv* env, jobject, jstring javaPath, 1419 jstring javaName) { 1420 ScopedUtfChars path(env, javaPath); 1421 if (path.c_str() == NULL) { 1422 return NULL; 1423 } 1424 ScopedUtfChars name(env, javaName); 1425 if (name.c_str() == NULL) { 1426 return NULL; 1427 } 1428 1429 while (true) { 1430 // Get the current size of the named extended attribute. 1431 ssize_t valueLength; 1432 if ((valueLength = getxattr(path.c_str(), name.c_str(), NULL, 0)) < 0) { 1433 throwErrnoException(env, "getxattr"); 1434 return NULL; 1435 } 1436 1437 // Create the actual byte array. 1438 std::vector<char> buf(valueLength); 1439 if ((valueLength = getxattr(path.c_str(), name.c_str(), buf.data(), valueLength)) < 0) { 1440 if (errno == ERANGE) { 1441 // The attribute value has changed since last getxattr call and buf no longer fits, 1442 // try again. 1443 continue; 1444 } 1445 throwErrnoException(env, "getxattr"); 1446 return NULL; 1447 } 1448 jbyteArray array = env->NewByteArray(valueLength); 1449 if (array == NULL) { 1450 return NULL; 1451 } 1452 env->SetByteArrayRegion(array, 0, valueLength, reinterpret_cast<const jbyte*>(buf.data())); 1453 return array; 1454 } 1455} 1456 1457static jobjectArray Linux_getifaddrs(JNIEnv* env, jobject) { 1458 static jmethodID ctor = env->GetMethodID(JniConstants::structIfaddrs, "<init>", 1459 "(Ljava/lang/String;ILjava/net/InetAddress;Ljava/net/InetAddress;Ljava/net/InetAddress;[B)V"); 1460 1461 ifaddrs* ifaddr; 1462 int rc = TEMP_FAILURE_RETRY(getifaddrs(&ifaddr)); 1463 if (rc == -1) { 1464 throwErrnoException(env, "getifaddrs"); 1465 return NULL; 1466 } 1467 std::unique_ptr<ifaddrs, decltype(&freeifaddrs)> ifaddrPtr(ifaddr, freeifaddrs); 1468 1469 // Count results so we know how to size the output array. 1470 jint ifCount = 0; 1471 for (ifaddrs* ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) { 1472 ++ifCount; 1473 } 1474 1475 // Prepare output array. 1476 jobjectArray result = env->NewObjectArray(ifCount, JniConstants::structIfaddrs, NULL); 1477 if (result == NULL) { 1478 return NULL; 1479 } 1480 1481 // Traverse the list and populate the output array. 1482 int index = 0; 1483 for (ifaddrs* ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next, ++index) { 1484 TO_JAVA_STRING(name, ifa->ifa_name); 1485 jint flags = ifa->ifa_flags; 1486 sockaddr_storage* interfaceAddr = 1487 reinterpret_cast<sockaddr_storage*>(ifa->ifa_addr); 1488 sockaddr_storage* netmaskAddr = 1489 reinterpret_cast<sockaddr_storage*>(ifa->ifa_netmask); 1490 sockaddr_storage* broadAddr = 1491 reinterpret_cast<sockaddr_storage*>(ifa->ifa_broadaddr); 1492 1493 jobject addr, netmask, broad; 1494 jbyteArray hwaddr = NULL; 1495 if (interfaceAddr != NULL) { 1496 switch (interfaceAddr->ss_family) { 1497 case AF_INET: 1498 case AF_INET6: 1499 // IPv4 / IPv6. 1500 // interfaceAddr and netmaskAddr are never null. 1501 if ((addr = sockaddrToInetAddress(env, *interfaceAddr, NULL)) == NULL) { 1502 return NULL; 1503 } 1504 if ((netmask = sockaddrToInetAddress(env, *netmaskAddr, NULL)) == NULL) { 1505 return NULL; 1506 } 1507 if (broadAddr != NULL && (ifa->ifa_flags & IFF_BROADCAST)) { 1508 if ((broad = sockaddrToInetAddress(env, *broadAddr, NULL)) == NULL) { 1509 return NULL; 1510 } 1511 } else { 1512 broad = NULL; 1513 } 1514 break; 1515 case AF_PACKET: 1516 // Raw Interface. 1517 sockaddr_ll* sll = reinterpret_cast<sockaddr_ll*>(ifa->ifa_addr); 1518 1519 bool allZero = true; 1520 for (int i = 0; i < sll->sll_halen; ++i) { 1521 if (sll->sll_addr[i] != 0) { 1522 allZero = false; 1523 break; 1524 } 1525 } 1526 1527 if (!allZero) { 1528 hwaddr = env->NewByteArray(sll->sll_halen); 1529 if (hwaddr == NULL) { 1530 return NULL; 1531 } 1532 env->SetByteArrayRegion(hwaddr, 0, sll->sll_halen, 1533 reinterpret_cast<const jbyte*>(sll->sll_addr)); 1534 } 1535 addr = netmask = broad = NULL; 1536 break; 1537 } 1538 } else { 1539 // Preserve the entry even if the interface has no interface address. 1540 // http://b/29243557/ 1541 addr = netmask = broad = NULL; 1542 } 1543 1544 jobject o = env->NewObject(JniConstants::structIfaddrs, ctor, name, flags, addr, netmask, 1545 broad, hwaddr); 1546 env->SetObjectArrayElement(result, index, o); 1547 } 1548 1549 return result; 1550} 1551 1552static jstring Linux_if_indextoname(JNIEnv* env, jobject, jint index) { 1553 char buf[IF_NAMESIZE]; 1554 char* name = if_indextoname(index, buf); 1555 // if_indextoname(3) returns NULL on failure, which will come out of NewStringUTF unscathed. 1556 // There's no useful information in errno, so we don't bother throwing. Callers can null-check. 1557 return env->NewStringUTF(name); 1558} 1559 1560static jint Linux_if_nametoindex(JNIEnv* env, jobject, jstring name) { 1561 ScopedUtfChars cname(env, name); 1562 if (cname.c_str() == NULL) { 1563 return 0; 1564 } 1565 1566 // There's no useful information in errno, so we don't bother throwing. Callers can zero-check. 1567 return if_nametoindex(cname.c_str()); 1568} 1569 1570static jobject Linux_inet_pton(JNIEnv* env, jobject, jint family, jstring javaName) { 1571 ScopedUtfChars name(env, javaName); 1572 if (name.c_str() == NULL) { 1573 return NULL; 1574 } 1575 sockaddr_storage ss; 1576 memset(&ss, 0, sizeof(ss)); 1577 // sockaddr_in and sockaddr_in6 are at the same address, so we can use either here. 1578 void* dst = &reinterpret_cast<sockaddr_in*>(&ss)->sin_addr; 1579 if (inet_pton(family, name.c_str(), dst) != 1) { 1580 return NULL; 1581 } 1582 ss.ss_family = family; 1583 return sockaddrToInetAddress(env, ss, NULL); 1584} 1585 1586static jint Linux_ioctlFlags(JNIEnv* env, jobject, jobject javaFd, jstring javaInterfaceName) { 1587 struct ifreq req; 1588 if (!fillIfreq(env, javaInterfaceName, req)) { 1589 return 0; 1590 } 1591 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1592 throwIfMinusOne(env, "ioctl", TEMP_FAILURE_RETRY(ioctl(fd, SIOCGIFFLAGS, &req))); 1593 return req.ifr_flags; 1594} 1595 1596static jobject Linux_ioctlInetAddress(JNIEnv* env, jobject, jobject javaFd, jint cmd, jstring javaInterfaceName) { 1597 struct ifreq req; 1598 if (!fillIfreq(env, javaInterfaceName, req)) { 1599 return NULL; 1600 } 1601 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1602 int rc = throwIfMinusOne(env, "ioctl", TEMP_FAILURE_RETRY(ioctl(fd, cmd, &req))); 1603 if (rc == -1) { 1604 return NULL; 1605 } 1606 return sockaddrToInetAddress(env, reinterpret_cast<sockaddr_storage&>(req.ifr_addr), NULL); 1607} 1608 1609static jint Linux_ioctlInt(JNIEnv* env, jobject, jobject javaFd, jint cmd, jobject javaArg) { 1610 // This is complicated because ioctls may return their result by updating their argument 1611 // or via their return value, so we need to support both. 1612 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1613 static jfieldID valueFid = env->GetFieldID(JniConstants::mutableIntClass, "value", "I"); 1614 jint arg = env->GetIntField(javaArg, valueFid); 1615 int rc = throwIfMinusOne(env, "ioctl", TEMP_FAILURE_RETRY(ioctl(fd, cmd, &arg))); 1616 if (!env->ExceptionCheck()) { 1617 env->SetIntField(javaArg, valueFid, arg); 1618 } 1619 return rc; 1620} 1621 1622static jint Linux_ioctlMTU(JNIEnv* env, jobject, jobject javaFd, jstring javaInterfaceName) { 1623 struct ifreq req; 1624 if (!fillIfreq(env, javaInterfaceName, req)) { 1625 return 0; 1626 } 1627 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1628 throwIfMinusOne(env, "ioctl", TEMP_FAILURE_RETRY(ioctl(fd, SIOCGIFMTU, &req))); 1629 return req.ifr_mtu; 1630} 1631 1632static jboolean Linux_isatty(JNIEnv* env, jobject, jobject javaFd) { 1633 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1634 return TEMP_FAILURE_RETRY(isatty(fd)) == 1; 1635} 1636 1637static void Linux_kill(JNIEnv* env, jobject, jint pid, jint sig) { 1638 throwIfMinusOne(env, "kill", TEMP_FAILURE_RETRY(kill(pid, sig))); 1639} 1640 1641static void Linux_lchown(JNIEnv* env, jobject, jstring javaPath, jint uid, jint gid) { 1642 ScopedUtfChars path(env, javaPath); 1643 if (path.c_str() == NULL) { 1644 return; 1645 } 1646 throwIfMinusOne(env, "lchown", TEMP_FAILURE_RETRY(lchown(path.c_str(), uid, gid))); 1647} 1648 1649static void Linux_link(JNIEnv* env, jobject, jstring javaOldPath, jstring javaNewPath) { 1650 ScopedUtfChars oldPath(env, javaOldPath); 1651 if (oldPath.c_str() == NULL) { 1652 return; 1653 } 1654 ScopedUtfChars newPath(env, javaNewPath); 1655 if (newPath.c_str() == NULL) { 1656 return; 1657 } 1658 throwIfMinusOne(env, "link", TEMP_FAILURE_RETRY(link(oldPath.c_str(), newPath.c_str()))); 1659} 1660 1661static void Linux_listen(JNIEnv* env, jobject, jobject javaFd, jint backlog) { 1662 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1663 throwIfMinusOne(env, "listen", TEMP_FAILURE_RETRY(listen(fd, backlog))); 1664} 1665 1666static jobjectArray Linux_listxattr(JNIEnv* env, jobject, jstring javaPath) { 1667 ScopedUtfChars path(env, javaPath); 1668 if (path.c_str() == NULL) { 1669 return NULL; 1670 } 1671 1672 while (true) { 1673 // Get the current size of the named extended attribute. 1674 ssize_t valueLength; 1675 if ((valueLength = listxattr(path.c_str(), NULL, 0)) < 0) { 1676 throwErrnoException(env, "listxattr"); 1677 return NULL; 1678 } 1679 1680 // Create the actual byte array. 1681 std::string buf(valueLength, '\0'); 1682 if ((valueLength = listxattr(path.c_str(), &buf[0], valueLength)) < 0) { 1683 if (errno == ERANGE) { 1684 // The attribute value has changed since last listxattr call and buf no longer fits, 1685 // try again. 1686 continue; 1687 } 1688 throwErrnoException(env, "listxattr"); 1689 return NULL; 1690 } 1691 1692 // Split the output by '\0'. 1693 buf.resize(valueLength > 0 ? valueLength - 1 : 0); // Remove the trailing NULL character. 1694 std::string delim("\0", 1); 1695 auto xattrs = android::base::Split(buf, delim); 1696 1697 return toStringArray(env, xattrs); 1698 } 1699} 1700 1701static jlong Linux_lseek(JNIEnv* env, jobject, jobject javaFd, jlong offset, jint whence) { 1702 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1703 return throwIfMinusOne(env, "lseek", TEMP_FAILURE_RETRY(lseek64(fd, offset, whence))); 1704} 1705 1706static jobject Linux_lstat(JNIEnv* env, jobject, jstring javaPath) { 1707 return doStat(env, javaPath, true); 1708} 1709 1710static void Linux_mincore(JNIEnv* env, jobject, jlong address, jlong byteCount, jbyteArray javaVector) { 1711 ScopedByteArrayRW vector(env, javaVector); 1712 if (vector.get() == NULL) { 1713 return; 1714 } 1715 void* ptr = reinterpret_cast<void*>(static_cast<uintptr_t>(address)); 1716 unsigned char* vec = reinterpret_cast<unsigned char*>(vector.get()); 1717 throwIfMinusOne(env, "mincore", TEMP_FAILURE_RETRY(mincore(ptr, byteCount, vec))); 1718} 1719 1720static void Linux_mkdir(JNIEnv* env, jobject, jstring javaPath, jint mode) { 1721 ScopedUtfChars path(env, javaPath); 1722 if (path.c_str() == NULL) { 1723 return; 1724 } 1725 throwIfMinusOne(env, "mkdir", TEMP_FAILURE_RETRY(mkdir(path.c_str(), mode))); 1726} 1727 1728static void Linux_mkfifo(JNIEnv* env, jobject, jstring javaPath, jint mode) { 1729 ScopedUtfChars path(env, javaPath); 1730 if (path.c_str() == NULL) { 1731 return; 1732 } 1733 throwIfMinusOne(env, "mkfifo", TEMP_FAILURE_RETRY(mkfifo(path.c_str(), mode))); 1734} 1735 1736static void Linux_mlock(JNIEnv* env, jobject, jlong address, jlong byteCount) { 1737 void* ptr = reinterpret_cast<void*>(static_cast<uintptr_t>(address)); 1738 throwIfMinusOne(env, "mlock", TEMP_FAILURE_RETRY(mlock(ptr, byteCount))); 1739} 1740 1741static jlong Linux_mmap(JNIEnv* env, jobject, jlong address, jlong byteCount, jint prot, jint flags, jobject javaFd, jlong offset) { 1742 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1743 void* suggestedPtr = reinterpret_cast<void*>(static_cast<uintptr_t>(address)); 1744 void* ptr = mmap64(suggestedPtr, byteCount, prot, flags, fd, offset); 1745 if (ptr == MAP_FAILED) { 1746 throwErrnoException(env, "mmap"); 1747 } 1748 return static_cast<jlong>(reinterpret_cast<uintptr_t>(ptr)); 1749} 1750 1751static void Linux_msync(JNIEnv* env, jobject, jlong address, jlong byteCount, jint flags) { 1752 void* ptr = reinterpret_cast<void*>(static_cast<uintptr_t>(address)); 1753 throwIfMinusOne(env, "msync", TEMP_FAILURE_RETRY(msync(ptr, byteCount, flags))); 1754} 1755 1756static void Linux_munlock(JNIEnv* env, jobject, jlong address, jlong byteCount) { 1757 void* ptr = reinterpret_cast<void*>(static_cast<uintptr_t>(address)); 1758 throwIfMinusOne(env, "munlock", TEMP_FAILURE_RETRY(munlock(ptr, byteCount))); 1759} 1760 1761static void Linux_munmap(JNIEnv* env, jobject, jlong address, jlong byteCount) { 1762 void* ptr = reinterpret_cast<void*>(static_cast<uintptr_t>(address)); 1763 throwIfMinusOne(env, "munmap", TEMP_FAILURE_RETRY(munmap(ptr, byteCount))); 1764} 1765 1766static jobject Linux_open(JNIEnv* env, jobject, jstring javaPath, jint flags, jint mode) { 1767 ScopedUtfChars path(env, javaPath); 1768 if (path.c_str() == NULL) { 1769 return NULL; 1770 } 1771 int fd = throwIfMinusOne(env, "open", TEMP_FAILURE_RETRY(open(path.c_str(), flags, mode))); 1772 return fd != -1 ? jniCreateFileDescriptor(env, fd) : NULL; 1773} 1774 1775static jobjectArray Linux_pipe2(JNIEnv* env, jobject, jint flags __unused) { 1776 int fds[2]; 1777 int pipe2_result = throwIfMinusOne(env, "pipe2", TEMP_FAILURE_RETRY(pipe2(&fds[0], flags))); 1778 if (pipe2_result == -1) { 1779 return NULL; 1780 } 1781 jobjectArray result = env->NewObjectArray(2, JniConstants::fileDescriptorClass, NULL); 1782 if (result == NULL) { 1783 return NULL; 1784 } 1785 for (int i = 0; i < 2; ++i) { 1786 ScopedLocalRef<jobject> fd(env, jniCreateFileDescriptor(env, fds[i])); 1787 if (fd.get() == NULL) { 1788 return NULL; 1789 } 1790 env->SetObjectArrayElement(result, i, fd.get()); 1791 if (env->ExceptionCheck()) { 1792 return NULL; 1793 } 1794 } 1795 return result; 1796} 1797 1798static jint Linux_poll(JNIEnv* env, jobject, jobjectArray javaStructs, jint timeoutMs) { 1799 static jfieldID fdFid = env->GetFieldID(JniConstants::structPollfdClass, "fd", "Ljava/io/FileDescriptor;"); 1800 static jfieldID eventsFid = env->GetFieldID(JniConstants::structPollfdClass, "events", "S"); 1801 static jfieldID reventsFid = env->GetFieldID(JniConstants::structPollfdClass, "revents", "S"); 1802 1803 // Turn the Java android.system.StructPollfd[] into a C++ struct pollfd[]. 1804 size_t arrayLength = env->GetArrayLength(javaStructs); 1805 std::unique_ptr<struct pollfd[]> fds(new struct pollfd[arrayLength]); 1806 memset(fds.get(), 0, sizeof(struct pollfd) * arrayLength); 1807 size_t count = 0; // Some trailing array elements may be irrelevant. (See below.) 1808 for (size_t i = 0; i < arrayLength; ++i) { 1809 ScopedLocalRef<jobject> javaStruct(env, env->GetObjectArrayElement(javaStructs, i)); 1810 if (javaStruct.get() == NULL) { 1811 break; // We allow trailing nulls in the array for caller convenience. 1812 } 1813 ScopedLocalRef<jobject> javaFd(env, env->GetObjectField(javaStruct.get(), fdFid)); 1814 if (javaFd.get() == NULL) { 1815 break; // We also allow callers to just clear the fd field (this is what Selector does). 1816 } 1817 fds[count].fd = jniGetFDFromFileDescriptor(env, javaFd.get()); 1818 fds[count].events = env->GetShortField(javaStruct.get(), eventsFid); 1819 ++count; 1820 } 1821 1822 std::vector<AsynchronousCloseMonitor*> monitors; 1823 for (size_t i = 0; i < count; ++i) { 1824 monitors.push_back(new AsynchronousCloseMonitor(fds[i].fd)); 1825 } 1826 1827 int rc; 1828 while (true) { 1829 timespec before; 1830 clock_gettime(CLOCK_MONOTONIC, &before); 1831 1832 rc = poll(fds.get(), count, timeoutMs); 1833 if (rc >= 0 || errno != EINTR) { 1834 break; 1835 } 1836 1837 // We got EINTR. Work out how much of the original timeout is still left. 1838 if (timeoutMs > 0) { 1839 timespec now; 1840 clock_gettime(CLOCK_MONOTONIC, &now); 1841 1842 timespec diff; 1843 diff.tv_sec = now.tv_sec - before.tv_sec; 1844 diff.tv_nsec = now.tv_nsec - before.tv_nsec; 1845 if (diff.tv_nsec < 0) { 1846 --diff.tv_sec; 1847 diff.tv_nsec += 1000000000; 1848 } 1849 1850 jint diffMs = diff.tv_sec * 1000 + diff.tv_nsec / 1000000; 1851 if (diffMs >= timeoutMs) { 1852 rc = 0; // We have less than 1ms left anyway, so just time out. 1853 break; 1854 } 1855 1856 timeoutMs -= diffMs; 1857 } 1858 } 1859 1860 for (size_t i = 0; i < monitors.size(); ++i) { 1861 delete monitors[i]; 1862 } 1863 if (rc == -1) { 1864 throwErrnoException(env, "poll"); 1865 return -1; 1866 } 1867 1868 // Update the revents fields in the Java android.system.StructPollfd[]. 1869 for (size_t i = 0; i < count; ++i) { 1870 ScopedLocalRef<jobject> javaStruct(env, env->GetObjectArrayElement(javaStructs, i)); 1871 if (javaStruct.get() == NULL) { 1872 return -1; 1873 } 1874 env->SetShortField(javaStruct.get(), reventsFid, fds[i].revents); 1875 } 1876 return rc; 1877} 1878 1879static void Linux_posix_fallocate(JNIEnv* env, jobject, jobject javaFd __unused, 1880 jlong offset __unused, jlong length __unused) { 1881 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1882 while ((errno = posix_fallocate64(fd, offset, length)) == EINTR) { 1883 } 1884 if (errno != 0) { 1885 throwErrnoException(env, "posix_fallocate"); 1886 } 1887} 1888 1889static jint Linux_prctl(JNIEnv* env, jobject, jint option __unused, jlong arg2 __unused, 1890 jlong arg3 __unused, jlong arg4 __unused, jlong arg5 __unused) { 1891 int result = TEMP_FAILURE_RETRY(prctl(static_cast<int>(option), 1892 static_cast<unsigned long>(arg2), 1893 static_cast<unsigned long>(arg3), 1894 static_cast<unsigned long>(arg4), 1895 static_cast<unsigned long>(arg5))); 1896 return throwIfMinusOne(env, "prctl", result); 1897} 1898 1899static jint Linux_preadBytes(JNIEnv* env, jobject, jobject javaFd, jobject javaBytes, jint byteOffset, jint byteCount, jlong offset) { 1900 ScopedBytesRW bytes(env, javaBytes); 1901 if (bytes.get() == NULL) { 1902 return -1; 1903 } 1904 return IO_FAILURE_RETRY(env, ssize_t, pread64, javaFd, bytes.get() + byteOffset, byteCount, offset); 1905} 1906 1907static jint Linux_pwriteBytes(JNIEnv* env, jobject, jobject javaFd, jbyteArray javaBytes, jint byteOffset, jint byteCount, jlong offset) { 1908 ScopedBytesRO bytes(env, javaBytes); 1909 if (bytes.get() == NULL) { 1910 return -1; 1911 } 1912 return IO_FAILURE_RETRY(env, ssize_t, pwrite64, javaFd, bytes.get() + byteOffset, byteCount, offset); 1913} 1914 1915static jint Linux_readBytes(JNIEnv* env, jobject, jobject javaFd, jobject javaBytes, jint byteOffset, jint byteCount) { 1916 ScopedBytesRW bytes(env, javaBytes); 1917 if (bytes.get() == NULL) { 1918 return -1; 1919 } 1920 return IO_FAILURE_RETRY(env, ssize_t, read, javaFd, bytes.get() + byteOffset, byteCount); 1921} 1922 1923static jstring Linux_readlink(JNIEnv* env, jobject, jstring javaPath) { 1924 ScopedUtfChars path(env, javaPath); 1925 if (path.c_str() == NULL) { 1926 return NULL; 1927 } 1928 1929 std::string result; 1930 if (!android::base::Readlink(path.c_str(), &result)) { 1931 throwErrnoException(env, "readlink"); 1932 return NULL; 1933 } 1934 return env->NewStringUTF(result.c_str()); 1935} 1936 1937static jstring Linux_realpath(JNIEnv* env, jobject, jstring javaPath) { 1938 ScopedUtfChars path(env, javaPath); 1939 if (path.c_str() == NULL) { 1940 return NULL; 1941 } 1942 1943 std::unique_ptr<char, c_deleter> real_path(realpath(path.c_str(), nullptr)); 1944 if (real_path.get() == nullptr) { 1945 throwErrnoException(env, "realpath"); 1946 return NULL; 1947 } 1948 1949 return env->NewStringUTF(real_path.get()); 1950} 1951 1952static jint Linux_readv(JNIEnv* env, jobject, jobject javaFd, jobjectArray buffers, jintArray offsets, jintArray byteCounts) { 1953 IoVec<ScopedBytesRW> ioVec(env, env->GetArrayLength(buffers)); 1954 if (!ioVec.init(buffers, offsets, byteCounts)) { 1955 return -1; 1956 } 1957 return IO_FAILURE_RETRY(env, ssize_t, readv, javaFd, ioVec.get(), ioVec.size()); 1958} 1959 1960static jint Linux_recvfromBytes(JNIEnv* env, jobject, jobject javaFd, jobject javaBytes, jint byteOffset, jint byteCount, jint flags, jobject javaInetSocketAddress) { 1961 ScopedBytesRW bytes(env, javaBytes); 1962 if (bytes.get() == NULL) { 1963 return -1; 1964 } 1965 sockaddr_storage ss; 1966 socklen_t sl = sizeof(ss); 1967 memset(&ss, 0, sizeof(ss)); 1968 sockaddr* from = (javaInetSocketAddress != NULL) ? reinterpret_cast<sockaddr*>(&ss) : NULL; 1969 socklen_t* fromLength = (javaInetSocketAddress != NULL) ? &sl : 0; 1970 jint recvCount = NET_FAILURE_RETRY(env, ssize_t, recvfrom, javaFd, bytes.get() + byteOffset, byteCount, flags, from, fromLength); 1971 if (recvCount >= 0) { 1972 // The socket may have performed orderly shutdown and recvCount would return 0 (see man 2 1973 // recvfrom), in which case ss.ss_family == AF_UNIX and fillInetSocketAddress would fail. 1974 // Don't fill in the address if recvfrom didn't succeed. http://b/33483694 1975 if (ss.ss_family == AF_INET || ss.ss_family == AF_INET6) { 1976 fillInetSocketAddress(env, javaInetSocketAddress, ss); 1977 } 1978 } 1979 return recvCount; 1980} 1981 1982static void Linux_remove(JNIEnv* env, jobject, jstring javaPath) { 1983 ScopedUtfChars path(env, javaPath); 1984 if (path.c_str() == NULL) { 1985 return; 1986 } 1987 throwIfMinusOne(env, "remove", TEMP_FAILURE_RETRY(remove(path.c_str()))); 1988} 1989 1990static void Linux_removexattr(JNIEnv* env, jobject, jstring javaPath, jstring javaName) { 1991 ScopedUtfChars path(env, javaPath); 1992 if (path.c_str() == NULL) { 1993 return; 1994 } 1995 ScopedUtfChars name(env, javaName); 1996 if (name.c_str() == NULL) { 1997 return; 1998 } 1999 2000 int res = removexattr(path.c_str(), name.c_str()); 2001 if (res < 0) { 2002 throwErrnoException(env, "removexattr"); 2003 } 2004} 2005 2006static void Linux_rename(JNIEnv* env, jobject, jstring javaOldPath, jstring javaNewPath) { 2007 ScopedUtfChars oldPath(env, javaOldPath); 2008 if (oldPath.c_str() == NULL) { 2009 return; 2010 } 2011 ScopedUtfChars newPath(env, javaNewPath); 2012 if (newPath.c_str() == NULL) { 2013 return; 2014 } 2015 throwIfMinusOne(env, "rename", TEMP_FAILURE_RETRY(rename(oldPath.c_str(), newPath.c_str()))); 2016} 2017 2018static jlong Linux_sendfile(JNIEnv* env, jobject, jobject javaOutFd, jobject javaInFd, jobject javaOffset, jlong byteCount) { 2019 int outFd = jniGetFDFromFileDescriptor(env, javaOutFd); 2020 int inFd = jniGetFDFromFileDescriptor(env, javaInFd); 2021 static jfieldID valueFid = env->GetFieldID(JniConstants::mutableLongClass, "value", "J"); 2022 off_t offset = 0; 2023 off_t* offsetPtr = NULL; 2024 if (javaOffset != NULL) { 2025 // TODO: fix bionic so we can have a 64-bit off_t! 2026 offset = env->GetLongField(javaOffset, valueFid); 2027 offsetPtr = &offset; 2028 } 2029 jlong result = throwIfMinusOne(env, "sendfile", TEMP_FAILURE_RETRY(sendfile(outFd, inFd, offsetPtr, byteCount))); 2030 if (result == -1) { 2031 return -1; 2032 } 2033 if (javaOffset != NULL) { 2034 env->SetLongField(javaOffset, valueFid, offset); 2035 } 2036 return result; 2037} 2038 2039static jint Linux_sendtoBytes(JNIEnv* env, jobject, jobject javaFd, jobject javaBytes, jint byteOffset, jint byteCount, jint flags, jobject javaInetAddress, jint port) { 2040 ScopedBytesRO bytes(env, javaBytes); 2041 if (bytes.get() == NULL) { 2042 return -1; 2043 } 2044 2045 return NET_IPV4_FALLBACK(env, ssize_t, sendto, javaFd, javaInetAddress, port, 2046 NULL_ADDR_OK, bytes.get() + byteOffset, byteCount, flags); 2047} 2048 2049static jint Linux_sendtoBytesSocketAddress(JNIEnv* env, jobject, jobject javaFd, jobject javaBytes, jint byteOffset, jint byteCount, jint flags, jobject javaSocketAddress) { 2050 if (env->IsInstanceOf(javaSocketAddress, JniConstants::inetSocketAddressClass)) { 2051 // Use the InetAddress version so we get the benefit of NET_IPV4_FALLBACK. 2052 jobject javaInetAddress; 2053 jint port; 2054 javaInetSocketAddressToInetAddressAndPort(env, javaSocketAddress, javaInetAddress, port); 2055 return Linux_sendtoBytes(env, NULL, javaFd, javaBytes, byteOffset, byteCount, flags, 2056 javaInetAddress, port); 2057 } 2058 2059 ScopedBytesRO bytes(env, javaBytes); 2060 if (bytes.get() == NULL) { 2061 return -1; 2062 } 2063 2064 sockaddr_storage ss; 2065 socklen_t sa_len; 2066 if (!javaSocketAddressToSockaddr(env, javaSocketAddress, ss, sa_len)) { 2067 return -1; 2068 } 2069 2070 const sockaddr* sa = reinterpret_cast<const sockaddr*>(&ss); 2071 // We don't need the return value because we'll already have thrown. 2072 return NET_FAILURE_RETRY(env, ssize_t, sendto, javaFd, bytes.get() + byteOffset, byteCount, flags, sa, sa_len); 2073} 2074 2075static void Linux_setegid(JNIEnv* env, jobject, jint egid) { 2076 throwIfMinusOne(env, "setegid", TEMP_FAILURE_RETRY(setegid(egid))); 2077} 2078 2079static void Linux_setenv(JNIEnv* env, jobject, jstring javaName, jstring javaValue, jboolean overwrite) { 2080 ScopedUtfChars name(env, javaName); 2081 if (name.c_str() == NULL) { 2082 return; 2083 } 2084 ScopedUtfChars value(env, javaValue); 2085 if (value.c_str() == NULL) { 2086 return; 2087 } 2088 throwIfMinusOne(env, "setenv", setenv(name.c_str(), value.c_str(), overwrite)); 2089} 2090 2091static void Linux_seteuid(JNIEnv* env, jobject, jint euid) { 2092 throwIfMinusOne(env, "seteuid", TEMP_FAILURE_RETRY(seteuid(euid))); 2093} 2094 2095static void Linux_setgid(JNIEnv* env, jobject, jint gid) { 2096 throwIfMinusOne(env, "setgid", TEMP_FAILURE_RETRY(setgid(gid))); 2097} 2098 2099static void Linux_setpgid(JNIEnv* env, jobject, jint pid, int pgid) { 2100 throwIfMinusOne(env, "setpgid", TEMP_FAILURE_RETRY(setpgid(pid, pgid))); 2101} 2102 2103static void Linux_setregid(JNIEnv* env, jobject, jint rgid, int egid) { 2104 throwIfMinusOne(env, "setregid", TEMP_FAILURE_RETRY(setregid(rgid, egid))); 2105} 2106 2107static void Linux_setreuid(JNIEnv* env, jobject, jint ruid, int euid) { 2108 throwIfMinusOne(env, "setreuid", TEMP_FAILURE_RETRY(setreuid(ruid, euid))); 2109} 2110 2111static jint Linux_setsid(JNIEnv* env, jobject) { 2112 return throwIfMinusOne(env, "setsid", TEMP_FAILURE_RETRY(setsid())); 2113} 2114 2115static void Linux_setsockoptByte(JNIEnv* env, jobject, jobject javaFd, jint level, jint option, jint value) { 2116 int fd = jniGetFDFromFileDescriptor(env, javaFd); 2117 u_char byte = value; 2118 throwIfMinusOne(env, "setsockopt", TEMP_FAILURE_RETRY(setsockopt(fd, level, option, &byte, sizeof(byte)))); 2119} 2120 2121static void Linux_setsockoptIfreq(JNIEnv* env, jobject, jobject javaFd, jint level, jint option, jstring javaInterfaceName) { 2122 struct ifreq req; 2123 if (!fillIfreq(env, javaInterfaceName, req)) { 2124 return; 2125 } 2126 int fd = jniGetFDFromFileDescriptor(env, javaFd); 2127 throwIfMinusOne(env, "setsockopt", TEMP_FAILURE_RETRY(setsockopt(fd, level, option, &req, sizeof(req)))); 2128} 2129 2130static void Linux_setsockoptInt(JNIEnv* env, jobject, jobject javaFd, jint level, jint option, jint value) { 2131 int fd = jniGetFDFromFileDescriptor(env, javaFd); 2132 throwIfMinusOne(env, "setsockopt", TEMP_FAILURE_RETRY(setsockopt(fd, level, option, &value, sizeof(value)))); 2133} 2134 2135static void Linux_setsockoptIpMreqn(JNIEnv* env, jobject, jobject javaFd, jint level, jint option, jint value) { 2136 ip_mreqn req; 2137 memset(&req, 0, sizeof(req)); 2138 req.imr_ifindex = value; 2139 int fd = jniGetFDFromFileDescriptor(env, javaFd); 2140 throwIfMinusOne(env, "setsockopt", TEMP_FAILURE_RETRY(setsockopt(fd, level, option, &req, sizeof(req)))); 2141} 2142 2143static void Linux_setsockoptGroupReq(JNIEnv* env, jobject, jobject javaFd, jint level, jint option, jobject javaGroupReq) { 2144 struct group_req req; 2145 memset(&req, 0, sizeof(req)); 2146 2147 static jfieldID grInterfaceFid = env->GetFieldID(JniConstants::structGroupReqClass, "gr_interface", "I"); 2148 req.gr_interface = env->GetIntField(javaGroupReq, grInterfaceFid); 2149 // Get the IPv4 or IPv6 multicast address to join or leave. 2150 static jfieldID grGroupFid = env->GetFieldID(JniConstants::structGroupReqClass, "gr_group", "Ljava/net/InetAddress;"); 2151 ScopedLocalRef<jobject> javaGroup(env, env->GetObjectField(javaGroupReq, grGroupFid)); 2152 socklen_t sa_len; 2153 if (!inetAddressToSockaddrVerbatim(env, javaGroup.get(), 0, req.gr_group, sa_len)) { 2154 return; 2155 } 2156 2157 int fd = jniGetFDFromFileDescriptor(env, javaFd); 2158 int rc = TEMP_FAILURE_RETRY(setsockopt(fd, level, option, &req, sizeof(req))); 2159 if (rc == -1 && errno == EINVAL) { 2160 // Maybe we're a 32-bit binary talking to a 64-bit kernel? 2161 // glibc doesn't automatically handle this. 2162 // http://sourceware.org/bugzilla/show_bug.cgi?id=12080 2163 struct group_req64 { 2164 uint32_t gr_interface; 2165 uint32_t my_padding; 2166 sockaddr_storage gr_group; 2167 }; 2168 group_req64 req64; 2169 req64.gr_interface = req.gr_interface; 2170 memcpy(&req64.gr_group, &req.gr_group, sizeof(req.gr_group)); 2171 rc = TEMP_FAILURE_RETRY(setsockopt(fd, level, option, &req64, sizeof(req64))); 2172 } 2173 throwIfMinusOne(env, "setsockopt", rc); 2174} 2175 2176static void Linux_setsockoptGroupSourceReq(JNIEnv* env, jobject, jobject javaFd, jint level, jint option, jobject javaGroupSourceReq) { 2177 socklen_t sa_len; 2178 struct group_source_req req; 2179 memset(&req, 0, sizeof(req)); 2180 2181 static jfieldID gsrInterfaceFid = env->GetFieldID(JniConstants::structGroupSourceReqClass, "gsr_interface", "I"); 2182 req.gsr_interface = env->GetIntField(javaGroupSourceReq, gsrInterfaceFid); 2183 // Get the IPv4 or IPv6 multicast address to join or leave. 2184 static jfieldID gsrGroupFid = env->GetFieldID(JniConstants::structGroupSourceReqClass, "gsr_group", "Ljava/net/InetAddress;"); 2185 ScopedLocalRef<jobject> javaGroup(env, env->GetObjectField(javaGroupSourceReq, gsrGroupFid)); 2186 if (!inetAddressToSockaddrVerbatim(env, javaGroup.get(), 0, req.gsr_group, sa_len)) { 2187 return; 2188 } 2189 2190 // Get the IPv4 or IPv6 multicast address to add to the filter. 2191 static jfieldID gsrSourceFid = env->GetFieldID(JniConstants::structGroupSourceReqClass, "gsr_source", "Ljava/net/InetAddress;"); 2192 ScopedLocalRef<jobject> javaSource(env, env->GetObjectField(javaGroupSourceReq, gsrSourceFid)); 2193 if (!inetAddressToSockaddrVerbatim(env, javaSource.get(), 0, req.gsr_source, sa_len)) { 2194 return; 2195 } 2196 2197 int fd = jniGetFDFromFileDescriptor(env, javaFd); 2198 int rc = TEMP_FAILURE_RETRY(setsockopt(fd, level, option, &req, sizeof(req))); 2199 if (rc == -1 && errno == EINVAL) { 2200 // Maybe we're a 32-bit binary talking to a 64-bit kernel? 2201 // glibc doesn't automatically handle this. 2202 // http://sourceware.org/bugzilla/show_bug.cgi?id=12080 2203 struct group_source_req64 { 2204 uint32_t gsr_interface; 2205 uint32_t my_padding; 2206 sockaddr_storage gsr_group; 2207 sockaddr_storage gsr_source; 2208 }; 2209 group_source_req64 req64; 2210 req64.gsr_interface = req.gsr_interface; 2211 memcpy(&req64.gsr_group, &req.gsr_group, sizeof(req.gsr_group)); 2212 memcpy(&req64.gsr_source, &req.gsr_source, sizeof(req.gsr_source)); 2213 rc = TEMP_FAILURE_RETRY(setsockopt(fd, level, option, &req64, sizeof(req64))); 2214 } 2215 throwIfMinusOne(env, "setsockopt", rc); 2216} 2217 2218static void Linux_setsockoptLinger(JNIEnv* env, jobject, jobject javaFd, jint level, jint option, jobject javaLinger) { 2219 static jfieldID lOnoffFid = env->GetFieldID(JniConstants::structLingerClass, "l_onoff", "I"); 2220 static jfieldID lLingerFid = env->GetFieldID(JniConstants::structLingerClass, "l_linger", "I"); 2221 int fd = jniGetFDFromFileDescriptor(env, javaFd); 2222 struct linger value; 2223 value.l_onoff = env->GetIntField(javaLinger, lOnoffFid); 2224 value.l_linger = env->GetIntField(javaLinger, lLingerFid); 2225 throwIfMinusOne(env, "setsockopt", TEMP_FAILURE_RETRY(setsockopt(fd, level, option, &value, sizeof(value)))); 2226} 2227 2228static void Linux_setsockoptTimeval(JNIEnv* env, jobject, jobject javaFd, jint level, jint option, jobject javaTimeval) { 2229 static jfieldID tvSecFid = env->GetFieldID(JniConstants::structTimevalClass, "tv_sec", "J"); 2230 static jfieldID tvUsecFid = env->GetFieldID(JniConstants::structTimevalClass, "tv_usec", "J"); 2231 int fd = jniGetFDFromFileDescriptor(env, javaFd); 2232 struct timeval value; 2233 value.tv_sec = env->GetLongField(javaTimeval, tvSecFid); 2234 value.tv_usec = env->GetLongField(javaTimeval, tvUsecFid); 2235 throwIfMinusOne(env, "setsockopt", TEMP_FAILURE_RETRY(setsockopt(fd, level, option, &value, sizeof(value)))); 2236} 2237 2238static void Linux_setuid(JNIEnv* env, jobject, jint uid) { 2239 throwIfMinusOne(env, "setuid", TEMP_FAILURE_RETRY(setuid(uid))); 2240} 2241 2242static void Linux_setxattr(JNIEnv* env, jobject, jstring javaPath, jstring javaName, 2243 jbyteArray javaValue, jint flags) { 2244 ScopedUtfChars path(env, javaPath); 2245 if (path.c_str() == NULL) { 2246 return; 2247 } 2248 ScopedUtfChars name(env, javaName); 2249 if (name.c_str() == NULL) { 2250 return; 2251 } 2252 ScopedBytesRO value(env, javaValue); 2253 if (value.get() == NULL) { 2254 return; 2255 } 2256 size_t valueLength = env->GetArrayLength(javaValue); 2257 int res = setxattr(path.c_str(), name.c_str(), value.get(), valueLength, flags); 2258 if (res < 0) { 2259 throwErrnoException(env, "setxattr"); 2260 } 2261} 2262 2263static void Linux_shutdown(JNIEnv* env, jobject, jobject javaFd, jint how) { 2264 int fd = jniGetFDFromFileDescriptor(env, javaFd); 2265 throwIfMinusOne(env, "shutdown", TEMP_FAILURE_RETRY(shutdown(fd, how))); 2266} 2267 2268static jobject Linux_socket(JNIEnv* env, jobject, jint domain, jint type, jint protocol) { 2269 if (domain == AF_PACKET) { 2270 protocol = htons(protocol); // Packet sockets specify the protocol in host byte order. 2271 } 2272 int fd = throwIfMinusOne(env, "socket", TEMP_FAILURE_RETRY(socket(domain, type, protocol))); 2273 return fd != -1 ? jniCreateFileDescriptor(env, fd) : NULL; 2274} 2275 2276static void Linux_socketpair(JNIEnv* env, jobject, jint domain, jint type, jint protocol, jobject javaFd1, jobject javaFd2) { 2277 int fds[2]; 2278 int rc = throwIfMinusOne(env, "socketpair", TEMP_FAILURE_RETRY(socketpair(domain, type, protocol, fds))); 2279 if (rc != -1) { 2280 jniSetFileDescriptorOfFD(env, javaFd1, fds[0]); 2281 jniSetFileDescriptorOfFD(env, javaFd2, fds[1]); 2282 } 2283} 2284 2285static jobject Linux_stat(JNIEnv* env, jobject, jstring javaPath) { 2286 return doStat(env, javaPath, false); 2287} 2288 2289static jobject Linux_statvfs(JNIEnv* env, jobject, jstring javaPath) { 2290 ScopedUtfChars path(env, javaPath); 2291 if (path.c_str() == NULL) { 2292 return NULL; 2293 } 2294 struct statvfs sb; 2295 int rc = TEMP_FAILURE_RETRY(statvfs(path.c_str(), &sb)); 2296 if (rc == -1) { 2297 throwErrnoException(env, "statvfs"); 2298 return NULL; 2299 } 2300 return makeStructStatVfs(env, sb); 2301} 2302 2303static jstring Linux_strerror(JNIEnv* env, jobject, jint errnum) { 2304 char buffer[BUFSIZ]; 2305 const char* message = jniStrError(errnum, buffer, sizeof(buffer)); 2306 return env->NewStringUTF(message); 2307} 2308 2309static jstring Linux_strsignal(JNIEnv* env, jobject, jint signal) { 2310 return env->NewStringUTF(strsignal(signal)); 2311} 2312 2313static void Linux_symlink(JNIEnv* env, jobject, jstring javaOldPath, jstring javaNewPath) { 2314 ScopedUtfChars oldPath(env, javaOldPath); 2315 if (oldPath.c_str() == NULL) { 2316 return; 2317 } 2318 ScopedUtfChars newPath(env, javaNewPath); 2319 if (newPath.c_str() == NULL) { 2320 return; 2321 } 2322 throwIfMinusOne(env, "symlink", TEMP_FAILURE_RETRY(symlink(oldPath.c_str(), newPath.c_str()))); 2323} 2324 2325static jlong Linux_sysconf(JNIEnv* env, jobject, jint name) { 2326 // Since -1 is a valid result from sysconf(3), detecting failure is a little more awkward. 2327 errno = 0; 2328 long result = sysconf(name); 2329 if (result == -1L && errno == EINVAL) { 2330 throwErrnoException(env, "sysconf"); 2331 } 2332 return result; 2333} 2334 2335static void Linux_tcdrain(JNIEnv* env, jobject, jobject javaFd) { 2336 int fd = jniGetFDFromFileDescriptor(env, javaFd); 2337 throwIfMinusOne(env, "tcdrain", TEMP_FAILURE_RETRY(tcdrain(fd))); 2338} 2339 2340static void Linux_tcsendbreak(JNIEnv* env, jobject, jobject javaFd, jint duration) { 2341 int fd = jniGetFDFromFileDescriptor(env, javaFd); 2342 throwIfMinusOne(env, "tcsendbreak", TEMP_FAILURE_RETRY(tcsendbreak(fd, duration))); 2343} 2344 2345static jint Linux_umaskImpl(JNIEnv*, jobject, jint mask) { 2346 return umask(mask); 2347} 2348 2349static jobject Linux_uname(JNIEnv* env, jobject) { 2350 struct utsname buf; 2351 if (TEMP_FAILURE_RETRY(uname(&buf)) == -1) { 2352 return NULL; // Can't happen. 2353 } 2354 return makeStructUtsname(env, buf); 2355} 2356 2357static void Linux_unlink(JNIEnv* env, jobject, jstring javaPathname) { 2358 ScopedUtfChars pathname(env, javaPathname); 2359 if (pathname.c_str() == NULL) { 2360 return; 2361 } 2362 throwIfMinusOne(env, "unlink", unlink(pathname.c_str())); 2363} 2364 2365static void Linux_unsetenv(JNIEnv* env, jobject, jstring javaName) { 2366 ScopedUtfChars name(env, javaName); 2367 if (name.c_str() == NULL) { 2368 return; 2369 } 2370 throwIfMinusOne(env, "unsetenv", unsetenv(name.c_str())); 2371} 2372 2373static jint Linux_waitpid(JNIEnv* env, jobject, jint pid, jobject javaStatus, jint options) { 2374 int status; 2375 int rc = throwIfMinusOne(env, "waitpid", TEMP_FAILURE_RETRY(waitpid(pid, &status, options))); 2376 if (rc != -1) { 2377 static jfieldID valueFid = env->GetFieldID(JniConstants::mutableIntClass, "value", "I"); 2378 env->SetIntField(javaStatus, valueFid, status); 2379 } 2380 return rc; 2381} 2382 2383static jint Linux_writeBytes(JNIEnv* env, jobject, jobject javaFd, jbyteArray javaBytes, jint byteOffset, jint byteCount) { 2384 ScopedBytesRO bytes(env, javaBytes); 2385 if (bytes.get() == NULL) { 2386 return -1; 2387 } 2388 return IO_FAILURE_RETRY(env, ssize_t, write, javaFd, bytes.get() + byteOffset, byteCount); 2389} 2390 2391static jint Linux_writev(JNIEnv* env, jobject, jobject javaFd, jobjectArray buffers, jintArray offsets, jintArray byteCounts) { 2392 IoVec<ScopedBytesRO> ioVec(env, env->GetArrayLength(buffers)); 2393 if (!ioVec.init(buffers, offsets, byteCounts)) { 2394 return -1; 2395 } 2396 return IO_FAILURE_RETRY(env, ssize_t, writev, javaFd, ioVec.get(), ioVec.size()); 2397} 2398 2399#define NATIVE_METHOD_OVERLOAD(className, functionName, signature, variant) \ 2400 { #functionName, signature, reinterpret_cast<void*>(className ## _ ## functionName ## variant) } 2401 2402static JNINativeMethod gMethods[] = { 2403 NATIVE_METHOD(Linux, accept, "(Ljava/io/FileDescriptor;Ljava/net/SocketAddress;)Ljava/io/FileDescriptor;"), 2404 NATIVE_METHOD(Linux, access, "(Ljava/lang/String;I)Z"), 2405 NATIVE_METHOD(Linux, android_getaddrinfo, "(Ljava/lang/String;Landroid/system/StructAddrinfo;I)[Ljava/net/InetAddress;"), 2406 NATIVE_METHOD(Linux, bind, "(Ljava/io/FileDescriptor;Ljava/net/InetAddress;I)V"), 2407 NATIVE_METHOD_OVERLOAD(Linux, bind, "(Ljava/io/FileDescriptor;Ljava/net/SocketAddress;)V", SocketAddress), 2408 NATIVE_METHOD(Linux, capget, 2409 "(Landroid/system/StructCapUserHeader;)[Landroid/system/StructCapUserData;"), 2410 NATIVE_METHOD(Linux, capset, 2411 "(Landroid/system/StructCapUserHeader;[Landroid/system/StructCapUserData;)V"), 2412 NATIVE_METHOD(Linux, chmod, "(Ljava/lang/String;I)V"), 2413 NATIVE_METHOD(Linux, chown, "(Ljava/lang/String;II)V"), 2414 NATIVE_METHOD(Linux, close, "(Ljava/io/FileDescriptor;)V"), 2415 NATIVE_METHOD(Linux, connect, "(Ljava/io/FileDescriptor;Ljava/net/InetAddress;I)V"), 2416 NATIVE_METHOD_OVERLOAD(Linux, connect, "(Ljava/io/FileDescriptor;Ljava/net/SocketAddress;)V", SocketAddress), 2417 NATIVE_METHOD(Linux, dup, "(Ljava/io/FileDescriptor;)Ljava/io/FileDescriptor;"), 2418 NATIVE_METHOD(Linux, dup2, "(Ljava/io/FileDescriptor;I)Ljava/io/FileDescriptor;"), 2419 NATIVE_METHOD(Linux, environ, "()[Ljava/lang/String;"), 2420 NATIVE_METHOD(Linux, execv, "(Ljava/lang/String;[Ljava/lang/String;)V"), 2421 NATIVE_METHOD(Linux, execve, "(Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/String;)V"), 2422 NATIVE_METHOD(Linux, fchmod, "(Ljava/io/FileDescriptor;I)V"), 2423 NATIVE_METHOD(Linux, fchown, "(Ljava/io/FileDescriptor;II)V"), 2424 NATIVE_METHOD(Linux, fcntlFlock, "(Ljava/io/FileDescriptor;ILandroid/system/StructFlock;)I"), 2425 NATIVE_METHOD(Linux, fcntlInt, "(Ljava/io/FileDescriptor;II)I"), 2426 NATIVE_METHOD(Linux, fcntlVoid, "(Ljava/io/FileDescriptor;I)I"), 2427 NATIVE_METHOD(Linux, fdatasync, "(Ljava/io/FileDescriptor;)V"), 2428 NATIVE_METHOD(Linux, fstat, "(Ljava/io/FileDescriptor;)Landroid/system/StructStat;"), 2429 NATIVE_METHOD(Linux, fstatvfs, "(Ljava/io/FileDescriptor;)Landroid/system/StructStatVfs;"), 2430 NATIVE_METHOD(Linux, fsync, "(Ljava/io/FileDescriptor;)V"), 2431 NATIVE_METHOD(Linux, ftruncate, "(Ljava/io/FileDescriptor;J)V"), 2432 NATIVE_METHOD(Linux, gai_strerror, "(I)Ljava/lang/String;"), 2433 NATIVE_METHOD(Linux, getegid, "()I"), 2434 NATIVE_METHOD(Linux, geteuid, "()I"), 2435 NATIVE_METHOD(Linux, getgid, "()I"), 2436 NATIVE_METHOD(Linux, getenv, "(Ljava/lang/String;)Ljava/lang/String;"), 2437 NATIVE_METHOD(Linux, getnameinfo, "(Ljava/net/InetAddress;I)Ljava/lang/String;"), 2438 NATIVE_METHOD(Linux, getpeername, "(Ljava/io/FileDescriptor;)Ljava/net/SocketAddress;"), 2439 NATIVE_METHOD(Linux, getpgid, "(I)I"), 2440 NATIVE_METHOD(Linux, getpid, "()I"), 2441 NATIVE_METHOD(Linux, getppid, "()I"), 2442 NATIVE_METHOD(Linux, getpwnam, "(Ljava/lang/String;)Landroid/system/StructPasswd;"), 2443 NATIVE_METHOD(Linux, getpwuid, "(I)Landroid/system/StructPasswd;"), 2444 NATIVE_METHOD(Linux, getrlimit, "(I)Landroid/system/StructRlimit;"), 2445 NATIVE_METHOD(Linux, getsockname, "(Ljava/io/FileDescriptor;)Ljava/net/SocketAddress;"), 2446 NATIVE_METHOD(Linux, getsockoptByte, "(Ljava/io/FileDescriptor;II)I"), 2447 NATIVE_METHOD(Linux, getsockoptInAddr, "(Ljava/io/FileDescriptor;II)Ljava/net/InetAddress;"), 2448 NATIVE_METHOD(Linux, getsockoptInt, "(Ljava/io/FileDescriptor;II)I"), 2449 NATIVE_METHOD(Linux, getsockoptLinger, "(Ljava/io/FileDescriptor;II)Landroid/system/StructLinger;"), 2450 NATIVE_METHOD(Linux, getsockoptTimeval, "(Ljava/io/FileDescriptor;II)Landroid/system/StructTimeval;"), 2451 NATIVE_METHOD(Linux, getsockoptUcred, "(Ljava/io/FileDescriptor;II)Landroid/system/StructUcred;"), 2452 NATIVE_METHOD(Linux, gettid, "()I"), 2453 NATIVE_METHOD(Linux, getuid, "()I"), 2454 NATIVE_METHOD(Linux, getxattr, "(Ljava/lang/String;Ljava/lang/String;)[B"), 2455 NATIVE_METHOD(Linux, getifaddrs, "()[Landroid/system/StructIfaddrs;"), 2456 NATIVE_METHOD(Linux, if_indextoname, "(I)Ljava/lang/String;"), 2457 NATIVE_METHOD(Linux, if_nametoindex, "(Ljava/lang/String;)I"), 2458 NATIVE_METHOD(Linux, inet_pton, "(ILjava/lang/String;)Ljava/net/InetAddress;"), 2459 NATIVE_METHOD(Linux, ioctlFlags, "(Ljava/io/FileDescriptor;Ljava/lang/String;)I"), 2460 NATIVE_METHOD(Linux, ioctlInetAddress, "(Ljava/io/FileDescriptor;ILjava/lang/String;)Ljava/net/InetAddress;"), 2461 NATIVE_METHOD(Linux, ioctlInt, "(Ljava/io/FileDescriptor;ILandroid/util/MutableInt;)I"), 2462 NATIVE_METHOD(Linux, ioctlMTU, "(Ljava/io/FileDescriptor;Ljava/lang/String;)I"), 2463 NATIVE_METHOD(Linux, isatty, "(Ljava/io/FileDescriptor;)Z"), 2464 NATIVE_METHOD(Linux, kill, "(II)V"), 2465 NATIVE_METHOD(Linux, lchown, "(Ljava/lang/String;II)V"), 2466 NATIVE_METHOD(Linux, link, "(Ljava/lang/String;Ljava/lang/String;)V"), 2467 NATIVE_METHOD(Linux, listen, "(Ljava/io/FileDescriptor;I)V"), 2468 NATIVE_METHOD(Linux, listxattr, "(Ljava/lang/String;)[Ljava/lang/String;"), 2469 NATIVE_METHOD(Linux, lseek, "(Ljava/io/FileDescriptor;JI)J"), 2470 NATIVE_METHOD(Linux, lstat, "(Ljava/lang/String;)Landroid/system/StructStat;"), 2471 NATIVE_METHOD(Linux, mincore, "(JJ[B)V"), 2472 NATIVE_METHOD(Linux, mkdir, "(Ljava/lang/String;I)V"), 2473 NATIVE_METHOD(Linux, mkfifo, "(Ljava/lang/String;I)V"), 2474 NATIVE_METHOD(Linux, mlock, "(JJ)V"), 2475 NATIVE_METHOD(Linux, mmap, "(JJIILjava/io/FileDescriptor;J)J"), 2476 NATIVE_METHOD(Linux, msync, "(JJI)V"), 2477 NATIVE_METHOD(Linux, munlock, "(JJ)V"), 2478 NATIVE_METHOD(Linux, munmap, "(JJ)V"), 2479 NATIVE_METHOD(Linux, open, "(Ljava/lang/String;II)Ljava/io/FileDescriptor;"), 2480 NATIVE_METHOD(Linux, pipe2, "(I)[Ljava/io/FileDescriptor;"), 2481 NATIVE_METHOD(Linux, poll, "([Landroid/system/StructPollfd;I)I"), 2482 NATIVE_METHOD(Linux, posix_fallocate, "(Ljava/io/FileDescriptor;JJ)V"), 2483 NATIVE_METHOD(Linux, prctl, "(IJJJJ)I"), 2484 NATIVE_METHOD(Linux, preadBytes, "(Ljava/io/FileDescriptor;Ljava/lang/Object;IIJ)I"), 2485 NATIVE_METHOD(Linux, pwriteBytes, "(Ljava/io/FileDescriptor;Ljava/lang/Object;IIJ)I"), 2486 NATIVE_METHOD(Linux, readBytes, "(Ljava/io/FileDescriptor;Ljava/lang/Object;II)I"), 2487 NATIVE_METHOD(Linux, readlink, "(Ljava/lang/String;)Ljava/lang/String;"), 2488 NATIVE_METHOD(Linux, realpath, "(Ljava/lang/String;)Ljava/lang/String;"), 2489 NATIVE_METHOD(Linux, readv, "(Ljava/io/FileDescriptor;[Ljava/lang/Object;[I[I)I"), 2490 NATIVE_METHOD(Linux, recvfromBytes, "(Ljava/io/FileDescriptor;Ljava/lang/Object;IIILjava/net/InetSocketAddress;)I"), 2491 NATIVE_METHOD(Linux, remove, "(Ljava/lang/String;)V"), 2492 NATIVE_METHOD(Linux, removexattr, "(Ljava/lang/String;Ljava/lang/String;)V"), 2493 NATIVE_METHOD(Linux, rename, "(Ljava/lang/String;Ljava/lang/String;)V"), 2494 NATIVE_METHOD(Linux, sendfile, "(Ljava/io/FileDescriptor;Ljava/io/FileDescriptor;Landroid/util/MutableLong;J)J"), 2495 NATIVE_METHOD(Linux, sendtoBytes, "(Ljava/io/FileDescriptor;Ljava/lang/Object;IIILjava/net/InetAddress;I)I"), 2496 NATIVE_METHOD_OVERLOAD(Linux, sendtoBytes, "(Ljava/io/FileDescriptor;Ljava/lang/Object;IIILjava/net/SocketAddress;)I", SocketAddress), 2497 NATIVE_METHOD(Linux, setegid, "(I)V"), 2498 NATIVE_METHOD(Linux, setenv, "(Ljava/lang/String;Ljava/lang/String;Z)V"), 2499 NATIVE_METHOD(Linux, seteuid, "(I)V"), 2500 NATIVE_METHOD(Linux, setgid, "(I)V"), 2501 NATIVE_METHOD(Linux, setpgid, "(II)V"), 2502 NATIVE_METHOD(Linux, setregid, "(II)V"), 2503 NATIVE_METHOD(Linux, setreuid, "(II)V"), 2504 NATIVE_METHOD(Linux, setsid, "()I"), 2505 NATIVE_METHOD(Linux, setsockoptByte, "(Ljava/io/FileDescriptor;III)V"), 2506 NATIVE_METHOD(Linux, setsockoptIfreq, "(Ljava/io/FileDescriptor;IILjava/lang/String;)V"), 2507 NATIVE_METHOD(Linux, setsockoptInt, "(Ljava/io/FileDescriptor;III)V"), 2508 NATIVE_METHOD(Linux, setsockoptIpMreqn, "(Ljava/io/FileDescriptor;III)V"), 2509 NATIVE_METHOD(Linux, setsockoptGroupReq, "(Ljava/io/FileDescriptor;IILandroid/system/StructGroupReq;)V"), 2510 NATIVE_METHOD(Linux, setsockoptGroupSourceReq, "(Ljava/io/FileDescriptor;IILandroid/system/StructGroupSourceReq;)V"), 2511 NATIVE_METHOD(Linux, setsockoptLinger, "(Ljava/io/FileDescriptor;IILandroid/system/StructLinger;)V"), 2512 NATIVE_METHOD(Linux, setsockoptTimeval, "(Ljava/io/FileDescriptor;IILandroid/system/StructTimeval;)V"), 2513 NATIVE_METHOD(Linux, setuid, "(I)V"), 2514 NATIVE_METHOD(Linux, setxattr, "(Ljava/lang/String;Ljava/lang/String;[BI)V"), 2515 NATIVE_METHOD(Linux, shutdown, "(Ljava/io/FileDescriptor;I)V"), 2516 NATIVE_METHOD(Linux, socket, "(III)Ljava/io/FileDescriptor;"), 2517 NATIVE_METHOD(Linux, socketpair, "(IIILjava/io/FileDescriptor;Ljava/io/FileDescriptor;)V"), 2518 NATIVE_METHOD(Linux, stat, "(Ljava/lang/String;)Landroid/system/StructStat;"), 2519 NATIVE_METHOD(Linux, statvfs, "(Ljava/lang/String;)Landroid/system/StructStatVfs;"), 2520 NATIVE_METHOD(Linux, strerror, "(I)Ljava/lang/String;"), 2521 NATIVE_METHOD(Linux, strsignal, "(I)Ljava/lang/String;"), 2522 NATIVE_METHOD(Linux, symlink, "(Ljava/lang/String;Ljava/lang/String;)V"), 2523 NATIVE_METHOD(Linux, sysconf, "(I)J"), 2524 NATIVE_METHOD(Linux, tcdrain, "(Ljava/io/FileDescriptor;)V"), 2525 NATIVE_METHOD(Linux, tcsendbreak, "(Ljava/io/FileDescriptor;I)V"), 2526 NATIVE_METHOD(Linux, umaskImpl, "(I)I"), 2527 NATIVE_METHOD(Linux, uname, "()Landroid/system/StructUtsname;"), 2528 NATIVE_METHOD(Linux, unlink, "(Ljava/lang/String;)V"), 2529 NATIVE_METHOD(Linux, unsetenv, "(Ljava/lang/String;)V"), 2530 NATIVE_METHOD(Linux, waitpid, "(ILandroid/util/MutableInt;I)I"), 2531 NATIVE_METHOD(Linux, writeBytes, "(Ljava/io/FileDescriptor;Ljava/lang/Object;II)I"), 2532 NATIVE_METHOD(Linux, writev, "(Ljava/io/FileDescriptor;[Ljava/lang/Object;[I[I)I"), 2533}; 2534void register_libcore_io_Linux(JNIEnv* env) { 2535 jniRegisterNativeMethods(env, "libcore/io/Linux", gMethods, NELEM(gMethods)); 2536} 2537