/*

 * 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.

 *

 * 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.

 */

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.io.PrintStream;

import java.net.Inet6Address;

import java.net.InetAddress;

import java.net.NetworkInterface;

import java.net.UnknownHostException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Enumeration;

import java.util.List;

/**

 * @test

 * @bug 8007373

 * @summary jdk7 backward compatibility serialization problem

 * @key intermittent

 */

public class Inet6AddressSerializationTest {

    static boolean failed;

    public static final int LOOPBACK_SCOPE_ID = 0;

    public static final byte[] IN6ADDR_ANY_INIT = { (byte) 0x00, (byte) 0x00,

            (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,

            (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,

            (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00 };

    public static final byte[] LOOPBACKIPV6ADDRESS = { (byte) 0x00,

            (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,

            (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,

            (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x01 };

    // fe80::21b:24ff:febd:f29c

    public static final byte[] E1000G0IPV6ADDRESS = { (byte) 0xfe, (byte) 0x80,

            (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,

            (byte) 0x00, (byte) 0x02, (byte) 0x1b, (byte) 0x24, (byte) 0xff,

            (byte) 0xfe, (byte) 0xbd, (byte) 0xf2, (byte) 0x9c };

    public static final String E1000G0HOSTNAME = "fe80:0:0:0:21b:24ff:febd:f29c%e1000g0";

    public static final String LOCALHOSTNAME = "localhost";

    public static final String NETWORK_IF_E1000G0 = "e1000g0";

    public static final String NETWORK_IF_LO0 = "lo0";

    public static final int SCOPE_ID_E1000G0 = 2;

    public static final int SCOPE_ID_LO0 = 1;

    public static final int SCOPE_ID_ZERO = 0;

    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();

        }

    }

    private static void runTests() throws UnknownHostException, Exception,

            IOException {

        byte[] thisHostIPV6Address = null;

        int scope_id = LOOPBACK_SCOPE_ID;

        System.out.println("Hostname: "

                + InetAddress.getLocalHost().getHostName());

        System.out.println("LocalHost isLoopback : "

                + InetAddress.getLocalHost().isLoopbackAddress());

        thisHostIPV6Address = getThisHostIPV6Address(InetAddress.getLocalHost()

                .getHostName());

        if (thisHostIPV6Address == null) {

            thisHostIPV6Address = IN6ADDR_ANY_INIT;

        }

        // testing JDK7 generated serialized loopback against locally generated

        // loopback address

        testInet6AddressSerialization(Inet6Address.getByAddress(InetAddress

                .getLoopbackAddress().getHostName(), LOOPBACKIPV6ADDRESS,

                scope_id), JDK7Inet6AddressSerialData);

        // testing JDK8 generated serialized loopback against locally generated

        // loopback address

        testInet6AddressSerialization(Inet6Address.getByAddress(InetAddress

                .getLoopbackAddress().getHostName(), LOOPBACKIPV6ADDRESS,

                scope_id), JDK8Inet6AddressSerialData);

        testInet6AddressSerialization(Inet6Address.getByAddress(InetAddress

                .getLocalHost().getHostName(), IN6ADDR_ANY_INIT, scope_id),

                null);

        testInet6AddressSerialization(Inet6Address.getByAddress(InetAddress

                .getLocalHost().getHostName(), thisHostIPV6Address, scope_id),

                null);

        testAllNetworkInterfaces();

        // test against lo0

        testSerializedLo0Inet6Address();

        testSerializedE1000gInet6Address();

        if (failed)

            throw new RuntimeException("Some tests failed, check output");

    }

    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;

    }

    static void testAllNetworkInterfaces() throws Exception {

        System.err.println("\n testAllNetworkInterfaces: \n ");

        for (Enumeration<NetworkInterface> e = NetworkInterface

                .getNetworkInterfaces(); e.hasMoreElements();) {

            NetworkInterface netIF = e.nextElement();

            for (Enumeration<InetAddress> iadrs = netIF.getInetAddresses(); iadrs

                    .hasMoreElements();) {

                InetAddress iadr = iadrs.nextElement();

                if (iadr instanceof Inet6Address) {

                    System.err.println("Test NetworkInterface:  " + netIF);

                    Inet6Address i6adr = (Inet6Address) iadr;

                    System.err.println("Testing with " + iadr);

                    System.err.println(" scoped iface: "

                            + i6adr.getScopedInterface());

                    testInet6AddressSerialization(i6adr, null);

                }

            }

        }

    }

    static void displayExpectedInet6Address(Inet6Address expectedInet6Address) {

        String expectedHostName = expectedInet6Address.getHostName();

        byte[] expectedAddress = expectedInet6Address.getAddress();

        String expectedHostAddress = expectedInet6Address.getHostAddress();

        int expectedScopeId = expectedInet6Address.getScopeId();

        NetworkInterface expectedNetIf = expectedInet6Address

                .getScopedInterface();

        System.err.println("Excpected HostName: " + expectedHostName);

        System.err.println("Expected Address: "

                + Arrays.toString(expectedAddress));

        System.err.println("Expected HostAddress: " + expectedHostAddress);

        System.err.println("Expected Scope Id " + expectedScopeId);

        System.err.println("Expected NetworkInterface " + expectedNetIf);

        System.err.println("Expected Inet6Address " + expectedInet6Address);

    }

    // test serialization deserialization of Inet6Address

    static void testInet6AddressSerialization(

            Inet6Address expectedInet6Address, byte[] serializedAddress)

            throws IOException {

        System.err.println("\n testInet6AddressSerialization:  enter \n");

        // displayExpectedInet6Address(expectedInet6Address);

        byte[] serialData = serializedAddress != null ? serializedAddress

                : generateSerializedInet6AddressData(expectedInet6Address,

                        null, false);

        try (ByteArrayInputStream bis = new ByteArrayInputStream(serialData);

                ObjectInputStream oin = new ObjectInputStream(bis)) {

            Inet6Address deserializedIPV6Addr = (Inet6Address) oin.readObject();

            System.err.println("Deserialized Inet6Address "

                    + deserializedIPV6Addr);

            assertHostNameEqual(expectedInet6Address.getHostName(),

                    deserializedIPV6Addr.getHostName());

            assertHostAddressEqual(expectedInet6Address.getHostAddress(),

                    deserializedIPV6Addr.getHostAddress());

            assertAddressEqual(expectedInet6Address.getAddress(),

                    deserializedIPV6Addr.getAddress());

            assertScopeIdEqual(expectedInet6Address.getScopeId(),

                    deserializedIPV6Addr.getScopeId());

            assertNetworkInterfaceEqual(

                    expectedInet6Address.getScopedInterface(),

                    deserializedIPV6Addr.getScopedInterface());

        } catch (Exception e) {

            System.err.println("Exception caught during deserialization");

            failed = true;

            e.printStackTrace();

        }

    }

    static void testSerializedE1000gInet6Address() throws IOException {

        System.err.println("\n testSerializedE1000gInet6Address:  enter \n");

        boolean testWithNetIf = true;

        boolean useMockInet6Address = false;

        NetworkInterface testNetIf = NetworkInterface

                .getByName(NETWORK_IF_E1000G0);

        Inet6Address expectedInet6Address = null;

        if (testNetIf != null) {

            System.err

                    .println("\n testSerializedE1000gInet6Address:  using netif \n");

            try {

                expectedInet6Address = Inet6Address.getByAddress(

                        E1000G0HOSTNAME, E1000G0IPV6ADDRESS, testNetIf);

            } catch (UnknownHostException ukhEx) {

                ukhEx.printStackTrace();

                testWithNetIf = true;

                useMockInet6Address = true;

            }

        } else {

            System.err

                    .println("\n testSerializedE1000gInet6Address:  using index \n");

            try {

                expectedInet6Address = Inet6Address.getByAddress(

                        E1000G0HOSTNAME, E1000G0IPV6ADDRESS, SCOPE_ID_ZERO);

            } catch (UnknownHostException ukhEx1) {

                ukhEx1.printStackTrace();

                useMockInet6Address = true;

            }

            testWithNetIf = false;

        }

        byte[] serializedAddress = SerialData_ifname_e1000g0;

        // displayExpectedInet6Address(expectedInet6Address);

        try (ByteArrayInputStream bis = new ByteArrayInputStream(

                serializedAddress);

                ObjectInputStream oin = new ObjectInputStream(bis)) {

            Inet6Address deserializedIPV6Addr = (Inet6Address) oin.readObject();

            System.err.println("Deserialized Inet6Address "

                    + deserializedIPV6Addr);

            if (!useMockInet6Address) {

                assertHostNameEqual(expectedInet6Address.getHostName(),

                        deserializedIPV6Addr.getHostName());

                if (testWithNetIf) {

                    assertHostAddressEqual(

                            expectedInet6Address.getHostAddress(),

                            deserializedIPV6Addr.getHostAddress());

                } else {

                    assertHostAddressEqual(

                            MockE1000g0Inet6Address.getBareHostAddress(),

                            deserializedIPV6Addr.getHostAddress());

                }

                assertAddressEqual(expectedInet6Address.getAddress(),

                        deserializedIPV6Addr.getAddress());

                assertScopeIdEqual(expectedInet6Address.getScopeId(),

                        deserializedIPV6Addr.getScopeId());

                if (testWithNetIf) {

                    assertNetworkInterfaceEqual(

                            expectedInet6Address.getScopedInterface(),

                            deserializedIPV6Addr.getScopedInterface());

                } else {

                    assertNetworkInterfaceEqual(null,

                            deserializedIPV6Addr.getScopedInterface());

                }

            } else { // use MockLo0Inet6Address

                assertHostNameEqual(MockE1000g0Inet6Address.getHostName(),

                        deserializedIPV6Addr.getHostName());

                if (testWithNetIf) {

                    assertHostAddressEqual(

                            MockE1000g0Inet6Address.getHostAddress(),

                            deserializedIPV6Addr.getHostAddress());

                } else {

                    assertHostAddressEqual(

                            MockE1000g0Inet6Address.getHostAddressWithIndex(),

                            deserializedIPV6Addr.getHostAddress());

                }

                assertAddressEqual(MockE1000g0Inet6Address.getAddress(),

                        deserializedIPV6Addr.getAddress());

                if (testWithNetIf) {

                assertScopeIdEqual(MockE1000g0Inet6Address.getScopeId(),

                        deserializedIPV6Addr.getScopeId());

                } else {

                    assertScopeIdEqual(MockE1000g0Inet6Address.getScopeZero(),

                            deserializedIPV6Addr.getScopeId());

                }

                assertNetworkInterfaceNameEqual(

                        MockE1000g0Inet6Address.getScopeIfName(),

                        deserializedIPV6Addr.getScopedInterface());

            }

        } catch (Exception e) {

            System.err.println("Exception caught during deserialization");

            failed = true;

            e.printStackTrace();

        }

    }

    static void testSerializedLo0Inet6Address() throws IOException {

        System.err.println("\n testSerializedLo0Inet6Address:  enter \n");

        boolean testWithNetIf = true;

        boolean useMockInet6Address = false;

        NetworkInterface testNetIf = NetworkInterface.getByName(NETWORK_IF_LO0);

        Inet6Address expectedInet6Address = null;

        if (testNetIf != null) {

            System.err

                    .println("\n testSerializedLo0Inet6Address:  using netif \n");

            try {

                expectedInet6Address = Inet6Address.getByAddress(LOCALHOSTNAME,

                        LOOPBACKIPV6ADDRESS, testNetIf);

            } catch (UnknownHostException ukhEx) {

                ukhEx.printStackTrace();

                testWithNetIf = true;

                useMockInet6Address = true;

            }

        } else {

            System.err

                    .println("\n testSerializedLo0Inet6Address:  using index \n");

            try {

                expectedInet6Address = Inet6Address.getByAddress(LOCALHOSTNAME,

                        LOOPBACKIPV6ADDRESS, SCOPE_ID_ZERO);

            } catch (UnknownHostException ukhEx1) {

                ukhEx1.printStackTrace();

                useMockInet6Address = true;

            }

            testWithNetIf = false;

        }

        // displayExpectedInet6Address(expectedInet6Address);

        byte[] serializedAddress = SerialData_ifname_lo0;

        try (ByteArrayInputStream bis = new ByteArrayInputStream(

                serializedAddress);

                ObjectInputStream oin = new ObjectInputStream(bis)) {

            Inet6Address deserializedIPV6Addr = (Inet6Address) oin.readObject();

            System.err.println("Deserialized Inet6Address "

                    + deserializedIPV6Addr);

            if (!useMockInet6Address) {

                assertHostNameEqual(expectedInet6Address.getHostName(),

                        deserializedIPV6Addr.getHostName());

                if (testWithNetIf) {

                    assertHostAddressEqual(

                            expectedInet6Address.getHostAddress(),

                            deserializedIPV6Addr.getHostAddress());

                } else {

                    assertHostAddressEqual(

                            MockLo0Inet6Address.getBareHostAddress(),

                            deserializedIPV6Addr.getHostAddress());

                }

                assertAddressEqual(expectedInet6Address.getAddress(),

                        deserializedIPV6Addr.getAddress());

                assertScopeIdEqual(expectedInet6Address.getScopeId(),

                        deserializedIPV6Addr.getScopeId());

                if (testWithNetIf) {

                    assertNetworkInterfaceEqual(

                            expectedInet6Address.getScopedInterface(),

                            deserializedIPV6Addr.getScopedInterface());

                } else {

                    assertNetworkInterfaceEqual(null,

                            deserializedIPV6Addr.getScopedInterface());

                }

            } else { // use MockLo0Inet6Address

                assertHostNameEqual(MockLo0Inet6Address.getHostName(),

                        deserializedIPV6Addr.getHostName());

                if (testWithNetIf) {

                    assertHostAddressEqual(

                            MockLo0Inet6Address.getHostAddress(),

                            deserializedIPV6Addr.getHostAddress());

                } else {

                    assertHostAddressEqual(

                            MockLo0Inet6Address.getHostAddressWithIndex(),

                            deserializedIPV6Addr.getHostAddress());

                }

                assertAddressEqual(MockLo0Inet6Address.getAddress(),

                        deserializedIPV6Addr.getAddress());

                if (testWithNetIf) {

                assertScopeIdEqual(MockLo0Inet6Address.getScopeId(),

                        deserializedIPV6Addr.getScopeId());

                } else {

                    assertScopeIdEqual(MockLo0Inet6Address.getScopeZero(),

                            deserializedIPV6Addr.getScopeId());

                }

                assertNetworkInterfaceNameEqual(

                        MockLo0Inet6Address.getScopeIfName(),

                        deserializedIPV6Addr.getScopedInterface());

            }

        } catch (Exception e) {

            System.err.println("Exception caught during deserialization");

            failed = true;

            e.printStackTrace();

        }

    }

    static List<Inet6Address> getAllInet6Addresses() throws Exception {

        // System.err.println("\n getAllInet6Addresses: \n ");

        ArrayList<Inet6Address> inet6Addresses = new ArrayList<Inet6Address>();

        for (Enumeration<NetworkInterface> e = NetworkInterface

                .getNetworkInterfaces(); e.hasMoreElements();) {

            NetworkInterface netIF = e.nextElement();

            for (Enumeration<InetAddress> iadrs = netIF.getInetAddresses(); iadrs

                    .hasMoreElements();) {

                InetAddress iadr = iadrs.nextElement();

                if (iadr instanceof Inet6Address) {

                    System.err.println("Test NetworkInterface:  " + netIF);

                    Inet6Address i6adr = (Inet6Address) iadr;

                    System.err.println(" address " + iadr);

                    System.err.println(" scoped iface: "

                            + i6adr.getScopedInterface());

                    // using this to actually set the hostName for an

                    // InetAddress

                    // created through the NetworkInterface

                    // have found that the fabricated instances has a null

                    // hostName

                    System.err.println(" hostName: " + i6adr.getHostName());

                    inet6Addresses.add(i6adr);

                }

            }

        }

        return inet6Addresses;

    }

    static void assertHostNameEqual(String expectedHostName,

            String deserializedHostName) {

        System.err

                .println("Inet6AddressSerializationTest.assertHostNameEqual:");

        if (expectedHostName == null) {

            if (deserializedHostName == null) {

                // ok, do nothing.

            } else {

                System.err.println("Error checking " + " HostName, expected:"

                        + expectedHostName + ", got :" + deserializedHostName);

                failed = true;

            }

        } else if (!expectedHostName.equals(deserializedHostName)) {

            System.err.println("Error checking "

                    + // versionStr +

                    " HostName, expected:" + expectedHostName + ", got :"

                    + deserializedHostName);

            failed = true;

        } else {

            System.err.println("HostName equality "

                    + // versionStr +

                    " HostName, expected:" + expectedHostName + ", got :"

                    + deserializedHostName);

        }

    }

    static void assertHostAddressEqual(String expectedHostAddress,

            String deserializedHostAddress) {

        System.err

                .println("Inet6AddressSerializationTest.assertHostAddressEqual:");

        if (expectedHostAddress == null) {

            if (deserializedHostAddress == null) {

                // ok, do nothing.

            } else {

                System.err.println("Error checking "

                        + " HostAddress, expected: " + expectedHostAddress

                        + ", got: " + deserializedHostAddress);

                failed = true;

            }

        } else if (!expectedHostAddress.equals(deserializedHostAddress)) {

            System.err.println("Error checking "

                    + // versionStr +

                    " HostAddress, expected: " + expectedHostAddress

                    + ", got: " + deserializedHostAddress);

            failed = true;

        } else {

            System.err.println("HostAddress equality "

                    + // versionStr +

                    " HostAddress, expected: " + expectedHostAddress

                    + ", got: " + deserializedHostAddress);