Java 类java.net.Inet6Address 实例源码

public static void main(String[] args) throws Exception {
    // args[0] == generate-loopback generates serial data for loopback if
    // args[0] == generateAll generates serial data for interfaces with an
    // IPV6 address binding

    if (args.length != 0) {

        if (args[0].equals("generate-loopback")) {

            generateSerializedInet6AddressData(Inet6Address.getByAddress(
                    InetAddress.getLoopbackAddress().getHostName(),
                    LOOPBACKIPV6ADDRESS, LOOPBACK_SCOPE_ID), System.out,
                    true);

        } else {
            generateAllInet6AddressSerializedData();
        }
    } else {
        runTests();
    }
}

/**
     * When the user clicks the button to submit the ip address
     * this activity is finished and the ip is passed on as data to the previous activity.
     * @param view
     */
    public void onClickConnect(View view) {
        bootstrapView = (EditText) findViewById(R.id.bootstrap_IP);
        try{
            Object res = InetAddress.getByName(bootstrapView.getText().toString());
            if(!(res instanceof Inet4Address) && !(res instanceof Inet6Address)){
                Log.i("Bootstrap IP Adress: ", res.toString());
                throw new Exception("Bootstrap IP is not a valid IP4 or IP6 address.");
            }
            Intent returnIntent = new Intent();
            BootstrapIPStorage.setIP(this, bootstrapView.getText().toString());
            returnIntent.putExtra("ConnectableAddress",bootstrapView.getText().toString());
            setResult(OverviewConnectionsActivity.RESULT_OK,returnIntent);
            finish();
        } catch (Exception e){
            Toast.makeText(this, "The bootstrap IP address is not a valid IP address: " + bootstrapView.getText().toString(), Toast.LENGTH_SHORT).show();
//             e.printStackTrace();
        }
    }

private static byte[] getThisHostIPV6Address(String hostName)
        throws Exception {
    InetAddress[] thisHostIPAddresses = null;
    try {
        thisHostIPAddresses = InetAddress.getAllByName(InetAddress
                .getLocalHost().getHostName());
    } catch (UnknownHostException uhEx) {
        uhEx.printStackTrace();
        throw uhEx;
    }
    byte[] thisHostIPV6Address = null;
    for (InetAddress inetAddress : thisHostIPAddresses) {
        if (inetAddress instanceof Inet6Address) {
            if (inetAddress.getHostName().equals(hostName)) {
                thisHostIPV6Address = inetAddress.getAddress();
                break;
            }
        }
    }
    // System.err.println("getThisHostIPV6Address: address is "
    // + Arrays.toString(thisHostIPV6Address));
    return thisHostIPV6Address;
}

public ConnectionBean(ServerCnxn connection,ZooKeeperServer zk){
    this.connection = connection;
    this.stats = connection;
    this.zk = zk;

    InetSocketAddress sockAddr = connection.getRemoteSocketAddress();
    if (sockAddr == null) {
        remoteIP = "Unknown";
    } else {
        InetAddress addr = sockAddr.getAddress();
        if (addr instanceof Inet6Address) {
            remoteIP = ObjectName.quote(addr.getHostAddress());
        } else {
            remoteIP = addr.getHostAddress();
        }
    }
    sessionId = connection.getSessionId();
}

/**
 * Returns the string representation of an {@link InetAddress}.
 *
 * <p>For IPv4 addresses, this is identical to {@link InetAddress#getHostAddress()}, but for IPv6
 * addresses, the output follows <a href="http://tools.ietf.org/html/rfc5952">RFC 5952</a> section
 * 4. The main difference is that this method uses "::" for zero compression, while Java's version
 * uses the uncompressed form.
 *
 * <p>This method uses hexadecimal for all IPv6 addresses, including IPv4-mapped IPv6 addresses
 * such as "::c000:201". The output does not include a Scope ID.
 *
 * @param ip {@link InetAddress} to be converted to an address string
 * @return {@code String} containing the text-formatted IP address
 * @since 10.0
 */
