Java Code Examples for java.net.IDN#toUnicode()

/**
 * {@link java.net.IDN#toUnicode(String)}
 * @since 1.6
 */
public void test_ToUnicode_LString() {
    try {
        IDN.toUnicode(null);
        fail("should throw NullPointerException");
    } catch (NullPointerException e) {
        // expected
    }

    assertEquals("", IDN.toUnicode(""));
    assertEquals("www.bcher.de", IDN.toUnicode("www.bcher.de"));
    assertEquals("www.b\u00FCcher.de", IDN.toUnicode("www.b\u00FCcher.de"));
    assertEquals("www.\u65E5\u672C\u5E73.jp", IDN
            .toUnicode("www.\u65E5\u672C\u5E73.jp"));
    assertEquals("www.\u65E5\u672C\u5E73.jp", IDN.toUnicode("www\uFF0Exn--gwtq9nb2a\uFF61jp"));
    assertEquals("www.\u65E5\u672C\u5E73.jp", IDN.toUnicode("www.xn--gwtq9nb2a.jp"));
}
 

/**
 * Parse a domain name starting at the current offset and moving the input
 * stream pointer past this domain name (even if cross references occure).
 *
 * @param dis  The input stream.
 * @param data The raw data (for cross references).
 * @return The domain name string.
 * @throws IOException Should never happen.
 */
private static String readName(DataInputStream dis, byte data[])
        throws IOException {
    int c = dis.readUnsignedByte();
    if ((c & 0xc0) == 0xc0) {
        c = ((c & 0x3f) << 8) + dis.readUnsignedByte();
        HashSet<Integer> jumps = new HashSet<Integer>();
        jumps.add(c);
        return readName(data, c, jumps);
    }
    if (c == 0) {
        return "";
    }
    byte b[] = new byte[c];
    dis.readFully(b);
    String s = IDN.toUnicode(new String(b));
    String t = readName(dis, data);
    if (t.length() > 0) {
        s = s + "." + t;
    }
    return s;
}
 

/**
 * Parse a domain name starting at the current offset and moving the input
 * stream pointer past this domain name (even if cross references occure).
 *
 * @param dis  The input stream.
 * @param data The raw data (for cross references).
 * @return The domain name string.
 * @throws IOException Should never happen.
 */
private static String readName(DataInputStream dis, byte data[])
        throws IOException {
    int c = dis.readUnsignedByte();
    if ((c & 0xc0) == 0xc0) {
        c = ((c & 0x3f) << 8) + dis.readUnsignedByte();
        HashSet<Integer> jumps = new HashSet<Integer>();
        jumps.add(c);
        return readName(data, c, jumps);
    }
    if (c == 0) {
        return "";
    }
    byte b[] = new byte[c];
    dis.readFully(b);
    String s = IDN.toUnicode(new String(b));
    String t = readName(dis, data);
    if (t.length() > 0) {
        s = s + "." + t;
    }
    return s;
}
 

static Dns parse(String hostname) {
  int lastDot = -1;
  for (int i = 0; i < hostname.length(); i++) {
    char c = hostname.charAt(i);
    if (!DNS.matches(c)) {
      throw new InvalidHostException(hostname, i);
    } else if (c == '.') {
      if (lastDot == i - 1) {
        throw new InvalidHostException(hostname, i);
      }
      lastDot = i;
    }
  }
  String lower = hostname.toLowerCase(Locale.US);
  return new AutoValue_Dns(lower, IDN.toUnicode(lower));
}
 

/**
 * Returns true if name matches against template.<p>
 *
 * The matching is performed as per RFC 2818 rules for TLS and
 * RFC 2830 rules for LDAP.<p>
 *
 * The <code>name</code> parameter should represent a DNS name.  The
 * <code>template</code> parameter may contain the wildcard character '*'.
 */
