/*
* Creates a socket suitable for raw socket operations. The socket is
* bound to the interface specified by the supplied name. The socket
* value is placed into the supplied FileDescriptor instance.
*
* TODO(chesnutt): consider breaking this into pieces: create a
* variety of constructors for different socket types, then a generic
* setBlocking() method followed by polymorphic bind().
*/
static void RawSocket_create(JNIEnv* env, jclass, jobject fileDescriptor,
jshort protocolType, jstring interfaceName)
{
ScopedUtfChars ifname(env, interfaceName);
if (ifname.c_str() == NULL) {
return;
}
memset(&su, 0, sizeof(su));
su.sll.sll_family = PF_PACKET;
su.sll.sll_protocol = htons(protocolType);
su.sll.sll_ifindex = if_nametoindex(ifname.c_str());
int sock = socket(PF_PACKET, SOCK_DGRAM, htons(protocolType));
if (sock == -1) {
ALOGE("Can't create socket %s", strerror(errno));
jniThrowSocketException(env, errno);
return;
}
jniSetFileDescriptorOfFD(env, fileDescriptor, sock);
if (!setBlocking(sock, false)) {
ALOGE("Can't set non-blocking mode on socket %s", strerror(errno));
jniThrowSocketException(env, errno);
return;
}
int err = bind(sock, &su.sa, sizeof(su));
if (err != 0) {
ALOGE("Socket bind error %s", strerror(errno));
jniThrowSocketException(env, errno);
return;
}
}
static jint OSNetworkSystem_writeDirect(JNIEnv* env, jobject,
jobject fileDescriptor, jint address, jint offset, jint count) {
if (count <= 0) {
return 0;
}
NetFd fd(env, fileDescriptor);
if (fd.isClosed()) {
return 0;
}
jbyte* src = reinterpret_cast<jbyte*>(static_cast<uintptr_t>(address + offset));
ssize_t bytesSent;
{
int intFd = fd.get();
AsynchronousSocketCloseMonitor monitor(intFd);
bytesSent = NET_FAILURE_RETRY(fd, write(intFd, src, count));
}
if (env->ExceptionOccurred()) {
return -1;
}
if (bytesSent == -1) {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
// We were asked to write to a non-blocking socket, but were told
// it would block, so report "no bytes written".
return 0;
} else {
jniThrowSocketException(env, errno);
return 0;
}
}
return bytesSent;
}
static void OSNetworkSystem_socket(JNIEnv* env, jobject, jobject fileDescriptor, jboolean stream) {
if (fileDescriptor == NULL) {
jniThrowNullPointerException(env, NULL);
errno = EBADF;
return;
}
// Try IPv6 but fall back to IPv4...
int type = stream ? SOCK_STREAM : SOCK_DGRAM;
int fd = socket(AF_INET6, type, 0);
if (fd == -1 && errno == EAFNOSUPPORT) {
fd = socket(AF_INET, type, 0);
}
if (fd == -1) {
jniThrowSocketException(env, errno);
return;
} else {
jniSetFileDescriptorOfFD(env, fileDescriptor, fd);
}
#ifdef __linux__
// The RFC (http://www.ietf.org/rfc/rfc3493.txt) says that IPV6_MULTICAST_HOPS defaults to 1.
// The Linux kernel (at least up to 2.6.32) accidentally defaults to 64 (which would be correct
// for the *unicast* hop limit). See http://www.spinics.net/lists/netdev/msg129022.html.
// When that bug is fixed, we can remove this code. Until then, we manually set the hop
// limit on IPv6 datagram sockets. (IPv4 is already correct.)
if (type == SOCK_DGRAM && getSocketAddressFamily(fd) == AF_INET6) {
int ttl = 1;
setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &ttl, sizeof(int));
}
#endif
}
// TODO: can we merge this with recvDirect?
static jint OSNetworkSystem_readDirect(JNIEnv* env, jobject, jobject fileDescriptor,
jint address, jint count) {
NetFd fd(env, fileDescriptor);
if (fd.isClosed()) {
return 0;
}
jbyte* dst = reinterpret_cast<jbyte*>(static_cast<uintptr_t>(address));
ssize_t bytesReceived;
{
int intFd = fd.get();
AsynchronousSocketCloseMonitor monitor(intFd);
bytesReceived = NET_FAILURE_RETRY(fd, read(intFd, dst, count));
}
if (env->ExceptionOccurred()) {
return -1;
}
if (bytesReceived == 0) {
return -1;
} else if (bytesReceived == -1) {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
// We were asked to read a non-blocking socket with no data
// available, so report "no bytes read".
return 0;
} else {
jniThrowSocketException(env, errno);
return 0;
}
} else {
return bytesReceived;
}
}
static jint OSNetworkSystem_sendDirect(JNIEnv* env, jobject, jobject fileDescriptor, jint address, jint offset, jint length, jint port, jobject inetAddress) {
NetFd fd(env, fileDescriptor);
if (fd.isClosed()) {
return -1;
}
sockaddr_storage receiver;
if (inetAddress != NULL && !inetAddressToSocketAddress(env, inetAddress, port, &receiver)) {
return -1;
}
int flags = 0;
char* buf = reinterpret_cast<char*>(static_cast<uintptr_t>(address + offset));
sockaddr* to = inetAddress ? reinterpret_cast<sockaddr*>(&receiver) : NULL;
socklen_t toLength = inetAddress ? sizeof(receiver) : 0;
ssize_t bytesSent;
{
int intFd = fd.get();
AsynchronousSocketCloseMonitor monitor(intFd);
bytesSent = NET_FAILURE_RETRY(fd, sendto(intFd, buf, length, flags, to, toLength));
}
if (env->ExceptionOccurred()) {
return -1;
}
if (bytesSent == -1) {
if (errno == ECONNRESET || errno == ECONNREFUSED) {
return 0;
} else {
jniThrowSocketException(env, errno);
}
}
return bytesSent;
}
static void setSocketOption(JNIEnv* env, const NetFd& fd, int level, int option, T* value) {
int rc = setsockopt(fd.get(), level, option, value, sizeof(*value));
if (rc == -1) {
LOGE("setSocketOption(fd=%i, level=%i, option=%i) failed: %s (errno=%i)",
fd.get(), level, option, strerror(errno), errno);
jniThrowSocketException(env, errno);
}
}
static void doShutdown(JNIEnv* env, jobject fileDescriptor, int how) {
NetFd fd(env, fileDescriptor);
if (fd.isClosed()) {
return;
}
int rc = shutdown(fd.get(), how);
if (rc == -1) {
jniThrowSocketException(env, errno);
}
}
static void OSNetworkSystem_listen(JNIEnv* env, jobject, jobject fileDescriptor, jint backlog) {
NetFd fd(env, fileDescriptor);
if (fd.isClosed()) {
return;
}
int rc = listen(fd.get(), backlog);
if (rc == -1) {
jniThrowSocketException(env, errno);
}
}
static bool getSocketOption(JNIEnv* env, const NetFd& fd, int level, int option, T* value) {
socklen_t size = sizeof(*value);
int rc = getsockopt(fd.get(), level, option, value, &size);
if (rc == -1) {
LOGE("getSocketOption(fd=%i, level=%i, option=%i) failed: %s (errno=%i)",
fd.get(), level, option, strerror(errno), errno);
jniThrowSocketException(env, errno);
return false;
}
return true;
}
static jobjectArray NetworkInterface_getAllInterfaceAddressesImpl(JNIEnv* env, jclass) {
// Get the list of interface addresses.
ScopedInterfaceAddresses addresses;
if (!addresses.init()) {
jniThrowSocketException(env, errno);
return NULL;
}
// Count how many there are.
int interfaceAddressCount = 0;
for (ifaddrs* ifa = addresses.list; ifa != NULL; ifa = ifa->ifa_next) {
++interfaceAddressCount;
}
// Build the InterfaceAddress[]...
jobjectArray result =
env->NewObjectArray(interfaceAddressCount, JniConstants::interfaceAddressClass, NULL);
if (result == NULL) {
return NULL;
}
// And fill it in...
int arrayIndex = 0;
for (ifaddrs* ifa = addresses.list; ifa != NULL; ifa = ifa->ifa_next) {
// We're only interested in IP addresses.
int family = ifa->ifa_addr->sa_family;
if (family != AF_INET && family != AF_INET6) {
continue;
}
// Until we implement Java 6's NetworkInterface.isUp,
// we only want interfaces that are up.
if ((ifa->ifa_flags & IFF_UP) == 0) {
continue;
}
// Find the interface's index, and skip this address if
// the interface has gone away.
int interfaceIndex = if_nametoindex(ifa->ifa_name);
if (interfaceIndex == 0) {
continue;
}
// Make a new InterfaceAddress, and insert it into the array.
jobject element = makeInterfaceAddress(env, interfaceIndex, ifa);
if (element == NULL) {
return NULL;
}
env->SetObjectArrayElement(result, arrayIndex, element);
if (env->ExceptionCheck()) {
return NULL;
}
++arrayIndex;
}
return result;
}
// TODO: can we merge this with readDirect?
static jint OSNetworkSystem_recvDirect(JNIEnv* env, jobject, jobject fileDescriptor, jobject packet,
jint address, jint offset, jint length, jboolean peek, jboolean connected) {
NetFd fd(env, fileDescriptor);
if (fd.isClosed()) {
return 0;
}
char* buf = reinterpret_cast<char*>(static_cast<uintptr_t>(address + offset));
const int flags = peek ? MSG_PEEK : 0;
sockaddr_storage ss;
memset(&ss, 0, sizeof(ss));
socklen_t sockAddrLen = sizeof(ss);
sockaddr* from = connected ? NULL : reinterpret_cast<sockaddr*>(&ss);
socklen_t* fromLength = connected ? NULL : &sockAddrLen;
ssize_t bytesReceived;
{
int intFd = fd.get();
AsynchronousSocketCloseMonitor monitor(intFd);
bytesReceived = NET_FAILURE_RETRY(fd, recvfrom(intFd, buf, length, flags, from, fromLength));
}
if (env->ExceptionOccurred()) {
return -1;
}
if (bytesReceived == -1) {
if (connected && errno == ECONNREFUSED) {
jniThrowException(env, "java/net/PortUnreachableException", "");
} else if (errno == EAGAIN || errno == EWOULDBLOCK) {
jniThrowSocketTimeoutException(env, errno);
} else {
jniThrowSocketException(env, errno);
}
return 0;
}
if (packet != NULL) {
env->SetIntField(packet, gCachedFields.dpack_length, bytesReceived);
if (!connected) {
jbyteArray addr = socketAddressToByteArray(env, &ss);
if (addr == NULL) {
return 0;
}
int port = getSocketAddressPort(&ss);
jobject sender = byteArrayToInetAddress(env, addr);
if (sender == NULL) {
return 0;
}
env->SetObjectField(packet, gCachedFields.dpack_address, sender);
env->SetIntField(packet, gCachedFields.dpack_port, port);
}
}
return bytesReceived;
}
static void OSNetworkSystem_sendUrgentData(JNIEnv* env, jobject,
jobject fileDescriptor, jbyte value) {
NetFd fd(env, fileDescriptor);
if (fd.isClosed()) {
return;
}
int rc = send(fd.get(), &value, 1, MSG_OOB);
if (rc == -1) {
jniThrowSocketException(env, errno);
}
}
static bool doIoctl(JNIEnv* env, jstring name, int request, ifreq& ifr) {
// Copy the name into the ifreq structure, if there's room...
jsize nameLength = env->GetStringLength(name);
if (nameLength >= IFNAMSIZ) {
errno = ENAMETOOLONG;
jniThrowSocketException(env, errno);
return false;
}
memset(&ifr, 0, sizeof(ifr));
env->GetStringUTFRegion(name, 0, nameLength, ifr.ifr_name);
// ...and do the ioctl.
ScopedFd fd(socket(AF_INET, SOCK_DGRAM, 0));
if (fd.get() == -1) {
jniThrowSocketException(env, errno);
return false;
}
int rc = ioctl(fd.get(), request, &ifr);
if (rc == -1) {
jniThrowSocketException(env, errno);
return false;
}
return true;
}
void didFail(int fd, int result) {
if (fd != -1) {
setBlocking(fd, true);
}
if (result == -ECONNRESET || result == -ECONNREFUSED || result == -EADDRNOTAVAIL ||
result == -EADDRINUSE || result == -ENETUNREACH) {
jniThrowConnectException(mEnv, -result);
} else if (result == -EACCES) {
jniThrowSecurityException(mEnv, -result);
} else if (result == -ETIMEDOUT) {
jniThrowSocketTimeoutException(mEnv, -result);
} else {
jniThrowSocketException(mEnv, -result);
}
}
static jboolean OSNetworkSystem_selectImpl(JNIEnv* env, jclass,
jobjectArray readFDArray, jobjectArray writeFDArray, jint countReadC,
jint countWriteC, jintArray outFlags, jlong timeoutMs) {
// Initialize the fd_sets.
int maxFd = -1;
fd_set readFds;
fd_set writeFds;
FD_ZERO(&readFds);
FD_ZERO(&writeFds);
bool initialized = initFdSet(env, readFDArray, countReadC, &readFds, &maxFd) &&
initFdSet(env, writeFDArray, countWriteC, &writeFds, &maxFd);
if (!initialized) {
return -1;
}
// Initialize the timeout, if any.
timeval tv;
timeval* tvp = NULL;
if (timeoutMs >= 0) {
tv = toTimeval(timeoutMs);
tvp = &tv;
}
// Perform the select.
int result = select(maxFd + 1, &readFds, &writeFds, NULL, tvp);
if (result == 0) {
// Timeout.
return JNI_FALSE;
} else if (result == -1) {
// Error.
if (errno == EINTR) {
return JNI_FALSE;
} else {
jniThrowSocketException(env, errno);
return JNI_FALSE;
}
}
// Translate the result into the int[] we're supposed to fill in.
ScopedIntArrayRW flagArray(env, outFlags);
if (flagArray.get() == NULL) {
return JNI_FALSE;
}
return translateFdSet(env, readFDArray, countReadC, readFds, flagArray.get(), 0, SOCKET_OP_READ) &&
translateFdSet(env, writeFDArray, countWriteC, writeFds, flagArray.get(), countReadC, SOCKET_OP_WRITE);
}
static void OSNetworkSystem_disconnectDatagram(JNIEnv* env, jobject, jobject fileDescriptor) {
NetFd fd(env, fileDescriptor);
if (fd.isClosed()) {
return;
}
// To disconnect a datagram socket, we connect to a bogus address with
// the family AF_UNSPEC.
sockaddr_storage ss;
memset(&ss, 0, sizeof(ss));
ss.ss_family = AF_UNSPEC;
const sockaddr* sa = reinterpret_cast<const sockaddr*>(&ss);
int rc = TEMP_FAILURE_RETRY(connect(fd.get(), sa, sizeof(ss)));
if (rc == -1) {
jniThrowSocketException(env, errno);
}
}
static void mcastJoinLeaveGroup(JNIEnv* env, int fd, jobject javaGroupRequest, bool join) {
group_req groupRequest;
// Get the IPv4 or IPv6 multicast address to join or leave.
jfieldID fid = env->GetFieldID(JniConstants::multicastGroupRequestClass,
"gr_group", "Ljava/net/InetAddress;");
jobject group = env->GetObjectField(javaGroupRequest, fid);
if (!inetAddressToSocketAddress(env, group, 0, &groupRequest.gr_group)) {
return;
}
// Get the interface index to use (or 0 for "whatever").
fid = env->GetFieldID(JniConstants::multicastGroupRequestClass, "gr_interface", "I");
groupRequest.gr_interface = env->GetIntField(javaGroupRequest, fid);
int level = groupRequest.gr_group.ss_family == AF_INET ? IPPROTO_IP : IPPROTO_IPV6;
int option = join ? MCAST_JOIN_GROUP : MCAST_LEAVE_GROUP;
int rc = setsockopt(fd, level, option, &groupRequest, sizeof(groupRequest));
if (rc == -1) {
jniThrowSocketException(env, errno);
return;
}
}
static void OSNetworkSystem_accept(JNIEnv* env, jobject, jobject serverFileDescriptor,
jobject newSocket, jobject clientFileDescriptor) {
if (newSocket == NULL) {
jniThrowNullPointerException(env, NULL);
return;
}
NetFd serverFd(env, serverFileDescriptor);
if (serverFd.isClosed()) {
return;
}
sockaddr_storage ss;
socklen_t addrLen = sizeof(ss);
sockaddr* sa = reinterpret_cast<sockaddr*>(&ss);
int clientFd;
{
int intFd = serverFd.get();
AsynchronousSocketCloseMonitor monitor(intFd);
clientFd = NET_FAILURE_RETRY(serverFd, accept(intFd, sa, &addrLen));
}
if (env->ExceptionOccurred()) {
return;
}
if (clientFd == -1) {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
jniThrowSocketTimeoutException(env, errno);
} else {
jniThrowSocketException(env, errno);
}
return;
}
// Reset the inherited read timeout to the Java-specified default of 0.
timeval timeout(toTimeval(0));
int rc = setsockopt(clientFd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
if (rc == -1) {
LOGE("couldn't reset SO_RCVTIMEO on accepted socket fd %i: %s", clientFd, strerror(errno));
jniThrowSocketException(env, errno);
}
/*
* For network sockets, put the peer address and port in instance variables.
* We don't bother to do this for UNIX domain sockets, since most peers are
* anonymous anyway.
*/
if (ss.ss_family == AF_INET || ss.ss_family == AF_INET6) {
// Remote address and port.
jobject remoteAddress = socketAddressToInetAddress(env, &ss);
if (remoteAddress == NULL) {
close(clientFd);
return;
}
int remotePort = getSocketAddressPort(&ss);
env->SetObjectField(newSocket, gCachedFields.socketimpl_address, remoteAddress);
env->SetIntField(newSocket, gCachedFields.socketimpl_port, remotePort);
// Local port.
memset(&ss, 0, addrLen);
int rc = getsockname(clientFd, sa, &addrLen);
if (rc == -1) {
close(clientFd);
jniThrowSocketException(env, errno);
return;
}
int localPort = getSocketAddressPort(&ss);
env->SetIntField(newSocket, gCachedFields.socketimpl_localport, localPort);
}
jniSetFileDescriptorOfFD(env, clientFileDescriptor, clientFd);
}
static void OSNetworkSystem_setSocketOption(JNIEnv* env, jobject, jobject fileDescriptor, jint option, jobject optVal) {
NetFd fd(env, fileDescriptor);
if (fd.isClosed()) {
return;
}
int intVal;
bool wasBoolean = false;
if (env->IsInstanceOf(optVal, JniConstants::integerClass)) {
intVal = (int) env->GetIntField(optVal, gCachedFields.integer_class_value);
} else if (env->IsInstanceOf(optVal, JniConstants::booleanClass)) {
intVal = (int) env->GetBooleanField(optVal, gCachedFields.boolean_class_value);
wasBoolean = true;
} else if (env->IsInstanceOf(optVal, JniConstants::inetAddressClass)) {
// We use optVal directly as an InetAddress for IP_MULTICAST_IF.
} else if (env->IsInstanceOf(optVal, JniConstants::multicastGroupRequestClass)) {
// We use optVal directly as a MulticastGroupRequest for MCAST_JOIN_GROUP/MCAST_LEAVE_GROUP.
} else {
jniThrowSocketException(env, EINVAL);
return;
}
int family = getSocketAddressFamily(fd.get());
if (family != AF_INET && family != AF_INET6) {
jniThrowSocketException(env, EAFNOSUPPORT);
return;
}
// Since we expect to have a AF_INET6 socket even if we're communicating via IPv4, we always
// set the IPPROTO_IP options. As long as we fall back to creating IPv4 sockets if creating
// an IPv6 socket fails, we need to make setting the IPPROTO_IPV6 options conditional.
switch (option) {
case JAVASOCKOPT_IP_TOS:
setSocketOption(env, fd, IPPROTO_IP, IP_TOS, &intVal);
if (family == AF_INET6) {
setSocketOption(env, fd, IPPROTO_IPV6, IPV6_TCLASS, &intVal);
}
return;
case JAVASOCKOPT_SO_BROADCAST:
setSocketOption(env, fd, SOL_SOCKET, SO_BROADCAST, &intVal);
return;
case JAVASOCKOPT_SO_KEEPALIVE:
setSocketOption(env, fd, SOL_SOCKET, SO_KEEPALIVE, &intVal);
return;
case JAVASOCKOPT_SO_LINGER:
{
linger l;
l.l_onoff = !wasBoolean;
l.l_linger = intVal <= 65535 ? intVal : 65535;
setSocketOption(env, fd, SOL_SOCKET, SO_LINGER, &l);
return;
}
case JAVASOCKOPT_SO_OOBINLINE:
setSocketOption(env, fd, SOL_SOCKET, SO_OOBINLINE, &intVal);
return;
case JAVASOCKOPT_SO_RCVBUF:
setSocketOption(env, fd, SOL_SOCKET, SO_RCVBUF, &intVal);
return;
case JAVASOCKOPT_SO_REUSEADDR:
setSocketOption(env, fd, SOL_SOCKET, SO_REUSEADDR, &intVal);
return;
case JAVASOCKOPT_SO_SNDBUF:
setSocketOption(env, fd, SOL_SOCKET, SO_SNDBUF, &intVal);
return;
case JAVASOCKOPT_SO_TIMEOUT:
{
timeval timeout(toTimeval(intVal));
setSocketOption(env, fd, SOL_SOCKET, SO_RCVTIMEO, &timeout);
return;
}
case JAVASOCKOPT_TCP_NODELAY:
setSocketOption(env, fd, IPPROTO_TCP, TCP_NODELAY, &intVal);
return;
#ifdef ENABLE_MULTICAST
case JAVASOCKOPT_MCAST_JOIN_GROUP:
mcastJoinLeaveGroup(env, fd.get(), optVal, true);
return;
case JAVASOCKOPT_MCAST_LEAVE_GROUP:
mcastJoinLeaveGroup(env, fd.get(), optVal, false);
return;
case JAVASOCKOPT_IP_MULTICAST_IF:
{
sockaddr_storage sockVal;
if (!env->IsInstanceOf(optVal, JniConstants::inetAddressClass) ||
!inetAddressToSocketAddress(env, optVal, 0, &sockVal)) {
return;
}
// This call is IPv4 only. The socket may be IPv6, but the address
// that identifies the interface to join must be an IPv4 address.
if (sockVal.ss_family != AF_INET) {
jniThrowSocketException(env, EAFNOSUPPORT);
return;
}
ip_mreqn mcast_req;
memset(&mcast_req, 0, sizeof(mcast_req));
mcast_req.imr_address = reinterpret_cast<sockaddr_in*>(&sockVal)->sin_addr;
setSocketOption(env, fd, IPPROTO_IP, IP_MULTICAST_IF, &mcast_req);
return;
}
case JAVASOCKOPT_IP_MULTICAST_IF2:
// TODO: is this right? should we unconditionally set the IPPROTO_IP state in case
// we have an IPv6 socket communicating via IPv4?
if (family == AF_INET) {
// IP_MULTICAST_IF expects a pointer to an ip_mreqn struct.
ip_mreqn multicastRequest;
memset(&multicastRequest, 0, sizeof(multicastRequest));
multicastRequest.imr_ifindex = intVal;
setSocketOption(env, fd, IPPROTO_IP, IP_MULTICAST_IF, &multicastRequest);
} else {
// IPV6_MULTICAST_IF expects a pointer to an integer.
setSocketOption(env, fd, IPPROTO_IPV6, IPV6_MULTICAST_IF, &intVal);
}
return;
case JAVASOCKOPT_MULTICAST_TTL:
{
// Although IPv6 was cleaned up to use int, and IPv4 non-multicast TTL uses int,
// IPv4 multicast TTL uses a byte.
u_char ttl = intVal;
setSocketOption(env, fd, IPPROTO_IP, IP_MULTICAST_TTL, &ttl);
if (family == AF_INET6) {
setSocketOption(env, fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &intVal);
}
return;
}
case JAVASOCKOPT_IP_MULTICAST_LOOP:
{
// Although IPv6 was cleaned up to use int, IPv4 multicast loopback uses a byte.
u_char loopback = intVal;
setSocketOption(env, fd, IPPROTO_IP, IP_MULTICAST_LOOP, &loopback);
if (family == AF_INET6) {
setSocketOption(env, fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &intVal);
}
return;
}
#else
case JAVASOCKOPT_MULTICAST_TTL:
case JAVASOCKOPT_MCAST_JOIN_GROUP:
case JAVASOCKOPT_MCAST_LEAVE_GROUP:
case JAVASOCKOPT_IP_MULTICAST_IF:
case JAVASOCKOPT_IP_MULTICAST_IF2:
case JAVASOCKOPT_IP_MULTICAST_LOOP:
jniThrowException(env, "java/lang/UnsupportedOperationException", NULL);
return;
#endif // def ENABLE_MULTICAST
default:
jniThrowSocketException(env, ENOPROTOOPT);
}
}
static jobject OSNetworkSystem_getSocketOption(JNIEnv* env, jobject, jobject fileDescriptor, jint option) {
NetFd fd(env, fileDescriptor);
if (fd.isClosed()) {
return NULL;
}
int family = getSocketAddressFamily(fd.get());
if (family != AF_INET && family != AF_INET6) {
jniThrowSocketException(env, EAFNOSUPPORT);
return NULL;
}
switch (option) {
case JAVASOCKOPT_TCP_NODELAY:
return getSocketOption_Boolean(env, fd, IPPROTO_TCP, TCP_NODELAY);
case JAVASOCKOPT_SO_SNDBUF:
return getSocketOption_Integer(env, fd, SOL_SOCKET, SO_SNDBUF);
case JAVASOCKOPT_SO_RCVBUF:
return getSocketOption_Integer(env, fd, SOL_SOCKET, SO_RCVBUF);
case JAVASOCKOPT_SO_BROADCAST:
return getSocketOption_Boolean(env, fd, SOL_SOCKET, SO_BROADCAST);
case JAVASOCKOPT_SO_REUSEADDR:
return getSocketOption_Boolean(env, fd, SOL_SOCKET, SO_REUSEADDR);
case JAVASOCKOPT_SO_KEEPALIVE:
return getSocketOption_Boolean(env, fd, SOL_SOCKET, SO_KEEPALIVE);
case JAVASOCKOPT_SO_OOBINLINE:
return getSocketOption_Boolean(env, fd, SOL_SOCKET, SO_OOBINLINE);
case JAVASOCKOPT_IP_TOS:
if (family == AF_INET) {
return getSocketOption_Integer(env, fd, IPPROTO_IP, IP_TOS);
} else {
return getSocketOption_Integer(env, fd, IPPROTO_IPV6, IPV6_TCLASS);
}
case JAVASOCKOPT_SO_LINGER:
{
linger lingr;
bool ok = getSocketOption(env, fd, SOL_SOCKET, SO_LINGER, &lingr);
if (!ok) {
return NULL; // We already threw.
} else if (!lingr.l_onoff) {
return booleanValueOf(env, false);
} else {
return integerValueOf(env, lingr.l_linger);
}
}
case JAVASOCKOPT_SO_TIMEOUT:
{
timeval timeout;
bool ok = getSocketOption(env, fd, SOL_SOCKET, SO_RCVTIMEO, &timeout);
return ok ? integerValueOf(env, toMs(timeout)) : NULL;
}
#ifdef ENABLE_MULTICAST
case JAVASOCKOPT_IP_MULTICAST_IF:
{
// Although setsockopt(2) can take an ip_mreqn for IP_MULTICAST_IF, getsockopt(2)
// always returns an in_addr.
sockaddr_storage ss;
memset(&ss, 0, sizeof(ss));
ss.ss_family = AF_INET; // This call is IPv4-only.
sockaddr_in* sa = reinterpret_cast<sockaddr_in*>(&ss);
if (!getSocketOption(env, fd, IPPROTO_IP, IP_MULTICAST_IF, &sa->sin_addr)) {
return NULL;
}
return socketAddressToInetAddress(env, &ss);
}
case JAVASOCKOPT_IP_MULTICAST_IF2:
if (family == AF_INET) {
// The caller's asking for an interface index, but that's not how IPv4 works.
// Our Java should never get here, because we'll try IP_MULTICAST_IF first and
// that will satisfy us.
jniThrowSocketException(env, EAFNOSUPPORT);
} else {
return getSocketOption_Integer(env, fd, IPPROTO_IPV6, IPV6_MULTICAST_IF);
}
case JAVASOCKOPT_IP_MULTICAST_LOOP:
if (family == AF_INET) {
// Although IPv6 was cleaned up to use int, IPv4 multicast loopback uses a byte.
u_char loopback;
bool ok = getSocketOption(env, fd, IPPROTO_IP, IP_MULTICAST_LOOP, &loopback);
return ok ? booleanValueOf(env, loopback) : NULL;
} else {
return getSocketOption_Boolean(env, fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP);
}
case JAVASOCKOPT_MULTICAST_TTL:
if (family == AF_INET) {
// Although IPv6 was cleaned up to use int, and IPv4 non-multicast TTL uses int,
// IPv4 multicast TTL uses a byte.
u_char ttl;
bool ok = getSocketOption(env, fd, IPPROTO_IP, IP_MULTICAST_TTL, &ttl);
return ok ? integerValueOf(env, ttl) : NULL;
} else {
return getSocketOption_Integer(env, fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS);
}
#else
case JAVASOCKOPT_MULTICAST_TTL:
case JAVASOCKOPT_IP_MULTICAST_IF:
case JAVASOCKOPT_IP_MULTICAST_IF2:
case JAVASOCKOPT_IP_MULTICAST_LOOP:
jniThrowException(env, "java/lang/UnsupportedOperationException", NULL);
return NULL;
#endif // def ENABLE_MULTICAST
default:
jniThrowSocketException(env, ENOPROTOOPT);
return NULL;
}
}