public static String toAddrString(InetAddress ip) {
  checkNotNull(ip);
  if (ip instanceof Inet4Address) {
    // For IPv4, Java's formatting is good enough.
    return ip.getHostAddress();
  }
  checkArgument(ip instanceof Inet6Address);
  byte[] bytes = ip.getAddress();
  int[] hextets = new int[IPV6_PART_COUNT];
  for (int i = 0; i < hextets.length; i++) {
    hextets[i] = Ints.fromBytes((byte) 0, (byte) 0, bytes[2 * i], bytes[2 * i + 1]);
  }
  compressLongestRunOfZeroes(hextets);
  return hextetsToIPv6String(hextets);
}

/**
 * Returns the Teredo information embedded in a Teredo address.
 *
 * @param ip {@link Inet6Address} to be examined for embedded Teredo information
 * @return extracted {@code TeredoInfo}
 * @throws IllegalArgumentException if the argument is not a valid IPv6 Teredo address
 */
public static TeredoInfo getTeredoInfo(Inet6Address ip) {
  checkArgument(isTeredoAddress(ip), "Address '%s' is not a Teredo address.", toAddrString(ip));

  byte[] bytes = ip.getAddress();
  Inet4Address server = getInet4Address(Arrays.copyOfRange(bytes, 4, 8));

  int flags = ByteStreams.newDataInput(bytes, 8).readShort() & 0xffff;

  // Teredo obfuscates the mapped client port, per section 4 of the RFC.
  int port = ~ByteStreams.newDataInput(bytes, 10).readShort() & 0xffff;

  byte[] clientBytes = Arrays.copyOfRange(bytes, 12, 16);
  for (int i = 0; i < clientBytes.length; i++) {
    // Teredo obfuscates the mapped client IP, per section 4 of the RFC.
    clientBytes[i] = (byte) ~clientBytes[i];
  }
  Inet4Address client = getInet4Address(clientBytes);

  return new TeredoInfo(server, client, port, flags);
}

/**
 * Evaluates whether the argument is an ISATAP address.
 *
 * <p>From RFC 5214: "ISATAP interface identifiers are constructed in Modified EUI-64 format [...]
 * by concatenating the 24-bit IANA OUI (00-00-5E), the 8-bit hexadecimal value 0xFE, and a 32-bit
 * IPv4 address in network byte order [...]"
 *
 * <p>For more on ISATAP addresses see section 6.1 of
 * <a target="_parent" href="http://tools.ietf.org/html/rfc5214#section-6.1">RFC 5214</a>.
 *
 * @param ip {@link Inet6Address} to be examined for ISATAP address format
 * @return {@code true} if the argument is an ISATAP address
 */
public static boolean isIsatapAddress(Inet6Address ip) {

  // If it's a Teredo address with the right port (41217, or 0xa101)
  // which would be encoded as 0x5efe then it can't be an ISATAP address.
  if (isTeredoAddress(ip)) {
    return false;
  }

  byte[] bytes = ip.getAddress();

  if ((bytes[8] | (byte) 0x03) != (byte) 0x03) {

    // Verify that high byte of the 64 bit identifier is zero, modulo
    // the U/L and G bits, with which we are not concerned.
    return false;
  }

  return (bytes[9] == (byte) 0x00) && (bytes[10] == (byte) 0x5e) && (bytes[11] == (byte) 0xfe);
}

/**
 * Returns the Teredo information embedded in a Teredo address.
 *
 * @param ip {@link Inet6Address} to be examined for embedded Teredo information
 * @return extracted {@code TeredoInfo}
 * @throws IllegalArgumentException if the argument is not a valid IPv6 Teredo address
 */
public static TeredoInfo getTeredoInfo(Inet6Address ip) {
  checkArgument(isTeredoAddress(ip), "Address '%s' is not a Teredo address.", toAddrString(ip));

  byte[] bytes = ip.getAddress();
  Inet4Address server = getInet4Address(Arrays.copyOfRange(bytes, 4, 8));

  int flags = ByteStreams.newDataInput(bytes, 8).readShort() & 0xffff;

  // Teredo obfuscates the mapped client port, per section 4 of the RFC.
  int port = ~ByteStreams.newDataInput(bytes, 10).readShort() & 0xffff;

  byte[] clientBytes = Arrays.copyOfRange(bytes, 12, 16);
  for (int i = 0; i < clientBytes.length; i++) {
    // Teredo obfuscates the mapped client IP, per section 4 of the RFC.
    clientBytes[i] = (byte) ~clientBytes[i];
  }
  Inet4Address client = getInet4Address(clientBytes);

  return new TeredoInfo(server, client, port, flags);
}

