| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package java.net; |
| |
| import java.io.FileDescriptor; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.nio.channels.SocketChannel; |
| import libcore.io.IoBridge; |
| |
| /** |
| * Provides a client-side TCP socket. |
| */ |
| public class Socket { |
| private static SocketImplFactory factory; |
| |
| final SocketImpl impl; |
| private final Proxy proxy; |
| |
| volatile boolean isCreated = false; |
| private boolean isBound = false; |
| private boolean isConnected = false; |
| private boolean isClosed = false; |
| private boolean isInputShutdown = false; |
| private boolean isOutputShutdown = false; |
| |
| private InetAddress localAddress = Inet4Address.ANY; |
| |
| private final Object connectLock = new Object(); |
| |
| /** |
| * Creates a new unconnected socket. When a SocketImplFactory is defined it |
| * creates the internal socket implementation, otherwise the default socket |
| * implementation will be used for this socket. |
| * |
| * @see SocketImplFactory |
| * @see SocketImpl |
| */ |
| public Socket() { |
| this.impl = factory != null ? factory.createSocketImpl() : new PlainSocketImpl(); |
| this.proxy = null; |
| } |
| |
| /** |
| * Creates a new unconnected socket using the given proxy type. When a |
| * {@code SocketImplFactory} is defined it creates the internal socket |
| * implementation, otherwise the default socket implementation will be used |
| * for this socket. |
| * <p> |
| * Example that will create a socket connection through a {@code SOCKS} |
| * proxy server: <br> |
| * {@code Socket sock = new Socket(new Proxy(Proxy.Type.SOCKS, new |
| * InetSocketAddress("test.domain.org", 2130)));} |
| * |
| * @param proxy |
| * the specified proxy for this socket. |
| * @throws IllegalArgumentException |
| * if the argument {@code proxy} is {@code null} or of an |
| * invalid type. |
| * @see SocketImplFactory |
| * @see SocketImpl |
| */ |
| public Socket(Proxy proxy) { |
| if (proxy == null || proxy.type() == Proxy.Type.HTTP) { |
| throw new IllegalArgumentException("Invalid proxy: " + proxy); |
| } |
| this.proxy = proxy; |
| this.impl = factory != null ? factory.createSocketImpl() : new PlainSocketImpl(proxy); |
| } |
| |
| /** |
| * Tries to connect a socket to all IP addresses of the given hostname. |
| * |
| * @param dstName |
| * the target host name or IP address to connect to. |
| * @param dstPort |
| * the port on the target host to connect to. |
| * @param localAddress |
| * the address on the local host to bind to. |
| * @param localPort |
| * the port on the local host to bind to. |
| * @param streaming |
| * if {@code true} a streaming socket is returned, a datagram |
| * socket otherwise. |
| * @throws UnknownHostException |
| * if the host name could not be resolved into an IP address. |
| * @throws IOException |
| * if an error occurs while creating the socket. |
| */ |
| private void tryAllAddresses(String dstName, int dstPort, InetAddress |
| localAddress, int localPort, boolean streaming) throws IOException { |
| InetAddress[] dstAddresses = InetAddress.getAllByName(dstName); |
| // Loop through all the destination addresses except the last, trying to |
| // connect to each one and ignoring errors. There must be at least one |
| // address, or getAllByName would have thrown UnknownHostException. |
| InetAddress dstAddress; |
| for (int i = 0; i < dstAddresses.length - 1; i++) { |
| dstAddress = dstAddresses[i]; |
| try { |
| checkDestination(dstAddress, dstPort); |
| startupSocket(dstAddress, dstPort, localAddress, localPort, streaming); |
| return; |
| } catch (IOException ex) { |
| } |
| } |
| |
| // Now try to connect to the last address in the array, handing back to |
| // the caller any exceptions that are thrown. |
| dstAddress = dstAddresses[dstAddresses.length - 1]; |
| checkDestination(dstAddress, dstPort); |
| startupSocket(dstAddress, dstPort, localAddress, localPort, streaming); |
| } |
| |
| /** |
| * Creates a new streaming socket connected to the target host specified by |
| * the parameters {@code dstName} and {@code dstPort}. The socket is bound |
| * to any available port on the local host. |
| * |
| * <p>This implementation tries each IP address for the given hostname (in |
| * <a href="http://www.ietf.org/rfc/rfc3484.txt">RFC 3484</a> order) |
| * until it either connects successfully or it exhausts the set. |
| * |
| * @param dstName |
| * the target host name or IP address to connect to. |
| * @param dstPort |
| * the port on the target host to connect to. |
| * @throws UnknownHostException |
| * if the host name could not be resolved into an IP address. |
| * @throws IOException |
| * if an error occurs while creating the socket. |
| */ |
| public Socket(String dstName, int dstPort) throws UnknownHostException, IOException { |
| this(dstName, dstPort, null, 0); |
| } |
| |
| /** |
| * Creates a new streaming socket connected to the target host specified by |
| * the parameters {@code dstName} and {@code dstPort}. On the local endpoint |
| * the socket is bound to the given address {@code localAddress} on port |
| * {@code localPort}. If {@code host} is {@code null} a loopback address is used to connect to. |
| * |
| * <p>This implementation tries each IP address for the given hostname (in |
| * <a href="http://www.ietf.org/rfc/rfc3484.txt">RFC 3484</a> order) |
| * until it either connects successfully or it exhausts the set. |
| * |
| * @param dstName |
| * the target host name or IP address to connect to. |
| * @param dstPort |
| * the port on the target host to connect to. |
| * @param localAddress |
| * the address on the local host to bind to. |
| * @param localPort |
| * the port on the local host to bind to. |
| * @throws UnknownHostException |
| * if the host name could not be resolved into an IP address. |
| * @throws IOException |
| * if an error occurs while creating the socket. |
| */ |
| public Socket(String dstName, int dstPort, InetAddress localAddress, int localPort) throws IOException { |
| this(); |
| tryAllAddresses(dstName, dstPort, localAddress, localPort, true); |
| } |
| |
| /** |
| * Creates a new streaming or datagram socket connected to the target host |
| * specified by the parameters {@code hostName} and {@code port}. The socket |
| * is bound to any available port on the local host. |
| * |
| * <p>This implementation tries each IP address for the given hostname (in |
| * <a href="http://www.ietf.org/rfc/rfc3484.txt">RFC 3484</a> order) |
| * until it either connects successfully or it exhausts the set. |
| * |
| * @param hostName |
| * the target host name or IP address to connect to. |
| * @param port |
| * the port on the target host to connect to. |
| * @param streaming |
| * if {@code true} a streaming socket is returned, a datagram |
| * socket otherwise. |
| * @throws UnknownHostException |
| * if the host name could not be resolved into an IP address. |
| * @throws IOException |
| * if an error occurs while creating the socket. |
| * @deprecated Use {@code Socket(String, int)} instead of this for streaming |
| * sockets or an appropriate constructor of {@code |
| * DatagramSocket} for UDP transport. |
| */ |
| @Deprecated |
| public Socket(String hostName, int port, boolean streaming) throws IOException { |
| this(); |
| tryAllAddresses(hostName, port, null, 0, streaming); |
| } |
| |
| /** |
| * Creates a new streaming socket connected to the target host specified by |
| * the parameters {@code dstAddress} and {@code dstPort}. The socket is |
| * bound to any available port on the local host. |
| * |
| * @param dstAddress |
| * the target host address to connect to. |
| * @param dstPort |
| * the port on the target host to connect to. |
| * @throws IOException |
| * if an error occurs while creating the socket. |
| */ |
| public Socket(InetAddress dstAddress, int dstPort) throws IOException { |
| this(); |
| checkDestination(dstAddress, dstPort); |
| startupSocket(dstAddress, dstPort, null, 0, true); |
| } |
| |
| /** |
| * Creates a new streaming socket connected to the target host specified by |
| * the parameters {@code dstAddress} and {@code dstPort}. On the local |
| * endpoint the socket is bound to the given address {@code localAddress} on |
| * port {@code localPort}. |
| * |
| * @param dstAddress |
| * the target host address to connect to. |
| * @param dstPort |
| * the port on the target host to connect to. |
| * @param localAddress |
| * the address on the local host to bind to. |
| * @param localPort |
| * the port on the local host to bind to. |
| * @throws IOException |
| * if an error occurs while creating the socket. |
| */ |
| public Socket(InetAddress dstAddress, int dstPort, |
| InetAddress localAddress, int localPort) throws IOException { |
| this(); |
| checkDestination(dstAddress, dstPort); |
| startupSocket(dstAddress, dstPort, localAddress, localPort, true); |
| } |
| |
| /** |
| * Creates a new streaming or datagram socket connected to the target host |
| * specified by the parameters {@code addr} and {@code port}. The socket is |
| * bound to any available port on the local host. |
| * |
| * @param addr |
| * the Internet address to connect to. |
| * @param port |
| * the port on the target host to connect to. |
| * @param streaming |
| * if {@code true} a streaming socket is returned, a datagram |
| * socket otherwise. |
| * @throws IOException |
| * if an error occurs while creating the socket. |
| * @deprecated Use {@code Socket(InetAddress, int)} instead of this for |
| * streaming sockets or an appropriate constructor of {@code |
| * DatagramSocket} for UDP transport. |
| */ |
| @Deprecated |
| public Socket(InetAddress addr, int port, boolean streaming) throws IOException { |
| this(); |
| checkDestination(addr, port); |
| startupSocket(addr, port, null, 0, streaming); |
| } |
| |
| /** |
| * Creates an unconnected socket with the given socket implementation. |
| * |
| * @param impl |
| * the socket implementation to be used. |
| * @throws SocketException |
| * if an error occurs while creating the socket. |
| */ |
| protected Socket(SocketImpl impl) throws SocketException { |
| this.impl = impl; |
| this.proxy = null; |
| } |
| |
| /** |
| * Checks whether the connection destination satisfies the security policy |
| * and the validity of the port range. |
| * |
| * @param destAddr |
| * the destination host address. |
| * @param dstPort |
| * the port on the destination host. |
| */ |
| private void checkDestination(InetAddress destAddr, int dstPort) { |
| if (dstPort < 0 || dstPort > 65535) { |
| throw new IllegalArgumentException("Port out of range: " + dstPort); |
| } |
| } |
| |
| /** |
| * Closes the socket. It is not possible to reconnect or rebind to this |
| * socket thereafter which means a new socket instance has to be created. |
| * |
| * @throws IOException |
| * if an error occurs while closing the socket. |
| */ |
| public synchronized void close() throws IOException { |
| isClosed = true; |
| // RI compatibility: the RI returns the any address (but the original local port) after close. |
| localAddress = Inet4Address.ANY; |
| impl.close(); |
| } |
| |
| /** |
| * Returns the IP address of the target host this socket is connected to, or null if this |
| * socket is not yet connected. |
| */ |
| public InetAddress getInetAddress() { |
| if (!isConnected()) { |
| return null; |
| } |
| return impl.getInetAddress(); |
| } |
| |
| /** |
| * Returns an input stream to read data from this socket. |
| * |
| * @return the byte-oriented input stream. |
| * @throws IOException |
| * if an error occurs while creating the input stream or the |
| * socket is in an invalid state. |
| */ |
| public InputStream getInputStream() throws IOException { |
| checkOpenAndCreate(false); |
| if (isInputShutdown()) { |
| throw new SocketException("Socket input is shutdown"); |
| } |
| return impl.getInputStream(); |
| } |
| |
| /** |
| * Returns this socket's {@link SocketOptions#SO_KEEPALIVE} setting. |
| */ |
| public boolean getKeepAlive() throws SocketException { |
| checkOpenAndCreate(true); |
| return (Boolean) impl.getOption(SocketOptions.SO_KEEPALIVE); |
| } |
| |
| /** |
| * Returns the local IP address this socket is bound to, or {@code InetAddress.ANY} if |
| * the socket is unbound. |
| */ |
| public InetAddress getLocalAddress() { |
| return localAddress; |
| } |
| |
| /** |
| * Returns the local port this socket is bound to, or -1 if the socket is unbound. |
| */ |
| public int getLocalPort() { |
| if (!isBound()) { |
| return -1; |
| } |
| return impl.getLocalPort(); |
| } |
| |
| /** |
| * Returns an output stream to write data into this socket. |
| * |
| * @return the byte-oriented output stream. |
| * @throws IOException |
| * if an error occurs while creating the output stream or the |
| * socket is in an invalid state. |
| */ |
| public OutputStream getOutputStream() throws IOException { |
| checkOpenAndCreate(false); |
| if (isOutputShutdown()) { |
| throw new SocketException("Socket output is shutdown"); |
| } |
| return impl.getOutputStream(); |
| } |
| |
| /** |
| * Returns the port number of the target host this socket is connected to, or 0 if this socket |
| * is not yet connected. |
| */ |
| public int getPort() { |
| if (!isConnected()) { |
| return 0; |
| } |
| return impl.getPort(); |
| } |
| |
| /** |
| * Returns this socket's {@link SocketOptions#SO_LINGER linger} timeout in seconds, or -1 |
| * for no linger (i.e. {@code close} will return immediately). |
| */ |
| public int getSoLinger() throws SocketException { |
| checkOpenAndCreate(true); |
| // The RI explicitly guarantees this idiocy in the SocketOptions.setOption documentation. |
| Object value = impl.getOption(SocketOptions.SO_LINGER); |
| if (value instanceof Integer) { |
| return (Integer) value; |
| } else { |
| return -1; |
| } |
| } |
| |
| /** |
| * Returns this socket's {@link SocketOptions#SO_RCVBUF receive buffer size}. |
| */ |
| public synchronized int getReceiveBufferSize() throws SocketException { |
| checkOpenAndCreate(true); |
| return (Integer) impl.getOption(SocketOptions.SO_RCVBUF); |
| } |
| |
| /** |
| * Returns this socket's {@link SocketOptions#SO_SNDBUF send buffer size}. |
| */ |
| public synchronized int getSendBufferSize() throws SocketException { |
| checkOpenAndCreate(true); |
| return (Integer) impl.getOption(SocketOptions.SO_SNDBUF); |
| } |
| |
| /** |
| * Returns this socket's {@link SocketOptions#SO_TIMEOUT receive timeout}. |
| */ |
| public synchronized int getSoTimeout() throws SocketException { |
| checkOpenAndCreate(true); |
| return (Integer) impl.getOption(SocketOptions.SO_TIMEOUT); |
| } |
| |
| /** |
| * Returns this socket's {@code SocketOptions#TCP_NODELAY} setting. |
| */ |
| public boolean getTcpNoDelay() throws SocketException { |
| checkOpenAndCreate(true); |
| return (Boolean) impl.getOption(SocketOptions.TCP_NODELAY); |
| } |
| |
| /** |
| * Sets this socket's {@link SocketOptions#SO_KEEPALIVE} option. |
| */ |
| public void setKeepAlive(boolean keepAlive) throws SocketException { |
| if (impl != null) { |
| checkOpenAndCreate(true); |
| impl.setOption(SocketOptions.SO_KEEPALIVE, Boolean.valueOf(keepAlive)); |
| } |
| } |
| |
| /** |
| * Sets the internal factory for creating socket implementations. This may |
| * only be executed once during the lifetime of the application. |
| * |
| * @param fac |
| * the socket implementation factory to be set. |
| * @throws IOException |
| * if the factory has been already set. |
| */ |
| public static synchronized void setSocketImplFactory(SocketImplFactory fac) |
| throws IOException { |
| if (factory != null) { |
| throw new SocketException("Factory already set"); |
| } |
| factory = fac; |
| } |
| |
| /** |
| * Sets this socket's {@link SocketOptions#SO_SNDBUF send buffer size}. |
| */ |
| public synchronized void setSendBufferSize(int size) throws SocketException { |
| checkOpenAndCreate(true); |
| if (size < 1) { |
| throw new IllegalArgumentException("size < 1"); |
| } |
| impl.setOption(SocketOptions.SO_SNDBUF, Integer.valueOf(size)); |
| } |
| |
| /** |
| * Sets this socket's {@link SocketOptions#SO_SNDBUF receive buffer size}. |
| */ |
| public synchronized void setReceiveBufferSize(int size) throws SocketException { |
| checkOpenAndCreate(true); |
| if (size < 1) { |
| throw new IllegalArgumentException("size < 1"); |
| } |
| impl.setOption(SocketOptions.SO_RCVBUF, Integer.valueOf(size)); |
| } |
| |
| /** |
| * Sets this socket's {@link SocketOptions#SO_LINGER linger} timeout in seconds. |
| * If {@code on} is false, {@code timeout} is irrelevant. |
| */ |
| public void setSoLinger(boolean on, int timeout) throws SocketException { |
| checkOpenAndCreate(true); |
| // The RI explicitly guarantees this idiocy in the SocketOptions.setOption documentation. |
| if (on && timeout < 0) { |
| throw new IllegalArgumentException("timeout < 0"); |
| } |
| if (on) { |
| impl.setOption(SocketOptions.SO_LINGER, Integer.valueOf(timeout)); |
| } else { |
| impl.setOption(SocketOptions.SO_LINGER, Boolean.FALSE); |
| } |
| } |
| |
| /** |
| * Sets this socket's {@link SocketOptions#SO_TIMEOUT read timeout} in milliseconds. |
| * Use 0 for no timeout. |
| * To take effect, this option must be set before the blocking method was called. |
| */ |
| public synchronized void setSoTimeout(int timeout) throws SocketException { |
| checkOpenAndCreate(true); |
| if (timeout < 0) { |
| throw new IllegalArgumentException("timeout < 0"); |
| } |
| impl.setOption(SocketOptions.SO_TIMEOUT, Integer.valueOf(timeout)); |
| } |
| |
| /** |
| * Sets this socket's {@link SocketOptions#TCP_NODELAY} option. |
| */ |
| public void setTcpNoDelay(boolean on) throws SocketException { |
| checkOpenAndCreate(true); |
| impl.setOption(SocketOptions.TCP_NODELAY, Boolean.valueOf(on)); |
| } |
| |
| /** |
| * Creates a stream socket, binds it to the nominated local address/port, |
| * then connects it to the nominated destination address/port. |
| * |
| * @param dstAddress |
| * the destination host address. |
| * @param dstPort |
| * the port on the destination host. |
| * @param localAddress |
| * the address on the local machine to bind. |
| * @param localPort |
| * the port on the local machine to bind. |
| * @throws IOException |
| * thrown if an error occurs during the bind or connect |
| * operations. |
| */ |
| private void startupSocket(InetAddress dstAddress, int dstPort, |
| InetAddress localAddress, int localPort, boolean streaming) |
| throws IOException { |
| |
| if (localPort < 0 || localPort > 65535) { |
| throw new IllegalArgumentException("Local port out of range: " + localPort); |
| } |
| |
| InetAddress addr = localAddress == null ? Inet4Address.ANY : localAddress; |
| synchronized (this) { |
| impl.create(streaming); |
| isCreated = true; |
| try { |
| if (!streaming || !usingSocks()) { |
| impl.bind(addr, localPort); |
| } |
| isBound = true; |
| impl.connect(dstAddress, dstPort); |
| isConnected = true; |
| cacheLocalAddress(); |
| } catch (IOException e) { |
| impl.close(); |
| throw e; |
| } |
| } |
| } |
| |
| private boolean usingSocks() { |
| return proxy != null && proxy.type() == Proxy.Type.SOCKS; |
| } |
| |
| /** |
| * Returns a {@code String} containing a concise, human-readable description of the |
| * socket. |
| * |
| * @return the textual representation of this socket. |
| */ |
| @Override |
| public String toString() { |
| if (!isConnected()) { |
| return "Socket[unconnected]"; |
| } |
| return impl.toString(); |
| } |
| |
| /** |
| * Closes the input stream of this socket. Any further data sent to this |
| * socket will be discarded. Reading from this socket after this method has |
| * been called will return the value {@code EOF}. |
| * |
| * @throws IOException |
| * if an error occurs while closing the socket input stream. |
| * @throws SocketException |
| * if the input stream is already closed. |
| */ |
| public void shutdownInput() throws IOException { |
| if (isInputShutdown()) { |
| throw new SocketException("Socket input is shutdown"); |
| } |
| checkOpenAndCreate(false); |
| impl.shutdownInput(); |
| isInputShutdown = true; |
| } |
| |
| /** |
| * Closes the output stream of this socket. All buffered data will be sent |
| * followed by the termination sequence. Writing to the closed output stream |
| * will cause an {@code IOException}. |
| * |
| * @throws IOException |
| * if an error occurs while closing the socket output stream. |
| * @throws SocketException |
| * if the output stream is already closed. |
| */ |
| public void shutdownOutput() throws IOException { |
| if (isOutputShutdown()) { |
| throw new SocketException("Socket output is shutdown"); |
| } |
| checkOpenAndCreate(false); |
| impl.shutdownOutput(); |
| isOutputShutdown = true; |
| } |
| |
| /** |
| * Checks whether the socket is closed, and throws an exception. Otherwise |
| * creates the underlying SocketImpl. |
| * |
| * @throws SocketException |
| * if the socket is closed. |
| */ |
| private void checkOpenAndCreate(boolean create) throws SocketException { |
| if (isClosed()) { |
| throw new SocketException("Socket is closed"); |
| } |
| if (!create) { |
| if (!isConnected()) { |
| throw new SocketException("Socket is not connected"); |
| // a connected socket must be created |
| } |
| |
| /* |
| * return directly to fix a possible bug, if !create, should return |
| * here |
| */ |
| return; |
| } |
| if (isCreated) { |
| return; |
| } |
| synchronized (this) { |
| if (isCreated) { |
| return; |
| } |
| try { |
| impl.create(true); |
| } catch (SocketException e) { |
| throw e; |
| } catch (IOException e) { |
| throw new SocketException(e.toString()); |
| } |
| isCreated = true; |
| } |
| } |
| |
| /** |
| * Returns the local address and port of this socket as a SocketAddress or |
| * null if the socket is unbound. This is useful on multihomed |
| * hosts. |
| */ |
| public SocketAddress getLocalSocketAddress() { |
| if (!isBound()) { |
| return null; |
| } |
| return new InetSocketAddress(getLocalAddress(), getLocalPort()); |
| } |
| |
| /** |
| * Returns the remote address and port of this socket as a {@code |
| * SocketAddress} or null if the socket is not connected. |
| * |
| * @return the remote socket address and port. |
| */ |
| public SocketAddress getRemoteSocketAddress() { |
| if (!isConnected()) { |
| return null; |
| } |
| return new InetSocketAddress(getInetAddress(), getPort()); |
| } |
| |
| /** |
| * Returns whether this socket is bound to a local address and port. |
| * |
| * @return {@code true} if the socket is bound to a local address, {@code |
| * false} otherwise. |
| */ |
| public boolean isBound() { |
| return isBound; |
| } |
| |
| /** |
| * Returns whether this socket is connected to a remote host. |
| * |
| * @return {@code true} if the socket is connected, {@code false} otherwise. |
| */ |
| public boolean isConnected() { |
| return isConnected; |
| } |
| |
| /** |
| * Returns whether this socket is closed. |
| * |
| * @return {@code true} if the socket is closed, {@code false} otherwise. |
| */ |
| public boolean isClosed() { |
| return isClosed; |
| } |
| |
| /** |
| * Binds this socket to the given local host address and port specified by |
| * the SocketAddress {@code localAddr}. If {@code localAddr} is set to |
| * {@code null}, this socket will be bound to an available local address on |
| * any free port. |
| * |
| * @param localAddr |
| * the specific address and port on the local machine to bind to. |
| * @throws IllegalArgumentException |
| * if the given SocketAddress is invalid or not supported. |
| * @throws IOException |
| * if the socket is already bound or an error occurs while |
| * binding. |
| */ |
| public void bind(SocketAddress localAddr) throws IOException { |
| checkOpenAndCreate(true); |
| if (isBound()) { |
| throw new BindException("Socket is already bound"); |
| } |
| |
| int port = 0; |
| InetAddress addr = Inet4Address.ANY; |
| if (localAddr != null) { |
| if (!(localAddr instanceof InetSocketAddress)) { |
| throw new IllegalArgumentException("Local address not an InetSocketAddress: " + |
| localAddr.getClass()); |
| } |
| InetSocketAddress inetAddr = (InetSocketAddress) localAddr; |
| if ((addr = inetAddr.getAddress()) == null) { |
| throw new UnknownHostException("Host is unresolved: " + inetAddr.getHostName()); |
| } |
| port = inetAddr.getPort(); |
| } |
| |
| synchronized (this) { |
| try { |
| impl.bind(addr, port); |
| isBound = true; |
| cacheLocalAddress(); |
| } catch (IOException e) { |
| impl.close(); |
| throw e; |
| } |
| } |
| } |
| |
| /** |
| * Connects this socket to the given remote host address and port specified |
| * by the SocketAddress {@code remoteAddr}. |
| * |
| * @param remoteAddr |
| * the address and port of the remote host to connect to. |
| * @throws IllegalArgumentException |
| * if the given SocketAddress is invalid or not supported. |
| * @throws IOException |
| * if the socket is already connected or an error occurs while |
| * connecting. |
| */ |
| public void connect(SocketAddress remoteAddr) throws IOException { |
| connect(remoteAddr, 0); |
| } |
| |
| /** |
| * Connects this socket to the given remote host address and port specified |
| * by the SocketAddress {@code remoteAddr} with the specified timeout. The |
| * connecting method will block until the connection is established or an |
| * error occurred. |
| * |
| * @param remoteAddr |
| * the address and port of the remote host to connect to. |
| * @param timeout |
| * the timeout value in milliseconds or {@code 0} for an infinite |
| * timeout. |
| * @throws IllegalArgumentException |
| * if the given SocketAddress is invalid or not supported or the |
| * timeout value is negative. |
| * @throws IOException |
| * if the socket is already connected or an error occurs while |
| * connecting. |
| */ |
| public void connect(SocketAddress remoteAddr, int timeout) throws IOException { |
| checkOpenAndCreate(true); |
| if (timeout < 0) { |
| throw new IllegalArgumentException("timeout < 0"); |
| } |
| if (isConnected()) { |
| throw new SocketException("Already connected"); |
| } |
| if (remoteAddr == null) { |
| throw new IllegalArgumentException("remoteAddr == null"); |
| } |
| |
| if (!(remoteAddr instanceof InetSocketAddress)) { |
| throw new IllegalArgumentException("Remote address not an InetSocketAddress: " + |
| remoteAddr.getClass()); |
| } |
| InetSocketAddress inetAddr = (InetSocketAddress) remoteAddr; |
| InetAddress addr; |
| if ((addr = inetAddr.getAddress()) == null) { |
| throw new UnknownHostException("Host is unresolved: " + inetAddr.getHostName()); |
| } |
| int port = inetAddr.getPort(); |
| |
| checkDestination(addr, port); |
| synchronized (connectLock) { |
| try { |
| if (!isBound()) { |
| // socket already created at this point by earlier call or |
| // checkOpenAndCreate this caused us to lose socket |
| // options on create |
| // impl.create(true); |
| if (!usingSocks()) { |
| impl.bind(Inet4Address.ANY, 0); |
| } |
| isBound = true; |
| } |
| impl.connect(remoteAddr, timeout); |
| isConnected = true; |
| cacheLocalAddress(); |
| } catch (IOException e) { |
| impl.close(); |
| throw e; |
| } |
| } |
| } |
| |
| /** |
| * Returns whether the incoming channel of the socket has already been |
| * closed. |
| * |
| * @return {@code true} if reading from this socket is not possible anymore, |
| * {@code false} otherwise. |
| */ |
| public boolean isInputShutdown() { |
| return isInputShutdown; |
| } |
| |
| /** |
| * Returns whether the outgoing channel of the socket has already been |
| * closed. |
| * |
| * @return {@code true} if writing to this socket is not possible anymore, |
| * {@code false} otherwise. |
| */ |
| public boolean isOutputShutdown() { |
| return isOutputShutdown; |
| } |
| |
| /** |
| * Sets this socket's {@link SocketOptions#SO_REUSEADDR} option. |
| */ |
| public void setReuseAddress(boolean reuse) throws SocketException { |
| checkOpenAndCreate(true); |
| impl.setOption(SocketOptions.SO_REUSEADDR, Boolean.valueOf(reuse)); |
| } |
| |
| /** |
| * Returns this socket's {@link SocketOptions#SO_REUSEADDR} setting. |
| */ |
| public boolean getReuseAddress() throws SocketException { |
| checkOpenAndCreate(true); |
| return (Boolean) impl.getOption(SocketOptions.SO_REUSEADDR); |
| } |
| |
| /** |
| * Sets this socket's {@link SocketOptions#SO_OOBINLINE} option. |
| */ |
| public void setOOBInline(boolean oobinline) throws SocketException { |
| checkOpenAndCreate(true); |
| impl.setOption(SocketOptions.SO_OOBINLINE, Boolean.valueOf(oobinline)); |
| } |
| |
| /** |
| * Returns this socket's {@link SocketOptions#SO_OOBINLINE} setting. |
| */ |
| public boolean getOOBInline() throws SocketException { |
| checkOpenAndCreate(true); |
| return (Boolean) impl.getOption(SocketOptions.SO_OOBINLINE); |
| } |
| |
| /** |
| * Sets this socket's {@link SocketOptions#IP_TOS} value for every packet sent by this socket. |
| */ |
| public void setTrafficClass(int value) throws SocketException { |
| checkOpenAndCreate(true); |
| if (value < 0 || value > 255) { |
| throw new IllegalArgumentException(); |
| } |
| impl.setOption(SocketOptions.IP_TOS, Integer.valueOf(value)); |
| } |
| |
| /** |
| * Returns this socket's {@see SocketOptions#IP_TOS} setting. |
| */ |
| public int getTrafficClass() throws SocketException { |
| checkOpenAndCreate(true); |
| return (Integer) impl.getOption(SocketOptions.IP_TOS); |
| } |
| |
| /** |
| * Sends the given single byte data which is represented by the lowest octet |
| * of {@code value} as "TCP urgent data". |
| * |
| * @param value |
| * the byte of urgent data to be sent. |
| * @throws IOException |
| * if an error occurs while sending urgent data. |
| */ |
| public void sendUrgentData(int value) throws IOException { |
| impl.sendUrgentData(value); |
| } |
| |
| /** |
| * Set the appropriate flags for a socket created by {@code |
| * ServerSocket.accept()}. |
| * |
| * @see ServerSocket#implAccept |
| */ |
| void accepted() { |
| isCreated = isBound = isConnected = true; |
| cacheLocalAddress(); |
| } |
| |
| private void cacheLocalAddress() { |
| this.localAddress = IoBridge.getSocketLocalAddress(impl.fd); |
| } |
| |
| /** |
| * Returns this socket's {@code SocketChannel}, if one exists. A channel is |
| * available only if this socket wraps a channel. (That is, you can go from a |
| * channel to a socket and back again, but you can't go from an arbitrary socket to a channel.) |
| * In practice, this means that the socket must have been created by |
| * {@link java.nio.channels.ServerSocketChannel#accept} or |
| * {@link java.nio.channels.SocketChannel#open}. |
| */ |
| public SocketChannel getChannel() { |
| return null; |
| } |
| |
| /** |
| * @hide internal use only |
| */ |
| public FileDescriptor getFileDescriptor$() { |
| return impl.fd; |
| } |
| |
| /** |
| * Sets performance preferences for connectionTime, latency and bandwidth. |
| * |
| * <p>This method does currently nothing. |
| * |
| * @param connectionTime |
| * the value representing the importance of a short connecting |
| * time. |
| * @param latency |
| * the value representing the importance of low latency. |
| * @param bandwidth |
| * the value representing the importance of high bandwidth. |
| */ |
| public void setPerformancePreferences(int connectionTime, int latency, int bandwidth) { |
| // Our socket implementation only provide one protocol: TCP/IP, so |
| // we do nothing for this method |
| } |
| } |