private boolean isMatched(String name, String template,
                          boolean chainsToPublicCA) {

    // Normalize to Unicode, because PSL is in Unicode.
    try {
        name = IDN.toUnicode(IDN.toASCII(name));
        template = IDN.toUnicode(IDN.toASCII(template));
    } catch (RuntimeException re) {
        if (SSLLogger.isOn) {
            SSLLogger.fine("Failed to normalize to Unicode: " + re);
        }

        return false;
    }

    if (hasIllegalWildcard(template, chainsToPublicCA)) {
        return false;
    }

    // check the validity of the domain name template.
    try {
        // Replacing wildcard character '*' with 'z' so as to check
        // the domain name template validity.
        //
        // Using the checking implemented in SNIHostName
        new SNIHostName(template.replace('*', 'z'));
    } catch (IllegalArgumentException iae) {
        // It would be nice to add debug log if not matching.
        return false;
    }

    if (checkType == TYPE_TLS) {
        return matchAllWildcards(name, template);
    } else if (checkType == TYPE_LDAP) {
        return matchLeftmostWildcard(name, template);
    } else {
        return false;
    }
}
 

@Override
public Set<String> generateCandidates(String originalString) {
  Set<String> result = new HashSet<>();
  String domain = originalString;
  if(StringUtils.isEmpty(domain)) {
    return result;
  }
  if(isAce(domain)) {
    //this is an ace domain.
    domain = IDN.toUnicode(domain);
  }
  for(int ws = 0;ws < domain.length();ws++) {
    for(int i = 0;i < domain.length() - ws + 1;++i) {
      String win = domain.substring(i, i+ws);
      for(int j = 0;j < ws;j++) {
        char c = win.charAt(j);
        if( glyphs.containsKey(c)) {
          for( String g : glyphs.get(c)) {
            String winNew = win.replaceAll("" + c, g);
            String d = domain.substring(0, i) + winNew + domain.substring(i + ws);
            result.add(d);
            if(!isAce(d)) {
              try {
                String dAscii = IDN.toASCII(d, IDN.ALLOW_UNASSIGNED);
                if (!d.equals(dAscii)) {
                  result.add(dAscii);
                }
              }
              catch(IllegalArgumentException iae) {
                LOG.debug("Unable to parse " + d + ": " + iae.getMessage(), iae);
              }
            }
          }
        }
      }
    }
  }
  return result;
}
 

/**
 * Returns the effective top-level domain plus one (eTLD+1) by referencing the public suffix list.
 * Returns null if the domain is a public suffix.
 *
 * <p>Here are some examples: <pre>{@code
 * assertEquals("google.com", getEffectiveTldPlusOne("google.com"));
 * assertEquals("google.com", getEffectiveTldPlusOne("www.google.com"));
 * assertNull(getEffectiveTldPlusOne("com"));
 * }</pre>
 *
 * @param domain A canonicalized domain. An International Domain Name (IDN) should be punycode
 *    encoded.
 */
public String getEffectiveTldPlusOne(String domain) {
  if (domain == null) throw new NullPointerException("domain == null");

  // We use UTF-8 in the list so we need to convert to Unicode.
  String unicodeDomain = IDN.toUnicode(domain);
  String[] domainLabels = unicodeDomain.split("\\.");
  String[] rule = findMatchingRule(domainLabels);
  if (domainLabels.length == rule.length && rule[0].charAt(0) != EXCEPTION_MARKER) {
    // The domain is a public suffix.
    return null;
  }

  int firstLabelOffset;
  if (rule[0].charAt(0) == EXCEPTION_MARKER) {
    // Exception rules hold the effective TLD plus one.
    firstLabelOffset = domainLabels.length - rule.length;
  } else {
    // Otherwise the rule is for a public suffix, so we must take one more label.
    firstLabelOffset = domainLabels.length - (rule.length + 1);
  }

  StringBuilder effectiveTldPlusOne = new StringBuilder();
  String[] punycodeLabels = domain.split("\\.");
  for (int i = firstLabelOffset; i < punycodeLabels.length; i++) {
    effectiveTldPlusOne.append(punycodeLabels[i]).append('.');
  }
  effectiveTldPlusOne.deleteCharAt(effectiveTldPlusOne.length() - 1);

  return effectiveTldPlusOne.toString();
}
 

/**
 * Converts an internationalized domain name (IDN) in an URL to and from ASCII/Unicode.
 * @param url the URL where the domain name should be converted
 * @param toASCII if true converts from Unicode to ASCII, if false converts from ASCII to Unicode
 * @return the URL containing the converted domain name
 */
