jdk-sandbox: comparison jdk/src/share/classes/sun/nio/ch/Net.java

equal deleted inserted replaced

-:4070cecdb99d
+:29d6145d1097
 */
 package sun.nio.ch;
 import java.io.*;
-import java.lang.reflect.*;
 import java.net.*;
 import java.nio.channels.*;
+import java.util.*;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
 class Net {                                             // package-private
 private Net() { }
+// unspecified protocol family
+static final ProtocolFamily UNSPEC = new ProtocolFamily() {
+public String name() {
+return "UNSPEC";
+}
+};
 // -- Miscellaneous utilities --
+private static volatile boolean checkedIPv6 = false;
+private static volatile boolean isIPv6Available;
+/**
+* Tells whether dual-IPv4/IPv6 sockets should be used.
+*/
+static boolean isIPv6Available() {
+if (!checkedIPv6) {
+isIPv6Available = isIPv6Available0();
+checkedIPv6 = true;
+}
+return isIPv6Available;
+}
 static InetSocketAddress checkAddress(SocketAddress sa) {
 if (sa == null)
-throw new IllegalArgumentException();
+throw new NullPointerException();
 if (!(sa instanceof InetSocketAddress))
 throw new UnsupportedAddressTypeException(); // ## needs arg
 InetSocketAddress isa = (InetSocketAddress)sa;
 if (isa.isUnresolved())
 throw new UnresolvedAddressException(); // ## needs arg
 if (x instanceof SocketException)
 throw (SocketException)x;
 Exception nx = x;
 if (x instanceof ClosedChannelException)
 nx = new SocketException("Socket is closed");
+else if (x instanceof NotYetConnectedException)
+nx = new SocketException("Socket is not connected");
 else if (x instanceof AlreadyBoundException)
 nx = new SocketException("Already bound");
 else if (x instanceof NotYetBoundException)
 nx = new SocketException("Socket is not bound yet");
 else if (x instanceof UnsupportedAddressTypeException)
 throws IOException
 {
 translateException(x, false);
 }
+/**
+* Returns any IPv4 address of the given network interface, or
+* null if the interface does not have any IPv4 addresses.
+*/
+static Inet4Address anyInet4Address(final NetworkInterface interf) {
+return AccessController.doPrivileged(new PrivilegedAction<Inet4Address>() {
+public Inet4Address run() {
+Enumeration<InetAddress> addrs = interf.getInetAddresses();
+while (addrs.hasMoreElements()) {
+InetAddress addr = addrs.nextElement();
+if (addr instanceof Inet4Address) {
+return (Inet4Address)addr;
+}
+}
+return null;
+}
+});
+}
+/**
+* Returns an IPv4 address as an int.
+*/
+static int inet4AsInt(InetAddress ia) {
+if (ia instanceof Inet4Address) {
+byte[] addr = ia.getAddress();
+int address  = addr[3] & 0xFF;
+address |= ((addr[2] << 8) & 0xFF00);
+address |= ((addr[1] << 16) & 0xFF0000);
+address |= ((addr[0] << 24) & 0xFF000000);
+return address;
+}
+throw new AssertionError("Should not reach here");
+}
+/**
+* Returns an InetAddress from the given IPv4 address
+* represented as an int.
+*/
+static InetAddress inet4FromInt(int address) {
+byte[] addr = new byte[4];
+addr[0] = (byte) ((address >>> 24) & 0xFF);
+addr[1] = (byte) ((address >>> 16) & 0xFF);
+addr[2] = (byte) ((address >>> 8) & 0xFF);
+addr[3] = (byte) (address & 0xFF);
+try {
+return InetAddress.getByAddress(addr);
+} catch (UnknownHostException uhe) {
+throw new AssertionError("Should not reach here");
+}
+}
+/**
+* Returns an IPv6 address as a byte array
+*/
+static byte[] inet6AsByteArray(InetAddress ia) {
+if (ia instanceof Inet6Address) {
+return ia.getAddress();
+}
+// need to construct IPv4-mapped address
+if (ia instanceof Inet4Address) {
+byte[] ip4address = ia.getAddress();
+byte[] address = new byte[16];
+address[10] = (byte)0xff;
+address[11] = (byte)0xff;
+address[12] = ip4address[0];
+address[13] = ip4address[1];
+address[14] = ip4address[2];
+address[15] = ip4address[3];
+return address;
+}
+throw new AssertionError("Should not reach here");
+}
+// -- Socket options
+static void setSocketOption(FileDescriptor fd, ProtocolFamily family,
+SocketOption name, Object value)
+throws IOException
+{
+if (value == null)
+throw new IllegalArgumentException("Invalid option value");
+// only simple values supported by this method
+Class<?> type = name.type();
+if (type != Integer.class && type != Boolean.class)
+throw new AssertionError("Should not reach here");
+// special handling
+if (name == StandardSocketOption.SO_RCVBUF ||
+name == StandardSocketOption.SO_SNDBUF)
+{
+int i = ((Integer)value).intValue();
+if (i < 0)
+throw new IllegalArgumentException("Invalid send/receive buffer size");
+}
+if (name == StandardSocketOption.SO_LINGER) {
+int i = ((Integer)value).intValue();
+if (i < 0)
+value = Integer.valueOf(-1);
+if (i > 65535)
+value = Integer.valueOf(65535);
+}
+if (name == StandardSocketOption.IP_TOS) {
+int i = ((Integer)value).intValue();
+if (i < 0 || i > 255)
+throw new IllegalArgumentException("Invalid IP_TOS value");
+}
+if (name == StandardSocketOption.IP_MULTICAST_TTL) {
+int i = ((Integer)value).intValue();
+if (i < 0 || i > 255)
+throw new IllegalArgumentException("Invalid TTL/hop value");
+}
+// map option name to platform level/name
+OptionKey key = SocketOptionRegistry.findOption(name, family);
+if (key == null)
+throw new AssertionError("Option not found");
+int arg;
+if (type == Integer.class) {
+arg = ((Integer)value).intValue();
+} else {
+boolean b = ((Boolean)value).booleanValue();
+arg = (b) ? 1 : 0;
+}
+boolean mayNeedConversion = (family == UNSPEC);
+setIntOption0(fd, mayNeedConversion, key.level(), key.name(), arg);
+}
+static Object getSocketOption(FileDescriptor fd, ProtocolFamily family,
+SocketOption name)
+throws IOException
+{
+Class<?> type = name.type();
+// only simple values supported by this method
+if (type != Integer.class && type != Boolean.class)
+throw new AssertionError("Should not reach here");
+// map option name to platform level/name
+OptionKey key = SocketOptionRegistry.findOption(name, family);
+if (key == null)
+throw new AssertionError("Option not found");
+boolean mayNeedConversion = (family == UNSPEC);
+int value = getIntOption0(fd, mayNeedConversion, key.level(), key.name());
+if (type == Integer.class) {
+return Integer.valueOf(value);
+} else {
+return (value == 0) ? Boolean.FALSE : Boolean.TRUE;
+}
+}
 // -- Socket operations --
+static native boolean isIPv6Available0();
 static FileDescriptor socket(boolean stream) {
-return IOUtil.newFD(socket0(stream, false));
+return socket(UNSPEC, stream);
+}
+static FileDescriptor socket(ProtocolFamily family, boolean stream) {
+boolean preferIPv6 = isIPv6Available() &&
+(family != StandardProtocolFamily.INET);
+return IOUtil.newFD(socket0(preferIPv6, stream, false));
 }
 static FileDescriptor serverSocket(boolean stream) {
-return IOUtil.newFD(socket0(stream, true));
+return IOUtil.newFD(socket0(isIPv6Available(), stream, true));
 }
 // Due to oddities SO_REUSEADDR on windows reuse is ignored
-private static native int socket0(boolean stream, boolean reuse);
+private static native int socket0(boolean preferIPv6, boolean stream, boolean reuse);
-static native void bind(FileDescriptor fd, InetAddress addr, int port)
+static void bind(FileDescriptor fd, InetAddress addr, int port)
-throws IOException;
+throws IOException
+{
-static native int connect(FileDescriptor fd,
+bind(UNSPEC, fd, addr, port);
-InetAddress remote,
+}
-int remotePort,
-int trafficClass)
+static void bind(ProtocolFamily family, FileDescriptor fd,
-throws IOException;
+InetAddress addr, int port) throws IOException
+{
+boolean preferIPv6 = isIPv6Available() &&
+(family != StandardProtocolFamily.INET);
+bind0(preferIPv6, fd, addr, port);
+}
+private static native void bind0(boolean preferIPv6, FileDescriptor fd,
+InetAddress addr, int port)
+throws IOException;
+static native void listen(FileDescriptor fd, int backlog) throws IOException;
+static int connect(FileDescriptor fd, InetAddress remote, int remotePort)
+throws IOException
+{
+return connect(UNSPEC, fd, remote, remotePort);
+}
+static int connect(ProtocolFamily family, FileDescriptor fd, InetAddress remote, int remotePort)
+throws IOException
+{
+boolean preferIPv6 = isIPv6Available() &&
+(family != StandardProtocolFamily.INET);
+return connect0(preferIPv6, fd, remote, remotePort);
+}
+private static native int connect0(boolean preferIPv6,
+FileDescriptor fd,
+InetAddress remote,
+int remotePort)
+throws IOException;
+public final static int SHUT_RD = 0;
+public final static int SHUT_WR = 1;
+public final static int SHUT_RDWR = 2;
+static native void shutdown(FileDescriptor fd, int how) throws IOException;
 private static native int localPort(FileDescriptor fd)
 throws IOException;
 private static native InetAddress localInetAddress(FileDescriptor fd)
 throws IOException;
-static InetSocketAddress localAddress(FileDescriptor fd) {
+static InetSocketAddress localAddress(FileDescriptor fd)
-try {
+throws IOException
-return new InetSocketAddress(localInetAddress(fd),
+{
-localPort(fd));
+return new InetSocketAddress(localInetAddress(fd), localPort(fd));
-} catch (IOException x) {
+}
-throw new Error(x);         // Can't happen
-}
+private static native int remotePort(FileDescriptor fd)
-}
+throws IOException;
-static int localPortNumber(FileDescriptor fd) {
+private static native InetAddress remoteInetAddress(FileDescriptor fd)
-try {
+throws IOException;
-return localPort(fd);
-} catch (IOException x) {
+static InetSocketAddress remoteAddress(FileDescriptor fd)
-throw new Error(x);         // Can't happen
+throws IOException
-}
+{
-}
+return new InetSocketAddress(remoteInetAddress(fd), remotePort(fd));
+}
-private static native int getIntOption0(FileDescriptor fd, int opt)
-throws IOException;
+private static native int getIntOption0(FileDescriptor fd, boolean mayNeedConversion,
+int level, int opt)
-static int getIntOption(FileDescriptor fd, int opt)
+throws IOException;
-throws IOException
-{
+private static native void setIntOption0(FileDescriptor fd, boolean mayNeedConversion,
-return getIntOption0(fd, opt);
+int level, int opt, int arg)
-}
+throws IOException;
+// -- Multicast support --
-private static native void setIntOption0(FileDescriptor fd,
-int opt, int arg)
-throws IOException;
+/**
+* Join IPv4 multicast group
-static void setIntOption(FileDescriptor fd, int opt, int arg)
+*/
-throws IOException
+static int join4(FileDescriptor fd, int group, int interf, int source)
-{
+throws IOException
-setIntOption0(fd, opt, arg);
+{
-}
+return joinOrDrop4(true, fd, group, interf, source);
+}
+/**
+* Drop membership of IPv4 multicast group
+*/
+static void drop4(FileDescriptor fd, int group, int interf, int source)
+throws IOException
+{
+joinOrDrop4(false, fd, group, interf, source);
+}
+private static native int joinOrDrop4(boolean join, FileDescriptor fd, int group, int interf, int source)
+throws IOException;
+/**
+* Block IPv4 source
+*/
+static int block4(FileDescriptor fd, int group, int interf, int source)
+throws IOException
+{
+return blockOrUnblock4(true, fd, group, interf, source);
+}
+/**
+* Unblock IPv6 source
+*/
+static void unblock4(FileDescriptor fd, int group, int interf, int source)
+throws IOException
+{
+blockOrUnblock4(false, fd, group, interf, source);
+}
+private static native int blockOrUnblock4(boolean block, FileDescriptor fd, int group,
+int interf, int source)
+throws IOException;
+/**
+* Join IPv6 multicast group
+*/
+static int join6(FileDescriptor fd, byte[] group, int index, byte[] source)
+throws IOException
+{
+return joinOrDrop6(true, fd, group, index, source);
+}
+/**
+* Drop membership of IPv6 multicast group
+*/
+static void drop6(FileDescriptor fd, byte[] group, int index, byte[] source)
+throws IOException
+{
+joinOrDrop6(false, fd, group, index, source);
+}
+private static native int joinOrDrop6(boolean join, FileDescriptor fd, byte[] group, int index, byte[] source)
+throws IOException;
+/**
+* Block IPv6 source
+*/
+static int block6(FileDescriptor fd, byte[] group, int index, byte[] source)
+throws IOException
+{
+return blockOrUnblock6(true, fd, group, index, source);
+}
+/**
+* Unblock IPv6 source
+*/
+static void unblock6(FileDescriptor fd, byte[] group, int index, byte[] source)
+throws IOException
+{
+blockOrUnblock6(false, fd, group, index, source);
+}
+static native int blockOrUnblock6(boolean block, FileDescriptor fd, byte[] group, int index, byte[] source)
+throws IOException;
+static native void setInterface4(FileDescriptor fd, int interf) throws IOException;
+static native int getInterface4(FileDescriptor fd) throws IOException;
+static native void setInterface6(FileDescriptor fd, int index) throws IOException;
+static native int getInterface6(FileDescriptor fd) throws IOException;
 private static native void initIDs();
 static {
 Util.load();

changeset 1152	29d6145d1097
parent 2	90ce3da70b43
child 1247	b4c26443dee5