| /* |
| * Copyright (C) 2014 The Android Open Source Project |
| * Copyright (c) 1995, 2013, 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 static android.system.OsConstants.SOL_SOCKET; |
| import static android.system.OsConstants.SO_BINDTODEVICE; |
| |
| import android.system.ErrnoException; |
| import java.io.FileDescriptor; |
| import java.io.IOException; |
| import java.nio.channels.DatagramChannel; |
| import java.security.AccessController; |
| import java.security.PrivilegedExceptionAction; |
| import libcore.io.Libcore; |
| |
| /** |
| * This class represents a socket for sending and receiving datagram packets. |
| * |
| * <p>A datagram socket is the sending or receiving point for a packet |
| * delivery service. Each packet sent or received on a datagram socket |
| * is individually addressed and routed. Multiple packets sent from |
| * one machine to another may be routed differently, and may arrive in |
| * any order. |
| * |
| * <p> Where possible, a newly constructed {@code DatagramSocket} has the |
| * {@link SocketOptions#SO_BROADCAST SO_BROADCAST} socket option enabled so as |
| * to allow the transmission of broadcast datagrams. In order to receive |
| * broadcast packets a DatagramSocket should be bound to the wildcard address. |
| * In some implementations, broadcast packets may also be received when |
| * a DatagramSocket is bound to a more specific address. |
| * <p> |
| * Example: |
| * {@code |
| * DatagramSocket s = new DatagramSocket(null); |
| * s.bind(new InetSocketAddress(8888)); |
| * } |
| * Which is equivalent to: |
| * {@code |
| * DatagramSocket s = new DatagramSocket(8888); |
| * } |
| * Both cases will create a DatagramSocket able to receive broadcasts on |
| * UDP port 8888. |
| * |
| * @author Pavani Diwanji |
| * @see java.net.DatagramPacket |
| * @see java.nio.channels.DatagramChannel |
| * @since JDK1.0 |
| */ |
| public |
| class DatagramSocket implements java.io.Closeable { |
| /** |
| * Various states of this socket. |
| */ |
| private boolean created = false; |
| private boolean bound = false; |
| private boolean closed = false; |
| private Object closeLock = new Object(); |
| |
| /* |
| * The implementation of this DatagramSocket. |
| */ |
| DatagramSocketImpl impl; |
| |
| /** |
| * Are we using an older DatagramSocketImpl? |
| */ |
| boolean oldImpl = false; |
| |
| /** |
| * 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; |
| |
| // Android-added: Store pending exception from connect |
| private SocketException pendingConnectException; |
| |
| /** |
| * Connects this socket to a remote socket address (IP address + port number). |
| * Binds socket if not already bound. |
| * <p> |
| * @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; |
| 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 (!isBound()) |
| bind(new InetSocketAddress(0)); |
| |
| // Android-changed: This section now throws any SocketException generated by connect() |
| // to enable it to be recorded as the pendingConnectException. It has been enclosed in a |
| // try-finally to ensure connectedAddress and connectedPort are set when the exception |
| // is thrown. |
| try { |
| // old impls do not support connect/disconnect |
| // Android-changed: Added special handling for AbstractPlainDatagramSocketImpl in |
| // the condition below. |
| 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; |
| // Android-changed: Propagate the SocketException so connect() can store it. |
| throw se; |
| } |
| } |
| } finally { |
| connectedAddress = address; |
| connectedPort = port; |
| } |
| } |
| |
| |
| /** |
| * Constructs a datagram socket and binds it to any available port |
| * on the local host machine. The socket will be bound to the |
| * {@link InetAddress#isAnyLocalAddress wildcard} address, |
| * an IP address chosen by the kernel. |
| * |
| * <p>If there is a security manager, |
| * its {@code checkListen} method is first called |
| * with 0 as its argument to ensure the operation is allowed. |
| * This could result in a SecurityException. |
| * |
| * @exception SocketException if the socket could not be opened, |
| * or the socket could not bind to the specified local port. |
| * @exception SecurityException if a security manager exists and its |
| * {@code checkListen} method doesn't allow the operation. |
| * |
| * @see SecurityManager#checkListen |
| */ |
| public DatagramSocket() throws SocketException { |
| this(new InetSocketAddress(0)); |
| } |
| |
| /** |
| * Creates an unbound datagram socket with the specified |
| * DatagramSocketImpl. |
| * |
| * @param impl an instance of a <B>DatagramSocketImpl</B> |
| * the subclass wishes to use on the DatagramSocket. |
| * @since 1.4 |
| */ |
| protected DatagramSocket(DatagramSocketImpl impl) { |
| if (impl == null) |
| throw new NullPointerException(); |
| this.impl = impl; |
| checkOldImpl(); |
| } |
| |
| /** |
| * Creates a datagram socket, bound to the specified local |
| * socket address. |
| * <p> |
| * If, if the address is {@code null}, creates an unbound socket. |
| * |
| * <p>If there is a security manager, |
| * its {@code checkListen} method is first called |
| * with the port from the socket address |
| * as its argument to ensure the operation is allowed. |
| * This could result in a SecurityException. |
| * |
| * @param bindaddr local socket address to bind, or {@code null} |
| * for an unbound socket. |
| * |
| * @exception SocketException if the socket could not be opened, |
| * or the socket could not bind to the specified local port. |
| * @exception SecurityException if a security manager exists and its |
| * {@code checkListen} method doesn't allow the operation. |
| * |
| * @see SecurityManager#checkListen |
| * @since 1.4 |
| */ |
| public DatagramSocket(SocketAddress bindaddr) throws SocketException { |
| // create a datagram socket. |
| createImpl(); |
| if (bindaddr != null) { |
| try { |
| bind(bindaddr); |
| } finally { |
| if (!isBound()) |
| close(); |
| } |
| } |
| } |
| |
| /** |
| * Constructs a datagram socket and binds it to the specified port |
| * on the local host machine. The socket will be bound to the |
| * {@link InetAddress#isAnyLocalAddress wildcard} address, |
| * an IP address chosen by the kernel. |
| * |
| * <p>If there is a security manager, |
| * its {@code checkListen} method is first called |
| * with the {@code port} argument |
| * as its argument to ensure the operation is allowed. |
| * This could result in a SecurityException. |
| * |
| * @param port port to use. |
| * @exception SocketException if the socket could not be opened, |
| * or the socket could not bind to the specified local port. |
| * @exception SecurityException if a security manager exists and its |
| * {@code checkListen} method doesn't allow the operation. |
| * |
| * @see SecurityManager#checkListen |
| */ |
| public DatagramSocket(int port) throws SocketException { |
| this(port, null); |
| } |
| |
| /** |
| * Creates a datagram socket, bound to the specified local |
| * address. The local port must be between 0 and 65535 inclusive. |
| * If the IP address is 0.0.0.0, the socket will be bound to the |
| * {@link InetAddress#isAnyLocalAddress wildcard} address, |
| * an IP address chosen by the kernel. |
| * |
| * <p>If there is a security manager, |
| * its {@code checkListen} method is first called |
| * with the {@code port} argument |
| * as its argument to ensure the operation is allowed. |
| * This could result in a SecurityException. |
| * |
| * @param port local port to use |
| * @param laddr local address to bind |
| * |
| * @exception SocketException if the socket could not be opened, |
| * or the socket could not bind to the specified local port. |
| * @exception SecurityException if a security manager exists and its |
| * {@code checkListen} method doesn't allow the operation. |
| * |
| * @see SecurityManager#checkListen |
| * @since JDK1.1 |
| */ |
| public DatagramSocket(int port, InetAddress laddr) throws SocketException { |
| this(new InetSocketAddress(laddr, port)); |
| } |
| |
| private void checkOldImpl() { |
| if (impl == null) |
| return; |
| // 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<Void>() { |
| public Void run() throws NoSuchMethodException { |
| Class<?>[] cl = new Class<?>[1]; |
| cl[0] = DatagramPacket.class; |
| impl.getClass().getDeclaredMethod("peekData", cl); |
| return null; |
| } |
| }); |
| } catch (java.security.PrivilegedActionException e) { |
| oldImpl = true; |
| } |
| } |
| |
| static Class<?> implClass = null; |
| |
| void createImpl() throws SocketException { |
| if (impl == null) { |
| if (factory != null) { |
| impl = factory.createDatagramSocketImpl(); |
| checkOldImpl(); |
| } else { |
| boolean isMulticast = (this instanceof MulticastSocket) ? true : false; |
| impl = DefaultDatagramSocketImplFactory.createDatagramSocketImpl(isMulticast); |
| |
| checkOldImpl(); |
| } |
| } |
| // creates a udp socket |
| impl.create(); |
| impl.setDatagramSocket(this); |
| created = true; |
| } |
| |
| /** |
| * Get the {@code DatagramSocketImpl} attached to this socket, |
| * creating it if necessary. |
| * |
| * @return the {@code DatagramSocketImpl} attached to that |
| * DatagramSocket |
| * @throws SocketException if creation fails. |
| * @since 1.4 |
| */ |
| DatagramSocketImpl getImpl() throws SocketException { |
| if (!created) |
| createImpl(); |
| return impl; |
| } |
| |
| /** |
| * Binds this DatagramSocket to a specific address and port. |
| * <p> |
| * If the address is {@code null}, then the system will pick up |
| * an ephemeral port and a valid local address to bind the socket. |
| *<p> |
| * @param addr The address and port to bind to. |
| * @throws SocketException if any error happens during the bind, or if the |
| * socket is already bound. |
| * @throws SecurityException if a security manager exists and its |
| * {@code checkListen} method doesn't allow the operation. |
| * @throws IllegalArgumentException if addr is a SocketAddress subclass |
| * not supported by this socket. |
| * @since 1.4 |
| */ |
| 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)) |
| throw new IllegalArgumentException("Unsupported address type!"); |
| InetSocketAddress epoint = (InetSocketAddress) addr; |
| if (epoint.isUnresolved()) |
| throw new SocketException("Unresolved address"); |
| InetAddress iaddr = epoint.getAddress(); |
| int port = epoint.getPort(); |
| checkAddress(iaddr, "bind"); |
| SecurityManager sec = System.getSecurityManager(); |
| if (sec != null) { |
| sec.checkListen(port); |
| } |
| try { |
| getImpl().bind(port, iaddr); |
| } catch (SocketException e) { |
| getImpl().close(); |
| throw e; |
| } |
| bound = true; |
| } |
| |
| void checkAddress (InetAddress addr, String op) { |
| if (addr == null) { |
| return; |
| } |
| if (!(addr instanceof Inet4Address || addr instanceof Inet6Address)) { |
| throw new IllegalArgumentException(op + ": invalid address type"); |
| } |
| } |
| |
| /** |
| * Connects the socket to a remote address for this socket. When a |
| * socket is connected to a remote address, packets may only be |
| * sent to or received from that address. By default a datagram |
| * socket is not connected. |
| * |
| * <p>If the remote destination to which the socket is connected does not |
| * exist, or is otherwise unreachable, and if an ICMP destination unreachable |
| * packet has been received for that address, then a subsequent call to |
| * send or receive may throw a PortUnreachableException. Note, there is no |
| * guarantee that the exception will be thrown. |
| * |
| * <p> If a security manager has been installed then it is invoked to check |
| * access to the remote address. Specifically, if the given {@code address} |
| * is a {@link InetAddress#isMulticastAddress multicast address}, |
| * the security manager's {@link |
| * java.lang.SecurityManager#checkMulticast(InetAddress) |
| * checkMulticast} method is invoked with the given {@code address}. |
| * Otherwise, the security manager's {@link |
| * java.lang.SecurityManager#checkConnect(String,int) checkConnect} |
| * and {@link java.lang.SecurityManager#checkAccept checkAccept} methods |
| * are invoked, with the given {@code address} and {@code port}, to |
| * verify that datagrams are permitted to be sent and received |
| * respectively. |
| * |
| * <p> When a socket is connected, {@link #receive receive} and |
| * {@link #send send} <b>will not perform any security checks</b> |
| * on incoming and outgoing packets, other than matching the packet's |
| * and the socket's address and port. On a send operation, if the |
| * packet's address is set and the packet's address and the socket's |
| * address do not match, an {@code IllegalArgumentException} will be |
| * thrown. A socket connected to a multicast address may only be used |
| * to send packets. |
| * |
| * @param address the remote address for the socket |
| * |
| * @param port the remote port for the socket. |
| * |
| * @throws IllegalArgumentException |
| * if the address is null, or the port is out of range. |
| * |
| * @throws SecurityException |
| * if a security manager has been installed and it does |
| * not permit access to the given remote address |
| * |
| * @see #disconnect |
| */ |
| public void connect(InetAddress address, int port) { |
| try { |
| connectInternal(address, port); |
| } catch (SocketException se) { |
| // Android-changed: this method can't throw checked SocketException. Throw it later |
| // throw new Error("connect failed", se); |
| // TODO: or just use SneakyThrow? There's a clear API bug here. |
| pendingConnectException = se; |
| } |
| } |
| |
| /** |
| * Connects this socket to a remote socket address (IP address + port number). |
| * |
| * <p> If given an {@link InetSocketAddress InetSocketAddress}, this method |
| * behaves as if invoking {@link #connect(InetAddress,int) connect(InetAddress,int)} |
| * with the the given socket addresses IP address and port number. |
| * |
| * @param addr The remote address. |
| * |
| * @throws SocketException |
| * if the connect fails |
| * |
| * @throws IllegalArgumentException |
| * if {@code addr} is {@code null}, or {@code addr} is a SocketAddress |
| * subclass not supported by this socket |
| * |
| * @throws SecurityException |
| * if a security manager has been installed and it does |
| * not permit access to the given remote address |
| * |
| * @since 1.4 |
| */ |
| public void connect(SocketAddress addr) throws SocketException { |
| if (addr == null) |
| throw new IllegalArgumentException("Address can't be null"); |
| if (!(addr instanceof InetSocketAddress)) |
| throw new IllegalArgumentException("Unsupported address type"); |
| InetSocketAddress epoint = (InetSocketAddress) addr; |
| if (epoint.isUnresolved()) |
| throw new SocketException("Unresolved address"); |
| connectInternal(epoint.getAddress(), epoint.getPort()); |
| } |
| |
| /** |
| * Disconnects the socket. If the socket is closed or not connected, |
| * then this method has no effect. |
| * |
| * @see #connect |
| */ |
| public void disconnect() { |
| synchronized (this) { |
| if (isClosed()) |
| return; |
| if (connectState == ST_CONNECTED) { |
| impl.disconnect (); |
| } |
| connectedAddress = null; |
| connectedPort = -1; |
| connectState = ST_NOT_CONNECTED; |
| explicitFilter = false; |
| } |
| } |
| |
| /** |
| * Returns the binding state of the socket. |
| * <p> |
| * If the socket was bound prior to being {@link #close closed}, |
| * then this method will continue to return {@code true} |
| * after the socket is closed. |
| * |
| * @return true if the socket successfully bound to an address |
| * @since 1.4 |
| */ |
| public boolean isBound() { |
| return bound; |
| } |
| |
| /** |
| * Returns the connection state of the socket. |
| * <p> |
| * If the socket was connected prior to being {@link #close closed}, |
| * then this method will continue to return {@code true} |
| * after the socket is closed. |
| * |
| * @return true if the socket successfully connected to a server |
| * @since 1.4 |
| */ |
| public boolean isConnected() { |
| return connectState != ST_NOT_CONNECTED; |
| } |
| |
| /** |
| * Returns the address to which this socket is connected. Returns |
| * {@code null} if the socket is not connected. |
| * <p> |
| * If the socket was connected prior to being {@link #close closed}, |
| * then this method will continue to return the connected address |
| * after the socket is closed. |
| * |
| * @return the address to which this socket is connected. |
| */ |
| public InetAddress getInetAddress() { |
| return connectedAddress; |
| } |
| |
| /** |
| * Returns the port number to which this socket is connected. |
| * Returns {@code -1} if the socket is not connected. |
| * <p> |
| * If the socket was connected prior to being {@link #close closed}, |
| * then this method will continue to return the connected port number |
| * after the socket is closed. |
| * |
| * @return the port number to which this socket is connected. |
| */ |
| public int getPort() { |
| return connectedPort; |
| } |
| |
| /** |
| * Returns the address of the endpoint this socket is connected to, or |
| * {@code null} if it is unconnected. |
| * <p> |
| * If the socket was connected prior to being {@link #close closed}, |
| * then this method will continue to return the connected address |
| * after the socket is closed. |
| * |
| * @return a {@code SocketAddress} representing the remote |
| * endpoint of this socket, or {@code null} if it is |
| * not connected yet. |
| * @see #getInetAddress() |
| * @see #getPort() |
| * @see #connect(SocketAddress) |
| * @since 1.4 |
| */ |
| public SocketAddress getRemoteSocketAddress() { |
| if (!isConnected()) |
| return null; |
| return new InetSocketAddress(getInetAddress(), getPort()); |
| } |
| |
| /** |
| * Returns the address of the endpoint this socket is bound to. |
| * |
| * @return a {@code SocketAddress} representing the local endpoint of this |
| * socket, or {@code null} if it is closed or not bound yet. |
| * @see #getLocalAddress() |
| * @see #getLocalPort() |
| * @see #bind(SocketAddress) |
| * @since 1.4 |
| */ |
| |
| public SocketAddress getLocalSocketAddress() { |
| if (isClosed()) |
| return null; |
| if (!isBound()) |
| return null; |
| return new InetSocketAddress(getLocalAddress(), getLocalPort()); |
| } |
| |
| /** |
| * Sends a datagram packet from this socket. The |
| * {@code DatagramPacket} includes information indicating the |
| * data to be sent, its length, the IP address of the remote host, |
| * and the port number on the remote host. |
| * |
| * <p>If there is a security manager, and the socket is not currently |
| * connected to a remote address, this method first performs some |
| * security checks. First, if {@code p.getAddress().isMulticastAddress()} |
| * is true, this method calls the |
| * security manager's {@code checkMulticast} method |
| * with {@code p.getAddress()} as its argument. |
| * If the evaluation of that expression is false, |
| * this method instead calls the security manager's |
| * {@code checkConnect} method with arguments |
| * {@code p.getAddress().getHostAddress()} and |
| * {@code p.getPort()}. Each call to a security manager method |
| * could result in a SecurityException if the operation is not allowed. |
| * |
| * @param p the {@code DatagramPacket} to be sent. |
| * |
| * @exception IOException if an I/O error occurs. |
| * @exception SecurityException if a security manager exists and its |
| * {@code checkMulticast} or {@code checkConnect} |
| * method doesn't allow the send. |
| * @exception PortUnreachableException may be thrown if the socket is connected |
| * to a currently unreachable destination. Note, there is no |
| * guarantee that the exception will be thrown. |
| * @exception java.nio.channels.IllegalBlockingModeException |
| * if this socket has an associated channel, |
| * and the channel is in non-blocking mode. |
| * @exception IllegalArgumentException if the socket is connected, |
| * and connected address and packet address differ. |
| * |
| * @see java.net.DatagramPacket |
| * @see SecurityManager#checkMulticast(InetAddress) |
| * @see SecurityManager#checkConnect |
| * @revised 1.4 |
| * @spec JSR-51 |
| */ |
| public void send(DatagramPacket p) throws IOException { |
| InetAddress packetAddress = null; |
| synchronized (p) { |
| // BEGIN Android-changed |
| if (pendingConnectException != null) { |
| throw new SocketException("Pending connect failure", pendingConnectException); |
| } |
| // END Android-changed |
| if (isClosed()) |
| throw new SocketException("Socket is closed"); |
| checkAddress (p.getAddress(), "send"); |
| if (connectState == ST_NOT_CONNECTED) { |
| // check the address is ok wiht the security manager on every send. |
| 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 (p.getAddress().isMulticastAddress()) { |
| security.checkMulticast(p.getAddress()); |
| } else { |
| security.checkConnect(p.getAddress().getHostAddress(), |
| p.getPort()); |
| } |
| } |
| } else { |
| // we're connected |
| packetAddress = p.getAddress(); |
| 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"); |
| } |
| } |
| // Check whether the socket is bound |
| if (!isBound()) |
| bind(new InetSocketAddress(0)); |
| // call the method to send |
| getImpl().send(p); |
| } |
| } |
| |
| /** |
| * Receives a datagram packet from this socket. When this method |
| * returns, the {@code DatagramPacket}'s buffer is filled with |
| * the data received. The datagram packet also contains the sender's |
| * IP address, and the port number on the sender's machine. |
| * <p> |
| * This method blocks until a datagram is received. The |
| * {@code length} field of the datagram packet object contains |
| * the length of the received message. If the message is longer than |
| * the packet's length, the message is truncated. |
| * <p> |
| * If there is a security manager, a packet cannot be received if the |
| * security manager's {@code checkAccept} method |
| * does not allow it. |
| * |
| * @param p the {@code DatagramPacket} into which to place |
| * the incoming data. |
| * @exception IOException if an I/O error occurs. |
| * @exception SocketTimeoutException if setSoTimeout was previously called |
| * and the timeout has expired. |
| * @exception PortUnreachableException may be thrown if the socket is connected |
| * to a currently unreachable destination. Note, there is no guarantee that the |
| * exception will be thrown. |
| * @exception java.nio.channels.IllegalBlockingModeException |
| * if this socket has an associated channel, |
| * and the channel is in non-blocking mode. |
| * @see java.net.DatagramPacket |
| * @see java.net.DatagramSocket |
| * @revised 1.4 |
| * @spec JSR-51 |
| */ |
| public synchronized void receive(DatagramPacket p) throws IOException { |
| synchronized (p) { |
| if (!isBound()) |
| bind(new InetSocketAddress(0)); |
| |
| // BEGIN Android-changed |
| if (pendingConnectException != null) { |
| throw new SocketException("Pending connect failure", pendingConnectException); |
| } |
| // END Android-changed |
| |
| if (connectState == ST_NOT_CONNECTED) { |
| // check the address is ok with the security manager before every recv. |
| 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; |
| } |
| |
| /** |
| * Gets the local address to which the socket is bound. |
| * |
| * <p>If there is a security manager, its |
| * {@code checkConnect} method is first called |
| * with the host address and {@code -1} |
| * as its arguments to see if the operation is allowed. |
| * |
| * @see SecurityManager#checkConnect |
| * @return the local address to which the socket is bound, |
| * {@code null} if the socket is closed, or |
| * an {@code InetAddress} representing |
| * {@link InetAddress#isAnyLocalAddress wildcard} |
| * address if either the socket is not bound, or |
| * the security manager {@code checkConnect} |
| * method does not allow the operation |
| * @since 1.1 |
| */ |
| public InetAddress getLocalAddress() { |
| if (isClosed()) |
| return null; |
| InetAddress in = null; |
| try { |
| in = (InetAddress) getImpl().getOption(SocketOptions.SO_BINDADDR); |
| if (in.isAnyLocalAddress()) { |
| in = InetAddress.anyLocalAddress(); |
| } |
| SecurityManager s = System.getSecurityManager(); |
| if (s != null) { |
| s.checkConnect(in.getHostAddress(), -1); |
| } |
| } catch (Exception e) { |
| in = InetAddress.anyLocalAddress(); // "0.0.0.0" |
| } |
| return in; |
| } |
| |
| /** |
| * Returns the port number on the local host to which this socket |
| * is bound. |
| * |
| * @return the port number on the local host to which this socket is bound, |
| {@code -1} if the socket is closed, or |
| {@code 0} if it is not bound yet. |
| */ |
| public int getLocalPort() { |
| if (isClosed()) |
| return -1; |
| try { |
| return getImpl().getLocalPort(); |
| } catch (Exception e) { |
| return 0; |
| } |
| } |
| |
| /** Enable/disable SO_TIMEOUT with the specified timeout, in |
| * milliseconds. With this option set to a non-zero timeout, |
| * a call to receive() for this DatagramSocket |
| * will block for only this amount of time. If the timeout expires, |
| * a <B>java.net.SocketTimeoutException</B> is raised, though the |
| * DatagramSocket is still valid. The option <B>must</B> be enabled |
| * prior to entering the blocking operation to have effect. The |
| * timeout must be {@code > 0}. |
| * A timeout of zero is interpreted as an infinite timeout. |
| * |
| * @param timeout the specified timeout in milliseconds. |
| * @throws SocketException if there is an error in the underlying protocol, such as an UDP error. |
| * @since JDK1.1 |
| * @see #getSoTimeout() |
| */ |
| public synchronized void setSoTimeout(int timeout) throws SocketException { |
| if (isClosed()) |
| throw new SocketException("Socket is closed"); |
| getImpl().setOption(SocketOptions.SO_TIMEOUT, new Integer(timeout)); |
| } |
| |
| /** |
| * Retrieve setting for SO_TIMEOUT. 0 returns implies that the |
| * option is disabled (i.e., timeout of infinity). |
| * |
| * @return the setting for SO_TIMEOUT |
| * @throws SocketException if there is an error in the underlying protocol, such as an UDP error. |
| * @since JDK1.1 |
| * @see #setSoTimeout(int) |
| */ |
| 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; |
| } |
| } |
| |
| /** |
| * Sets the SO_SNDBUF option to the specified value for this |
| * {@code DatagramSocket}. The SO_SNDBUF option is used by the |
| * network implementation as a hint to size the underlying |
| * network I/O buffers. The SO_SNDBUF setting may also be used |
| * by the network implementation to determine the maximum size |
| * of the packet that can be sent on this socket. |
| * <p> |
| * As SO_SNDBUF is a hint, applications that want to verify |
| * what size the buffer is should call {@link #getSendBufferSize()}. |
| * <p> |
| * Increasing the buffer size may allow multiple outgoing packets |
| * to be queued by the network implementation when the send rate |
| * is high. |
| * <p> |
| * Note: If {@link #send(DatagramPacket)} is used to send a |
| * {@code DatagramPacket} that is larger than the setting |
| * of SO_SNDBUF then it is implementation specific if the |
| * packet is sent or discarded. |
| * |
| * @param size the size to which to set the send buffer |
| * size. This value must be greater than 0. |
| * |
| * @exception SocketException if there is an error |
| * in the underlying protocol, such as an UDP error. |
| * @exception IllegalArgumentException if the value is 0 or is |
| * negative. |
| * @see #getSendBufferSize() |
| */ |
| 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, new Integer(size)); |
| } |
| |
| /** |
| * Get value of the SO_SNDBUF option for this {@code DatagramSocket}, that is the |
| * buffer size used by the platform for output on this {@code DatagramSocket}. |
| * |
| * @return the value of the SO_SNDBUF option for this {@code DatagramSocket} |
| * @exception SocketException if there is an error in |
| * the underlying protocol, such as an UDP error. |
| * @see #setSendBufferSize |
| */ |
| 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; |
| } |
| |
| /** |
| * Sets the SO_RCVBUF option to the specified value for this |
| * {@code DatagramSocket}. The SO_RCVBUF option is used by the |
| * the network implementation as a hint to size the underlying |
| * network I/O buffers. The SO_RCVBUF setting may also be used |
| * by the network implementation to determine the maximum size |
| * of the packet that can be received on this socket. |
| * <p> |
| * Because SO_RCVBUF is a hint, applications that want to |
| * verify what size the buffers were set to should call |
| * {@link #getReceiveBufferSize()}. |
| * <p> |
| * Increasing SO_RCVBUF may allow the network implementation |
| * to buffer multiple packets when packets arrive faster than |
| * are being received using {@link #receive(DatagramPacket)}. |
| * <p> |
| * Note: It is implementation specific if a packet larger |
| * than SO_RCVBUF can be received. |
| * |
| * @param size the size to which to set the receive buffer |
| * size. This value must be greater than 0. |
| * |
| * @exception SocketException if there is an error in |
| * the underlying protocol, such as an UDP error. |
| * @exception IllegalArgumentException if the value is 0 or is |
| * negative. |
| * @see #getReceiveBufferSize() |
| */ |
| 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, new Integer(size)); |
| } |
| |
| /** |
| * Get value of the SO_RCVBUF option for this {@code DatagramSocket}, that is the |
| * buffer size used by the platform for input on this {@code DatagramSocket}. |
| * |
| * @return the value of the SO_RCVBUF option for this {@code DatagramSocket} |
| * @exception SocketException if there is an error in the underlying protocol, such as an UDP error. |
| * @see #setReceiveBufferSize(int) |
| */ |
| 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; |
| } |
| |
| /** |
| * Enable/disable the SO_REUSEADDR socket option. |
| * <p> |
| * For UDP sockets it may be necessary to bind more than one |
| * socket to the same socket address. This is typically for the |
| * purpose of receiving multicast packets |
| * (See {@link java.net.MulticastSocket}). The |
| * {@code SO_REUSEADDR} socket option allows multiple |
| * sockets to be bound to the same socket address if the |
| * {@code SO_REUSEADDR} socket option is enabled prior |
| * to binding the socket using {@link #bind(SocketAddress)}. |
| * <p> |
| * Note: This functionality is not supported by all existing platforms, |
| * so it is implementation specific whether this option will be ignored |
| * or not. However, if it is not supported then |
| * {@link #getReuseAddress()} will always return {@code false}. |
| * <p> |
| * When a {@code DatagramSocket} is created the initial setting |
| * of {@code SO_REUSEADDR} is disabled. |
| * <p> |
| * The behaviour when {@code SO_REUSEADDR} is enabled or |
| * disabled after a socket is bound (See {@link #isBound()}) |
| * is not defined. |
| * |
| * @param on whether to enable or disable the |
| * @exception SocketException if an error occurs enabling or |
| * disabling the {@code SO_RESUEADDR} socket option, |
| * or the socket is closed. |
| * @since 1.4 |
| * @see #getReuseAddress() |
| * @see #bind(SocketAddress) |
| * @see #isBound() |
| * @see #isClosed() |
| */ |
| 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, new Integer(on?-1:0)); |
| else |
| getImpl().setOption(SocketOptions.SO_REUSEADDR, Boolean.valueOf(on)); |
| } |
| |
| /** |
| * Tests if SO_REUSEADDR is enabled. |
| * |
| * @return a {@code boolean} indicating whether or not SO_REUSEADDR is enabled. |
| * @exception SocketException if there is an error |
| * in the underlying protocol, such as an UDP error. |
| * @since 1.4 |
| * @see #setReuseAddress(boolean) |
| */ |
| 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(); |
| } |
| |
| /** |
| * Enable/disable SO_BROADCAST. |
| * |
| * <p> Some operating systems may require that the Java virtual machine be |
| * started with implementation specific privileges to enable this option or |
| * send broadcast datagrams. |
| * |
| * @param on |
| * whether or not to have broadcast turned on. |
| * |
| * @throws SocketException |
| * if there is an error in the underlying protocol, such as an UDP |
| * error. |
| * |
| * @since 1.4 |
| * @see #getBroadcast() |
| */ |
| public synchronized void setBroadcast(boolean on) throws SocketException { |
| if (isClosed()) |
| throw new SocketException("Socket is closed"); |
| getImpl().setOption(SocketOptions.SO_BROADCAST, Boolean.valueOf(on)); |
| } |
| |
| /** |
| * Tests if SO_BROADCAST is enabled. |
| * @return a {@code boolean} indicating whether or not SO_BROADCAST is enabled. |
| * @exception SocketException if there is an error |
| * in the underlying protocol, such as an UDP error. |
| * @since 1.4 |
| * @see #setBroadcast(boolean) |
| */ |
| public synchronized boolean getBroadcast() throws SocketException { |
| if (isClosed()) |
| throw new SocketException("Socket is closed"); |
| return ((Boolean)(getImpl().getOption(SocketOptions.SO_BROADCAST))).booleanValue(); |
| } |
| |
| /** |
| * Sets traffic class or type-of-service octet in the IP |
| * datagram header for datagrams sent from this DatagramSocket. |
| * As the underlying network implementation may ignore this |
| * value applications should consider it a hint. |
| * |
| * <P> The tc <B>must</B> be in the range {@code 0 <= tc <= |
| * 255} or an IllegalArgumentException will be thrown. |
| * <p>Notes: |
| * <p>For Internet Protocol v4 the value consists of an |
| * {@code integer}, the least significant 8 bits of which |
| * represent the value of the TOS octet in IP packets sent by |
| * the socket. |
| * RFC 1349 defines the TOS values as follows: |
| * |
| * <UL> |
| * <LI><CODE>IPTOS_LOWCOST (0x02)</CODE></LI> |
| * <LI><CODE>IPTOS_RELIABILITY (0x04)</CODE></LI> |
| * <LI><CODE>IPTOS_THROUGHPUT (0x08)</CODE></LI> |
| * <LI><CODE>IPTOS_LOWDELAY (0x10)</CODE></LI> |
| * </UL> |
| * The last low order bit is always ignored as this |
| * corresponds to the MBZ (must be zero) bit. |
| * <p> |
| * Setting bits in the precedence field may result in a |
| * SocketException indicating that the operation is not |
| * permitted. |
| * <p> |
| * for Internet Protocol v6 {@code tc} is the value that |
| * would be placed into the sin6_flowinfo field of the IP header. |
| * |
| * @param tc an {@code int} value for the bitset. |
| * @throws SocketException if there is an error setting the |
| * traffic class or type-of-service |
| * @since 1.4 |
| * @see #getTrafficClass |
| */ |
| 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; |
| } |
| } |
| |
| /** |
| * Gets traffic class or type-of-service in the IP datagram |
| * header for packets sent from this DatagramSocket. |
| * <p> |
| * As the underlying network implementation may ignore the |
| * traffic class or type-of-service set using {@link #setTrafficClass(int)} |
| * this method may return a different value than was previously |
| * set using the {@link #setTrafficClass(int)} method on this |
| * DatagramSocket. |
| * |
| * @return the traffic class or type-of-service already set |
| * @throws SocketException if there is an error obtaining the |
| * traffic class or type-of-service value. |
| * @since 1.4 |
| * @see #setTrafficClass(int) |
| */ |
| public synchronized int getTrafficClass() throws SocketException { |
| if (isClosed()) |
| throw new SocketException("Socket is closed"); |
| return ((Integer)(getImpl().getOption(SocketOptions.IP_TOS))).intValue(); |
| } |
| |
| /** |
| * Closes this datagram socket. |
| * <p> |
| * Any thread currently blocked in {@link #receive} upon this socket |
| * will throw a {@link SocketException}. |
| * |
| * <p> If this socket has an associated channel then the channel is closed |
| * as well. |
| * |
| * @revised 1.4 |
| * @spec JSR-51 |
| */ |
| public void close() { |
| synchronized(closeLock) { |
| if (isClosed()) |
| return; |
| impl.close(); |
| closed = true; |
| } |
| } |
| |
| /** |
| * Returns whether the socket is closed or not. |
| * |
| * @return true if the socket has been closed |
| * @since 1.4 |
| */ |
| public boolean isClosed() { |
| synchronized(closeLock) { |
| return closed; |
| } |
| } |
| |
| /** |
| * Returns the unique {@link java.nio.channels.DatagramChannel} object |
| * associated with this datagram socket, if any. |
| * |
| * <p> A datagram socket will have a channel if, and only if, the channel |
| * itself was created via the {@link java.nio.channels.DatagramChannel#open |
| * DatagramChannel.open} method. |
| * |
| * @return the datagram channel associated with this datagram socket, |
| * or {@code null} if this socket was not created for a channel |
| * |
| * @since 1.4 |
| * @spec JSR-51 |
| */ |
| public DatagramChannel getChannel() { |
| return null; |
| } |
| |
| /** |
| * User defined factory for all datagram sockets. |
| */ |
| static DatagramSocketImplFactory factory; |
| |
| /** |
| * Sets the datagram socket implementation factory for the |
| * application. The factory can be specified only once. |
| * <p> |
| * When an application creates a new datagram socket, the socket |
| * implementation factory's {@code createDatagramSocketImpl} method is |
| * called to create the actual datagram socket implementation. |
| * <p> |
| * Passing {@code null} to the method is a no-op unless the factory |
| * was already set. |
| * |
| * <p>If there is a security manager, this method first calls |
| * the security manager's {@code checkSetFactory} method |
| * to ensure the operation is allowed. |
| * This could result in a SecurityException. |
| * |
| * @param fac the desired factory. |
| * @exception IOException if an I/O error occurs when setting the |
| * datagram socket factory. |
| * @exception SocketException if the factory is already defined. |
| * @exception SecurityException if a security manager exists and its |
| * {@code checkSetFactory} method doesn't allow the |
| operation. |
| * @see |
| java.net.DatagramSocketImplFactory#createDatagramSocketImpl() |
| * @see SecurityManager#checkSetFactory |
| * @since 1.3 |
| */ |
| public static synchronized void |
| setDatagramSocketImplFactory(DatagramSocketImplFactory fac) |
| throws IOException |
| { |
| if (factory != null) { |
| throw new SocketException("factory already defined"); |
| } |
| SecurityManager security = System.getSecurityManager(); |
| if (security != null) { |
| security.checkSetFactory(); |
| } |
| factory = fac; |
| } |
| |
| // Android-added: for testing and internal use. |
| /** |
| * @hide internal use only |
| */ |
| public FileDescriptor getFileDescriptor$() { |
| return impl.fd; |
| } |
| |
| } |