001/*
002 * Copyright (C) 2009 The Guava Authors
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
005 * in compliance with the License. You may obtain a copy of the License at
006 *
007 * http://www.apache.org/licenses/LICENSE-2.0
008 *
009 * Unless required by applicable law or agreed to in writing, software distributed under the License
010 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
011 * or implied. See the License for the specific language governing permissions and limitations under
012 * the License.
013 */
014
015package com.google.common.net;
016
017import com.google.common.annotations.Beta;
018import com.google.common.annotations.GwtIncompatible;
019import com.google.common.base.Preconditions;
020import java.net.InetAddress;
021import java.text.ParseException;
022import javax.annotation.CheckForNull;
023
024/**
025 * A syntactically valid host specifier, suitable for use in a URI. This may be either a numeric IP
026 * address in IPv4 or IPv6 notation, or a domain name.
027 *
028 * <p>Because this class is intended to represent host specifiers which can reasonably be used in a
029 * URI, the domain name case is further restricted to include only those domain names which end in a
030 * recognized public suffix; see {@link InternetDomainName#isPublicSuffix()} for details.
031 *
032 * <p>Note that no network lookups are performed by any {@code HostSpecifier} methods. No attempt is
033 * made to verify that a provided specifier corresponds to a real or accessible host. Only syntactic
034 * and pattern-based checks are performed.
035 *
036 * <p>If you know that a given string represents a numeric IP address, use {@link InetAddresses} to
037 * obtain and manipulate a {@link java.net.InetAddress} instance from it rather than using this
038 * class. Similarly, if you know that a given string represents a domain name, use {@link
039 * InternetDomainName} rather than this class.
040 *
041 * @author Craig Berry
042 * @since 5.0
043 */
044@Beta
045@GwtIncompatible
046@ElementTypesAreNonnullByDefault
047public final class HostSpecifier {
048
049  private final String canonicalForm;
050
051  private HostSpecifier(String canonicalForm) {
052    this.canonicalForm = canonicalForm;
053  }
054
055  /**
056   * Returns a {@code HostSpecifier} built from the provided {@code specifier}, which is already
057   * known to be valid. If the {@code specifier} might be invalid, use {@link #from(String)}
058   * instead.
059   *
060   * <p>The specifier must be in one of these formats:
061   *
062   * <ul>
063   *   <li>A domain name, like {@code google.com}
064   *   <li>A IPv4 address string, like {@code 127.0.0.1}
065   *   <li>An IPv6 address string with or without brackets, like {@code [2001:db8::1]} or {@code
066   *       2001:db8::1}
067   * </ul>
068   *
069   * @throws IllegalArgumentException if the specifier is not valid.
070   */
071  public static HostSpecifier fromValid(String specifier) {
072    // Verify that no port was specified, and strip optional brackets from
073    // IPv6 literals.
074    final HostAndPort parsedHost = HostAndPort.fromString(specifier);
075    Preconditions.checkArgument(!parsedHost.hasPort());
076    final String host = parsedHost.getHost();
077
078    // Try to interpret the specifier as an IP address. Note we build
079    // the address rather than using the .is* methods because we want to
080    // use InetAddresses.toUriString to convert the result to a string in
081    // canonical form.
082    InetAddress addr = null;
083    try {
084      addr = InetAddresses.forString(host);
085    } catch (IllegalArgumentException e) {
086      // It is not an IPv4 or IPv6 literal
087    }
088
089    if (addr != null) {
090      return new HostSpecifier(InetAddresses.toUriString(addr));
091    }
092
093    // It is not any kind of IP address; must be a domain name or invalid.
094
095    // TODO(user): different versions of this for different factories?
096    final InternetDomainName domain = InternetDomainName.from(host);
097
098    if (domain.hasPublicSuffix()) {
099      return new HostSpecifier(domain.toString());
100    }
101
102    throw new IllegalArgumentException(
103        "Domain name does not have a recognized public suffix: " + host);
104  }
105
106  /**
107   * Attempts to return a {@code HostSpecifier} for the given string, throwing an exception if
108   * parsing fails. Always use this method in preference to {@link #fromValid(String)} for a
109   * specifier that is not already known to be valid.
110   *
111   * @throws ParseException if the specifier is not valid.
112   */
113  public static HostSpecifier from(String specifier) throws ParseException {
114    try {
115      return fromValid(specifier);
116    } catch (IllegalArgumentException e) {
117      // Since the IAE can originate at several different points inside
118      // fromValid(), we implement this method in terms of that one rather
119      // than the reverse.
120
121      ParseException parseException = new ParseException("Invalid host specifier: " + specifier, 0);
122      parseException.initCause(e);
123      throw parseException;
124    }
125  }
126
127  /**
128   * Determines whether {@code specifier} represents a valid {@link HostSpecifier} as described in
129   * the documentation for {@link #fromValid(String)}.
130   */
131  public static boolean isValid(String specifier) {
132    try {
133      fromValid(specifier);
134      return true;
135    } catch (IllegalArgumentException e) {
136      return false;
137    }
138  }
139
140  @Override
141  public boolean equals(@CheckForNull Object other) {
142    if (this == other) {
143      return true;
144    }
145
146    if (other instanceof HostSpecifier) {
147      final HostSpecifier that = (HostSpecifier) other;
148      return this.canonicalForm.equals(that.canonicalForm);
149    }
150
151    return false;
152  }
153
154  @Override
155  public int hashCode() {
156    return canonicalForm.hashCode();
157  }
158
159  /**
160   * Returns a string representation of the host specifier suitable for inclusion in a URI. If the
161   * host specifier is a domain name, the string will be normalized to all lower case. If the
162   * specifier was an IPv6 address without brackets, brackets are added so that the result will be
163   * usable in the host part of a URI.
164   */
165  @Override
166  public String toString() {
167    return canonicalForm;
168  }
169}