libcore_io_Linux.cpp revision 069525a39125c203b658c805685b6045a7d4dfeb
128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org/* 228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org * Copyright (C) 2011 The Android Open Source Project 328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org * 428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org * Licensed under the Apache License, Version 2.0 (the "License"); 528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org * you may not use this file except in compliance with the License. 628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org * You may obtain a copy of the License at 728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org * 828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org * http://www.apache.org/licenses/LICENSE-2.0 928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org * 1028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org * Unless required by applicable law or agreed to in writing, software 1128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org * distributed under the License is distributed on an "AS IS" BASIS, 1228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 1328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org * See the License for the specific language governing permissions and 1428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org * limitations under the License. 1528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org */ 1628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 1728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#define LOG_TAG "Posix" 1828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 1928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include "AsynchronousSocketCloseMonitor.h" 2028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include "ExecStrings.h" 2128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include "JNIHelp.h" 2228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include "JniConstants.h" 2328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include "JniException.h" 2428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include "NetworkUtilities.h" 2528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include "Portability.h" 2628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include "ScopedBytes.h" 2728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include "ScopedLocalRef.h" 2828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include "ScopedPrimitiveArray.h" 2928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include "ScopedUtfChars.h" 3028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include "StaticAssert.h" 3128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include "UniquePtr.h" 3228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include "toStringArray.h" 334551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 344551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org#include <arpa/inet.h> 3528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include <errno.h> 3628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include <fcntl.h> 3728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include <net/if.h> 3828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include <netdb.h> 3928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include <netinet/in.h> 4028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include <poll.h> 4128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include <pwd.h> 4228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include <signal.h> 4328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include <stdlib.h> 4428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include <sys/ioctl.h> 4528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include <sys/mman.h> 4628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include <sys/socket.h> 4728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include <sys/stat.h> 4828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include <sys/syscall.h> 4928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include <sys/time.h> 5028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include <sys/types.h> 5128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include <sys/uio.h> 5228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include <sys/utsname.h> 5328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include <sys/wait.h> 5428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include <termios.h> 5528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#include <unistd.h> 5628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 5728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#define TO_JAVA_STRING(NAME, EXP) \ 5828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org jstring NAME = env->NewStringUTF(EXP); \ 5928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org if (NAME == NULL) return NULL; 6028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 6128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgstruct addrinfo_deleter { 6228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org void operator()(addrinfo* p) const { 6328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org if (p != NULL) { // bionic's freeaddrinfo(3) crashes when passed NULL. 6428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org freeaddrinfo(p); 654551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org } 6628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org } 6728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org}; 6828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 6928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org/** 704551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org * Used to retry networking system calls that can return EINTR. Unlike TEMP_FAILURE_RETRY, 7128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org * this also handles the case where the reason for failure is that another thread called 7228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org * Socket.close. This macro also throws exceptions on failure. 7328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org * 7428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org * Returns the result of 'exp', though a Java exception will be pending if the result is -1. 7528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org */ 7628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org#define NET_FAILURE_RETRY(jni_env, return_type, syscall_name, java_fd, ...) ({ \ 7728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return_type _rc = -1; \ 7828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org do { \ 7928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org { \ 8028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org int _fd = jniGetFDFromFileDescriptor(jni_env, java_fd); \ 8128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org AsynchronousSocketCloseMonitor _monitor(_fd); \ 824551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org _rc = syscall_name(_fd, __VA_ARGS__); \ 834551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org } \ 844551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org if (_rc == -1) { \ 854551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org if (jniGetFDFromFileDescriptor(jni_env, java_fd) == -1) { \ 864551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org jniThrowException(jni_env, "java/net/SocketException", "Socket closed"); \ 874551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org break; \ 884551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org } else if (errno != EINTR) { \ 894551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org /* TODO: with a format string we could show the arguments too, like strace(1). */ \ 904551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org throwErrnoException(jni_env, # syscall_name); \ 914551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org break; \ 924551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org } \ 934551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org } \ 944551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org } while (_rc == -1); \ 9528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org _rc; }) 964551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 9728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgstatic void throwException(JNIEnv* env, jclass exceptionClass, jmethodID ctor3, jmethodID ctor2, 9828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org const char* functionName, int error) { 9928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org jthrowable cause = NULL; 10028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org if (env->ExceptionCheck()) { 10128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org cause = env->ExceptionOccurred(); 10228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org env->ExceptionClear(); 10328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org } 1044551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 1054551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org ScopedLocalRef<jstring> detailMessage(env, env->NewStringUTF(functionName)); 1064551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org if (detailMessage.get() == NULL) { 10728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org // Not really much we can do here. We're probably dead in the water, 10828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org // but let's try to stumble on... 10928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org env->ExceptionClear(); 11028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org } 11128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 11228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org jobject exception; 11328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org if (cause != NULL) { 11428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org exception = env->NewObject(exceptionClass, ctor3, detailMessage.get(), error, cause); 1154551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org } else { 1164551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org exception = env->NewObject(exceptionClass, ctor2, detailMessage.get(), error); 11728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org } 11828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org env->Throw(reinterpret_cast<jthrowable>(exception)); 11928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org} 12028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 12128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgstatic void throwErrnoException(JNIEnv* env, const char* functionName) { 12228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org int error = errno; 12328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org static jmethodID ctor3 = env->GetMethodID(JniConstants::errnoExceptionClass, 12428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org "<init>", "(Ljava/lang/String;ILjava/lang/Throwable;)V"); 12528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org static jmethodID ctor2 = env->GetMethodID(JniConstants::errnoExceptionClass, 12628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org "<init>", "(Ljava/lang/String;I)V"); 1274551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org throwException(env, JniConstants::errnoExceptionClass, ctor3, ctor2, functionName, error); 12828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org} 12928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 13028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgstatic void throwGaiException(JNIEnv* env, const char* functionName, int error) { 13128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org // Cache the methods ids before we throw, so we don't call GetMethodID with a pending exception. 13228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org static jmethodID ctor3 = env->GetMethodID(JniConstants::gaiExceptionClass, "<init>", 13328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org "(Ljava/lang/String;ILjava/lang/Throwable;)V"); 13428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org static jmethodID ctor2 = env->GetMethodID(JniConstants::gaiExceptionClass, "<init>", 13528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org "(Ljava/lang/String;I)V"); 13628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org if (errno != 0) { 13728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org // EAI_SYSTEM should mean "look at errno instead", but both glibc and bionic seem to 13828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org // mess this up. In particular, if you don't have INTERNET permission, errno will be EACCES 13928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org // but you'll get EAI_NONAME or EAI_NODATA. So we want our GaiException to have a 14028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org // potentially-relevant ErrnoException as its cause even if error != EAI_SYSTEM. 14128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org // http://code.google.com/p/android/issues/detail?id=15722 14228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org throwErrnoException(env, functionName); 14328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org // Deliberately fall through to throw another exception... 14428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org } 14528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org throwException(env, JniConstants::gaiExceptionClass, ctor3, ctor2, functionName, error); 14628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org} 14728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 14828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgtemplate <typename rc_t> 1494551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.orgstatic rc_t throwIfMinusOne(JNIEnv* env, const char* name, rc_t rc) { 1504551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org if (rc == rc_t(-1)) { 1514551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org throwErrnoException(env, name); 1524551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org } 1534551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return rc; 1544551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org} 1554551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 1564551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.orgtemplate <typename ScopedT> 1574551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.orgclass IoVec { 1584551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.orgpublic: 1594551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org IoVec(JNIEnv* env, size_t bufferCount) : mEnv(env), mBufferCount(bufferCount) { 1604551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org } 1614551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 1624551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org bool init(jobjectArray javaBuffers, jintArray javaOffsets, jintArray javaByteCounts) { 1634551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org // We can't delete our local references until after the I/O, so make sure we have room. 1644551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org if (mEnv->PushLocalFrame(mBufferCount + 16) < 0) { 1654551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return false; 1664551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org } 1674551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org ScopedIntArrayRO offsets(mEnv, javaOffsets); 1684551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org if (offsets.get() == NULL) { 1694551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return false; 1704551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org } 17119f27e6a24f877fc2b0409a94b02d5f40ba3dc8cmallinath@webrtc.org ScopedIntArrayRO byteCounts(mEnv, javaByteCounts); 1724551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org if (byteCounts.get() == NULL) { 1734551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return false; 1744551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org } 1754551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org // TODO: Linux actually has a 1024 buffer limit. glibc works around this, and we should too. 1764551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org // TODO: you can query the limit at runtime with sysconf(_SC_IOV_MAX). 1774551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org for (size_t i = 0; i < mBufferCount; ++i) { 17819f27e6a24f877fc2b0409a94b02d5f40ba3dc8cmallinath@webrtc.org jobject buffer = mEnv->GetObjectArrayElement(javaBuffers, i); // We keep this local ref. 17919f27e6a24f877fc2b0409a94b02d5f40ba3dc8cmallinath@webrtc.org mScopedBuffers.push_back(new ScopedT(mEnv, buffer)); 18019f27e6a24f877fc2b0409a94b02d5f40ba3dc8cmallinath@webrtc.org jbyte* ptr = const_cast<jbyte*>(mScopedBuffers.back()->get()); 18119f27e6a24f877fc2b0409a94b02d5f40ba3dc8cmallinath@webrtc.org if (ptr == NULL) { 18219f27e6a24f877fc2b0409a94b02d5f40ba3dc8cmallinath@webrtc.org return false; 18319f27e6a24f877fc2b0409a94b02d5f40ba3dc8cmallinath@webrtc.org } 18419f27e6a24f877fc2b0409a94b02d5f40ba3dc8cmallinath@webrtc.org struct iovec iov; 18519f27e6a24f877fc2b0409a94b02d5f40ba3dc8cmallinath@webrtc.org iov.iov_base = reinterpret_cast<void*>(ptr + offsets[i]); 18619f27e6a24f877fc2b0409a94b02d5f40ba3dc8cmallinath@webrtc.org iov.iov_len = byteCounts[i]; 18719f27e6a24f877fc2b0409a94b02d5f40ba3dc8cmallinath@webrtc.org mIoVec.push_back(iov); 18819f27e6a24f877fc2b0409a94b02d5f40ba3dc8cmallinath@webrtc.org } 18919f27e6a24f877fc2b0409a94b02d5f40ba3dc8cmallinath@webrtc.org return true; 19019f27e6a24f877fc2b0409a94b02d5f40ba3dc8cmallinath@webrtc.org } 19119f27e6a24f877fc2b0409a94b02d5f40ba3dc8cmallinath@webrtc.org 19219f27e6a24f877fc2b0409a94b02d5f40ba3dc8cmallinath@webrtc.org ~IoVec() { 19319f27e6a24f877fc2b0409a94b02d5f40ba3dc8cmallinath@webrtc.org for (size_t i = 0; i < mScopedBuffers.size(); ++i) { 1944551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org delete mScopedBuffers[i]; 1954551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org } 1964551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org mEnv->PopLocalFrame(NULL); 1974551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org } 1984551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 1994551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org iovec* get() { 2004551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return &mIoVec[0]; 2014551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org } 20228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 20328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org size_t size() { 20428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return mBufferCount; 20528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org } 20628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 20728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgprivate: 20828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org JNIEnv* mEnv; 20928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org size_t mBufferCount; 21028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org std::vector<iovec> mIoVec; 21128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org std::vector<ScopedT*> mScopedBuffers; 21228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org}; 21328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 21428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgstatic jobject makeSocketAddress(JNIEnv* env, const sockaddr_storage& ss) { 2154551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org jint port; 2164551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org jobject inetAddress = sockaddrToInetAddress(env, ss, &port); 2174551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org if (inetAddress == NULL) { 2184551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return NULL; 2194551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org } 2204551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org static jmethodID ctor = env->GetMethodID(JniConstants::inetSocketAddressClass, "<init>", 2214551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org "(Ljava/net/InetAddress;I)V"); 2224551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return env->NewObject(JniConstants::inetSocketAddressClass, ctor, inetAddress, port); 2234551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org} 2244551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 2254551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.orgstatic jobject makeStructPasswd(JNIEnv* env, const struct passwd& pw) { 2264551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org TO_JAVA_STRING(pw_name, pw.pw_name); 2274551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org TO_JAVA_STRING(pw_dir, pw.pw_dir); 2284551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org TO_JAVA_STRING(pw_shell, pw.pw_shell); 2294551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org static jmethodID ctor = env->GetMethodID(JniConstants::structPasswdClass, "<init>", 2304551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org "(Ljava/lang/String;IILjava/lang/String;Ljava/lang/String;)V"); 2314551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return env->NewObject(JniConstants::structPasswdClass, ctor, 2324551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org pw_name, static_cast<jint>(pw.pw_uid), static_cast<jint>(pw.pw_gid), pw_dir, pw_shell); 2334551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org} 2344551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 2354551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.orgstatic jobject makeStructStat(JNIEnv* env, const struct stat& sb) { 2364551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org static jmethodID ctor = env->GetMethodID(JniConstants::structStatClass, "<init>", 2374551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org "(JJIJIIJJJJJJJ)V"); 2384551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return env->NewObject(JniConstants::structStatClass, ctor, 2394551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org static_cast<jlong>(sb.st_dev), static_cast<jlong>(sb.st_ino), 2404551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org static_cast<jint>(sb.st_mode), static_cast<jlong>(sb.st_nlink), 2414551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org static_cast<jint>(sb.st_uid), static_cast<jint>(sb.st_gid), 2424551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org static_cast<jlong>(sb.st_rdev), static_cast<jlong>(sb.st_size), 2434551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org static_cast<jlong>(sb.st_atime), static_cast<jlong>(sb.st_mtime), 2444551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org static_cast<jlong>(sb.st_ctime), static_cast<jlong>(sb.st_blksize), 2454551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org static_cast<jlong>(sb.st_blocks)); 2464551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org} 2474551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 2484551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.orgstatic jobject makeStructStatVfs(JNIEnv* env, const struct statvfs& sb) { 2494551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org#if defined(__APPLE__) 2504551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org // Mac OS has no f_namelen field in struct statfs. 2514551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org jlong max_name_length = 255; // __DARWIN_MAXNAMLEN 2524551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org#else 2534551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org jlong max_name_length = static_cast<jlong>(sb.f_namemax); 2544551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org#endif 2554551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 2564551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org static jmethodID ctor = env->GetMethodID(JniConstants::structStatVfsClass, "<init>", 2574551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org "(JJJJJJJJJJJ)V"); 2584551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return env->NewObject(JniConstants::structStatVfsClass, ctor, 2594551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org static_cast<jlong>(sb.f_bsize), 2604551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org static_cast<jlong>(sb.f_frsize), 2614551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org static_cast<jlong>(sb.f_blocks), 2624551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org static_cast<jlong>(sb.f_bfree), 2634551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org static_cast<jlong>(sb.f_bavail), 2644551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org static_cast<jlong>(sb.f_files), 2654551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org static_cast<jlong>(sb.f_ffree), 2664551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org static_cast<jlong>(sb.f_favail), 2674551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org static_cast<jlong>(sb.f_fsid), 2684551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org static_cast<jlong>(sb.f_flag), 2694551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org max_name_length); 2704551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org} 2714551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 2724551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.orgstatic jobject makeStructLinger(JNIEnv* env, const struct linger& l) { 2734551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org static jmethodID ctor = env->GetMethodID(JniConstants::structLingerClass, "<init>", "(II)V"); 2744551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return env->NewObject(JniConstants::structLingerClass, ctor, l.l_onoff, l.l_linger); 2754551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org} 2764551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 2774551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.orgstatic jobject makeStructTimeval(JNIEnv* env, const struct timeval& tv) { 2784551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org static jmethodID ctor = env->GetMethodID(JniConstants::structTimevalClass, "<init>", "(JJ)V"); 2794551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return env->NewObject(JniConstants::structTimevalClass, ctor, 2804551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org static_cast<jlong>(tv.tv_sec), static_cast<jlong>(tv.tv_usec)); 2814551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org} 2824551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 2834551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.orgstatic jobject makeStructUcred(JNIEnv* env, const struct ucred& u) { 2844551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org static jmethodID ctor = env->GetMethodID(JniConstants::structUcredClass, "<init>", "(III)V"); 2854551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return env->NewObject(JniConstants::structUcredClass, ctor, u.pid, u.uid, u.gid); 28628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org} 28728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 28828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgstatic jobject makeStructUtsname(JNIEnv* env, const struct utsname& buf) { 28928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org TO_JAVA_STRING(sysname, buf.sysname); 29028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org TO_JAVA_STRING(nodename, buf.nodename); 29128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org TO_JAVA_STRING(release, buf.release); 29228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org TO_JAVA_STRING(version, buf.version); 29328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org TO_JAVA_STRING(machine, buf.machine); 29428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org static jmethodID ctor = env->GetMethodID(JniConstants::structUtsnameClass, "<init>", 29528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V"); 29628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return env->NewObject(JniConstants::structUtsnameClass, ctor, 29728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org sysname, nodename, release, version, machine); 29828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org}; 29928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 30028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgstatic bool fillIfreq(JNIEnv* env, jstring javaInterfaceName, struct ifreq& req) { 30128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org ScopedUtfChars interfaceName(env, javaInterfaceName); 30228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org if (interfaceName.c_str() == NULL) { 30328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return false; 30428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org } 30528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org memset(&req, 0, sizeof(req)); 30628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org strncpy(req.ifr_name, interfaceName.c_str(), sizeof(req.ifr_name)); 30728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org req.ifr_name[sizeof(req.ifr_name) - 1] = '\0'; 30828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return true; 30928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org} 31028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 31128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgstatic bool fillInetSocketAddress(JNIEnv* env, jint rc, jobject javaInetSocketAddress, const sockaddr_storage& ss) { 31228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org if (rc == -1 || javaInetSocketAddress == NULL) { 31328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return true; 31428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org } 31528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org // Fill out the passed-in InetSocketAddress with the sender's IP address and port number. 31628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org jint port; 31728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org jobject sender = sockaddrToInetAddress(env, ss, &port); 31828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org if (sender == NULL) { 31928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return false; 32028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org } 32128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org static jfieldID addressFid = env->GetFieldID(JniConstants::inetSocketAddressClass, "addr", "Ljava/net/InetAddress;"); 32228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org static jfieldID portFid = env->GetFieldID(JniConstants::inetSocketAddressClass, "port", "I"); 32328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org env->SetObjectField(javaInetSocketAddress, addressFid, sender); 32428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org env->SetIntField(javaInetSocketAddress, portFid, port); 32528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return true; 32628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org} 32728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 32828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgstatic jobject doStat(JNIEnv* env, jstring javaPath, bool isLstat) { 32928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org ScopedUtfChars path(env, javaPath); 33028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org if (path.c_str() == NULL) { 33128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return NULL; 33228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org } 33328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org struct stat sb; 33428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org int rc = isLstat ? TEMP_FAILURE_RETRY(lstat(path.c_str(), &sb)) 33528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org : TEMP_FAILURE_RETRY(stat(path.c_str(), &sb)); 33628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org if (rc == -1) { 33728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org throwErrnoException(env, isLstat ? "lstat" : "stat"); 33828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return NULL; 33928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org } 34028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return makeStructStat(env, sb); 34128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org} 34228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 34328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgstatic jobject doGetSockName(JNIEnv* env, jobject javaFd, bool is_sockname) { 34428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org int fd = jniGetFDFromFileDescriptor(env, javaFd); 34528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org sockaddr_storage ss; 34628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org sockaddr* sa = reinterpret_cast<sockaddr*>(&ss); 34728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org socklen_t byteCount = sizeof(ss); 34828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org memset(&ss, 0, byteCount); 34928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org int rc = is_sockname ? TEMP_FAILURE_RETRY(getsockname(fd, sa, &byteCount)) 35028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org : TEMP_FAILURE_RETRY(getpeername(fd, sa, &byteCount)); 35128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org if (rc == -1) { 35228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org throwErrnoException(env, is_sockname ? "getsockname" : "getpeername"); 35328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return NULL; 35428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org } 35528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return makeSocketAddress(env, ss); 35628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org} 35728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 35828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgclass Passwd { 35928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgpublic: 36028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org Passwd(JNIEnv* env) : mEnv(env), mResult(NULL) { 36128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org mBufferSize = sysconf(_SC_GETPW_R_SIZE_MAX); 36228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org mBuffer.reset(new char[mBufferSize]); 36328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org } 36428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 36528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org jobject getpwnam(const char* name) { 36628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return process("getpwnam_r", getpwnam_r(name, &mPwd, mBuffer.get(), mBufferSize, &mResult)); 36728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org } 36828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 36928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org jobject getpwuid(uid_t uid) { 37028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return process("getpwuid_r", getpwuid_r(uid, &mPwd, mBuffer.get(), mBufferSize, &mResult)); 37128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org } 37228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 37328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org struct passwd* get() { 37428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return mResult; 37528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org } 37628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 37728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgprivate: 37828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org jobject process(const char* syscall, int error) { 37928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org if (mResult == NULL) { 38028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org errno = error; 38128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org throwErrnoException(mEnv, syscall); 38228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return NULL; 38328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org } 38428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return makeStructPasswd(mEnv, *mResult); 38528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org } 38628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 38728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org JNIEnv* mEnv; 38828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org UniquePtr<char[]> mBuffer; 38928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org size_t mBufferSize; 39028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org struct passwd mPwd; 39128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org struct passwd* mResult; 39228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org}; 39328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 39428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgstatic jobject Posix_accept(JNIEnv* env, jobject, jobject javaFd, jobject javaInetSocketAddress) { 39528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org sockaddr_storage ss; 39628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org socklen_t sl = sizeof(ss); 39728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org memset(&ss, 0, sizeof(ss)); 39828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org sockaddr* peer = (javaInetSocketAddress != NULL) ? reinterpret_cast<sockaddr*>(&ss) : NULL; 39928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org socklen_t* peerLength = (javaInetSocketAddress != NULL) ? &sl : 0; 40028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org jint clientFd = NET_FAILURE_RETRY(env, int, accept, javaFd, peer, peerLength); 40128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org if (clientFd == -1 || !fillInetSocketAddress(env, clientFd, javaInetSocketAddress, ss)) { 40228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org close(clientFd); 40328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return NULL; 40428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org } 40528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return (clientFd != -1) ? jniCreateFileDescriptor(env, clientFd) : NULL; 40628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org} 40728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 40828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgstatic jboolean Posix_access(JNIEnv* env, jobject, jstring javaPath, jint mode) { 40928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org ScopedUtfChars path(env, javaPath); 41028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org if (path.c_str() == NULL) { 41128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return JNI_FALSE; 41228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org } 41328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org int rc = TEMP_FAILURE_RETRY(access(path.c_str(), mode)); 41428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org if (rc == -1) { 41528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org throwErrnoException(env, "access"); 41628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org } 41728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return (rc == 0); 41828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org} 41928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 42028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgstatic void Posix_bind(JNIEnv* env, jobject, jobject javaFd, jobject javaAddress, jint port) { 42128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org sockaddr_storage ss; 42228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org socklen_t sa_len; 42328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org if (!inetAddressToSockaddr(env, javaAddress, port, ss, sa_len)) { 42428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return; 42528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org } 42628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org const sockaddr* sa = reinterpret_cast<const sockaddr*>(&ss); 42728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org // We don't need the return value because we'll already have thrown. 42828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org (void) NET_FAILURE_RETRY(env, int, bind, javaFd, sa, sa_len); 42928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org} 43028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 43128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgstatic void Posix_chmod(JNIEnv* env, jobject, jstring javaPath, jint mode) { 43228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org ScopedUtfChars path(env, javaPath); 43328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org if (path.c_str() == NULL) { 43428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return; 43528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org } 43628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org throwIfMinusOne(env, "chmod", TEMP_FAILURE_RETRY(chmod(path.c_str(), mode))); 43728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org} 43828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 43928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgstatic void Posix_chown(JNIEnv* env, jobject, jstring javaPath, jint uid, jint gid) { 44028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org ScopedUtfChars path(env, javaPath); 44128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org if (path.c_str() == NULL) { 44228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return; 44328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org } 44428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org throwIfMinusOne(env, "chown", TEMP_FAILURE_RETRY(chown(path.c_str(), uid, gid))); 44528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org} 44628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 44728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgstatic void Posix_close(JNIEnv* env, jobject, jobject javaFd) { 44828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org // Get the FileDescriptor's 'fd' field and clear it. 44928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org // We need to do this before we can throw an IOException (http://b/3222087). 45028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org int fd = jniGetFDFromFileDescriptor(env, javaFd); 45128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org jniSetFileDescriptorOfFD(env, javaFd, -1); 45228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 45328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org // Even if close(2) fails with EINTR, the fd will have been closed. 45428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org // Using TEMP_FAILURE_RETRY will either lead to EBADF or closing someone else's fd. 45528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org // http://lkml.indiana.edu/hypermail/linux/kernel/0509.1/0877.html 45628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org throwIfMinusOne(env, "close", close(fd)); 45728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org} 45828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 45928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgstatic void Posix_connect(JNIEnv* env, jobject, jobject javaFd, jobject javaAddress, jint port) { 46028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org sockaddr_storage ss; 46128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org socklen_t sa_len; 46228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org if (!inetAddressToSockaddr(env, javaAddress, port, ss, sa_len)) { 46328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return; 46428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org } 46528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org const sockaddr* sa = reinterpret_cast<const sockaddr*>(&ss); 46628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org // We don't need the return value because we'll already have thrown. 46728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org (void) NET_FAILURE_RETRY(env, int, connect, javaFd, sa, sa_len); 46828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org} 46928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 47028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgstatic jobject Posix_dup(JNIEnv* env, jobject, jobject javaOldFd) { 47128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org int oldFd = jniGetFDFromFileDescriptor(env, javaOldFd); 47228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org int newFd = throwIfMinusOne(env, "dup", TEMP_FAILURE_RETRY(dup(oldFd))); 47328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return (newFd != -1) ? jniCreateFileDescriptor(env, newFd) : NULL; 47428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org} 47528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 47628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgstatic jobject Posix_dup2(JNIEnv* env, jobject, jobject javaOldFd, jint newFd) { 47728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org int oldFd = jniGetFDFromFileDescriptor(env, javaOldFd); 47828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org int fd = throwIfMinusOne(env, "dup2", TEMP_FAILURE_RETRY(dup2(oldFd, newFd))); 47928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return (fd != -1) ? jniCreateFileDescriptor(env, fd) : NULL; 48028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org} 48128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 48228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgstatic jobjectArray Posix_environ(JNIEnv* env, jobject) { 48328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org extern char** environ; // Standard, but not in any header file. 48428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return toStringArray(env, environ); 48528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org} 48628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 48728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgstatic void Posix_execve(JNIEnv* env, jobject, jstring javaFilename, jobjectArray javaArgv, jobjectArray javaEnvp) { 48828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org ScopedUtfChars path(env, javaFilename); 48928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org if (path.c_str() == NULL) { 49028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return; 49128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org } 49228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 49328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org ExecStrings argv(env, javaArgv); 49428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org ExecStrings envp(env, javaEnvp); 49528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org execve(path.c_str(), argv.get(), envp.get()); 49628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 49728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org throwErrnoException(env, "execve"); 49828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org} 49928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 50028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgstatic void Posix_execv(JNIEnv* env, jobject, jstring javaFilename, jobjectArray javaArgv) { 50128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org ScopedUtfChars path(env, javaFilename); 50228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org if (path.c_str() == NULL) { 50328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return; 50428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org } 50528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 50628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org ExecStrings argv(env, javaArgv); 50728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org execv(path.c_str(), argv.get()); 50828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 50928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org throwErrnoException(env, "execv"); 51028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org} 51128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 51228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgstatic void Posix_fchmod(JNIEnv* env, jobject, jobject javaFd, jint mode) { 51328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org int fd = jniGetFDFromFileDescriptor(env, javaFd); 51428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org throwIfMinusOne(env, "fchmod", TEMP_FAILURE_RETRY(fchmod(fd, mode))); 51528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org} 51628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 51728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgstatic void Posix_fchown(JNIEnv* env, jobject, jobject javaFd, jint uid, jint gid) { 51828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org int fd = jniGetFDFromFileDescriptor(env, javaFd); 51928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org throwIfMinusOne(env, "fchown", TEMP_FAILURE_RETRY(fchown(fd, uid, gid))); 52028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org} 52128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 52228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgstatic jint Posix_fcntlVoid(JNIEnv* env, jobject, jobject javaFd, jint cmd) { 52328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org int fd = jniGetFDFromFileDescriptor(env, javaFd); 52428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return throwIfMinusOne(env, "fcntl", TEMP_FAILURE_RETRY(fcntl(fd, cmd))); 52528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org} 52628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 52728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgstatic jint Posix_fcntlLong(JNIEnv* env, jobject, jobject javaFd, jint cmd, jlong arg) { 52828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org int fd = jniGetFDFromFileDescriptor(env, javaFd); 52928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return throwIfMinusOne(env, "fcntl", TEMP_FAILURE_RETRY(fcntl(fd, cmd, arg))); 53028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org} 53128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 53228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgstatic jint Posix_fcntlFlock(JNIEnv* env, jobject, jobject javaFd, jint cmd, jobject javaFlock) { 53328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org static jfieldID typeFid = env->GetFieldID(JniConstants::structFlockClass, "l_type", "S"); 53428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org static jfieldID whenceFid = env->GetFieldID(JniConstants::structFlockClass, "l_whence", "S"); 53528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org static jfieldID startFid = env->GetFieldID(JniConstants::structFlockClass, "l_start", "J"); 53628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org static jfieldID lenFid = env->GetFieldID(JniConstants::structFlockClass, "l_len", "J"); 53728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org static jfieldID pidFid = env->GetFieldID(JniConstants::structFlockClass, "l_pid", "I"); 53828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 53928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org struct flock64 lock; 54028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org memset(&lock, 0, sizeof(lock)); 54128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org lock.l_type = env->GetShortField(javaFlock, typeFid); 54228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org lock.l_whence = env->GetShortField(javaFlock, whenceFid); 54328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org lock.l_start = env->GetLongField(javaFlock, startFid); 54428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org lock.l_len = env->GetLongField(javaFlock, lenFid); 54528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org lock.l_pid = env->GetIntField(javaFlock, pidFid); 54628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 54728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org int fd = jniGetFDFromFileDescriptor(env, javaFd); 54828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org int rc = throwIfMinusOne(env, "fcntl", TEMP_FAILURE_RETRY(fcntl(fd, cmd, &lock))); 54928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org if (rc != -1) { 55028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org env->SetShortField(javaFlock, typeFid, lock.l_type); 55128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org env->SetShortField(javaFlock, whenceFid, lock.l_whence); 55228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org env->SetLongField(javaFlock, startFid, lock.l_start); 55328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org env->SetLongField(javaFlock, lenFid, lock.l_len); 55428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org env->SetIntField(javaFlock, pidFid, lock.l_pid); 55528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org } 55628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return rc; 55728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org} 55828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 55928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgstatic void Posix_fdatasync(JNIEnv* env, jobject, jobject javaFd) { 56028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org int fd = jniGetFDFromFileDescriptor(env, javaFd); 56128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org throwIfMinusOne(env, "fdatasync", TEMP_FAILURE_RETRY(fdatasync(fd))); 56228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org} 56328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 56428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgstatic jobject Posix_fstat(JNIEnv* env, jobject, jobject javaFd) { 56528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org int fd = jniGetFDFromFileDescriptor(env, javaFd); 56628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org struct stat sb; 56728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org int rc = TEMP_FAILURE_RETRY(fstat(fd, &sb)); 56828e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org if (rc == -1) { 56928e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org throwErrnoException(env, "fstat"); 57028e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return NULL; 57128e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org } 57228e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org return makeStructStat(env, sb); 57328e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org} 57428e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org 57528e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.orgstatic jobject Posix_fstatvfs(JNIEnv* env, jobject, jobject javaFd) { 57628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org int fd = jniGetFDFromFileDescriptor(env, javaFd); 57728e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org struct statvfs sb; 5784551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org int rc = TEMP_FAILURE_RETRY(fstatvfs(fd, &sb)); 5794551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org if (rc == -1) { 58019f27e6a24f877fc2b0409a94b02d5f40ba3dc8cmallinath@webrtc.org throwErrnoException(env, "fstatvfs"); 5814551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return NULL; 5824551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org } 5834551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return makeStructStatVfs(env, sb); 5844551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org} 5854551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 5864551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.orgstatic void Posix_fsync(JNIEnv* env, jobject, jobject javaFd) { 5874551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org int fd = jniGetFDFromFileDescriptor(env, javaFd); 5884551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org throwIfMinusOne(env, "fsync", TEMP_FAILURE_RETRY(fsync(fd))); 5894551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org} 5904551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 5914551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.orgstatic void Posix_ftruncate(JNIEnv* env, jobject, jobject javaFd, jlong length) { 5924551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org int fd = jniGetFDFromFileDescriptor(env, javaFd); 5934551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org throwIfMinusOne(env, "ftruncate", TEMP_FAILURE_RETRY(ftruncate64(fd, length))); 5944551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org} 5954551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 5964551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.orgstatic jstring Posix_gai_strerror(JNIEnv* env, jobject, jint error) { 5974551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return env->NewStringUTF(gai_strerror(error)); 5984551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org} 5994551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 6004551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.orgstatic jobjectArray Posix_getaddrinfo(JNIEnv* env, jobject, jstring javaNode, jobject javaHints) { 6014551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org ScopedUtfChars node(env, javaNode); 6024551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org if (node.c_str() == NULL) { 60319f27e6a24f877fc2b0409a94b02d5f40ba3dc8cmallinath@webrtc.org return NULL; 6044551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org } 6054551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 6064551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org static jfieldID flagsFid = env->GetFieldID(JniConstants::structAddrinfoClass, "ai_flags", "I"); 6074551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org static jfieldID familyFid = env->GetFieldID(JniConstants::structAddrinfoClass, "ai_family", "I"); 6084551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org static jfieldID socktypeFid = env->GetFieldID(JniConstants::structAddrinfoClass, "ai_socktype", "I"); 6094551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org static jfieldID protocolFid = env->GetFieldID(JniConstants::structAddrinfoClass, "ai_protocol", "I"); 6104551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 6114551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org addrinfo hints; 6124551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org memset(&hints, 0, sizeof(hints)); 6134551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org hints.ai_flags = env->GetIntField(javaHints, flagsFid); 6144551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org hints.ai_family = env->GetIntField(javaHints, familyFid); 6154551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org hints.ai_socktype = env->GetIntField(javaHints, socktypeFid); 6164551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org hints.ai_protocol = env->GetIntField(javaHints, protocolFid); 6174551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 61819f27e6a24f877fc2b0409a94b02d5f40ba3dc8cmallinath@webrtc.org addrinfo* addressList = NULL; 6194551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org errno = 0; 6204551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org int rc = getaddrinfo(node.c_str(), NULL, &hints, &addressList); 6214551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org UniquePtr<addrinfo, addrinfo_deleter> addressListDeleter(addressList); 6224551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org if (rc != 0) { 6234551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org throwGaiException(env, "getaddrinfo", rc); 6244551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return NULL; 6254551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org } 6264551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 6274551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org // Count results so we know how to size the output array. 6284551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org int addressCount = 0; 6294551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org for (addrinfo* ai = addressList; ai != NULL; ai = ai->ai_next) { 6304551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org if (ai->ai_family == AF_INET || ai->ai_family == AF_INET6) { 6314551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org ++addressCount; 6324551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org } else { 6334551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org ALOGE("getaddrinfo unexpected ai_family %i", ai->ai_family); 6344551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org } 6354551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org } 6364551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org if (addressCount == 0) { 6374551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return NULL; 6384551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org } 6394551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 6404551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org // Prepare output array. 6414551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org jobjectArray result = env->NewObjectArray(addressCount, JniConstants::inetAddressClass, NULL); 6424551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org if (result == NULL) { 6434551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return NULL; 6444551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org } 6454551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 6464551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org // Examine returned addresses one by one, save them in the output array. 6474551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org int index = 0; 6484551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org for (addrinfo* ai = addressList; ai != NULL; ai = ai->ai_next) { 6494551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org if (ai->ai_family != AF_INET && ai->ai_family != AF_INET6) { 6504551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org // Unknown address family. Skip this address. 6514551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org ALOGE("getaddrinfo unexpected ai_family %i", ai->ai_family); 6524551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org continue; 6534551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org } 6544551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 6554551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org // Convert each IP address into a Java byte array. 6564551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org sockaddr_storage& address = *reinterpret_cast<sockaddr_storage*>(ai->ai_addr); 6574551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org ScopedLocalRef<jobject> inetAddress(env, sockaddrToInetAddress(env, address, NULL)); 6584551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org if (inetAddress.get() == NULL) { 6594551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return NULL; 6604551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org } 6614551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org env->SetObjectArrayElement(result, index, inetAddress.get()); 6624551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org ++index; 6634551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org } 66419f27e6a24f877fc2b0409a94b02d5f40ba3dc8cmallinath@webrtc.org return result; 6654551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org} 6664551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 6674551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.orgstatic jint Posix_getegid(JNIEnv*, jobject) { 6684551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return getegid(); 6694551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org} 6704551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 6714551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.orgstatic jint Posix_geteuid(JNIEnv*, jobject) { 6724551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return geteuid(); 6734551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org} 6744551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 6754551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.orgstatic jint Posix_getgid(JNIEnv*, jobject) { 6764551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return getgid(); 6774551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org} 6784551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 6794551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.orgstatic jstring Posix_getenv(JNIEnv* env, jobject, jstring javaName) { 6804551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org ScopedUtfChars name(env, javaName); 6814551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org if (name.c_str() == NULL) { 6824551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return NULL; 6834551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org } 6844551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return env->NewStringUTF(getenv(name.c_str())); 6854551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org} 6864551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 6874551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.orgstatic jstring Posix_getnameinfo(JNIEnv* env, jobject, jobject javaAddress, jint flags) { 6884551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org sockaddr_storage ss; 6894551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org socklen_t sa_len; 6904551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org if (!inetAddressToSockaddrVerbatim(env, javaAddress, 0, ss, sa_len)) { 6914551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return NULL; 6924551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org } 6934551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org char buf[NI_MAXHOST]; // NI_MAXHOST is longer than INET6_ADDRSTRLEN. 6944551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org errno = 0; 6954551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org int rc = getnameinfo(reinterpret_cast<sockaddr*>(&ss), sa_len, buf, sizeof(buf), NULL, 0, flags); 6964551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org if (rc != 0) { 6974551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org throwGaiException(env, "getnameinfo", rc); 6984551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return NULL; 6994551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org } 7004551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return env->NewStringUTF(buf); 7014551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org} 7024551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 7034551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.orgstatic jobject Posix_getpeername(JNIEnv* env, jobject, jobject javaFd) { 7044551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return doGetSockName(env, javaFd, false); 7054551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org} 7064551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 7074551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.orgstatic jint Posix_getpid(JNIEnv*, jobject) { 7084551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return getpid(); 7094551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org} 7104551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 7114551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.orgstatic jint Posix_getppid(JNIEnv*, jobject) { 7124551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org return getppid(); 7134551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org} 7144551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.org 7154551b793dea4b5451cbfa13b206b6d11a25081d0wu@webrtc.orgstatic jobject Posix_getpwnam(JNIEnv* env, jobject, jstring javaName) { 71628e20752806a492f5a6a5d343c02f9556f39b1cdhenrike@webrtc.org ScopedUtfChars name(env, javaName); 717 if (name.c_str() == NULL) { 718 return NULL; 719 } 720 return Passwd(env).getpwnam(name.c_str()); 721} 722 723static jobject Posix_getpwuid(JNIEnv* env, jobject, jint uid) { 724 return Passwd(env).getpwuid(uid); 725} 726 727static jobject Posix_getsockname(JNIEnv* env, jobject, jobject javaFd) { 728 return doGetSockName(env, javaFd, true); 729} 730 731static jint Posix_getsockoptByte(JNIEnv* env, jobject, jobject javaFd, jint level, jint option) { 732 int fd = jniGetFDFromFileDescriptor(env, javaFd); 733 u_char result = 0; 734 socklen_t size = sizeof(result); 735 throwIfMinusOne(env, "getsockopt", TEMP_FAILURE_RETRY(getsockopt(fd, level, option, &result, &size))); 736 return result; 737} 738 739static jobject Posix_getsockoptInAddr(JNIEnv* env, jobject, jobject javaFd, jint level, jint option) { 740 int fd = jniGetFDFromFileDescriptor(env, javaFd); 741 sockaddr_storage ss; 742 memset(&ss, 0, sizeof(ss)); 743 ss.ss_family = AF_INET; // This is only for the IPv4-only IP_MULTICAST_IF. 744 sockaddr_in* sa = reinterpret_cast<sockaddr_in*>(&ss); 745 socklen_t size = sizeof(sa->sin_addr); 746 int rc = TEMP_FAILURE_RETRY(getsockopt(fd, level, option, &sa->sin_addr, &size)); 747 if (rc == -1) { 748 throwErrnoException(env, "getsockopt"); 749 return NULL; 750 } 751 return sockaddrToInetAddress(env, ss, NULL); 752} 753 754static jint Posix_getsockoptInt(JNIEnv* env, jobject, jobject javaFd, jint level, jint option) { 755 int fd = jniGetFDFromFileDescriptor(env, javaFd); 756 jint result = 0; 757 socklen_t size = sizeof(result); 758 throwIfMinusOne(env, "getsockopt", TEMP_FAILURE_RETRY(getsockopt(fd, level, option, &result, &size))); 759 return result; 760} 761 762static jobject Posix_getsockoptLinger(JNIEnv* env, jobject, jobject javaFd, jint level, jint option) { 763 int fd = jniGetFDFromFileDescriptor(env, javaFd); 764 struct linger l; 765 socklen_t size = sizeof(l); 766 memset(&l, 0, size); 767 int rc = TEMP_FAILURE_RETRY(getsockopt(fd, level, option, &l, &size)); 768 if (rc == -1) { 769 throwErrnoException(env, "getsockopt"); 770 return NULL; 771 } 772 return makeStructLinger(env, l); 773} 774 775static jobject Posix_getsockoptTimeval(JNIEnv* env, jobject, jobject javaFd, jint level, jint option) { 776 int fd = jniGetFDFromFileDescriptor(env, javaFd); 777 struct timeval tv; 778 socklen_t size = sizeof(tv); 779 memset(&tv, 0, size); 780 int rc = TEMP_FAILURE_RETRY(getsockopt(fd, level, option, &tv, &size)); 781 if (rc == -1) { 782 throwErrnoException(env, "getsockopt"); 783 return NULL; 784 } 785 return makeStructTimeval(env, tv); 786} 787 788static jobject Posix_getsockoptUcred(JNIEnv* env, jobject, jobject javaFd, jint level, jint option) { 789 int fd = jniGetFDFromFileDescriptor(env, javaFd); 790 struct ucred u; 791 socklen_t size = sizeof(u); 792 memset(&u, 0, size); 793 int rc = TEMP_FAILURE_RETRY(getsockopt(fd, level, option, &u, &size)); 794 if (rc == -1) { 795 throwErrnoException(env, "getsockopt"); 796 return NULL; 797 } 798 return makeStructUcred(env, u); 799} 800 801static jint Posix_gettid(JNIEnv*, jobject) { 802 // Neither bionic nor glibc exposes gettid(2). 803 return syscall(__NR_gettid); 804} 805 806static jint Posix_getuid(JNIEnv*, jobject) { 807 return getuid(); 808} 809 810static jstring Posix_if_indextoname(JNIEnv* env, jobject, jint index) { 811 char buf[IF_NAMESIZE]; 812 char* name = if_indextoname(index, buf); 813 // if_indextoname(3) returns NULL on failure, which will come out of NewStringUTF unscathed. 814 // There's no useful information in errno, so we don't bother throwing. Callers can null-check. 815 return env->NewStringUTF(name); 816} 817 818static jobject Posix_inet_pton(JNIEnv* env, jobject, jint family, jstring javaName) { 819 ScopedUtfChars name(env, javaName); 820 if (name.c_str() == NULL) { 821 return NULL; 822 } 823 sockaddr_storage ss; 824 memset(&ss, 0, sizeof(ss)); 825 // sockaddr_in and sockaddr_in6 are at the same address, so we can use either here. 826 void* dst = &reinterpret_cast<sockaddr_in*>(&ss)->sin_addr; 827 if (inet_pton(family, name.c_str(), dst) != 1) { 828 return NULL; 829 } 830 ss.ss_family = family; 831 return sockaddrToInetAddress(env, ss, NULL); 832} 833 834static jobject Posix_ioctlInetAddress(JNIEnv* env, jobject, jobject javaFd, jint cmd, jstring javaInterfaceName) { 835 struct ifreq req; 836 if (!fillIfreq(env, javaInterfaceName, req)) { 837 return NULL; 838 } 839 int fd = jniGetFDFromFileDescriptor(env, javaFd); 840 int rc = throwIfMinusOne(env, "ioctl", TEMP_FAILURE_RETRY(ioctl(fd, cmd, &req))); 841 if (rc == -1) { 842 return NULL; 843 } 844 return sockaddrToInetAddress(env, reinterpret_cast<sockaddr_storage&>(req.ifr_addr), NULL); 845} 846 847static jint Posix_ioctlInt(JNIEnv* env, jobject, jobject javaFd, jint cmd, jobject javaArg) { 848 // This is complicated because ioctls may return their result by updating their argument 849 // or via their return value, so we need to support both. 850 int fd = jniGetFDFromFileDescriptor(env, javaFd); 851 static jfieldID valueFid = env->GetFieldID(JniConstants::mutableIntClass, "value", "I"); 852 jint arg = env->GetIntField(javaArg, valueFid); 853 int rc = throwIfMinusOne(env, "ioctl", TEMP_FAILURE_RETRY(ioctl(fd, cmd, &arg))); 854 if (!env->ExceptionCheck()) { 855 env->SetIntField(javaArg, valueFid, arg); 856 } 857 return rc; 858} 859 860static jboolean Posix_isatty(JNIEnv* env, jobject, jobject javaFd) { 861 int fd = jniGetFDFromFileDescriptor(env, javaFd); 862 return TEMP_FAILURE_RETRY(isatty(fd)) == 1; 863} 864 865static void Posix_kill(JNIEnv* env, jobject, jint pid, jint sig) { 866 throwIfMinusOne(env, "kill", TEMP_FAILURE_RETRY(kill(pid, sig))); 867} 868 869static void Posix_lchown(JNIEnv* env, jobject, jstring javaPath, jint uid, jint gid) { 870 ScopedUtfChars path(env, javaPath); 871 if (path.c_str() == NULL) { 872 return; 873 } 874 throwIfMinusOne(env, "lchown", TEMP_FAILURE_RETRY(lchown(path.c_str(), uid, gid))); 875} 876 877static void Posix_listen(JNIEnv* env, jobject, jobject javaFd, jint backlog) { 878 int fd = jniGetFDFromFileDescriptor(env, javaFd); 879 throwIfMinusOne(env, "listen", TEMP_FAILURE_RETRY(listen(fd, backlog))); 880} 881 882static jlong Posix_lseek(JNIEnv* env, jobject, jobject javaFd, jlong offset, jint whence) { 883 int fd = jniGetFDFromFileDescriptor(env, javaFd); 884 return throwIfMinusOne(env, "lseek", TEMP_FAILURE_RETRY(lseek64(fd, offset, whence))); 885} 886 887static jobject Posix_lstat(JNIEnv* env, jobject, jstring javaPath) { 888 return doStat(env, javaPath, true); 889} 890 891static void Posix_mincore(JNIEnv* env, jobject, jlong address, jlong byteCount, jbyteArray javaVector) { 892 ScopedByteArrayRW vector(env, javaVector); 893 if (vector.get() == NULL) { 894 return; 895 } 896 void* ptr = reinterpret_cast<void*>(static_cast<uintptr_t>(address)); 897 unsigned char* vec = reinterpret_cast<unsigned char*>(vector.get()); 898 throwIfMinusOne(env, "mincore", TEMP_FAILURE_RETRY(mincore(ptr, byteCount, vec))); 899} 900 901static void Posix_mkdir(JNIEnv* env, jobject, jstring javaPath, jint mode) { 902 ScopedUtfChars path(env, javaPath); 903 if (path.c_str() == NULL) { 904 return; 905 } 906 throwIfMinusOne(env, "mkdir", TEMP_FAILURE_RETRY(mkdir(path.c_str(), mode))); 907} 908 909static void Posix_mlock(JNIEnv* env, jobject, jlong address, jlong byteCount) { 910 void* ptr = reinterpret_cast<void*>(static_cast<uintptr_t>(address)); 911 throwIfMinusOne(env, "mlock", TEMP_FAILURE_RETRY(mlock(ptr, byteCount))); 912} 913 914static jlong Posix_mmap(JNIEnv* env, jobject, jlong address, jlong byteCount, jint prot, jint flags, jobject javaFd, jlong offset) { 915 int fd = jniGetFDFromFileDescriptor(env, javaFd); 916 void* suggestedPtr = reinterpret_cast<void*>(static_cast<uintptr_t>(address)); 917 void* ptr = mmap(suggestedPtr, byteCount, prot, flags, fd, offset); 918 if (ptr == MAP_FAILED) { 919 throwErrnoException(env, "mmap"); 920 } 921 return static_cast<jlong>(reinterpret_cast<uintptr_t>(ptr)); 922} 923 924static void Posix_msync(JNIEnv* env, jobject, jlong address, jlong byteCount, jint flags) { 925 void* ptr = reinterpret_cast<void*>(static_cast<uintptr_t>(address)); 926 throwIfMinusOne(env, "msync", TEMP_FAILURE_RETRY(msync(ptr, byteCount, flags))); 927} 928 929static void Posix_munlock(JNIEnv* env, jobject, jlong address, jlong byteCount) { 930 void* ptr = reinterpret_cast<void*>(static_cast<uintptr_t>(address)); 931 throwIfMinusOne(env, "munlock", TEMP_FAILURE_RETRY(munlock(ptr, byteCount))); 932} 933 934static void Posix_munmap(JNIEnv* env, jobject, jlong address, jlong byteCount) { 935 void* ptr = reinterpret_cast<void*>(static_cast<uintptr_t>(address)); 936 throwIfMinusOne(env, "munmap", TEMP_FAILURE_RETRY(munmap(ptr, byteCount))); 937} 938 939static jobject Posix_open(JNIEnv* env, jobject, jstring javaPath, jint flags, jint mode) { 940 ScopedUtfChars path(env, javaPath); 941 if (path.c_str() == NULL) { 942 return NULL; 943 } 944 int fd = throwIfMinusOne(env, "open", TEMP_FAILURE_RETRY(open(path.c_str(), flags, mode))); 945 return fd != -1 ? jniCreateFileDescriptor(env, fd) : NULL; 946} 947 948static jobjectArray Posix_pipe(JNIEnv* env, jobject) { 949 int fds[2]; 950 throwIfMinusOne(env, "pipe", TEMP_FAILURE_RETRY(pipe(&fds[0]))); 951 jobjectArray result = env->NewObjectArray(2, JniConstants::fileDescriptorClass, NULL); 952 if (result == NULL) { 953 return NULL; 954 } 955 for (int i = 0; i < 2; ++i) { 956 ScopedLocalRef<jobject> fd(env, jniCreateFileDescriptor(env, fds[i])); 957 if (fd.get() == NULL) { 958 return NULL; 959 } 960 env->SetObjectArrayElement(result, i, fd.get()); 961 if (env->ExceptionCheck()) { 962 return NULL; 963 } 964 } 965 return result; 966} 967 968static jint Posix_poll(JNIEnv* env, jobject, jobjectArray javaStructs, jint timeoutMs) { 969 static jfieldID fdFid = env->GetFieldID(JniConstants::structPollfdClass, "fd", "Ljava/io/FileDescriptor;"); 970 static jfieldID eventsFid = env->GetFieldID(JniConstants::structPollfdClass, "events", "S"); 971 static jfieldID reventsFid = env->GetFieldID(JniConstants::structPollfdClass, "revents", "S"); 972 973 // Turn the Java libcore.io.StructPollfd[] into a C++ struct pollfd[]. 974 size_t arrayLength = env->GetArrayLength(javaStructs); 975 UniquePtr<struct pollfd[]> fds(new struct pollfd[arrayLength]); 976 memset(fds.get(), 0, sizeof(struct pollfd) * arrayLength); 977 size_t count = 0; // Some trailing array elements may be irrelevant. (See below.) 978 for (size_t i = 0; i < arrayLength; ++i) { 979 ScopedLocalRef<jobject> javaStruct(env, env->GetObjectArrayElement(javaStructs, i)); 980 if (javaStruct.get() == NULL) { 981 break; // We allow trailing nulls in the array for caller convenience. 982 } 983 ScopedLocalRef<jobject> javaFd(env, env->GetObjectField(javaStruct.get(), fdFid)); 984 if (javaFd.get() == NULL) { 985 break; // We also allow callers to just clear the fd field (this is what Selector does). 986 } 987 fds[count].fd = jniGetFDFromFileDescriptor(env, javaFd.get()); 988 fds[count].events = env->GetShortField(javaStruct.get(), eventsFid); 989 ++count; 990 } 991 992 // Since we don't know which fds -- if any -- are sockets, be conservative and register 993 // all fds for asynchronous socket close monitoring. 994 std::vector<AsynchronousSocketCloseMonitor*> monitors; 995 for (size_t i = 0; i < count; ++i) { 996 monitors.push_back(new AsynchronousSocketCloseMonitor(fds[i].fd)); 997 } 998 int rc = poll(fds.get(), count, timeoutMs); 999 for (size_t i = 0; i < monitors.size(); ++i) { 1000 delete monitors[i]; 1001 } 1002 if (rc == -1) { 1003 throwErrnoException(env, "poll"); 1004 return -1; 1005 } 1006 1007 // Update the revents fields in the Java libcore.io.StructPollfd[]. 1008 for (size_t i = 0; i < count; ++i) { 1009 ScopedLocalRef<jobject> javaStruct(env, env->GetObjectArrayElement(javaStructs, i)); 1010 if (javaStruct.get() == NULL) { 1011 return -1; 1012 } 1013 env->SetShortField(javaStruct.get(), reventsFid, fds[i].revents); 1014 } 1015 return rc; 1016} 1017 1018static jint Posix_preadBytes(JNIEnv* env, jobject, jobject javaFd, jobject javaBytes, jint byteOffset, jint byteCount, jlong offset) { 1019 ScopedBytesRW bytes(env, javaBytes); 1020 if (bytes.get() == NULL) { 1021 return -1; 1022 } 1023 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1024 return throwIfMinusOne(env, "pread", TEMP_FAILURE_RETRY(pread64(fd, bytes.get() + byteOffset, byteCount, offset))); 1025} 1026 1027static jint Posix_pwriteBytes(JNIEnv* env, jobject, jobject javaFd, jbyteArray javaBytes, jint byteOffset, jint byteCount, jlong offset) { 1028 ScopedBytesRO bytes(env, javaBytes); 1029 if (bytes.get() == NULL) { 1030 return -1; 1031 } 1032 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1033 return throwIfMinusOne(env, "pwrite", TEMP_FAILURE_RETRY(pwrite64(fd, bytes.get() + byteOffset, byteCount, offset))); 1034} 1035 1036static jint Posix_readBytes(JNIEnv* env, jobject, jobject javaFd, jobject javaBytes, jint byteOffset, jint byteCount) { 1037 ScopedBytesRW bytes(env, javaBytes); 1038 if (bytes.get() == NULL) { 1039 return -1; 1040 } 1041 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1042 return throwIfMinusOne(env, "read", TEMP_FAILURE_RETRY(read(fd, bytes.get() + byteOffset, byteCount))); 1043} 1044 1045static jint Posix_readv(JNIEnv* env, jobject, jobject javaFd, jobjectArray buffers, jintArray offsets, jintArray byteCounts) { 1046 IoVec<ScopedBytesRW> ioVec(env, env->GetArrayLength(buffers)); 1047 if (!ioVec.init(buffers, offsets, byteCounts)) { 1048 return -1; 1049 } 1050 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1051 return throwIfMinusOne(env, "readv", TEMP_FAILURE_RETRY(readv(fd, ioVec.get(), ioVec.size()))); 1052} 1053 1054static jint Posix_recvfromBytes(JNIEnv* env, jobject, jobject javaFd, jobject javaBytes, jint byteOffset, jint byteCount, jint flags, jobject javaInetSocketAddress) { 1055 ScopedBytesRW bytes(env, javaBytes); 1056 if (bytes.get() == NULL) { 1057 return -1; 1058 } 1059 sockaddr_storage ss; 1060 socklen_t sl = sizeof(ss); 1061 memset(&ss, 0, sizeof(ss)); 1062 sockaddr* from = (javaInetSocketAddress != NULL) ? reinterpret_cast<sockaddr*>(&ss) : NULL; 1063 socklen_t* fromLength = (javaInetSocketAddress != NULL) ? &sl : 0; 1064 jint recvCount = NET_FAILURE_RETRY(env, ssize_t, recvfrom, javaFd, bytes.get() + byteOffset, byteCount, flags, from, fromLength); 1065 fillInetSocketAddress(env, recvCount, javaInetSocketAddress, ss); 1066 return recvCount; 1067} 1068 1069static void Posix_remove(JNIEnv* env, jobject, jstring javaPath) { 1070 ScopedUtfChars path(env, javaPath); 1071 if (path.c_str() == NULL) { 1072 return; 1073 } 1074 throwIfMinusOne(env, "remove", TEMP_FAILURE_RETRY(remove(path.c_str()))); 1075} 1076 1077static void Posix_rename(JNIEnv* env, jobject, jstring javaOldPath, jstring javaNewPath) { 1078 ScopedUtfChars oldPath(env, javaOldPath); 1079 if (oldPath.c_str() == NULL) { 1080 return; 1081 } 1082 ScopedUtfChars newPath(env, javaNewPath); 1083 if (newPath.c_str() == NULL) { 1084 return; 1085 } 1086 throwIfMinusOne(env, "rename", TEMP_FAILURE_RETRY(rename(oldPath.c_str(), newPath.c_str()))); 1087} 1088 1089static jlong Posix_sendfile(JNIEnv* env, jobject, jobject javaOutFd, jobject javaInFd, jobject javaOffset, jlong byteCount) { 1090 int outFd = jniGetFDFromFileDescriptor(env, javaOutFd); 1091 int inFd = jniGetFDFromFileDescriptor(env, javaInFd); 1092 static jfieldID valueFid = env->GetFieldID(JniConstants::mutableLongClass, "value", "J"); 1093 off_t offset = 0; 1094 off_t* offsetPtr = NULL; 1095 if (javaOffset != NULL) { 1096 // TODO: fix bionic so we can have a 64-bit off_t! 1097 offset = env->GetLongField(javaOffset, valueFid); 1098 offsetPtr = &offset; 1099 } 1100 jlong result = throwIfMinusOne(env, "sendfile", TEMP_FAILURE_RETRY(sendfile(outFd, inFd, offsetPtr, byteCount))); 1101 if (javaOffset != NULL) { 1102 env->SetLongField(javaOffset, valueFid, offset); 1103 } 1104 return result; 1105} 1106 1107static jint Posix_sendtoBytes(JNIEnv* env, jobject, jobject javaFd, jobject javaBytes, jint byteOffset, jint byteCount, jint flags, jobject javaInetAddress, jint port) { 1108 ScopedBytesRO bytes(env, javaBytes); 1109 if (bytes.get() == NULL) { 1110 return -1; 1111 } 1112 sockaddr_storage ss; 1113 socklen_t sa_len = 0; 1114 if (javaInetAddress != NULL && !inetAddressToSockaddr(env, javaInetAddress, port, ss, sa_len)) { 1115 return -1; 1116 } 1117 const sockaddr* to = (javaInetAddress != NULL) ? reinterpret_cast<const sockaddr*>(&ss) : NULL; 1118 return NET_FAILURE_RETRY(env, ssize_t, sendto, javaFd, bytes.get() + byteOffset, byteCount, flags, to, sa_len); 1119} 1120 1121static void Posix_setegid(JNIEnv* env, jobject, jint egid) { 1122 throwIfMinusOne(env, "setegid", TEMP_FAILURE_RETRY(setegid(egid))); 1123} 1124 1125static void Posix_setenv(JNIEnv* env, jobject, jstring javaName, jstring javaValue, jboolean overwrite) { 1126 ScopedUtfChars name(env, javaName); 1127 if (name.c_str() == NULL) { 1128 return; 1129 } 1130 ScopedUtfChars value(env, javaValue); 1131 if (value.c_str() == NULL) { 1132 return; 1133 } 1134 throwIfMinusOne(env, "setenv", setenv(name.c_str(), value.c_str(), overwrite)); 1135} 1136 1137static void Posix_seteuid(JNIEnv* env, jobject, jint euid) { 1138 throwIfMinusOne(env, "seteuid", TEMP_FAILURE_RETRY(seteuid(euid))); 1139} 1140 1141static void Posix_setgid(JNIEnv* env, jobject, jint gid) { 1142 throwIfMinusOne(env, "setgid", TEMP_FAILURE_RETRY(setgid(gid))); 1143} 1144 1145static jint Posix_setsid(JNIEnv* env, jobject) { 1146 return throwIfMinusOne(env, "setsid", TEMP_FAILURE_RETRY(setsid())); 1147} 1148 1149static void Posix_setsockoptByte(JNIEnv* env, jobject, jobject javaFd, jint level, jint option, jint value) { 1150 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1151 u_char byte = value; 1152 throwIfMinusOne(env, "setsockopt", TEMP_FAILURE_RETRY(setsockopt(fd, level, option, &byte, sizeof(byte)))); 1153} 1154 1155static void Posix_setsockoptIfreq(JNIEnv* env, jobject, jobject javaFd, jint level, jint option, jstring javaInterfaceName) { 1156 struct ifreq req; 1157 if (!fillIfreq(env, javaInterfaceName, req)) { 1158 return; 1159 } 1160 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1161 throwIfMinusOne(env, "setsockopt", TEMP_FAILURE_RETRY(setsockopt(fd, level, option, &req, sizeof(req)))); 1162} 1163 1164static void Posix_setsockoptInt(JNIEnv* env, jobject, jobject javaFd, jint level, jint option, jint value) { 1165 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1166 throwIfMinusOne(env, "setsockopt", TEMP_FAILURE_RETRY(setsockopt(fd, level, option, &value, sizeof(value)))); 1167} 1168 1169#if defined(__APPLE__) && MAC_OS_X_VERSION_MAX_ALLOWED < 1070 1170// Mac OS didn't support modern multicast APIs until 10.7. 1171static void Posix_setsockoptIpMreqn(JNIEnv*, jobject, jobject, jint, jint, jint) { abort(); } 1172static void Posix_setsockoptGroupReq(JNIEnv*, jobject, jobject, jint, jint, jobject) { abort(); } 1173#else 1174static void Posix_setsockoptIpMreqn(JNIEnv* env, jobject, jobject javaFd, jint level, jint option, jint value) { 1175 ip_mreqn req; 1176 memset(&req, 0, sizeof(req)); 1177 req.imr_ifindex = value; 1178 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1179 throwIfMinusOne(env, "setsockopt", TEMP_FAILURE_RETRY(setsockopt(fd, level, option, &req, sizeof(req)))); 1180} 1181 1182static void Posix_setsockoptGroupReq(JNIEnv* env, jobject, jobject javaFd, jint level, jint option, jobject javaGroupReq) { 1183 struct group_req req; 1184 memset(&req, 0, sizeof(req)); 1185 1186 static jfieldID grInterfaceFid = env->GetFieldID(JniConstants::structGroupReqClass, "gr_interface", "I"); 1187 req.gr_interface = env->GetIntField(javaGroupReq, grInterfaceFid); 1188 // Get the IPv4 or IPv6 multicast address to join or leave. 1189 static jfieldID grGroupFid = env->GetFieldID(JniConstants::structGroupReqClass, "gr_group", "Ljava/net/InetAddress;"); 1190 ScopedLocalRef<jobject> javaGroup(env, env->GetObjectField(javaGroupReq, grGroupFid)); 1191 socklen_t sa_len; 1192 if (!inetAddressToSockaddrVerbatim(env, javaGroup.get(), 0, req.gr_group, sa_len)) { 1193 return; 1194 } 1195 1196 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1197 int rc = TEMP_FAILURE_RETRY(setsockopt(fd, level, option, &req, sizeof(req))); 1198 if (rc == -1 && errno == EINVAL) { 1199 // Maybe we're a 32-bit binary talking to a 64-bit kernel? 1200 // glibc doesn't automatically handle this. 1201 struct group_req64 { 1202 uint32_t gr_interface; 1203 uint32_t my_padding; 1204 sockaddr_storage gr_group; 1205 }; 1206 group_req64 req64; 1207 req64.gr_interface = req.gr_interface; 1208 memcpy(&req64.gr_group, &req.gr_group, sizeof(req.gr_group)); 1209 rc = TEMP_FAILURE_RETRY(setsockopt(fd, level, option, &req64, sizeof(req64))); 1210 } 1211 throwIfMinusOne(env, "setsockopt", rc); 1212} 1213#endif 1214 1215static void Posix_setsockoptLinger(JNIEnv* env, jobject, jobject javaFd, jint level, jint option, jobject javaLinger) { 1216 static jfieldID lOnoffFid = env->GetFieldID(JniConstants::structLingerClass, "l_onoff", "I"); 1217 static jfieldID lLingerFid = env->GetFieldID(JniConstants::structLingerClass, "l_linger", "I"); 1218 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1219 struct linger value; 1220 value.l_onoff = env->GetIntField(javaLinger, lOnoffFid); 1221 value.l_linger = env->GetIntField(javaLinger, lLingerFid); 1222 throwIfMinusOne(env, "setsockopt", TEMP_FAILURE_RETRY(setsockopt(fd, level, option, &value, sizeof(value)))); 1223} 1224 1225static void Posix_setsockoptTimeval(JNIEnv* env, jobject, jobject javaFd, jint level, jint option, jobject javaTimeval) { 1226 static jfieldID tvSecFid = env->GetFieldID(JniConstants::structTimevalClass, "tv_sec", "J"); 1227 static jfieldID tvUsecFid = env->GetFieldID(JniConstants::structTimevalClass, "tv_usec", "J"); 1228 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1229 struct timeval value; 1230 value.tv_sec = env->GetLongField(javaTimeval, tvSecFid); 1231 value.tv_usec = env->GetLongField(javaTimeval, tvUsecFid); 1232 throwIfMinusOne(env, "setsockopt", TEMP_FAILURE_RETRY(setsockopt(fd, level, option, &value, sizeof(value)))); 1233} 1234 1235static void Posix_setuid(JNIEnv* env, jobject, jint uid) { 1236 throwIfMinusOne(env, "setuid", TEMP_FAILURE_RETRY(setuid(uid))); 1237} 1238 1239static void Posix_shutdown(JNIEnv* env, jobject, jobject javaFd, jint how) { 1240 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1241 throwIfMinusOne(env, "shutdown", TEMP_FAILURE_RETRY(shutdown(fd, how))); 1242} 1243 1244static jobject Posix_socket(JNIEnv* env, jobject, jint domain, jint type, jint protocol) { 1245 int fd = throwIfMinusOne(env, "socket", TEMP_FAILURE_RETRY(socket(domain, type, protocol))); 1246 return fd != -1 ? jniCreateFileDescriptor(env, fd) : NULL; 1247} 1248 1249static void Posix_socketpair(JNIEnv* env, jobject, jint domain, jint type, jint protocol, jobject javaFd1, jobject javaFd2) { 1250 int fds[2]; 1251 int rc = throwIfMinusOne(env, "socketpair", TEMP_FAILURE_RETRY(socketpair(domain, type, protocol, fds))); 1252 if (rc != -1) { 1253 jniSetFileDescriptorOfFD(env, javaFd1, fds[0]); 1254 jniSetFileDescriptorOfFD(env, javaFd2, fds[1]); 1255 } 1256} 1257 1258static jobject Posix_stat(JNIEnv* env, jobject, jstring javaPath) { 1259 return doStat(env, javaPath, false); 1260} 1261 1262static jobject Posix_statvfs(JNIEnv* env, jobject, jstring javaPath) { 1263 ScopedUtfChars path(env, javaPath); 1264 if (path.c_str() == NULL) { 1265 return NULL; 1266 } 1267 struct statvfs sb; 1268 int rc = TEMP_FAILURE_RETRY(statvfs(path.c_str(), &sb)); 1269 if (rc == -1) { 1270 throwErrnoException(env, "statvfs"); 1271 return NULL; 1272 } 1273 return makeStructStatVfs(env, sb); 1274} 1275 1276static jstring Posix_strerror(JNIEnv* env, jobject, jint errnum) { 1277 char buffer[BUFSIZ]; 1278 const char* message = jniStrError(errnum, buffer, sizeof(buffer)); 1279 return env->NewStringUTF(message); 1280} 1281 1282static jstring Posix_strsignal(JNIEnv* env, jobject, jint signal) { 1283 return env->NewStringUTF(strsignal(signal)); 1284} 1285 1286static void Posix_symlink(JNIEnv* env, jobject, jstring javaOldPath, jstring javaNewPath) { 1287 ScopedUtfChars oldPath(env, javaOldPath); 1288 if (oldPath.c_str() == NULL) { 1289 return; 1290 } 1291 ScopedUtfChars newPath(env, javaNewPath); 1292 if (newPath.c_str() == NULL) { 1293 return; 1294 } 1295 throwIfMinusOne(env, "symlink", TEMP_FAILURE_RETRY(symlink(oldPath.c_str(), newPath.c_str()))); 1296} 1297 1298static jlong Posix_sysconf(JNIEnv* env, jobject, jint name) { 1299 // Since -1 is a valid result from sysconf(3), detecting failure is a little more awkward. 1300 errno = 0; 1301 long result = sysconf(name); 1302 if (result == -1L && errno == EINVAL) { 1303 throwErrnoException(env, "sysconf"); 1304 } 1305 return result; 1306} 1307 1308static void Posix_tcdrain(JNIEnv* env, jobject, jobject javaFd) { 1309 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1310 throwIfMinusOne(env, "tcdrain", TEMP_FAILURE_RETRY(tcdrain(fd))); 1311} 1312 1313static void Posix_tcsendbreak(JNIEnv* env, jobject, jobject javaFd, jint duration) { 1314 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1315 throwIfMinusOne(env, "tcsendbreak", TEMP_FAILURE_RETRY(tcsendbreak(fd, duration))); 1316} 1317 1318static jint Posix_umaskImpl(JNIEnv*, jobject, jint mask) { 1319 return umask(mask); 1320} 1321 1322static jobject Posix_uname(JNIEnv* env, jobject) { 1323 struct utsname buf; 1324 if (TEMP_FAILURE_RETRY(uname(&buf)) == -1) { 1325 return NULL; // Can't happen. 1326 } 1327 return makeStructUtsname(env, buf); 1328} 1329 1330static void Posix_unsetenv(JNIEnv* env, jobject, jstring javaName) { 1331 ScopedUtfChars name(env, javaName); 1332 if (name.c_str() == NULL) { 1333 return; 1334 } 1335 throwIfMinusOne(env, "unsetenv", unsetenv(name.c_str())); 1336} 1337 1338static jint Posix_waitpid(JNIEnv* env, jobject, jint pid, jobject javaStatus, jint options) { 1339 int status; 1340 int rc = throwIfMinusOne(env, "waitpid", TEMP_FAILURE_RETRY(waitpid(pid, &status, options))); 1341 if (rc != -1) { 1342 static jfieldID valueFid = env->GetFieldID(JniConstants::mutableIntClass, "value", "I"); 1343 env->SetIntField(javaStatus, valueFid, status); 1344 } 1345 return rc; 1346} 1347 1348static jint Posix_writeBytes(JNIEnv* env, jobject, jobject javaFd, jbyteArray javaBytes, jint byteOffset, jint byteCount) { 1349 ScopedBytesRO bytes(env, javaBytes); 1350 if (bytes.get() == NULL) { 1351 return -1; 1352 } 1353 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1354 return throwIfMinusOne(env, "write", TEMP_FAILURE_RETRY(write(fd, bytes.get() + byteOffset, byteCount))); 1355} 1356 1357static jint Posix_writev(JNIEnv* env, jobject, jobject javaFd, jobjectArray buffers, jintArray offsets, jintArray byteCounts) { 1358 IoVec<ScopedBytesRO> ioVec(env, env->GetArrayLength(buffers)); 1359 if (!ioVec.init(buffers, offsets, byteCounts)) { 1360 return -1; 1361 } 1362 int fd = jniGetFDFromFileDescriptor(env, javaFd); 1363 return throwIfMinusOne(env, "writev", TEMP_FAILURE_RETRY(writev(fd, ioVec.get(), ioVec.size()))); 1364} 1365 1366static JNINativeMethod gMethods[] = { 1367 NATIVE_METHOD(Posix, accept, "(Ljava/io/FileDescriptor;Ljava/net/InetSocketAddress;)Ljava/io/FileDescriptor;"), 1368 NATIVE_METHOD(Posix, access, "(Ljava/lang/String;I)Z"), 1369 NATIVE_METHOD(Posix, bind, "(Ljava/io/FileDescriptor;Ljava/net/InetAddress;I)V"), 1370 NATIVE_METHOD(Posix, chmod, "(Ljava/lang/String;I)V"), 1371 NATIVE_METHOD(Posix, chown, "(Ljava/lang/String;II)V"), 1372 NATIVE_METHOD(Posix, close, "(Ljava/io/FileDescriptor;)V"), 1373 NATIVE_METHOD(Posix, connect, "(Ljava/io/FileDescriptor;Ljava/net/InetAddress;I)V"), 1374 NATIVE_METHOD(Posix, dup, "(Ljava/io/FileDescriptor;)Ljava/io/FileDescriptor;"), 1375 NATIVE_METHOD(Posix, dup2, "(Ljava/io/FileDescriptor;I)Ljava/io/FileDescriptor;"), 1376 NATIVE_METHOD(Posix, environ, "()[Ljava/lang/String;"), 1377 NATIVE_METHOD(Posix, execv, "(Ljava/lang/String;[Ljava/lang/String;)V"), 1378 NATIVE_METHOD(Posix, execve, "(Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/String;)V"), 1379 NATIVE_METHOD(Posix, fchmod, "(Ljava/io/FileDescriptor;I)V"), 1380 NATIVE_METHOD(Posix, fchown, "(Ljava/io/FileDescriptor;II)V"), 1381 NATIVE_METHOD(Posix, fcntlVoid, "(Ljava/io/FileDescriptor;I)I"), 1382 NATIVE_METHOD(Posix, fcntlLong, "(Ljava/io/FileDescriptor;IJ)I"), 1383 NATIVE_METHOD(Posix, fcntlFlock, "(Ljava/io/FileDescriptor;ILlibcore/io/StructFlock;)I"), 1384 NATIVE_METHOD(Posix, fdatasync, "(Ljava/io/FileDescriptor;)V"), 1385 NATIVE_METHOD(Posix, fstat, "(Ljava/io/FileDescriptor;)Llibcore/io/StructStat;"), 1386 NATIVE_METHOD(Posix, fstatvfs, "(Ljava/io/FileDescriptor;)Llibcore/io/StructStatVfs;"), 1387 NATIVE_METHOD(Posix, fsync, "(Ljava/io/FileDescriptor;)V"), 1388 NATIVE_METHOD(Posix, ftruncate, "(Ljava/io/FileDescriptor;J)V"), 1389 NATIVE_METHOD(Posix, gai_strerror, "(I)Ljava/lang/String;"), 1390 NATIVE_METHOD(Posix, getaddrinfo, "(Ljava/lang/String;Llibcore/io/StructAddrinfo;)[Ljava/net/InetAddress;"), 1391 NATIVE_METHOD(Posix, getegid, "()I"), 1392 NATIVE_METHOD(Posix, geteuid, "()I"), 1393 NATIVE_METHOD(Posix, getgid, "()I"), 1394 NATIVE_METHOD(Posix, getenv, "(Ljava/lang/String;)Ljava/lang/String;"), 1395 NATIVE_METHOD(Posix, getnameinfo, "(Ljava/net/InetAddress;I)Ljava/lang/String;"), 1396 NATIVE_METHOD(Posix, getpeername, "(Ljava/io/FileDescriptor;)Ljava/net/SocketAddress;"), 1397 NATIVE_METHOD(Posix, getpid, "()I"), 1398 NATIVE_METHOD(Posix, getppid, "()I"), 1399 NATIVE_METHOD(Posix, getpwnam, "(Ljava/lang/String;)Llibcore/io/StructPasswd;"), 1400 NATIVE_METHOD(Posix, getpwuid, "(I)Llibcore/io/StructPasswd;"), 1401 NATIVE_METHOD(Posix, getsockname, "(Ljava/io/FileDescriptor;)Ljava/net/SocketAddress;"), 1402 NATIVE_METHOD(Posix, getsockoptByte, "(Ljava/io/FileDescriptor;II)I"), 1403 NATIVE_METHOD(Posix, getsockoptInAddr, "(Ljava/io/FileDescriptor;II)Ljava/net/InetAddress;"), 1404 NATIVE_METHOD(Posix, getsockoptInt, "(Ljava/io/FileDescriptor;II)I"), 1405 NATIVE_METHOD(Posix, getsockoptLinger, "(Ljava/io/FileDescriptor;II)Llibcore/io/StructLinger;"), 1406 NATIVE_METHOD(Posix, getsockoptTimeval, "(Ljava/io/FileDescriptor;II)Llibcore/io/StructTimeval;"), 1407 NATIVE_METHOD(Posix, getsockoptUcred, "(Ljava/io/FileDescriptor;II)Llibcore/io/StructUcred;"), 1408 NATIVE_METHOD(Posix, gettid, "()I"), 1409 NATIVE_METHOD(Posix, getuid, "()I"), 1410 NATIVE_METHOD(Posix, if_indextoname, "(I)Ljava/lang/String;"), 1411 NATIVE_METHOD(Posix, inet_pton, "(ILjava/lang/String;)Ljava/net/InetAddress;"), 1412 NATIVE_METHOD(Posix, ioctlInetAddress, "(Ljava/io/FileDescriptor;ILjava/lang/String;)Ljava/net/InetAddress;"), 1413 NATIVE_METHOD(Posix, ioctlInt, "(Ljava/io/FileDescriptor;ILlibcore/util/MutableInt;)I"), 1414 NATIVE_METHOD(Posix, isatty, "(Ljava/io/FileDescriptor;)Z"), 1415 NATIVE_METHOD(Posix, kill, "(II)V"), 1416 NATIVE_METHOD(Posix, lchown, "(Ljava/lang/String;II)V"), 1417 NATIVE_METHOD(Posix, listen, "(Ljava/io/FileDescriptor;I)V"), 1418 NATIVE_METHOD(Posix, lseek, "(Ljava/io/FileDescriptor;JI)J"), 1419 NATIVE_METHOD(Posix, lstat, "(Ljava/lang/String;)Llibcore/io/StructStat;"), 1420 NATIVE_METHOD(Posix, mincore, "(JJ[B)V"), 1421 NATIVE_METHOD(Posix, mkdir, "(Ljava/lang/String;I)V"), 1422 NATIVE_METHOD(Posix, mlock, "(JJ)V"), 1423 NATIVE_METHOD(Posix, mmap, "(JJIILjava/io/FileDescriptor;J)J"), 1424 NATIVE_METHOD(Posix, msync, "(JJI)V"), 1425 NATIVE_METHOD(Posix, munlock, "(JJ)V"), 1426 NATIVE_METHOD(Posix, munmap, "(JJ)V"), 1427 NATIVE_METHOD(Posix, open, "(Ljava/lang/String;II)Ljava/io/FileDescriptor;"), 1428 NATIVE_METHOD(Posix, pipe, "()[Ljava/io/FileDescriptor;"), 1429 NATIVE_METHOD(Posix, poll, "([Llibcore/io/StructPollfd;I)I"), 1430 NATIVE_METHOD(Posix, preadBytes, "(Ljava/io/FileDescriptor;Ljava/lang/Object;IIJ)I"), 1431 NATIVE_METHOD(Posix, pwriteBytes, "(Ljava/io/FileDescriptor;Ljava/lang/Object;IIJ)I"), 1432 NATIVE_METHOD(Posix, readBytes, "(Ljava/io/FileDescriptor;Ljava/lang/Object;II)I"), 1433 NATIVE_METHOD(Posix, readv, "(Ljava/io/FileDescriptor;[Ljava/lang/Object;[I[I)I"), 1434 NATIVE_METHOD(Posix, recvfromBytes, "(Ljava/io/FileDescriptor;Ljava/lang/Object;IIILjava/net/InetSocketAddress;)I"), 1435 NATIVE_METHOD(Posix, remove, "(Ljava/lang/String;)V"), 1436 NATIVE_METHOD(Posix, rename, "(Ljava/lang/String;Ljava/lang/String;)V"), 1437 NATIVE_METHOD(Posix, sendfile, "(Ljava/io/FileDescriptor;Ljava/io/FileDescriptor;Llibcore/util/MutableLong;J)J"), 1438 NATIVE_METHOD(Posix, sendtoBytes, "(Ljava/io/FileDescriptor;Ljava/lang/Object;IIILjava/net/InetAddress;I)I"), 1439 NATIVE_METHOD(Posix, setegid, "(I)V"), 1440 NATIVE_METHOD(Posix, setenv, "(Ljava/lang/String;Ljava/lang/String;Z)V"), 1441 NATIVE_METHOD(Posix, seteuid, "(I)V"), 1442 NATIVE_METHOD(Posix, setgid, "(I)V"), 1443 NATIVE_METHOD(Posix, setsid, "()I"), 1444 NATIVE_METHOD(Posix, setsockoptByte, "(Ljava/io/FileDescriptor;III)V"), 1445 NATIVE_METHOD(Posix, setsockoptIfreq, "(Ljava/io/FileDescriptor;IILjava/lang/String;)V"), 1446 NATIVE_METHOD(Posix, setsockoptInt, "(Ljava/io/FileDescriptor;III)V"), 1447 NATIVE_METHOD(Posix, setsockoptIpMreqn, "(Ljava/io/FileDescriptor;III)V"), 1448 NATIVE_METHOD(Posix, setsockoptGroupReq, "(Ljava/io/FileDescriptor;IILlibcore/io/StructGroupReq;)V"), 1449 NATIVE_METHOD(Posix, setsockoptLinger, "(Ljava/io/FileDescriptor;IILlibcore/io/StructLinger;)V"), 1450 NATIVE_METHOD(Posix, setsockoptTimeval, "(Ljava/io/FileDescriptor;IILlibcore/io/StructTimeval;)V"), 1451 NATIVE_METHOD(Posix, setuid, "(I)V"), 1452 NATIVE_METHOD(Posix, shutdown, "(Ljava/io/FileDescriptor;I)V"), 1453 NATIVE_METHOD(Posix, socket, "(III)Ljava/io/FileDescriptor;"), 1454 NATIVE_METHOD(Posix, socketpair, "(IIILjava/io/FileDescriptor;Ljava/io/FileDescriptor;)V"), 1455 NATIVE_METHOD(Posix, stat, "(Ljava/lang/String;)Llibcore/io/StructStat;"), 1456 NATIVE_METHOD(Posix, statvfs, "(Ljava/lang/String;)Llibcore/io/StructStatVfs;"), 1457 NATIVE_METHOD(Posix, strerror, "(I)Ljava/lang/String;"), 1458 NATIVE_METHOD(Posix, strsignal, "(I)Ljava/lang/String;"), 1459 NATIVE_METHOD(Posix, symlink, "(Ljava/lang/String;Ljava/lang/String;)V"), 1460 NATIVE_METHOD(Posix, sysconf, "(I)J"), 1461 NATIVE_METHOD(Posix, tcdrain, "(Ljava/io/FileDescriptor;)V"), 1462 NATIVE_METHOD(Posix, tcsendbreak, "(Ljava/io/FileDescriptor;I)V"), 1463 NATIVE_METHOD(Posix, umaskImpl, "(I)I"), 1464 NATIVE_METHOD(Posix, uname, "()Llibcore/io/StructUtsname;"), 1465 NATIVE_METHOD(Posix, unsetenv, "(Ljava/lang/String;)V"), 1466 NATIVE_METHOD(Posix, waitpid, "(ILlibcore/util/MutableInt;I)I"), 1467 NATIVE_METHOD(Posix, writeBytes, "(Ljava/io/FileDescriptor;Ljava/lang/Object;II)I"), 1468 NATIVE_METHOD(Posix, writev, "(Ljava/io/FileDescriptor;[Ljava/lang/Object;[I[I)I"), 1469}; 1470void register_libcore_io_Posix(JNIEnv* env) { 1471 jniRegisterNativeMethods(env, "libcore/io/Posix", gMethods, NELEM(gMethods)); 1472} 1473