/*

 * Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.

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

 */

/*

 * @test

 * @bug 4865397

 * @summary Tests remote JMX connections

 * @author Eamonn McManus

 * @modules java.management

 * @run clean ConnectionTest

 * @run build ConnectionTest

 * @run main ConnectionTest

 */

import java.io.IOException;

import java.net.MalformedURLException;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.LinkedList;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.StringTokenizer;

import java.security.Principal;

import java.util.regex.Pattern;

import javax.security.auth.Subject;

import javax.management.MBeanServer;

import javax.management.MBeanServerConnection;

import javax.management.MBeanServerFactory;

import javax.management.Notification;

import javax.management.NotificationListener;

import javax.management.ObjectName;

import javax.management.remote.JMXAuthenticator;

import javax.management.remote.JMXConnectionNotification;

import javax.management.remote.JMXConnector;

import javax.management.remote.JMXConnectorFactory;

import javax.management.remote.JMXConnectorServer;

import javax.management.remote.JMXConnectorServerFactory;

import javax.management.remote.JMXPrincipal;

import javax.management.remote.JMXServiceURL;

public class ConnectionTest {

    public static void main(String[] args) {

//      System.setProperty("java.util.logging.config.file",

//                         "../../../../logging.properties");

//      // we are in <workspace>/build/test/JTwork/scratch

//      java.util.logging.LogManager.getLogManager().readConfiguration();

        boolean ok = true;

        String[] protocols = {"rmi", "iiop", "jmxmp"};

        if (args.length > 0)

            protocols = args;

        for (int i = 0; i < protocols.length; i++) {

            final String proto = protocols[i];

            System.out.println("Testing for protocol " + proto);

            try {

                ok &= test(proto);

            } catch (Exception e) {

                System.err.println("Unexpected exception: " + e);

                e.printStackTrace();

                ok = false;

            }

        }

        if (ok)

            System.out.println("Test passed");

        else {

            System.out.println("TEST FAILED");

            System.exit(1);

        }

    }

    private static boolean test(String proto) throws Exception {

        ObjectName serverName = ObjectName.getInstance("d:type=server");

        MBeanServer mbs = MBeanServerFactory.newMBeanServer();

        JMXAuthenticator authenticator = new BogusAuthenticator();

        Map env = Collections.singletonMap("jmx.remote.authenticator",

                                           authenticator);

        JMXServiceURL url = new JMXServiceURL("service:jmx:" + proto + "://");

        JMXConnectorServer server;

        try {

            server =

                JMXConnectorServerFactory.newJMXConnectorServer(url, env,

                                                                null);

        } catch (MalformedURLException e) {

            System.out.println("Protocol " + proto +

                               " not supported, ignoring");

            return true;

        }

        System.out.println("Created connector server");

        mbs.registerMBean(server, serverName);

        System.out.println("Registered connector server in MBean server");

        mbs.addNotificationListener(serverName, logListener, null, null);

        mbs.invoke(serverName, "start", null, null);

        System.out.println("Started connector server");

        JMXServiceURL address =

            (JMXServiceURL) mbs.getAttribute(serverName, "Address");

        System.out.println("Retrieved address: " + address);

        if (address.getHost().length() == 0) {

            System.out.println("Generated address has empty hostname");

            return false;

        }

        JMXConnector client = JMXConnectorFactory.connect(address);

        System.out.println("Client connected");

        String clientConnId = client.getConnectionId();

        System.out.println("Got connection ID on client: " + clientConnId);

        boolean ok = checkConnectionId(proto, clientConnId);

        if (!ok)

            return false;

        System.out.println("Connection ID is OK");

        // 4901826: connection ids need some time to be updated using jmxmp

        // we don't get the notif immediately either

        // this was originally timeout 1ms, which was not enough

        Notification notif = waitForNotification(1000);

        System.out.println("Server got notification: " + notif);

        ok = mustBeConnectionNotification(notif, clientConnId,

                                         JMXConnectionNotification.OPENED);

        if (!ok)

            return false;

        client.close();

        System.out.println("Closed client");

        notif = waitForNotification(1000);

        System.out.println("Got notification: " + notif);

        ok = mustBeConnectionNotification(notif, clientConnId,

                                          JMXConnectionNotification.CLOSED);

        if (!ok)

            return false;

        client = JMXConnectorFactory.connect(address);

        System.out.println("Second client connected");

        String clientConnId2 = client.getConnectionId();

        if (clientConnId.equals(clientConnId2)) {

            System.out.println("Same connection ID for two connections: " +

                               clientConnId2);

            return false;

        }

        System.out.println("Second client connection ID is different");

        notif = waitForNotification(1);

        ok = mustBeConnectionNotification(notif, clientConnId2,

                                          JMXConnectionNotification.OPENED);

        if (!ok)

            return false;

        MBeanServerConnection mbsc = client.getMBeanServerConnection();

        Map attrs = (Map) mbsc.getAttribute(serverName, "Attributes");

        System.out.println("Server attributes received by client: " + attrs);

        server.stop();

        System.out.println("Server stopped");

        notif = waitForNotification(1000);

        System.out.println("Server got connection-closed notification: " +

                           notif);

        ok = mustBeConnectionNotification(notif, clientConnId2,

                                          JMXConnectionNotification.CLOSED);

        if (!ok)

            return false;

        try {

            mbsc.getDefaultDomain();

            System.out.println("Connection still working but should not be");

            return false;

        } catch (IOException e) {

            System.out.println("Connection correctly got exception: " + e);

        }

        try {

            client = JMXConnectorFactory.connect(address);

            System.out.println("Connector server still working but should " +

                               "not be");

            return false;

        } catch (IOException e) {

            System.out.println("New connection correctly got exception: " + e);

        }

        return true;

    }