private String getActiveNetworkInterfaceIP() throws SocketException {
    Enumeration<NetworkInterface>
            networkInterface = NetworkInterface.getNetworkInterfaces();
    String ipv6AddrStr = null;
    while (networkInterface.hasMoreElements()) {
        NetworkInterface nic = networkInterface.nextElement();
        if (nic.isUp() && !nic.isLoopback()) {
            Enumeration<InetAddress> inet = nic.getInetAddresses();
            while (inet.hasMoreElements()) {
                InetAddress addr = inet.nextElement();
                if (addr instanceof Inet4Address
                        && !addr.isLinkLocalAddress()) {
                    return addr.getHostAddress();
                }else if (addr instanceof Inet6Address
                        && !addr.isLinkLocalAddress()) {
                    /*
                    We save last seen IPv6 address which we will return
                    if we do not find any interface with IPv4 address.
                    */
                    ipv6AddrStr = addr.getHostAddress();
                }
            }
        }
    }
    return ipv6AddrStr;
}

private boolean ipVersionMatch(InetAddress addr) {
    if (opts.ipVersion() != null) {
        switch (opts.ipVersion()) {
            case V4: {
                return addr instanceof Inet4Address;
            }
            case V6: {
                return addr instanceof Inet6Address;
            }
            default: {
                throw new IllegalStateException("Unexpected IP version type: " + opts.ipVersion());
            }
        }
    }

    return true;
}

/**
 * Constructs new instance.
 *
 * @param cfg Configuration.
 *
 * @throws UnknownHostException If failed to resolve multicast group address.
 */
public MulticastSeedNodeProvider(MulticastSeedNodeProviderConfig cfg) throws UnknownHostException {
    ConfigCheck check = ConfigCheck.get(getClass());

    check.notNull(cfg, "configuration");
    check.positive(cfg.getPort(), "port");
    check.nonNegative(cfg.getTtl(), "TTL");
    check.notEmpty(cfg.getGroup(), "multicast group");
    check.positive(cfg.getInterval(), "discovery interval");
    check.positive(cfg.getWaitTime(), "wait time");
    check.that(cfg.getInterval() < cfg.getWaitTime(), "discovery interval must be greater than wait time "
        + "[discovery-interval=" + cfg.getInterval() + ", wait-time=" + cfg.getWaitTime() + ']');

    InetAddress groupAddress = InetAddress.getByName(cfg.getGroup());

    check.isTrue(groupAddress.isMulticastAddress(), "address is not a multicast address [address=" + groupAddress + ']');

    group = new InetSocketAddress(groupAddress, cfg.getPort());
    ttl = cfg.getTtl();
    interval = cfg.getInterval();
    waitTime = cfg.getWaitTime();
    loopBackDisabled = cfg.isLoopBackDisabled();

    ipVer = group.getAddress() instanceof Inet6Address ? InternetProtocolFamily.IPv6 : InternetProtocolFamily.IPv4;
}

private static byte[] getThisHostIPV6Address(String hostName)
        throws Exception {
    InetAddress[] thisHostIPAddresses = null;
    try {
        thisHostIPAddresses = InetAddress.getAllByName(InetAddress
                .getLocalHost().getHostName());
    } catch (UnknownHostException uhEx) {
        uhEx.printStackTrace();
        throw uhEx;
    }
    byte[] thisHostIPV6Address = null;
    for (InetAddress inetAddress : thisHostIPAddresses) {
        if (inetAddress instanceof Inet6Address) {
            if (inetAddress.getHostName().equals(hostName)) {
                thisHostIPV6Address = inetAddress.getAddress();
                break;
            }
        }
    }
    // System.err.println("getThisHostIPV6Address: address is "
    // + Arrays.toString(thisHostIPV6Address));
    return thisHostIPV6Address;
}

public static void main(String... args) throws Exception {
    NetworkConfiguration.printSystemConfiguration(out);

    NetworkConfiguration nc = NetworkConfiguration.probe();
    String list;
    list = nc.ip4MulticastInterfaces()
              .map(NetworkInterface::getName)
              .collect(joining(" "));
    out.println("ip4MulticastInterfaces: " +  list);

    list = nc.ip4Addresses()
              .map(Inet4Address::toString)
              .collect(joining(" "));
    out.println("ip4Addresses: " +  list);

    list = nc.ip6MulticastInterfaces()
              .map(NetworkInterface::getName)
              .collect(joining(" "));
    out.println("ip6MulticastInterfaces: " +  list);

    list = nc.ip6Addresses()
              .map(Inet6Address::toString)
              .collect(joining(" "));
    out.println("ip6Addresses: " +  list);
}

