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 static com.google.common.base.Preconditions.checkArgument; 018import static com.google.common.base.Preconditions.checkNotNull; 019import static com.google.common.base.Preconditions.checkState; 020 021import com.google.common.annotations.Beta; 022import com.google.common.annotations.GwtCompatible; 023import com.google.common.base.Ascii; 024import com.google.common.base.CharMatcher; 025import com.google.common.base.Joiner; 026import com.google.common.base.Optional; 027import com.google.common.base.Splitter; 028import com.google.common.collect.ImmutableList; 029import com.google.errorprone.annotations.Immutable; 030import com.google.thirdparty.publicsuffix.PublicSuffixPatterns; 031import com.google.thirdparty.publicsuffix.PublicSuffixType; 032import java.util.List; 033import org.checkerframework.checker.nullness.qual.Nullable; 034 035/** 036 * An immutable well-formed internet domain name, such as {@code com} or {@code foo.co.uk}. Only 037 * syntactic analysis is performed; no DNS lookups or other network interactions take place. Thus 038 * there is no guarantee that the domain actually exists on the internet. 039 * 040 * <p>One common use of this class is to determine whether a given string is likely to represent an 041 * addressable domain on the web -- that is, for a candidate string {@code "xxx"}, might browsing to 042 * {@code "http://xxx/"} result in a webpage being displayed? In the past, this test was frequently 043 * done by determining whether the domain ended with a {@linkplain #isPublicSuffix() public suffix} 044 * but was not itself a public suffix. However, this test is no longer accurate. There are many 045 * domains which are both public suffixes and addressable as hosts; {@code "uk.com"} is one example. 046 * Using the subset of public suffixes that are {@linkplain #isRegistrySuffix() registry suffixes}, 047 * one can get a better result, as only a few registry suffixes are addressable. However, the most 048 * useful test to determine if a domain is a plausible web host is {@link #hasPublicSuffix()}. This 049 * will return {@code true} for many domains which (currently) are not hosts, such as {@code "com"}, 050 * but given that any public suffix may become a host without warning, it is better to err on the 051 * side of permissiveness and thus avoid spurious rejection of valid sites. Of course, to actually 052 * determine addressability of any host, clients of this class will need to perform their own DNS 053 * lookups. 054 * 055 * <p>During construction, names are normalized in two ways: 056 * 057 * <ol> 058 * <li>ASCII uppercase characters are converted to lowercase. 059 * <li>Unicode dot separators other than the ASCII period ({@code '.'}) are converted to the ASCII 060 * period. 061 * </ol> 062 * 063 * <p>The normalized values will be returned from {@link #toString()} and {@link #parts()}, and will 064 * be reflected in the result of {@link #equals(Object)}. 065 * 066 * <p><a href="http://en.wikipedia.org/wiki/Internationalized_domain_name">Internationalized domain 067 * names</a> such as {@code 网络.cn} are supported, as are the equivalent <a 068 * href="http://en.wikipedia.org/wiki/Internationalized_domain_name">IDNA Punycode-encoded</a> 069 * versions. 070 * 071 * @author Catherine Berry 072 * @since 5.0 073 */ 074@Beta 075@GwtCompatible 076@Immutable 077public final class InternetDomainName { 078 079 private static final CharMatcher DOTS_MATCHER = CharMatcher.anyOf(".\u3002\uFF0E\uFF61"); 080 private static final Splitter DOT_SPLITTER = Splitter.on('.'); 081 private static final Joiner DOT_JOINER = Joiner.on('.'); 082 083 /** 084 * Value of {@link #publicSuffixIndex} or {@link #registrySuffixIndex} which indicates that no 085 * relevant suffix was found. 086 */ 087 private static final int NO_SUFFIX_FOUND = -1; 088 089 /** 090 * Maximum parts (labels) in a domain name. This value arises from the 255-octet limit described 091 * in <a href="http://www.ietf.org/rfc/rfc2181.txt">RFC 2181</a> part 11 with the fact that the 092 * encoding of each part occupies at least two bytes (dot plus label externally, length byte plus 093 * label internally). Thus, if all labels have the minimum size of one byte, 127 of them will fit. 094 */ 095 private static final int MAX_PARTS = 127; 096 097 /** 098 * Maximum length of a full domain name, including separators, and leaving room for the root 099 * label. See <a href="http://www.ietf.org/rfc/rfc2181.txt">RFC 2181</a> part 11. 100 */ 101 private static final int MAX_LENGTH = 253; 102 103 /** 104 * Maximum size of a single part of a domain name. See <a 105 * href="http://www.ietf.org/rfc/rfc2181.txt">RFC 2181</a> part 11. 106 */ 107 private static final int MAX_DOMAIN_PART_LENGTH = 63; 108 109 /** The full domain name, converted to lower case. */ 110 private final String name; 111 112 /** The parts of the domain name, converted to lower case. */ 113 private final ImmutableList<String> parts; 114 115 /** 116 * The index in the {@link #parts()} list at which the public suffix begins. For example, for the 117 * domain name {@code myblog.blogspot.co.uk}, the value would be 1 (the index of the {@code 118 * blogspot} part). The value is negative (specifically, {@link #NO_SUFFIX_FOUND}) if no public 119 * suffix was found. 120 */ 121 private final int publicSuffixIndex; 122 123 /** 124 * The index in the {@link #parts()} list at which the registry suffix begins. For example, for 125 * the domain name {@code myblog.blogspot.co.uk}, the value would be 2 (the index of the {@code 126 * co} part). The value is negative (specifically, {@link #NO_SUFFIX_FOUND}) if no registry suffix 127 * was found. 128 */ 129 private final int registrySuffixIndex; 130 131 /** Constructor used to implement {@link #from(String)}, and from subclasses. */ 132 InternetDomainName(String name) { 133 // Normalize: 134 // * ASCII characters to lowercase 135 // * All dot-like characters to '.' 136 // * Strip trailing '.' 137 138 name = Ascii.toLowerCase(DOTS_MATCHER.replaceFrom(name, '.')); 139 140 if (name.endsWith(".")) { 141 name = name.substring(0, name.length() - 1); 142 } 143 144 checkArgument(name.length() <= MAX_LENGTH, "Domain name too long: '%s':", name); 145 this.name = name; 146 147 this.parts = ImmutableList.copyOf(DOT_SPLITTER.split(name)); 148 checkArgument(parts.size() <= MAX_PARTS, "Domain has too many parts: '%s'", name); 149 checkArgument(validateSyntax(parts), "Not a valid domain name: '%s'", name); 150 151 this.publicSuffixIndex = findSuffixOfType(Optional.<PublicSuffixType>absent()); 152 this.registrySuffixIndex = findSuffixOfType(Optional.of(PublicSuffixType.REGISTRY)); 153 } 154 155 /** 156 * Returns the index of the leftmost part of the suffix, or -1 if not found. Note that the value 157 * defined as a suffix may not produce {@code true} results from {@link #isPublicSuffix()} or 158 * {@link #isRegistrySuffix()} if the domain ends with an excluded domain pattern such as {@code 159 * "nhs.uk"}. 160 * 161 * <p>If a {@code desiredType} is specified, this method only finds suffixes of the given type. 162 * Otherwise, it finds the first suffix of any type. 163 */ 164 private int findSuffixOfType(Optional<PublicSuffixType> desiredType) { 165 final int partsSize = parts.size(); 166 167 for (int i = 0; i < partsSize; i++) { 168 String ancestorName = DOT_JOINER.join(parts.subList(i, partsSize)); 169 170 if (matchesType( 171 desiredType, Optional.fromNullable(PublicSuffixPatterns.EXACT.get(ancestorName)))) { 172 return i; 173 } 174 175 // Excluded domains (e.g. !nhs.uk) use the next highest 176 // domain as the effective public suffix (e.g. uk). 177 178 if (PublicSuffixPatterns.EXCLUDED.containsKey(ancestorName)) { 179 return i + 1; 180 } 181 182 if (matchesWildcardSuffixType(desiredType, ancestorName)) { 183 return i; 184 } 185 } 186 187 return NO_SUFFIX_FOUND; 188 } 189 190 /** 191 * Returns an instance of {@link InternetDomainName} after lenient validation. Specifically, 192 * validation against <a href="http://www.ietf.org/rfc/rfc3490.txt">RFC 3490</a> 193 * ("Internationalizing Domain Names in Applications") is skipped, while validation against <a 194 * href="http://www.ietf.org/rfc/rfc1035.txt">RFC 1035</a> is relaxed in the following ways: 195 * 196 * <ul> 197 * <li>Any part containing non-ASCII characters is considered valid. 198 * <li>Underscores ('_') are permitted wherever dashes ('-') are permitted. 199 * <li>Parts other than the final part may start with a digit, as mandated by <a 200 * href="https://tools.ietf.org/html/rfc1123#section-2">RFC 1123</a>. 201 * </ul> 202 * 203 * 204 * @param domain A domain name (not IP address) 205 * @throws IllegalArgumentException if {@code domain} is not syntactically valid according to 206 * {@link #isValid} 207 * @since 10.0 (previously named {@code fromLenient}) 208 */ 209 public static InternetDomainName from(String domain) { 210 return new InternetDomainName(checkNotNull(domain)); 211 } 212 213 /** 214 * Validation method used by {@code from} to ensure that the domain name is syntactically valid 215 * according to RFC 1035. 216 * 217 * @return Is the domain name syntactically valid? 218 */ 219 private static boolean validateSyntax(List<String> parts) { 220 final int lastIndex = parts.size() - 1; 221 222 // Validate the last part specially, as it has different syntax rules. 223 224 if (!validatePart(parts.get(lastIndex), true)) { 225 return false; 226 } 227 228 for (int i = 0; i < lastIndex; i++) { 229 String part = parts.get(i); 230 if (!validatePart(part, false)) { 231 return false; 232 } 233 } 234 235 return true; 236 } 237 238 private static final CharMatcher DASH_MATCHER = CharMatcher.anyOf("-_"); 239 240 private static final CharMatcher PART_CHAR_MATCHER = 241 CharMatcher.javaLetterOrDigit().or(DASH_MATCHER); 242 243 /** 244 * Helper method for {@link #validateSyntax(List)}. Validates that one part of a domain name is 245 * valid. 246 * 247 * @param part The domain name part to be validated 248 * @param isFinalPart Is this the final (rightmost) domain part? 249 * @return Whether the part is valid 250 */ 251 private static boolean validatePart(String part, boolean isFinalPart) { 252 253 // These tests could be collapsed into one big boolean expression, but 254 // they have been left as independent tests for clarity. 255 256 if (part.length() < 1 || part.length() > MAX_DOMAIN_PART_LENGTH) { 257 return false; 258 } 259 260 /* 261 * GWT claims to support java.lang.Character's char-classification methods, but it actually only 262 * works for ASCII. So for now, assume any non-ASCII characters are valid. The only place this 263 * seems to be documented is here: 264 * http://osdir.com/ml/GoogleWebToolkitContributors/2010-03/msg00178.html 265 * 266 * <p>ASCII characters in the part are expected to be valid per RFC 1035, with underscore also 267 * being allowed due to widespread practice. 268 */ 269 270 String asciiChars = CharMatcher.ascii().retainFrom(part); 271 272 if (!PART_CHAR_MATCHER.matchesAllOf(asciiChars)) { 273 return false; 274 } 275 276 // No initial or final dashes or underscores. 277 278 if (DASH_MATCHER.matches(part.charAt(0)) 279 || DASH_MATCHER.matches(part.charAt(part.length() - 1))) { 280 return false; 281 } 282 283 /* 284 * Note that we allow (in contravention of a strict interpretation of the relevant RFCs) domain 285 * parts other than the last may begin with a digit (for example, "3com.com"). It's important to 286 * disallow an initial digit in the last part; it's the only thing that stops an IPv4 numeric 287 * address like 127.0.0.1 from looking like a valid domain name. 288 */ 289 290 if (isFinalPart && CharMatcher.digit().matches(part.charAt(0))) { 291 return false; 292 } 293 294 return true; 295 } 296 297 /** 298 * Returns the individual components of this domain name, normalized to all lower case. For 299 * example, for the domain name {@code mail.google.com}, this method returns the list {@code 300 * ["mail", "google", "com"]}. 301 */ 302 public ImmutableList<String> parts() { 303 return parts; 304 } 305 306 /** 307 * Indicates whether this domain name represents a <i>public suffix</i>, as defined by the Mozilla 308 * Foundation's <a href="http://publicsuffix.org/">Public Suffix List</a> (PSL). A public suffix 309 * is one under which Internet users can directly register names, such as {@code com}, {@code 310 * co.uk} or {@code pvt.k12.wy.us}. Examples of domain names that are <i>not</i> public suffixes 311 * include {@code google.com}, {@code foo.co.uk}, and {@code myblog.blogspot.com}. 312 * 313 * <p>Public suffixes are a proper superset of {@linkplain #isRegistrySuffix() registry suffixes}. 314 * The list of public suffixes additionally contains privately owned domain names under which 315 * Internet users can register subdomains. An example of a public suffix that is not a registry 316 * suffix is {@code blogspot.com}. Note that it is true that all public suffixes <i>have</i> 317 * registry suffixes, since domain name registries collectively control all internet domain names. 318 * 319 * <p>For considerations on whether the public suffix or registry suffix designation is more 320 * suitable for your application, see <a 321 * href="https://github.com/google/guava/wiki/InternetDomainNameExplained">this article</a>. 322 * 323 * @return {@code true} if this domain name appears exactly on the public suffix list 324 * @since 6.0 325 */ 326 public boolean isPublicSuffix() { 327 return publicSuffixIndex == 0; 328 } 329 330 /** 331 * Indicates whether this domain name ends in a {@linkplain #isPublicSuffix() public suffix}, 332 * including if it is a public suffix itself. For example, returns {@code true} for {@code 333 * www.google.com}, {@code foo.co.uk} and {@code com}, but not for {@code invalid} or {@code 334 * google.invalid}. This is the recommended method for determining whether a domain is potentially 335 * an addressable host. 336 * 337 * <p>Note that this method is equivalent to {@link #hasRegistrySuffix()} because all registry 338 * suffixes are public suffixes <i>and</i> all public suffixes have registry suffixes. 339 * 340 * @since 6.0 341 */ 342 public boolean hasPublicSuffix() { 343 return publicSuffixIndex != NO_SUFFIX_FOUND; 344 } 345 346 /** 347 * Returns the {@linkplain #isPublicSuffix() public suffix} portion of the domain name, or {@code 348 * null} if no public suffix is present. 349 * 350 * @since 6.0 351 */ 352 public InternetDomainName publicSuffix() { 353 return hasPublicSuffix() ? ancestor(publicSuffixIndex) : null; 354 } 355 356 /** 357 * Indicates whether this domain name ends in a {@linkplain #isPublicSuffix() public suffix}, 358 * while not being a public suffix itself. For example, returns {@code true} for {@code 359 * www.google.com}, {@code foo.co.uk} and {@code myblog.blogspot.com}, but not for {@code com}, 360 * {@code co.uk}, {@code google.invalid}, or {@code blogspot.com}. 361 * 362 * <p>This method can be used to determine whether it will probably be possible to set cookies on 363 * the domain, though even that depends on individual browsers' implementations of cookie 364 * controls. See <a href="http://www.ietf.org/rfc/rfc2109.txt">RFC 2109</a> for details. 365 * 366 * @since 6.0 367 */ 368 public boolean isUnderPublicSuffix() { 369 return publicSuffixIndex > 0; 370 } 371 372 /** 373 * Indicates whether this domain name is composed of exactly one subdomain component followed by a 374 * {@linkplain #isPublicSuffix() public suffix}. For example, returns {@code true} for {@code 375 * google.com} {@code foo.co.uk}, and {@code myblog.blogspot.com}, but not for {@code 376 * www.google.com}, {@code co.uk}, or {@code blogspot.com}. 377 * 378 * <p>This method can be used to determine whether a domain is probably the highest level for 379 * which cookies may be set, though even that depends on individual browsers' implementations of 380 * cookie controls. See <a href="http://www.ietf.org/rfc/rfc2109.txt">RFC 2109</a> for details. 381 * 382 * @since 6.0 383 */ 384 public boolean isTopPrivateDomain() { 385 return publicSuffixIndex == 1; 386 } 387 388 /** 389 * Returns the portion of this domain name that is one level beneath the {@linkplain 390 * #isPublicSuffix() public suffix}. For example, for {@code x.adwords.google.co.uk} it returns 391 * {@code google.co.uk}, since {@code co.uk} is a public suffix. Similarly, for {@code 392 * myblog.blogspot.com} it returns the same domain, {@code myblog.blogspot.com}, since {@code 393 * blogspot.com} is a public suffix. 394 * 395 * <p>If {@link #isTopPrivateDomain()} is true, the current domain name instance is returned. 396 * 397 * <p>This method can be used to determine the probable highest level parent domain for which 398 * cookies may be set, though even that depends on individual browsers' implementations of cookie 399 * controls. 400 * 401 * @throws IllegalStateException if this domain does not end with a public suffix 402 * @since 6.0 403 */ 404 public InternetDomainName topPrivateDomain() { 405 if (isTopPrivateDomain()) { 406 return this; 407 } 408 checkState(isUnderPublicSuffix(), "Not under a public suffix: %s", name); 409 return ancestor(publicSuffixIndex - 1); 410 } 411 412 /** 413 * Indicates whether this domain name represents a <i>registry suffix</i>, as defined by a subset 414 * of the Mozilla Foundation's <a href="http://publicsuffix.org/">Public Suffix List</a> (PSL). A 415 * registry suffix is one under which Internet users can directly register names via a domain name 416 * registrar, and have such registrations lawfully protected by internet-governing bodies such as 417 * ICANN. Examples of registry suffixes include {@code com}, {@code co.uk}, and {@code 418 * pvt.k12.wy.us}. Examples of domain names that are <i>not</i> registry suffixes include {@code 419 * google.com} and {@code foo.co.uk}. 420 * 421 * <p>Registry suffixes are a proper subset of {@linkplain #isPublicSuffix() public suffixes}. The 422 * list of public suffixes additionally contains privately owned domain names under which Internet 423 * users can register subdomains. An example of a public suffix that is not a registry suffix is 424 * {@code blogspot.com}. Note that it is true that all public suffixes <i>have</i> registry 425 * suffixes, since domain name registries collectively control all internet domain names. 426 * 427 * <p>For considerations on whether the public suffix or registry suffix designation is more 428 * suitable for your application, see <a 429 * href="https://github.com/google/guava/wiki/InternetDomainNameExplained">this article</a>. 430 * 431 * @return {@code true} if this domain name appears exactly on the public suffix list as part of 432 * the registry suffix section (labelled "ICANN"). 433 * @since 23.3 434 */ 435 public boolean isRegistrySuffix() { 436 return registrySuffixIndex == 0; 437 } 438 439 /** 440 * Indicates whether this domain name ends in a {@linkplain #isRegistrySuffix() registry suffix}, 441 * including if it is a registry suffix itself. For example, returns {@code true} for {@code 442 * www.google.com}, {@code foo.co.uk} and {@code com}, but not for {@code invalid} or {@code 443 * google.invalid}. 444 * 445 * <p>Note that this method is equivalent to {@link #hasPublicSuffix()} because all registry 446 * suffixes are public suffixes <i>and</i> all public suffixes have registry suffixes. 447 * 448 * @since 23.3 449 */ 450 public boolean hasRegistrySuffix() { 451 return registrySuffixIndex != NO_SUFFIX_FOUND; 452 } 453 454 /** 455 * Returns the {@linkplain #isRegistrySuffix() registry suffix} portion of the domain name, or 456 * {@code null} if no registry suffix is present. 457 * 458 * @since 23.3 459 */ 460 public InternetDomainName registrySuffix() { 461 return hasRegistrySuffix() ? ancestor(registrySuffixIndex) : null; 462 } 463 464 /** 465 * Indicates whether this domain name ends in a {@linkplain #isRegistrySuffix() registry suffix}, 466 * while not being a registry suffix itself. For example, returns {@code true} for {@code 467 * www.google.com}, {@code foo.co.uk} and {@code blogspot.com}, but not for {@code com}, {@code 468 * co.uk}, or {@code google.invalid}. 469 * 470 * @since 23.3 471 */ 472 public boolean isUnderRegistrySuffix() { 473 return registrySuffixIndex > 0; 474 } 475 476 /** 477 * Indicates whether this domain name is composed of exactly one subdomain component followed by a 478 * {@linkplain #isRegistrySuffix() registry suffix}. For example, returns {@code true} for {@code 479 * google.com}, {@code foo.co.uk}, and {@code blogspot.com}, but not for {@code www.google.com}, 480 * {@code co.uk}, or {@code myblog.blogspot.com}. 481 * 482 * <p><b>Warning:</b> This method should not be used to determine the probable highest level 483 * parent domain for which cookies may be set. Use {@link #topPrivateDomain()} for that purpose. 484 * 485 * @since 23.3 486 */ 487 public boolean isTopDomainUnderRegistrySuffix() { 488 return registrySuffixIndex == 1; 489 } 490 491 /** 492 * Returns the portion of this domain name that is one level beneath the {@linkplain 493 * #isRegistrySuffix() registry suffix}. For example, for {@code x.adwords.google.co.uk} it 494 * returns {@code google.co.uk}, since {@code co.uk} is a registry suffix. Similarly, for {@code 495 * myblog.blogspot.com} it returns {@code blogspot.com}, since {@code com} is a registry suffix. 496 * 497 * <p>If {@link #isTopDomainUnderRegistrySuffix()} is true, the current domain name instance is 498 * returned. 499 * 500 * <p><b>Warning:</b> This method should not be used to determine whether a domain is probably the 501 * highest level for which cookies may be set. Use {@link #isTopPrivateDomain()} for that purpose. 502 * 503 * @throws IllegalStateException if this domain does not end with a registry suffix 504 * @since 23.3 505 */ 506 public InternetDomainName topDomainUnderRegistrySuffix() { 507 if (isTopDomainUnderRegistrySuffix()) { 508 return this; 509 } 510 checkState(isUnderRegistrySuffix(), "Not under a registry suffix: %s", name); 511 return ancestor(registrySuffixIndex - 1); 512 } 513 514 /** Indicates whether this domain is composed of two or more parts. */ 515 public boolean hasParent() { 516 return parts.size() > 1; 517 } 518 519 /** 520 * Returns an {@code InternetDomainName} that is the immediate ancestor of this one; that is, the 521 * current domain with the leftmost part removed. For example, the parent of {@code 522 * www.google.com} is {@code google.com}. 523 * 524 * @throws IllegalStateException if the domain has no parent, as determined by {@link #hasParent} 525 */ 526 public InternetDomainName parent() { 527 checkState(hasParent(), "Domain '%s' has no parent", name); 528 return ancestor(1); 529 } 530 531 /** 532 * Returns the ancestor of the current domain at the given number of levels "higher" (rightward) 533 * in the subdomain list. The number of levels must be non-negative, and less than {@code N-1}, 534 * where {@code N} is the number of parts in the domain. 535 * 536 * <p>TODO: Reasonable candidate for addition to public API. 537 */ 538 private InternetDomainName ancestor(int levels) { 539 return from(DOT_JOINER.join(parts.subList(levels, parts.size()))); 540 } 541 542 /** 543 * Creates and returns a new {@code InternetDomainName} by prepending the argument and a dot to 544 * the current name. For example, {@code InternetDomainName.from("foo.com").child("www.bar")} 545 * returns a new {@code InternetDomainName} with the value {@code www.bar.foo.com}. Only lenient 546 * validation is performed, as described {@link #from(String) here}. 547 * 548 * @throws NullPointerException if leftParts is null 549 * @throws IllegalArgumentException if the resulting name is not valid 550 */ 551 public InternetDomainName child(String leftParts) { 552 return from(checkNotNull(leftParts) + "." + name); 553 } 554 555 /** 556 * Indicates whether the argument is a syntactically valid domain name using lenient validation. 557 * Specifically, validation against <a href="http://www.ietf.org/rfc/rfc3490.txt">RFC 3490</a> 558 * ("Internationalizing Domain Names in Applications") is skipped. 559 * 560 * <p>The following two code snippets are equivalent: 561 * 562 * <pre>{@code 563 * domainName = InternetDomainName.isValid(name) 564 * ? InternetDomainName.from(name) 565 * : DEFAULT_DOMAIN; 566 * }</pre> 567 * 568 * <pre>{@code 569 * try { 570 * domainName = InternetDomainName.from(name); 571 * } catch (IllegalArgumentException e) { 572 * domainName = DEFAULT_DOMAIN; 573 * } 574 * }</pre> 575 * 576 * @since 8.0 (previously named {@code isValidLenient}) 577 */ 578 public static boolean isValid(String name) { 579 try { 580 from(name); 581 return true; 582 } catch (IllegalArgumentException e) { 583 return false; 584 } 585 } 586 587 /** 588 * Does the domain name match one of the "wildcard" patterns (e.g. {@code "*.ar"})? If a {@code 589 * desiredType} is specified, the wildcard pattern must also match that type. 590 */ 591 private static boolean matchesWildcardSuffixType( 592 Optional<PublicSuffixType> desiredType, String domain) { 593 List<String> pieces = DOT_SPLITTER.limit(2).splitToList(domain); 594 return pieces.size() == 2 595 && matchesType( 596 desiredType, Optional.fromNullable(PublicSuffixPatterns.UNDER.get(pieces.get(1)))); 597 } 598 599 /** 600 * If a {@code desiredType} is specified, returns true only if the {@code actualType} is 601 * identical. Otherwise, returns true as long as {@code actualType} is present. 602 */ 603 private static boolean matchesType( 604 Optional<PublicSuffixType> desiredType, Optional<PublicSuffixType> actualType) { 605 return desiredType.isPresent() ? desiredType.equals(actualType) : actualType.isPresent(); 606 } 607 608 /** Returns the domain name, normalized to all lower case. */ 609 @Override 610 public String toString() { 611 return name; 612 } 613 614 /** 615 * Equality testing is based on the text supplied by the caller, after normalization as described 616 * in the class documentation. For example, a non-ASCII Unicode domain name and the Punycode 617 * version of the same domain name would not be considered equal. 618 */ 619 @Override 620 public boolean equals(@Nullable Object object) { 621 if (object == this) { 622 return true; 623 } 624 625 if (object instanceof InternetDomainName) { 626 InternetDomainName that = (InternetDomainName) object; 627 return this.name.equals(that.name); 628 } 629 630 return false; 631 } 632 633 @Override 634 public int hashCode() { 635 return name.hashCode(); 636 } 637}