    private static boolean

        mustBeConnectionNotification(Notification notif,

                                     String requiredConnId,

                                     String requiredType) {

        if (!(notif instanceof JMXConnectionNotification)) {

            System.out.println("Should have been a " +

                               "JMXConnectionNotification: " +

                               notif.getClass());

            return false;

        }

        JMXConnectionNotification cnotif = (JMXConnectionNotification) notif;

        if (!cnotif.getType().equals(requiredType)) {

            System.out.println("Wrong type notif: is \"" + cnotif.getType() +

                               "\", should be \"" + requiredType + "\"");

            return false;

        }

        if (!cnotif.getConnectionId().equals(requiredConnId)) {

            System.out.println("Wrong connection id: is \"" +

                               cnotif.getConnectionId() + "\", should be \"" +

                               requiredConnId);

            return false;

        }

        return true;

    }

    private static final String IPV4_PTN = "^(?:[0-9]{1,3}\\.){3}[0-9]{1,3}(\\:[1-9][0-9]{3})?$";

    /**

     * Checks the connection id for validity.

     * The {@link

     * javax.management.remote package description} describes the

     * conventions for connection IDs.

     * @param proto Connection protocol

     * @param clientConnId The connection ID

     * @return Returns {@code true} if the connection id conforms to the specification; {@code false} otherwise.

     * @throws Exception

     */

    private static boolean checkConnectionId(String proto, String clientConnId)

            throws Exception {

        StringTokenizer tok = new StringTokenizer(clientConnId, " ", true);

        String s;

        s = tok.nextToken();

        if (!s.startsWith(proto + ":")) {

            System.out.println("Expected \"" + proto + ":\", found \"" + s +

                               "\"");

            return false;

        }

        int hostAddrInd = s.indexOf("//");

        if (hostAddrInd > -1) {

            s = s.substring(hostAddrInd + 2);

            if (!Pattern.matches(IPV4_PTN, s)) {

                if (!s.startsWith("[") || !s.endsWith("]")) {

                    System.out.println("IPv6 address must be enclosed in \"[]\"");

                    return false;

                }

            }

        }

        s = tok.nextToken();

        if (!s.equals(" ")) {

            System.out.println("Expected \" \", found \"" + s + "\"");

            return false;

        }

        s = tok.nextToken();

        StringTokenizer tok2 = new StringTokenizer(s, ";", true);

        Set principalNames = new HashSet();

        String s2;

        s2 = tok2.nextToken();

        if (s2.equals(";")) {

            System.out.println("In identity \"" + s +

                               "\", expected name, found \";\"");

            return false;

        }

        principalNames.add(s2);

        s2 = tok2.nextToken();

        if (!s2.equals(";"))

            throw new Exception("Can't happen");

        s2 = tok2.nextToken();

        if (s2.equals(";")) {

            System.out.println("In identity \"" + s +

                               "\", expected name, found \";\"");

            return false;

        }

        principalNames.add(s2);

        if (tok2.hasMoreTokens()) {

            System.out.println("In identity \"" + s + "\", too many tokens");

            return false;

        }

        if (principalNames.size() != bogusPrincipals.size()) {

            System.out.println("Wrong number of principal names: " +

                               principalNames.size() + " != " +

                               bogusPrincipals.size());

            return false;

        }

        for (Iterator it = bogusPrincipals.iterator(); it.hasNext(); ) {

            Principal p = (Principal) it.next();

            if (!principalNames.contains(p.getName())) {

                System.out.println("Principal names don't contain \"" +

                                   p.getName() + "\"");

                return false;

            }

        }

        s = tok.nextToken();

        if (!s.equals(" ")) {

            System.out.println("Expected \" \", found \"" + s + "\"");

            return false;

        }

        return true;

    }

    private static Notification waitForNotification(long timeout)

            throws InterruptedException {

        synchronized (log) {

            if (log.isEmpty()) {

                long remainingTime = timeout;

                final long startTime = System.currentTimeMillis();

                while (log.isEmpty() && remainingTime >0) {

                    log.wait(remainingTime);

                    remainingTime = timeout - (System.currentTimeMillis() - startTime);

                }

                if (log.isEmpty()) {

                    throw new InterruptedException("Timed out waiting for " +

                                                   "notification!");

                }

            }

            return (Notification) log.remove(0);

        }

    }

    private static class LogListener implements NotificationListener {

        LogListener(List log) {

            this.log = log;

        }

        public void handleNotification(Notification n, Object h) {

            synchronized (log) {

                log.add(n);

                log.notifyAll();

            }

        }

        private final List log;

    }

    private static List log = new LinkedList();

    private static NotificationListener logListener = new LogListener(log);

    private static class BogusAuthenticator implements JMXAuthenticator {

        public Subject authenticate(Object credentials) {

            Subject subject =

                new Subject(true, bogusPrincipals,

                            Collections.EMPTY_SET, Collections.EMPTY_SET);

            System.out.println("Authenticator returns: " + subject);

            return subject;

        }

    }

    private static final Set bogusPrincipals = new HashSet();

    static {

        bogusPrincipals.add(new JMXPrincipal("foo"));

        bogusPrincipals.add(new JMXPrincipal("bar"));

    }

}