private InetAddress addDnsServer(Builder builder, String format, byte[] ipv6Template, InetAddress address) throws UnknownHostException {
    int size = dnsServers.size();
    size++;
    if (address instanceof Inet6Address && ipv6Template == null) {
        Log.i(TAG, "addDnsServer: Ignoring DNS server " + address);
    } else if (address instanceof Inet4Address) {
        String alias = String.format(format, size + 1);
        dnsServers.put(alias, address.getHostAddress());
        builder.addRoute(alias, 32);
        return InetAddress.getByName(alias);
    } else if (address instanceof Inet6Address) {
        ipv6Template[ipv6Template.length - 1] = (byte) (size + 1);
        InetAddress i6addr = Inet6Address.getByAddress(ipv6Template);
        dnsServers.put(i6addr.getHostAddress(), address.getHostAddress());
        return i6addr;
    }
    return null;
}

@Override
public void writeTo(DataOutput out) throws Exception {
  if (ip_addr != null) {
    byte[] address = ip_addr.getAddress(); // 4 bytes (IPv4) or 16 bytes (IPv6)
    out.writeByte(address.length); // 1 byte
    out.write(address, 0, address.length);
    if (ip_addr instanceof Inet6Address)
      out.writeInt(((Inet6Address) ip_addr).getScopeId());
  } else {
    out.writeByte(0);
  }
  out.writeShort(port);
  out.writeInt(vmViewId);
  out.writeLong(mostSigBits);
  out.writeLong(leastSigBits);
}

public boolean send(V2GTPMessage message, Inet6Address udpClientAddress, int udpClientPort) {
     byte[] v2gTPMessage = message.getMessage();
    // Set up the UDP packet containing the V2GTP message to be sent to the UDP client
    DatagramPacket udpServerPacket = new DatagramPacket(v2gTPMessage, 
                                                        v2gTPMessage.length,
                                                        udpClientAddress,
                                                        udpClientPort);

    // Send the response to the UDP client
    try {
        udpServerSocket.send(udpServerPacket);
        getLogger().debug("Message sent");

        return true;
    } catch (IOException e) {
        getLogger().error("UDP response failed (IOException) while trying to send message!", e);
        return false;
    }
}

public void setData(InetAddress data) {
    if (data instanceof Inet4Address) {
        this.addressType = ADDRESS_TYPE_IPv4;
        this.address = data;
        byteData = new byte[6];
        byteData[1] = ADDRESS_TYPE_IPv4;
        System.arraycopy(data.getAddress(), 0, byteData, 2, 4);
        addDataLength(6);
    } else if (data instanceof Inet6Address) {
        this.addressType = ADDRESS_TYPE_IPv6;
        this.address = data;
        byteData = new byte[18];
        byteData[1] = ADDRESS_TYPE_IPv6;
        System.arraycopy(data.getAddress(), 0, byteData, 2, 16);
        addDataLength(18);
    } else {
        // TODO: Throw Custom Error
    }
}

public void addDefaultSerializers() {

        // InetAddress
        addSerializer(converters, InetAddress.class, (value) -> {
            return value.getCanonicalHostName();
        });
        addSerializer(converters, Inet4Address.class, (value) -> {
            return value.getCanonicalHostName();
        });
        addSerializer(converters, Inet6Address.class, (value) -> {
            return value.getCanonicalHostName();
        });

        // UUID
        addSerializer(converters, UUID.class, (value) -> {
            return value.toString();
        });
    }

