| /* |
| * Copyright (C) 2014 The Android Open Source Project |
| * Copyright (c) 2000, 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.InvalidObjectException; |
| import java.io.ObjectInputStream; |
| import java.io.ObjectOutputStream; |
| import java.io.ObjectStreamException; |
| import java.io.ObjectStreamField; |
| |
| /** |
| * |
| * This class implements an IP Socket Address (IP address + port number) |
| * It can also be a pair (hostname + port number), in which case an attempt |
| * will be made to resolve the hostname. If resolution fails then the address |
| * is said to be <I>unresolved</I> but can still be used on some circumstances |
| * like connecting through a proxy. |
| * <p> |
| * It provides an immutable object used by sockets for binding, connecting, or |
| * as returned values. |
| * <p> |
| * The <i>wildcard</i> is a special local IP address. It usually means "any" |
| * and can only be used for {@code bind} operations. |
| * |
| * @see java.net.Socket |
| * @see java.net.ServerSocket |
| * @since 1.4 |
| */ |
| public class InetSocketAddress |
| extends SocketAddress |
| { |
| // Private implementation class pointed to by all public methods. |
| private static class InetSocketAddressHolder { |
| // The hostname of the Socket Address |
| private String hostname; |
| // The IP address of the Socket Address |
| private InetAddress addr; |
| // The port number of the Socket Address |
| private int port; |
| |
| private InetSocketAddressHolder(String hostname, InetAddress addr, int port) { |
| this.hostname = hostname; |
| this.addr = addr; |
| this.port = port; |
| } |
| |
| private int getPort() { |
| return port; |
| } |
| |
| private InetAddress getAddress() { |
| return addr; |
| } |
| |
| private String getHostName() { |
| if (hostname != null) |
| return hostname; |
| if (addr != null) |
| return addr.getHostName(); |
| return null; |
| } |
| |
| private String getHostString() { |
| if (hostname != null) |
| return hostname; |
| if (addr != null) { |
| if (addr.holder().getHostName() != null) |
| return addr.holder().getHostName(); |
| else |
| return addr.getHostAddress(); |
| } |
| return null; |
| } |
| |
| private boolean isUnresolved() { |
| return addr == null; |
| } |
| |
| @Override |
| public String toString() { |
| |
| String formatted; |
| |
| if (isUnresolved()) { |
| formatted = hostname + "/<unresolved>"; |
| } else { |
| formatted = addr.toString(); |
| if (addr instanceof Inet6Address) { |
| int i = formatted.lastIndexOf("/"); |
| formatted = formatted.substring(0, i + 1) |
| + "[" + formatted.substring(i + 1) + "]"; |
| } |
| } |
| return formatted + ":" + port; |
| } |
| |
| @Override |
| public final boolean equals(Object obj) { |
| if (obj == null || !(obj instanceof InetSocketAddressHolder)) |
| return false; |
| InetSocketAddressHolder that = (InetSocketAddressHolder)obj; |
| boolean sameIP; |
| if (addr != null) |
| sameIP = addr.equals(that.addr); |
| else if (hostname != null) |
| sameIP = (that.addr == null) && |
| hostname.equalsIgnoreCase(that.hostname); |
| else |
| sameIP = (that.addr == null) && (that.hostname == null); |
| return sameIP && (port == that.port); |
| } |
| |
| @Override |
| public final int hashCode() { |
| if (addr != null) |
| return addr.hashCode() + port; |
| if (hostname != null) |
| return hostname.toLowerCase().hashCode() + port; |
| return port; |
| } |
| } |
| |
| private final transient InetSocketAddressHolder holder; |
| |
| @java.io.Serial |
| private static final long serialVersionUID = 5076001401234631237L; |
| |
| private static int checkPort(int port) { |
| if (port < 0 || port > 0xFFFF) |
| throw new IllegalArgumentException("port out of range:" + port); |
| return port; |
| } |
| |
| private static String checkHost(String hostname) { |
| if (hostname == null) |
| throw new IllegalArgumentException("hostname can't be null"); |
| return hostname; |
| } |
| |
| // BEGIN Android-added: InetSocketAddress() ctor used by IoBridge. |
| /** |
| * @hide internal use only |
| */ |
| public InetSocketAddress() { |
| // These will be filled in the native implementation of recvfrom. |
| holder = new InetSocketAddressHolder(null, null, 0); |
| } |
| // END Android-added: InetSocketAddress() ctor used by IoBridge. |
| |
| /** |
| * Creates a socket address where the IP address is the wildcard address |
| * and the port number a specified value. |
| * <p> |
| * A valid port value is between 0 and 65535. |
| * A port number of {@code zero} will let the system pick up an |
| * ephemeral port in a {@code bind} operation. |
| * |
| * @param port The port number |
| * @throws IllegalArgumentException if the port parameter is outside the specified |
| * range of valid port values. |
| */ |
| public InetSocketAddress(int port) { |
| // Android-changed: Defaults to IPv6. |
| // this(InetAddress.anyLocalAddress(), port); |
| this((InetAddress)null, port); |
| } |
| |
| /** |
| * |
| * Creates a socket address from an IP address and a port number. |
| * <p> |
| * A valid port value is between 0 and 65535. |
| * A port number of {@code zero} will let the system pick up an |
| * ephemeral port in a {@code bind} operation. |
| * <P> |
| * A {@code null} address will assign the <i>wildcard</i> address. |
| * |
| * @param addr The IP address |
| * @param port The port number |
| * @throws IllegalArgumentException if the port parameter is outside the specified |
| * range of valid port values. |
| */ |
| public InetSocketAddress(InetAddress addr, int port) { |
| holder = new InetSocketAddressHolder( |
| null, |
| // Android-changed: Defaults to IPv6 if addr is null. |
| // addr == null ? InetAddress.anyLocalAddress() : addr, |
| addr == null ? Inet6Address.ANY : addr, |
| checkPort(port)); |
| } |
| |
| /** |
| * |
| * Creates a socket address from a hostname and a port number. |
| * <p> |
| * An attempt will be made to resolve the hostname into an InetAddress. |
| * If that attempt fails, the address will be flagged as <I>unresolved</I>. |
| * <p> |
| * If there is a security manager, its {@code checkConnect} method |
| * is called with the host name as its argument to check the permission |
| * to resolve it. This could result in a SecurityException. |
| * <P> |
| * A valid port value is between 0 and 65535. |
| * A port number of {@code zero} will let the system pick up an |
| * ephemeral port in a {@code bind} operation. |
| * |
| * @param hostname the Host name |
| * @param port The port number |
| * @throws IllegalArgumentException if the port parameter is outside the range |
| * of valid port values, or if the hostname parameter is {@code null}. |
| * @throws SecurityException if a security manager is present and |
| * permission to resolve the host name is |
| * denied. |
| * @see #isUnresolved() |
| */ |
| public InetSocketAddress(String hostname, int port) { |
| checkHost(hostname); |
| InetAddress addr = null; |
| String host = null; |
| try { |
| addr = InetAddress.getByName(hostname); |
| } catch(UnknownHostException e) { |
| host = hostname; |
| } |
| holder = new InetSocketAddressHolder(host, addr, checkPort(port)); |
| } |
| |
| // private constructor for creating unresolved instances |
| private InetSocketAddress(int port, String hostname) { |
| holder = new InetSocketAddressHolder(hostname, null, port); |
| } |
| |
| /** |
| * |
| * Creates an unresolved socket address from a hostname and a port number. |
| * <p> |
| * No attempt will be made to resolve the hostname into an InetAddress. |
| * The address will be flagged as <I>unresolved</I>. |
| * <p> |
| * A valid port value is between 0 and 65535. |
| * A port number of {@code zero} will let the system pick up an |
| * ephemeral port in a {@code bind} operation. |
| * |
| * @param host the Host name |
| * @param port The port number |
| * @throws IllegalArgumentException if the port parameter is outside |
| * the range of valid port values, or if the hostname |
| * parameter is {@code null}. |
| * @see #isUnresolved() |
| * @return an {@code InetSocketAddress} representing the unresolved |
| * socket address |
| * @since 1.5 |
| */ |
| public static InetSocketAddress createUnresolved(String host, int port) { |
| return new InetSocketAddress(checkPort(port), checkHost(host)); |
| } |
| |
| /** |
| * @serialField hostname String the hostname of the Socket Address |
| * @serialField addr InetAddress the IP address of the Socket Address |
| * @serialField port int the port number of the Socket Address |
| */ |
| @java.io.Serial |
| private static final ObjectStreamField[] serialPersistentFields = { |
| new ObjectStreamField("hostname", String.class), |
| new ObjectStreamField("addr", InetAddress.class), |
| new ObjectStreamField("port", int.class)}; |
| |
| /** |
| * Writes the state of this object to the stream. |
| * |
| * @param out the {@code ObjectOutputStream} to which data is written |
| * @throws IOException if an I/O error occurs |
| */ |
| @java.io.Serial |
| private void writeObject(ObjectOutputStream out) |
| throws IOException |
| { |
| // Don't call defaultWriteObject() |
| ObjectOutputStream.PutField pfields = out.putFields(); |
| pfields.put("hostname", holder.hostname); |
| pfields.put("addr", holder.addr); |
| pfields.put("port", holder.port); |
| out.writeFields(); |
| } |
| |
| /** |
| * Restores the state of this object from the stream. |
| * |
| * @param in the {@code ObjectInputStream} from which data is read |
| * @throws IOException if an I/O error occurs |
| * @throws ClassNotFoundException if a serialized class cannot be loaded |
| */ |
| @java.io.Serial |
| private void readObject(ObjectInputStream in) |
| throws IOException, ClassNotFoundException |
| { |
| // Don't call defaultReadObject() |
| ObjectInputStream.GetField oisFields = in.readFields(); |
| final String oisHostname = (String)oisFields.get("hostname", null); |
| final InetAddress oisAddr = (InetAddress)oisFields.get("addr", null); |
| final int oisPort = oisFields.get("port", -1); |
| |
| // Check that our invariants are satisfied |
| checkPort(oisPort); |
| if (oisHostname == null && oisAddr == null) |
| throw new InvalidObjectException("hostname and addr " + |
| "can't both be null"); |
| |
| InetSocketAddressHolder h = new InetSocketAddressHolder(oisHostname, |
| oisAddr, |
| oisPort); |
| UNSAFE.putReference(this, FIELDS_OFFSET, h); |
| } |
| |
| /** |
| * Throws {@code InvalidObjectException}, always. |
| * @throws ObjectStreamException always |
| */ |
| @java.io.Serial |
| private void readObjectNoData() |
| throws ObjectStreamException |
| { |
| throw new InvalidObjectException("Stream data required"); |
| } |
| |
| private static final jdk.internal.misc.Unsafe UNSAFE |
| = jdk.internal.misc.Unsafe.getUnsafe(); |
| private static final long FIELDS_OFFSET |
| = UNSAFE.objectFieldOffset(InetSocketAddress.class, "holder"); |
| |
| /** |
| * Gets the port number. |
| * |
| * @return the port number. |
| */ |
| public final int getPort() { |
| return holder.getPort(); |
| } |
| |
| /** |
| * Gets the {@code InetAddress}. |
| * |
| * @return the InetAddress or {@code null} if it is unresolved. |
| */ |
| public final InetAddress getAddress() { |
| return holder.getAddress(); |
| } |
| |
| /** |
| * Gets the {@code hostname}. |
| * Note: This method may trigger a name service reverse lookup if the |
| * address was created with a literal IP address. |
| * |
| * @return the hostname part of the address. |
| */ |
| public final String getHostName() { |
| return holder.getHostName(); |
| } |
| |
| /** |
| * Returns the hostname, or the String form of the address if it |
| * doesn't have a hostname (it was created using a literal). |
| * This has the benefit of <b>not</b> attempting a reverse lookup. |
| * |
| * @return the hostname, or String representation of the address. |
| * @since 1.7 |
| */ |
| public final String getHostString() { |
| return holder.getHostString(); |
| } |
| |
| /** |
| * Checks whether the address has been resolved or not. |
| * |
| * @return {@code true} if the hostname couldn't be resolved into |
| * an {@code InetAddress}. |
| */ |
| public final boolean isUnresolved() { |
| return holder.isUnresolved(); |
| } |
| |
| /** |
| * Constructs a string representation of this InetSocketAddress. |
| * This string is constructed by calling {@link InetAddress#toString()} |
| * on the InetAddress and concatenating the port number (with a colon). |
| * <p> |
| * If the address is an IPv6 address, the IPv6 literal is enclosed in |
| * square brackets, for example: {@code "localhost/[0:0:0:0:0:0:0:1]:80"}. |
| * If the address is {@linkplain #isUnresolved() unresolved}, |
| * {@code <unresolved>} is displayed in place of the address literal, for |
| * example {@code "foo/<unresolved>:80"}. |
| * <p> |
| * To retrieve a string representation of the hostname or the address, use |
| * {@link #getHostString()}, rather than parsing the string returned by this |
| * {@link #toString()} method. |
| * |
| * @return a string representation of this object. |
| */ |
| @Override |
| public String toString() { |
| return holder.toString(); |
| } |
| |
| /** |
| * Compares this object against the specified object. |
| * The result is {@code true} if and only if the argument is |
| * not {@code null} and it represents the same address as |
| * this object. |
| * <p> |
| * Two instances of {@code InetSocketAddress} represent the same |
| * address if both the InetAddresses (or hostnames if it is unresolved) and port |
| * numbers are equal. |
| * If both addresses are unresolved, then the hostname and the port number |
| * are compared. |
| * |
| * Note: Hostnames are case insensitive. e.g. "FooBar" and "foobar" are |
| * considered equal. |
| * |
| * @param obj the object to compare against. |
| * @return {@code true} if the objects are the same; |
| * {@code false} otherwise. |
| * @see java.net.InetAddress#equals(java.lang.Object) |
| */ |
| @Override |
| public final boolean equals(Object obj) { |
| if (obj == null || !(obj instanceof InetSocketAddress)) |
| return false; |
| return holder.equals(((InetSocketAddress) obj).holder); |
| } |
| |
| /** |
| * Returns a hashcode for this socket address. |
| * |
| * @return a hash code value for this socket address. |
| */ |
| @Override |
| public final int hashCode() { |
| return holder.hashCode(); |
| } |
| } |