@TargetApi(Build.VERSION_CODES.GINGERBREAD)
public static String convertIdn(String url, boolean toASCII) {

    String urlNoDots = url;
    String dots="";
    while (urlNoDots.startsWith(".")) {
        urlNoDots = url.substring(1);
        dots = dots + ".";
    }

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD) {
        // Find host name after '//' or '@'
        int hostStart = 0;
        if  (urlNoDots.contains("//")) {
            hostStart = url.indexOf("//") + "//".length();
        } else if (url.contains("@")) {
            hostStart = url.indexOf("@") + "@".length();
        }

        int hostEnd = url.substring(hostStart).indexOf("/");
        // Handle URL which doesn't have a path (path is implicitly '/')
        hostEnd = (hostEnd == -1 ? urlNoDots.length() : hostStart + hostEnd);

        String host = urlNoDots.substring(hostStart, hostEnd);
        host = (toASCII ? IDN.toASCII(host) : IDN.toUnicode(host));

        return dots + urlNoDots.substring(0, hostStart) + host + urlNoDots.substring(hostEnd);
    } else {
        return dots + url;
    }
}
 

/**
 * Returns true if name matches against template.<p>
 *
 * The matching is performed as per RFC 2818 rules for TLS and
 * RFC 2830 rules for LDAP.<p>
 *
 * The <code>name</code> parameter should represent a DNS name.  The
 * <code>template</code> parameter may contain the wildcard character '*'.
 */
private boolean isMatched(String name, String template,
                          boolean chainsToPublicCA) {

    // Normalize to Unicode, because PSL is in Unicode.
    try {
        name = IDN.toUnicode(IDN.toASCII(name));
        template = IDN.toUnicode(IDN.toASCII(template));
    } catch (RuntimeException re) {
        if (SSLLogger.isOn) {
            SSLLogger.fine("Failed to normalize to Unicode: " + re);
        }

        return false;
    }

    if (hasIllegalWildcard(template, chainsToPublicCA)) {
        return false;
    }

    // check the validity of the domain name template.
    try {
        // Replacing wildcard character '*' with 'z' so as to check
        // the domain name template validity.
        //
        // Using the checking implemented in SNIHostName
        new SNIHostName(template.replace('*', 'z'));
    } catch (IllegalArgumentException iae) {
        // It would be nice to add debug log if not matching.
        return false;
    }

    if (checkType == TYPE_TLS) {
        return matchAllWildcards(name, template);
    } else if (checkType == TYPE_LDAP) {
        return matchLeftmostWildcard(name, template);
    } else {
        return false;
    }
}
 

/**
  * @return the hostname in IDN encoding
  */
public String getDecodedHostname() {
    return (hostname == null) ? null : IDN.toUnicode(hostname);
}
 

/**
 * Normalizes this IRI's components.
 * <p>
 * Because IRIs exist to identify resources, presumably they should be considered equivalent when they identify the
 * same resource. However, this definition of equivalence is not of much practical use, as there is no way for an
 * implementation to compare two resources unless it has full knowledge or control of them. Therefore, IRI
 * normalization is designed to minimize false negatives while strictly avoiding false positives.
 * <p>
 * <b>Case Normalization</b> the hexadecimal digits within a percent-encoding triplet (e.g., "%3a" versus "%3A") are
 * case-insensitive and are normalized to use uppercase letters for the digits A - F. The scheme and host are case
 * insensitive and are normalized to lowercase.
 * <p>
 * <b>Character Normalization</b> The Unicode Standard defines various equivalences between sequences of characters
 * for various purposes. Unicode Standard Annex defines various Normalization Forms for these equivalences and is
 * applied to the IRI components.
 * <p>
 * <b>Percent-Encoding Normalization</b> decodes any percent-encoded octet sequence that corresponds to an
 * unreserved character anywhere in the IRI.
 * <p>
 * <b>Path Segment Normalization</b> is the process of removing unnecessary {@code "."} and {@code ".."} segments
 * from the path component of a hierarchical IRI. Each {@code "."} segment is simply removed. A {@code ".."} segment
 * is removed only if it is preceded by a non-{@code ".."} segment or the start of the path.
 * <p>
 * <b>HTTP(S) Scheme Normalization</b> if the port uses the default port number or not given it is set to undefined.
 * An empty path is replaced with "/".
 * <p>
 * <b>File Scheme Normalization</b> if the host is "localhost" or empty it is set to undefined.
 * <p>
 * <b>Internationalized Domain Name Normalization</b> of the host component to Unicode.
 *
 * @return normalized IRI
 */