public static final Genson create(boolean pretty) {
    GensonBuilder builder = new GensonBuilder();

    // Install MongoDB / BSON serializers
    tryToAddSerializers("io.datatree.dom.adapters.JsonGensonBsonSerializers", builder);

    // Install serializers for Apache Cassandra
    addSerializer(builder, InetAddress.class, (value, writer, ctx) -> {
        writer.writeString(value.getCanonicalHostName());
    });
    addSerializer(builder, Inet4Address.class, (value, writer, ctx) -> {
        writer.writeString(value.getCanonicalHostName());
    });
    addSerializer(builder, Inet6Address.class, (value, writer, ctx) -> {
        writer.writeString(value.getCanonicalHostName());
    });

    // Set Date format
    builder.useDateAsTimestamp(!Config.USE_TIMESTAMPS);
    if (Config.USE_TIMESTAMPS) {
        builder.useDateFormat(new SimpleDateFormat(Config.TIMESTAMP_FORMAT));
    }
    builder.useIndentation(pretty);
    return builder.create();
}

/**
 * Converts an InetAddress into an IP address.
 *
 * @param inetAddress the InetAddress value to use
 * @return an IP address
 * @throws IllegalArgumentException if the argument is invalid
 */
public static IpAddress valueOf(InetAddress inetAddress) {
    byte[] bytes = inetAddress.getAddress();
    if (inetAddress instanceof Inet4Address) {
        return new IpAddress(Version.INET, bytes);
    }
    if (inetAddress instanceof Inet6Address) {
        return new IpAddress(Version.INET6, bytes);
    }
    // Use the number of bytes as a hint
    if (bytes.length == INET_BYTE_LENGTH) {
        return new IpAddress(Version.INET, bytes);
    }
    if (bytes.length == INET6_BYTE_LENGTH) {
        return new IpAddress(Version.INET6, bytes);
    }
    final String msg = "Unrecognized IP version address string: " +
        inetAddress.toString();
    throw new IllegalArgumentException(msg);
}

@Override
public DHTPluginContact
importContact(
    InetSocketAddress               address,
    byte                            version )
{
    if ( !isEnabled()){

        throw( new RuntimeException( "DHT isn't enabled" ));
    }

    InetAddress contact_address = address.getAddress();

    for ( DHTPluginImpl dht: dhts ){

        InetAddress dht_address = dht.getLocalAddress().getAddress().getAddress();

        if (    ( contact_address instanceof Inet4Address && dht_address instanceof Inet4Address ) ||
                ( contact_address instanceof Inet6Address && dht_address instanceof Inet6Address )){

            return( dht.importContact( address, version ));
        }
    }

    return( null );
}

public static void main(String[] args) throws Exception {
    // args[0] == generate-loopback generates serial data for loopback if
    // args[0] == generateAll generates serial data for interfaces with an
    // IPV6 address binding

    if (args.length != 0) {

        if (args[0].equals("generate-loopback")) {

            generateSerializedInet6AddressData(Inet6Address.getByAddress(
                    InetAddress.getLoopbackAddress().getHostName(),
                    LOOPBACKIPV6ADDRESS, LOOPBACK_SCOPE_ID), System.out,
                    true);

        } else {
            generateAllInet6AddressSerializedData();
        }
    } else {
        runTests();
    }
}

/**
 * Create a new broadcaster
 *
 * @param address - multicast group address
 * @param srcAddress - address of interface we should use to broadcast.
 * @param port - udp port to use
 * @param ttl - packet ttl
 * @throws IOException
 */
public JdpBroadcaster(InetAddress address, InetAddress srcAddress, int port, int ttl)
        throws IOException, JdpException {
    this.addr = address;
    this.port = port;

    ProtocolFamily family = (address instanceof Inet6Address)
            ? StandardProtocolFamily.INET6 : StandardProtocolFamily.INET;

    channel = DatagramChannel.open(family);
    channel.setOption(StandardSocketOptions.SO_REUSEADDR, true);
    channel.setOption(StandardSocketOptions.IP_MULTICAST_TTL, ttl);

    // with srcAddress equal to null, this constructor do exactly the same as
    // if srcAddress is not passed
    if (srcAddress != null) {
        // User requests particular interface to bind to
        NetworkInterface interf = NetworkInterface.getByInetAddress(srcAddress);

        if (interf == null) {
            throw new JdpException("Unable to get network interface for " + srcAddress.toString());
        }

        if (!interf.isUp()) {
            throw new JdpException(interf.getName() + " is not up.");
        }

        if (!interf.supportsMulticast()) {
            throw new JdpException(interf.getName() + " does not support multicast.");
        }

        try {
            channel.bind(new InetSocketAddress(srcAddress, 0));
        } catch (UnsupportedAddressTypeException ex) {
            throw new JdpException("Unable to bind to source address");
        }
        channel.setOption(StandardSocketOptions.IP_MULTICAST_IF, interf);
    }
}

