| /* |
| * Copyright (c) 1995, 2021, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package java.net; |
| |
| import java.io.IOException; |
| import java.io.UncheckedIOException; |
| import java.nio.channels.DatagramChannel; |
| import java.security.AccessController; |
| import java.security.PrivilegedExceptionAction; |
| import java.util.Enumeration; |
| import java.util.Objects; |
| import java.util.Set; |
| import java.util.Collections; |
| |
| /** |
| * A multicast datagram socket that delegates socket operations to a |
| * {@link DatagramSocketImpl}. |
| * |
| * This class overrides every public method defined by {@link DatagramSocket} |
| * and {@link MulticastSocket}. |
| */ |
| final class NetMulticastSocket extends MulticastSocket { |
| /** |
| * Various states of this socket. |
| */ |
| private boolean bound = false; |
| private boolean closed = false; |
| private volatile boolean created; |
| private final Object closeLock = new Object(); |
| |
| /* |
| * The implementation of this DatagramSocket. |
| */ |
| private final DatagramSocketImpl impl; |
| |
| /** |
| * Are we using an older DatagramSocketImpl? |
| */ |
| private final boolean oldImpl; |
| |
| /** |
| * Set when a socket is ST_CONNECTED until we are certain |
| * that any packets which might have been received prior |
| * to calling connect() but not read by the application |
| * have been read. During this time we check the source |
| * address of all packets received to be sure they are from |
| * the connected destination. Other packets are read but |
| * silently dropped. |
| */ |
| private boolean explicitFilter = false; |
| private int bytesLeftToFilter; |
| /* |
| * Connection state: |
| * ST_NOT_CONNECTED = socket not connected |
| * ST_CONNECTED = socket connected |
| * ST_CONNECTED_NO_IMPL = socket connected but not at impl level |
| */ |
| static final int ST_NOT_CONNECTED = 0; |
| static final int ST_CONNECTED = 1; |
| static final int ST_CONNECTED_NO_IMPL = 2; |
| |
| int connectState = ST_NOT_CONNECTED; |
| |
| /* |
| * Connected address & port |
| */ |
| InetAddress connectedAddress = null; |
| int connectedPort = -1; |
| |
| /** |
| * This constructor is also used by {@link DatagramSocket#DatagramSocket(DatagramSocketImpl)}. |
| * @param impl The impl used in this instance. |
| */ |
| NetMulticastSocket(DatagramSocketImpl impl) { |
| super((MulticastSocket) null); |
| this.impl = Objects.requireNonNull(impl); |
| this.oldImpl = checkOldImpl(impl); |
| } |
| |
| /** |
| * Connects this socket to a remote socket address (IP address + port number). |
| * Binds socket if not already bound. |
| * |
| * @param address The remote address. |
| * @param port The remote port |
| * @throws SocketException if binding the socket fails. |
| */ |
| private synchronized void connectInternal(InetAddress address, int port) throws SocketException { |
| if (port < 0 || port > 0xFFFF) { |
| throw new IllegalArgumentException("connect: " + port); |
| } |
| if (address == null) { |
| throw new IllegalArgumentException("connect: null address"); |
| } |
| checkAddress(address, "connect"); |
| if (isClosed()) |
| return; |
| @SuppressWarnings("removal") |
| SecurityManager security = System.getSecurityManager(); |
| if (security != null) { |
| if (address.isMulticastAddress()) { |
| security.checkMulticast(address); |
| } else { |
| security.checkConnect(address.getHostAddress(), port); |
| security.checkAccept(address.getHostAddress(), port); |
| } |
| } |
| |
| if (port == 0) { |
| throw new SocketException("Can't connect to port 0"); |
| } |
| if (!isBound()) |
| bind(new InetSocketAddress(0)); |
| |
| // old impls do not support connect/disconnect |
| if (oldImpl || (impl instanceof AbstractPlainDatagramSocketImpl && |
| ((AbstractPlainDatagramSocketImpl) impl).nativeConnectDisabled())) { |
| connectState = ST_CONNECTED_NO_IMPL; |
| } else { |
| try { |
| getImpl().connect(address, port); |
| |
| // socket is now connected by the impl |
| connectState = ST_CONNECTED; |
| // Do we need to filter some packets? |
| int avail = getImpl().dataAvailable(); |
| if (avail == -1) { |
| throw new SocketException(); |
| } |
| explicitFilter = avail > 0; |
| if (explicitFilter) { |
| bytesLeftToFilter = getReceiveBufferSize(); |
| } |
| } catch (SocketException se) { |
| |
| // connection will be emulated by DatagramSocket |
| connectState = ST_CONNECTED_NO_IMPL; |
| } |
| } |
| |
| connectedAddress = address; |
| connectedPort = port; |
| } |
| |
| /** |
| * Return true if the given DatagramSocketImpl is an "old" impl. An old impl |
| * is one that doesn't implement the abstract methods added in Java SE 1.4. |
| */ |
| @SuppressWarnings("removal") |
| private static boolean checkOldImpl(DatagramSocketImpl impl) { |
| // DatagramSocketImpl.peekData() is a protected method, therefore we need to use |
| // getDeclaredMethod, therefore we need permission to access the member |
| try { |
| AccessController.doPrivileged( |
| new PrivilegedExceptionAction<>() { |
| public Void run() throws NoSuchMethodException { |
| Class<?>[] cl = new Class<?>[1]; |
| cl[0] = DatagramPacket.class; |
| impl.getClass().getDeclaredMethod("peekData", cl); |
| return null; |
| } |
| }); |
| return false; |
| } catch (java.security.PrivilegedActionException e) { |
| return true; |
| } |
| } |
| |
| /** |
| * Return the {@code DatagramSocketImpl} attached to this socket, |
| * creating the socket if not already created. |
| * |
| * @return the {@code DatagramSocketImpl} attached to that |
| * DatagramSocket |
| * @throws SocketException if creating the socket fails |
| * @since 1.4 |
| */ |
| final DatagramSocketImpl getImpl() throws SocketException { |
| if (!created) { |
| synchronized (this) { |
| if (!created) { |
| impl.create(); |
| created = true; |
| } |
| } |
| } |
| return impl; |
| } |
| |
| @Override |
| public synchronized void bind(SocketAddress addr) throws SocketException { |
| if (isClosed()) |
| throw new SocketException("Socket is closed"); |
| if (isBound()) |
| throw new SocketException("already bound"); |
| if (addr == null) |
| addr = new InetSocketAddress(0); |
| if (!(addr instanceof InetSocketAddress epoint)) |
| throw new IllegalArgumentException("Unsupported address type!"); |
| if (epoint.isUnresolved()) |
| throw new SocketException("Unresolved address"); |
| InetAddress iaddr = epoint.getAddress(); |
| int port = epoint.getPort(); |
| checkAddress(iaddr, "bind"); |
| @SuppressWarnings("removal") |
| SecurityManager sec = System.getSecurityManager(); |
| if (sec != null) { |
| sec.checkListen(port); |
| } |
| try { |
| getImpl().bind(port, iaddr); |
| } catch (SocketException e) { |
| getImpl().close(); |
| throw e; |
| } |
| bound = true; |
| } |
| |
| static void checkAddress(InetAddress addr, String op) { |
| if (addr == null) { |
| return; |
| } |
| if (!(addr instanceof Inet4Address || addr instanceof Inet6Address)) { |
| throw new IllegalArgumentException(op + ": invalid address type"); |
| } |
| } |
| |
| @Override |
| public void connect(InetAddress address, int port) { |
| try { |
| connectInternal(address, port); |
| } catch (SocketException se) { |
| throw new UncheckedIOException("connect failed", se); |
| } |
| } |
| |
| @Override |
| public void connect(SocketAddress addr) throws SocketException { |
| if (addr == null) |
| throw new IllegalArgumentException("Address can't be null"); |
| if (!(addr instanceof InetSocketAddress epoint)) |
| throw new IllegalArgumentException("Unsupported address type"); |
| if (epoint.isUnresolved()) |
| throw new SocketException("Unresolved address"); |
| connectInternal(epoint.getAddress(), epoint.getPort()); |
| } |
| |
| @Override |
| public void disconnect() { |
| synchronized (this) { |
| if (isClosed()) |
| return; |
| if (connectState == ST_CONNECTED) { |
| impl.disconnect(); |
| } |
| connectedAddress = null; |
| connectedPort = -1; |
| connectState = ST_NOT_CONNECTED; |
| explicitFilter = false; |
| } |
| } |
| |
| @Override |
| public boolean isBound() { |
| return bound; |
| } |
| |
| @Override |
| public boolean isConnected() { |
| return connectState != ST_NOT_CONNECTED; |
| } |
| |
| @Override |
| public InetAddress getInetAddress() { |
| return connectedAddress; |
| } |
| |
| @Override |
| public int getPort() { |
| return connectedPort; |
| } |
| |
| @Override |
| public SocketAddress getRemoteSocketAddress() { |
| if (!isConnected()) |
| return null; |
| return new InetSocketAddress(getInetAddress(), getPort()); |
| } |
| |
| @Override |
| public SocketAddress getLocalSocketAddress() { |
| if (isClosed()) |
| return null; |
| if (!isBound()) |
| return null; |
| return new InetSocketAddress(getLocalAddress(), getLocalPort()); |
| } |
| |
| @Override |
| public void send(DatagramPacket p) throws IOException { |
| synchronized (p) { |
| if (isClosed()) |
| throw new SocketException("Socket is closed"); |
| InetAddress packetAddress = p.getAddress(); |
| int packetPort = p.getPort(); |
| checkAddress(packetAddress, "send"); |
| if (connectState == ST_NOT_CONNECTED) { |
| if (packetAddress == null) { |
| throw new IllegalArgumentException("Address not set"); |
| } |
| if (packetPort < 0 || packetPort > 0xFFFF) |
| throw new IllegalArgumentException("port out of range: " + packetPort); |
| // check the address is ok with the security manager on every send. |
| @SuppressWarnings("removal") |
| SecurityManager security = System.getSecurityManager(); |
| |
| // The reason you want to synchronize on datagram packet |
| // is because you don't want an applet to change the address |
| // while you are trying to send the packet for example |
| // after the security check but before the send. |
| if (security != null) { |
| if (packetAddress.isMulticastAddress()) { |
| security.checkMulticast(packetAddress); |
| } else { |
| security.checkConnect(packetAddress.getHostAddress(), |
| packetPort); |
| } |
| } |
| if (packetPort == 0) { |
| throw new SocketException("Can't send to port 0"); |
| } |
| } else { |
| // we're connected |
| if (packetAddress == null) { |
| p.setAddress(connectedAddress); |
| p.setPort(connectedPort); |
| } else if ((!packetAddress.equals(connectedAddress)) || |
| packetPort != connectedPort) { |
| throw new IllegalArgumentException("connected address " + |
| "and packet address" + |
| " differ"); |
| } |
| } |
| // Check whether the socket is bound |
| if (!isBound()) |
| bind(new InetSocketAddress(0)); |
| // call the method to send |
| getImpl().send(p); |
| } |
| } |
| |
| @Override |
| public synchronized void receive(DatagramPacket p) throws IOException { |
| synchronized (p) { |
| if (!isBound()) |
| bind(new InetSocketAddress(0)); |
| if (connectState == ST_NOT_CONNECTED) { |
| // check the address is ok with the security manager before every recv. |
| @SuppressWarnings("removal") |
| SecurityManager security = System.getSecurityManager(); |
| if (security != null) { |
| while (true) { |
| String peekAd = null; |
| int peekPort = 0; |
| // peek at the packet to see who it is from. |
| if (!oldImpl) { |
| // We can use the new peekData() API |
| DatagramPacket peekPacket = new DatagramPacket(new byte[1], 1); |
| peekPort = getImpl().peekData(peekPacket); |
| peekAd = peekPacket.getAddress().getHostAddress(); |
| } else { |
| InetAddress adr = new InetAddress(); |
| peekPort = getImpl().peek(adr); |
| peekAd = adr.getHostAddress(); |
| } |
| try { |
| security.checkAccept(peekAd, peekPort); |
| // security check succeeded - so now break |
| // and recv the packet. |
| break; |
| } catch (SecurityException se) { |
| // Throw away the offending packet by consuming |
| // it in a tmp buffer. |
| DatagramPacket tmp = new DatagramPacket(new byte[1], 1); |
| getImpl().receive(tmp); |
| |
| // silently discard the offending packet |
| // and continue: unknown/malicious |
| // entities on nets should not make |
| // runtime throw security exception and |
| // disrupt the applet by sending random |
| // datagram packets. |
| continue; |
| } |
| } // end of while |
| } |
| } |
| DatagramPacket tmp = null; |
| if ((connectState == ST_CONNECTED_NO_IMPL) || explicitFilter) { |
| // We have to do the filtering the old fashioned way since |
| // the native impl doesn't support connect or the connect |
| // via the impl failed, or .. "explicitFilter" may be set when |
| // a socket is connected via the impl, for a period of time |
| // when packets from other sources might be queued on socket. |
| boolean stop = false; |
| while (!stop) { |
| InetAddress peekAddress = null; |
| int peekPort = -1; |
| // peek at the packet to see who it is from. |
| if (!oldImpl) { |
| // We can use the new peekData() API |
| DatagramPacket peekPacket = new DatagramPacket(new byte[1], 1); |
| peekPort = getImpl().peekData(peekPacket); |
| peekAddress = peekPacket.getAddress(); |
| } else { |
| // this api only works for IPv4 |
| peekAddress = new InetAddress(); |
| peekPort = getImpl().peek(peekAddress); |
| } |
| if ((!connectedAddress.equals(peekAddress)) || |
| (connectedPort != peekPort)) { |
| // throw the packet away and silently continue |
| tmp = new DatagramPacket( |
| new byte[1024], 1024); |
| getImpl().receive(tmp); |
| if (explicitFilter) { |
| if (checkFiltering(tmp)) { |
| stop = true; |
| } |
| } |
| } else { |
| stop = true; |
| } |
| } |
| } |
| // If the security check succeeds, or the datagram is |
| // connected then receive the packet |
| getImpl().receive(p); |
| if (explicitFilter && tmp == null) { |
| // packet was not filtered, account for it here |
| checkFiltering(p); |
| } |
| } |
| } |
| |
| private boolean checkFiltering(DatagramPacket p) throws SocketException { |
| bytesLeftToFilter -= p.getLength(); |
| if (bytesLeftToFilter <= 0 || getImpl().dataAvailable() <= 0) { |
| explicitFilter = false; |
| return true; |
| } |
| return false; |
| } |
| |
| @Override |
| public InetAddress getLocalAddress() { |
| if (isClosed()) |
| return null; |
| InetAddress in; |
| try { |
| in = (InetAddress) getImpl().getOption(SocketOptions.SO_BINDADDR); |
| if (in.isAnyLocalAddress()) { |
| in = InetAddress.anyLocalAddress(); |
| } |
| @SuppressWarnings("removal") |
| SecurityManager s = System.getSecurityManager(); |
| if (s != null) { |
| s.checkConnect(in.getHostAddress(), -1); |
| } |
| } catch (Exception e) { |
| in = InetAddress.anyLocalAddress(); // "0.0.0.0" |
| } |
| return in; |
| } |
| |
| @Override |
| public int getLocalPort() { |
| if (isClosed()) |
| return -1; |
| try { |
| return getImpl().getLocalPort(); |
| } catch (Exception e) { |
| return 0; |
| } |
| } |
| |
| @Override |
| public synchronized void setSoTimeout(int timeout) throws SocketException { |
| if (isClosed()) |
| throw new SocketException("Socket is closed"); |
| if (timeout < 0) |
| throw new IllegalArgumentException("timeout < 0"); |
| getImpl().setOption(SocketOptions.SO_TIMEOUT, timeout); |
| } |
| |
| @Override |
| public synchronized int getSoTimeout() throws SocketException { |
| if (isClosed()) |
| throw new SocketException("Socket is closed"); |
| if (getImpl() == null) |
| return 0; |
| Object o = getImpl().getOption(SocketOptions.SO_TIMEOUT); |
| /* extra type safety */ |
| if (o instanceof Integer) { |
| return ((Integer) o).intValue(); |
| } else { |
| return 0; |
| } |
| } |
| |
| @Override |
| public synchronized void setSendBufferSize(int size) throws SocketException { |
| if (!(size > 0)) { |
| throw new IllegalArgumentException("negative send size"); |
| } |
| if (isClosed()) |
| throw new SocketException("Socket is closed"); |
| getImpl().setOption(SocketOptions.SO_SNDBUF, size); |
| } |
| |
| @Override |
| public synchronized int getSendBufferSize() throws SocketException { |
| if (isClosed()) |
| throw new SocketException("Socket is closed"); |
| int result = 0; |
| Object o = getImpl().getOption(SocketOptions.SO_SNDBUF); |
| if (o instanceof Integer) { |
| result = ((Integer) o).intValue(); |
| } |
| return result; |
| } |
| |
| @Override |
| public synchronized void setReceiveBufferSize(int size) throws SocketException { |
| if (size <= 0) { |
| throw new IllegalArgumentException("invalid receive size"); |
| } |
| if (isClosed()) |
| throw new SocketException("Socket is closed"); |
| getImpl().setOption(SocketOptions.SO_RCVBUF, size); |
| } |
| |
| @Override |
| public synchronized int getReceiveBufferSize() throws SocketException { |
| if (isClosed()) |
| throw new SocketException("Socket is closed"); |
| int result = 0; |
| Object o = getImpl().getOption(SocketOptions.SO_RCVBUF); |
| if (o instanceof Integer) { |
| result = ((Integer) o).intValue(); |
| } |
| return result; |
| } |
| |
| @Override |
| public synchronized void setReuseAddress(boolean on) throws SocketException { |
| if (isClosed()) |
| throw new SocketException("Socket is closed"); |
| // Integer instead of Boolean for compatibility with older DatagramSocketImpl |
| if (oldImpl) |
| getImpl().setOption(SocketOptions.SO_REUSEADDR, on ? -1 : 0); |
| else |
| getImpl().setOption(SocketOptions.SO_REUSEADDR, Boolean.valueOf(on)); |
| } |
| |
| @Override |
| public synchronized boolean getReuseAddress() throws SocketException { |
| if (isClosed()) |
| throw new SocketException("Socket is closed"); |
| Object o = getImpl().getOption(SocketOptions.SO_REUSEADDR); |
| return ((Boolean) o).booleanValue(); |
| } |
| |
| @Override |
| public synchronized void setBroadcast(boolean on) throws SocketException { |
| if (isClosed()) |
| throw new SocketException("Socket is closed"); |
| getImpl().setOption(SocketOptions.SO_BROADCAST, Boolean.valueOf(on)); |
| } |
| |
| @Override |
| public synchronized boolean getBroadcast() throws SocketException { |
| if (isClosed()) |
| throw new SocketException("Socket is closed"); |
| return ((Boolean) (getImpl().getOption(SocketOptions.SO_BROADCAST))).booleanValue(); |
| } |
| |
| @Override |
| public synchronized void setTrafficClass(int tc) throws SocketException { |
| if (tc < 0 || tc > 255) |
| throw new IllegalArgumentException("tc is not in range 0 -- 255"); |
| |
| if (isClosed()) |
| throw new SocketException("Socket is closed"); |
| try { |
| getImpl().setOption(SocketOptions.IP_TOS, tc); |
| } catch (SocketException se) { |
| // not supported if socket already connected |
| // Solaris returns error in such cases |
| if (!isConnected()) |
| throw se; |
| } |
| } |
| |
| @Override |
| public synchronized int getTrafficClass() throws SocketException { |
| if (isClosed()) |
| throw new SocketException("Socket is closed"); |
| return ((Integer) (getImpl().getOption(SocketOptions.IP_TOS))).intValue(); |
| } |
| |
| @Override |
| public void close() { |
| synchronized (closeLock) { |
| if (isClosed()) |
| return; |
| impl.close(); |
| closed = true; |
| } |
| } |
| |
| @Override |
| public boolean isClosed() { |
| synchronized (closeLock) { |
| return closed; |
| } |
| } |
| |
| @Override |
| public <T> DatagramSocket setOption(SocketOption<T> name, T value) |
| throws IOException |
| { |
| Objects.requireNonNull(name); |
| if (isClosed()) |
| throw new SocketException("Socket is closed"); |
| getImpl().setOption(name, value); |
| return this; |
| } |
| |
| @Override |
| public <T> T getOption(SocketOption<T> name) throws IOException { |
| Objects.requireNonNull(name); |
| if (isClosed()) |
| throw new SocketException("Socket is closed"); |
| return getImpl().getOption(name); |
| } |
| |
| private volatile Set<SocketOption<?>> options; |
| private final Object optionsLock = new Object(); |
| |
| @Override |
| public Set<SocketOption<?>> supportedOptions() { |
| Set<SocketOption<?>> options = this.options; |
| if (options != null) |
| return options; |
| synchronized (optionsLock) { |
| options = this.options; |
| if (options != null) { |
| return options; |
| } |
| try { |
| DatagramSocketImpl impl = getImpl(); |
| options = Collections.unmodifiableSet(impl.supportedOptions()); |
| } catch (IOException e) { |
| options = Collections.emptySet(); |
| } |
| return this.options = options; |
| } |
| } |
| |
| // Multicast socket support |
| |
| /** |
| * Used on some platforms to record if an outgoing interface |
| * has been set for this socket. |
| */ |
| private boolean interfaceSet; |
| |
| /** |
| * The lock on the socket's TTL. This is for set/getTTL and |
| * send(packet,ttl). |
| */ |
| private final Object ttlLock = new Object(); |
| |
| /** |
| * The lock on the socket's interface - used by setInterface |
| * and getInterface |
| */ |
| private final Object infLock = new Object(); |
| |
| /** |
| * The "last" interface set by setInterface on this MulticastSocket |
| */ |
| private InetAddress infAddress = null; |
| |
| @Deprecated |
| @Override |
| public void setTTL(byte ttl) throws IOException { |
| if (isClosed()) |
| throw new SocketException("Socket is closed"); |
| getImpl().setTTL(ttl); |
| } |
| |
| @Override |
| public void setTimeToLive(int ttl) throws IOException { |
| if (ttl < 0 || ttl > 255) { |
| throw new IllegalArgumentException("ttl out of range"); |
| } |
| if (isClosed()) |
| throw new SocketException("Socket is closed"); |
| getImpl().setTimeToLive(ttl); |
| } |
| |
| @Deprecated |
| @Override |
| public byte getTTL() throws IOException { |
| if (isClosed()) |
| throw new SocketException("Socket is closed"); |
| return getImpl().getTTL(); |
| } |
| |
| @Override |
| public int getTimeToLive() throws IOException { |
| if (isClosed()) |
| throw new SocketException("Socket is closed"); |
| return getImpl().getTimeToLive(); |
| } |
| |
| @Override |
| @Deprecated |
| public void joinGroup(InetAddress mcastaddr) throws IOException { |
| if (isClosed()) { |
| throw new SocketException("Socket is closed"); |
| } |
| |
| checkAddress(mcastaddr, "joinGroup"); |
| @SuppressWarnings("removal") |
| SecurityManager security = System.getSecurityManager(); |
| if (security != null) { |
| security.checkMulticast(mcastaddr); |
| } |
| |
| if (!mcastaddr.isMulticastAddress()) { |
| throw new SocketException("Not a multicast address"); |
| } |
| |
| /** |
| * required for some platforms where it's not possible to join |
| * a group without setting the interface first. |
| */ |
| NetworkInterface defaultInterface = NetworkInterface.getDefault(); |
| |
| if (!interfaceSet && defaultInterface != null) { |
| setNetworkInterface(defaultInterface); |
| } |
| |
| getImpl().join(mcastaddr); |
| } |
| |
| @Override |
| @Deprecated |
| public void leaveGroup(InetAddress mcastaddr) throws IOException { |
| if (isClosed()) { |
| throw new SocketException("Socket is closed"); |
| } |
| |
| checkAddress(mcastaddr, "leaveGroup"); |
| @SuppressWarnings("removal") |
| SecurityManager security = System.getSecurityManager(); |
| if (security != null) { |
| security.checkMulticast(mcastaddr); |
| } |
| |
| if (!mcastaddr.isMulticastAddress()) { |
| throw new SocketException("Not a multicast address"); |
| } |
| |
| getImpl().leave(mcastaddr); |
| } |
| |
| @Override |
| public void joinGroup(SocketAddress mcastaddr, NetworkInterface netIf) |
| throws IOException { |
| if (isClosed()) |
| throw new SocketException("Socket is closed"); |
| |
| if (!(mcastaddr instanceof InetSocketAddress addr)) |
| throw new IllegalArgumentException("Unsupported address type"); |
| |
| if (oldImpl) |
| throw new UnsupportedOperationException(); |
| |
| checkAddress(addr.getAddress(), "joinGroup"); |
| @SuppressWarnings("removal") |
| SecurityManager security = System.getSecurityManager(); |
| if (security != null) { |
| security.checkMulticast(addr.getAddress()); |
| } |
| |
| if (!addr.getAddress().isMulticastAddress()) { |
| throw new SocketException("Not a multicast address"); |
| } |
| |
| getImpl().joinGroup(mcastaddr, netIf); |
| } |
| |
| @Override |
| public void leaveGroup(SocketAddress mcastaddr, NetworkInterface netIf) |
| throws IOException { |
| if (isClosed()) |
| throw new SocketException("Socket is closed"); |
| |
| if (!(mcastaddr instanceof InetSocketAddress addr)) |
| throw new IllegalArgumentException("Unsupported address type"); |
| |
| if (oldImpl) |
| throw new UnsupportedOperationException(); |
| |
| checkAddress(addr.getAddress(), "leaveGroup"); |
| @SuppressWarnings("removal") |
| SecurityManager security = System.getSecurityManager(); |
| if (security != null) { |
| security.checkMulticast(addr.getAddress()); |
| } |
| |
| if (!addr.getAddress().isMulticastAddress()) { |
| throw new SocketException("Not a multicast address"); |
| } |
| |
| getImpl().leaveGroup(mcastaddr, netIf); |
| } |
| |
| @Override |
| @Deprecated |
| public void setInterface(InetAddress inf) throws SocketException { |
| if (isClosed()) { |
| throw new SocketException("Socket is closed"); |
| } |
| checkAddress(inf, "setInterface"); |
| synchronized (infLock) { |
| getImpl().setOption(SocketOptions.IP_MULTICAST_IF, inf); |
| infAddress = inf; |
| interfaceSet = true; |
| } |
| } |
| |
| @Override |
| @Deprecated |
| public InetAddress getInterface() throws SocketException { |
| if (isClosed()) { |
| throw new SocketException("Socket is closed"); |
| } |
| synchronized (infLock) { |
| InetAddress ia = |
| (InetAddress)getImpl().getOption(SocketOptions.IP_MULTICAST_IF); |
| |
| /** |
| * No previous setInterface or interface can be |
| * set using setNetworkInterface |
| */ |
| if (infAddress == null) { |
| return ia; |
| } |
| |
| /** |
| * Same interface set with setInterface? |
| */ |
| if (ia.equals(infAddress)) { |
| return ia; |
| } |
| |
| /** |
| * Different InetAddress from what we set with setInterface |
| * so enumerate the current interface to see if the |
| * address set by setInterface is bound to this interface. |
| */ |
| try { |
| NetworkInterface ni = NetworkInterface.getByInetAddress(ia); |
| Enumeration<InetAddress> addrs = ni.getInetAddresses(); |
| while (addrs.hasMoreElements()) { |
| InetAddress addr = addrs.nextElement(); |
| if (addr.equals(infAddress)) { |
| return infAddress; |
| } |
| } |
| |
| /** |
| * No match so reset infAddress to indicate that the |
| * interface has changed via means |
| */ |
| infAddress = null; |
| return ia; |
| } catch (Exception e) { |
| return ia; |
| } |
| } |
| } |
| |
| @Override |
| public void setNetworkInterface(NetworkInterface netIf) |
| throws SocketException { |
| |
| synchronized (infLock) { |
| getImpl().setOption(SocketOptions.IP_MULTICAST_IF2, netIf); |
| infAddress = null; |
| interfaceSet = true; |
| } |
| } |
| |
| @Override |
| public NetworkInterface getNetworkInterface() throws SocketException { |
| NetworkInterface ni |
| = (NetworkInterface)getImpl().getOption(SocketOptions.IP_MULTICAST_IF2); |
| if (ni == null) { |
| InetAddress[] addrs = new InetAddress[1]; |
| addrs[0] = InetAddress.anyLocalAddress(); |
| return new NetworkInterface(addrs[0].getHostName(), 0, addrs); |
| } else { |
| return ni; |
| } |
| } |
| |
| @Override |
| @Deprecated |
| public void setLoopbackMode(boolean disable) throws SocketException { |
| getImpl().setOption(SocketOptions.IP_MULTICAST_LOOP, Boolean.valueOf(disable)); |
| } |
| |
| @Override |
| @Deprecated |
| public boolean getLoopbackMode() throws SocketException { |
| return ((Boolean)getImpl().getOption(SocketOptions.IP_MULTICAST_LOOP)).booleanValue(); |
| } |
| |
| @SuppressWarnings("removal") |
| @Deprecated |
| @Override |
| public void send(DatagramPacket p, byte ttl) |
| throws IOException { |
| if (isClosed()) |
| throw new SocketException("Socket is closed"); |
| synchronized(ttlLock) { |
| synchronized(p) { |
| InetAddress packetAddress = p.getAddress(); |
| checkAddress(packetAddress, "send"); |
| if (connectState == NetMulticastSocket.ST_NOT_CONNECTED) { |
| if (packetAddress == null) { |
| throw new IllegalArgumentException("Address not set"); |
| } |
| // Security manager makes sure that the multicast address |
| // is allowed one and that the ttl used is less |
| // than the allowed maxttl. |
| SecurityManager security = System.getSecurityManager(); |
| if (security != null) { |
| if (packetAddress.isMulticastAddress()) { |
| security.checkMulticast(packetAddress, ttl); |
| } else { |
| security.checkConnect(packetAddress.getHostAddress(), |
| p.getPort()); |
| } |
| } |
| } else { |
| // we're connected |
| if (packetAddress == null) { |
| p.setAddress(connectedAddress); |
| p.setPort(connectedPort); |
| } else if ((!packetAddress.equals(connectedAddress)) || |
| p.getPort() != connectedPort) { |
| throw new IllegalArgumentException("connected address and packet address" + |
| " differ"); |
| } |
| } |
| byte dttl = getTTL(); |
| try { |
| if (ttl != dttl) { |
| // set the ttl |
| getImpl().setTTL(ttl); |
| } |
| if (p.getPort() == 0) { |
| throw new SocketException("Can't send to port 0"); |
| } |
| // call the datagram method to send |
| getImpl().send(p); |
| } finally { |
| // set it back to default |
| if (ttl != dttl) { |
| getImpl().setTTL(dttl); |
| } |
| } |
| } // synch p |
| } //synch ttl |
| } //method |
| } |
