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