private static String createOutputFileName(Inet6Address inet6Addr) {
    String inet6AddressOutputFilename;
    if (inet6Addr.getScopedInterface() != null) {
        inet6AddressOutputFilename = "IPV6Address_"
                + inet6Addr.getScopedInterface().getName() + ".out";
    } else {
        inet6AddressOutputFilename = "IPV6Address_"
                + Integer.valueOf(inet6Addr.getScopeId()).toString()
                + ".out";
    }
    return inet6AddressOutputFilename;
}

@Test
@Ignore
public void testConnectIPv6LocalAddress() throws Exception {
    for(String address : Arrays.asList("fe80::c62c:3ff:fe0b:8670")) {
        final Socket socket = new ProxySocketFactory(new TestProtocol(), new TrustManagerHostnameCallback() {
            @Override
            public String getTarget() {
                return "localhost";
            }
        }).withBlacklistedNetworkInterfaces(Arrays.asList("awdl0")).createSocket(address, 22);
        assertNotNull(socket);
        assertTrue(socket.getInetAddress() instanceof Inet6Address);
    }
}

/**
 * Sets the local InetAddress's.
 */
private void setLocalInetAddresses() {

    try {
        Enumeration<NetworkInterface> nets = NetworkInterface.getNetworkInterfaces();
        for (NetworkInterface netint : Collections.list(nets)) {

            Enumeration<InetAddress> inetAddresses = netint.getInetAddresses();
            if (inetAddresses.hasMoreElements()) {
                // System.out.printf("Display name: %s\n",
                // netint.getDisplayName());
                // System.out.printf("Name: %s\n", netint.getName());
                for (InetAddress inetAddress : Collections.list(inetAddresses)) {
                    if (inetAddress instanceof Inet4Address) {
                        if (this.getLocalIP4InetAddresses().contains(inetAddress)==false) {
                            this.getLocalIP4InetAddresses().add(inetAddress);   
                        }

                    } else if (inetAddress instanceof Inet6Address) {
                        if (this.getLocalIP6InetAddresses().contains(inetAddress)==false) {
                            this.getLocalIP6InetAddresses().add(inetAddress);   
                        }

                    }
                }
            }
        }

    } catch (SocketException e) {
        System.err.println("Error retrieving local network addresses list ... ");
    }
}

protected void assumeIPv6Available() {
    try {
        InetAddress address = Inet6Address.getByName("0:0:0:0:0:0:0:1");
        Assume.assumeTrue(address.isReachable(1000));
    } catch (IOException exception) {
        Assume.assumeTrue(false);
    }
}

@Override
public String toString() {

    String description = null; 
    switch (this.getInetAddressType()) {
    case Inet4Address:
        description = "[IP4] " + this.inetAddress.getHostAddress() + " (" + this.networkInterface.getName() + " - " + this.networkInterface.getDisplayName() + ")";
        break;

    case Inet6Address:
        description = "[IP6] " + this.inetAddress.getHostAddress() + " (" + this.networkInterface.getName() + " - " + this.networkInterface.getDisplayName() + ")";
        break;
    }
    return description;
}

public static String getHostIP() {

        String hostIp = null;
        try {
            Enumeration nis = NetworkInterface.getNetworkInterfaces();
            InetAddress ia = null;
            while (nis.hasMoreElements()) {
                NetworkInterface ni = (NetworkInterface) nis.nextElement();
                Enumeration<InetAddress> ias = ni.getInetAddresses();
                while (ias.hasMoreElements()) {
                    ia = ias.nextElement();
                    if (ia instanceof Inet6Address) {
                        continue;// skip ipv6
                    }
                    String ip = ia.getHostAddress();
                    if (!"127.0.0.1".equals(ip)) {
                        hostIp = ia.getHostAddress();
                        break;
                    }
                }
            }
        } catch (SocketException e) {
            // Log.i("yao", "SocketException");
            e.printStackTrace();
        }
        return hostIp;

    }