public ParsedIRI normalize() {
	String _scheme = toLowerCase(scheme);
	boolean optionalPort = isScheme("http") && 80 == port || isScheme("https") && 443 == port;
	int _port = optionalPort ? -1 : port;
	boolean localhost = isScheme("file") && userInfo == null && -1 == port
			&& ("".equals(host) || "localhost".equals(host));
	String _host = localhost ? null
			: host == null || host.length() == 0 ? host
					: IDN.toUnicode(pctEncodingNormalization(toLowerCase(host)),
							IDN.USE_STD3_ASCII_RULES | IDN.ALLOW_UNASSIGNED);
	String _path = _scheme != null && path == null ? "" : normalizePath(path);
	String _userInfo = pctEncodingNormalization(userInfo);
	String _query = pctEncodingNormalization(query);
	String _fragment = pctEncodingNormalization(fragment);
	ParsedIRI normalized = new ParsedIRI(_scheme, _userInfo, _host, _port, _path, _query, _fragment);
	if (this.iri.equals(normalized.iri)) {
		return this;
	} else {
		return normalized;
	}
}
 

public String host() {
    return IDN.toUnicode(this.host);
}
 

/**
  * @return the hostname in IDN encoding
  */
public String getDecodedHostname() {
    return (hostname == null) ? null : IDN.toUnicode(hostname);
}
 

/**
 * Returns host that is used as a parameter in {@link io.netty.handler.codec.socks.SocksCmdType}.
 * Host (BND.ADDR field in response) is address that server used when connecting to the target host.
 * This is typically different from address which client uses to connect to the SOCKS server.
 *
 * @return host that is used as a parameter in {@link io.netty.handler.codec.socks.SocksCmdType}
 *         or null when there was no host specified during response construction
 */
public String host() {
    if (host != null) {
        return IDN.toUnicode(host);
    } else {
        return null;
    }
}
 

/**
 * Decodes a domain name into UTF-8 if it is in Punycode ASCII.
 *
 * If the domain name was already UTF-8 nothing will happen. This
 * method saves the original format (Punycode or UTF-8) in
 * {@link #decoded}. {@link #recode(String)} can return the string
 * in the saved format.
 *
 * @param domain  the domain name, may be null
 * @return the UTF-8 domain name
 */
public String decode(final String domain) {
    if (domain == null) {
        return null;

    }
    String asciiDomain = IDN.toUnicode(domain);
    decoded = !asciiDomain.equals(domain);
    return asciiDomain;
}
 

/**
 * Get the primary hostname for this server
 * If hostname is IDN, it is decoded from Puny encoding
 * @return Returns the primary hostname for this server
 */
public String getDecodedHostname() {
    return (hostname == null) ? null : IDN.toUnicode(hostname);
}
 

/**
 * Returns host that is used as a parameter in {@link SocksCmdType}
 *
 * @return host that is used as a parameter in {@link SocksCmdType}
 */
public String host() {
    return IDN.toUnicode(host);
}
 

/**
 * Returns host that is used as a parameter in {@link SocksCmdType}.
 * Host (BND.ADDR field in response) is address that server used when connecting to the target host.
 * This is typically different from address which client uses to connect to the SOCKS server.
 *
 * @return host that is used as a parameter in {@link SocksCmdType}
 *         or null when there was no host specified during response construction
 */
public String host() {
    return host != null && addressType == SocksAddressType.DOMAIN ? IDN.toUnicode(host) : host;
}
 

/**
 * Returns host that is used as a parameter in {@link SocksCmdType}
 *
 * @return host that is used as a parameter in {@link SocksCmdType}
 */
public String host() {
    return addressType == SocksAddressType.DOMAIN ? IDN.toUnicode(host) : host;
}
 

/**
 * Get the primary hostname for this server
 * If hostname is IDN, it is decoded from Puny encoding
 * @return Returns the primary hostname for this server
 */
public String getDecodedHostname() {
    String hostname = getHostname();
    return (hostname == null) ? null : IDN.toUnicode(hostname);
}