@Test
public void testOneIpv6() {
  runCommonTestsWith(
      AuthorityClassifiers.builder()
      .host(InetAddresses.forUriString("[3ffe:0:0:0:0:0:0:1]"))
      .build(),
      "http://[3ffe:0:0:0:0:0:0:1]/"
      );
  runCommonTestsWith(
      AuthorityClassifiers.builder()
      .host((Inet6Address) InetAddresses.forUriString("[3ffe:0:0:0:0:0:0:1]"))
      .build(),
      "http://[3ffe:0:0:0:0:0:0:1]/"
      );
}

/**
 * The broadcast mac address for a icmpv6 request is replaced all bytes with 33:33:ff except the last thress bytes
 * fe80::250:56ff:fe95:f8d -> 33:33:ff:95:0f:8d
 *
 * @param inet6Address
 * @return
 */
private MacAddress _getBroadcastMacAddress4IPv6(Inet6Address inet6Address) {
    byte[] ipInBytes = inet6Address.getAddress();
    byte[] broadcastMacAddress = new byte[_IPv6_BROADCAST_MACADDRESS_PREFIX.length];
    System.arraycopy(_IPv6_BROADCAST_MACADDRESS_PREFIX, 0, broadcastMacAddress, 0, _IPv6_BROADCAST_MACADDRESS_PREFIX.length);
    int reservedBytes = 3;
    System.arraycopy(ipInBytes, ipInBytes.length - reservedBytes, broadcastMacAddress, _IPv6_BROADCAST_MACADDRESS_PREFIX.length -
            reservedBytes, reservedBytes);
    return MacAddress.getByAddress(broadcastMacAddress);
}

public static String normalizeHostAddress(final InetAddress localHost) {
    if (localHost instanceof Inet6Address) {
        return "[" + localHost.getHostAddress() + "]";
    }
    else {
        return localHost.getHostAddress();
    }
}

/***
 * A convenience method to send the FTP EPRT command to the server,
 * receive the reply, and return the reply code.
 *
 * Examples:
 * <code>
 * <ul>
 * <li>EPRT |1|132.235.1.2|6275|</li>
 * <li>EPRT |2|1080::8:800:200C:417A|5282|</li>
 * </ul>
 * </code>
 * <p>
 * @see "http://www.faqs.org/rfcs/rfc2428.html"
 *
 * @param host  The host owning the port.
 * @param port  The new port.
 * @return The reply code received from the server.
 * @exception FTPConnectionClosedException
 *      If the FTP server prematurely closes the connection as a result
 *      of the client being idle or some other reason causing the server
 *      to send FTP reply code 421.  This exception may be caught either
 *      as an IOException or independently as itself.
 * @exception IOException  If an I/O error occurs while either sending the
 *      command or receiving the server reply.
 * @since 2.2
 ***/
public int eprt(InetAddress host, int port) throws IOException
{
    int num;
    StringBuilder info = new StringBuilder();
    String h;

    // If IPv6, trim the zone index
    h = host.getHostAddress();
    num = h.indexOf("%");
    if (num > 0) {
        h = h.substring(0, num);
    }

    info.append("|");

    if (host instanceof Inet4Address) {
        info.append("1");
    } else if (host instanceof Inet6Address) {
        info.append("2");
    }
    info.append("|");
    info.append(h);
    info.append("|");
    info.append(port);
    info.append("|");

    return sendCommand(FTPCommand.EPRT, info.toString());
}

/** format internet address: java's default doesn't include everything useful */
private static String formatAddress(InterfaceAddress interfaceAddress) throws IOException {
    StringBuilder sb = new StringBuilder();

    InetAddress address = interfaceAddress.getAddress();
    if (address instanceof Inet6Address) {
        sb.append("inet6 ");
        sb.append(NetworkAddress.format(address));
        sb.append(" prefixlen:");
        sb.append(interfaceAddress.getNetworkPrefixLength());
    } else {
        sb.append("inet ");
        sb.append(NetworkAddress.format(address));
        int netmask = 0xFFFFFFFF << (32 - interfaceAddress.getNetworkPrefixLength());
        sb.append(" netmask:" + NetworkAddress.format(InetAddress.getByAddress(new byte[] {
                (byte)(netmask >>> 24),
                (byte)(netmask >>> 16 & 0xFF),
                (byte)(netmask >>> 8 & 0xFF),
                (byte)(netmask & 0xFF)
        })));
        InetAddress broadcast = interfaceAddress.getBroadcast();
        if (broadcast != null) {
            sb.append(" broadcast:" + NetworkAddress.format(broadcast));
        }
    }
    if (address.isLoopbackAddress()) {
        sb.append(" scope:host");
    } else if (address.isLinkLocalAddress()) {
        sb.append(" scope:link");
    } else if (address.isSiteLocalAddress()) {
        sb.append(" scope:site");
    }
    return sb.toString();
}

/** Returns only the IPV6 addresses in {@code addresses} */
static InetAddress[] filterIPV6(InetAddress addresses[]) {
    List<InetAddress> list = new ArrayList<>();
    for (InetAddress address : addresses) {
        if (address instanceof Inet6Address) {
            list.add(address);
        }
    }
    if (list.isEmpty()) {
        throw new IllegalArgumentException("No ipv6 addresses found in " + Arrays.toString(addresses));
    }
    return list.toArray(new InetAddress[list.size()]);
}

public static InetAddress getIpAddress() throws SocketException {
  return getIpAddress(new AddressSelectionCondition() {
    @Override
    public boolean isAcceptableAddress(InetAddress addr) {
      return addr instanceof Inet4Address || addr instanceof Inet6Address;
    }
  });
}

/**
 * Returns all the IP addresses of the local host.
 */
public static HostAddresses getLocalAddresses() throws IOException
{
    String hostname = null;
    InetAddress[] inetAddresses = null;
    try {
        InetAddress localHost = InetAddress.getLocalHost();
        hostname = localHost.getHostName();
        inetAddresses = InetAddress.getAllByName(hostname);
        HostAddress[] hAddresses = new HostAddress[inetAddresses.length];
        for (int i = 0; i < inetAddresses.length; i++)
            {
                hAddresses[i] = new HostAddress(inetAddresses[i]);
            }
        if (DEBUG) {
            System.out.println(">>> KrbKdcReq local addresses for "
                               + hostname + " are: ");

            for (int i = 0; i < inetAddresses.length; i++) {
                System.out.println("\n\t" + inetAddresses[i]);
                if (inetAddresses[i] instanceof Inet4Address)
                    System.out.println("IPv4 address");
                if (inetAddresses[i] instanceof Inet6Address)
                    System.out.println("IPv6 address");
            }
        }
        return (new HostAddresses(hAddresses));
    } catch (Exception exc) {
        throw new IOException(exc.toString());
    }

}

/**
 * Returns all the IP addresses of the local host.
 */
public static HostAddresses getLocalAddresses() throws IOException
{
    String hostname = null;
    InetAddress[] inetAddresses = null;
    try {
        InetAddress localHost = InetAddress.getLocalHost();
        hostname = localHost.getHostName();
        inetAddresses = InetAddress.getAllByName(hostname);
        HostAddress[] hAddresses = new HostAddress[inetAddresses.length];
        for (int i = 0; i < inetAddresses.length; i++)
            {
                hAddresses[i] = new HostAddress(inetAddresses[i]);
            }
        if (DEBUG) {
            System.out.println(">>> KrbKdcReq local addresses for "
                               + hostname + " are: ");

            for (int i = 0; i < inetAddresses.length; i++) {
                System.out.println("\n\t" + inetAddresses[i]);
                if (inetAddresses[i] instanceof Inet4Address)
                    System.out.println("IPv4 address");
                if (inetAddresses[i] instanceof Inet6Address)
                    System.out.println("IPv6 address");
            }
        }
        return (new HostAddresses(hAddresses));
    } catch (Exception exc) {
        throw new IOException(exc.toString());
    }

}

@Nullable
public static String scrubInetAddress(InetAddress address) {
    // don't scrub link and site local addresses
    if (address.isLinkLocalAddress() || address.isSiteLocalAddress())
        return address.toString();
    // completely scrub IPv6 addresses
    if (address instanceof Inet6Address) return "[scrubbed]";
    // keep first and last octet of IPv4 addresses
    return scrubInetAddress(address.toString());
}

@Nullable
public static String scrubInetAddress(InetAddress address) {
    // don't scrub link and site local addresses
    if (address.isLinkLocalAddress() || address.isSiteLocalAddress())
        return address.toString();
    // completely scrub IPv6 addresses
    if (address instanceof Inet6Address) return "[scrubbed]";
    // keep first and last octet of IPv4 addresses
    return scrubInetAddress(address.toString());
}