/*
 * Copyright (c) 2019, 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 8231358
 * @run main Bind
 * @summary Bind test
 */

import java.io.Closeable;
import java.io.IOException;
import java.net.*;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Set;

/**
 * Check that all bind variations work
 */
public class Bind {

    static Path spath, cpath;

    static UnixDomainSocketAddress sAddr, cAddr, nullAddr;
    static ServerSocketChannel server;
    static SocketChannel client, accept1;

    public static void main(String args[]) throws Exception {
        if (!supported()) {
            System.out.println("Unix domain channels not supported");
            return;
        }
	spath = Path.of("server.sock");
	cpath = Path.of("client.sock");
	sAddr = new UnixDomainSocketAddress(spath);
	cAddr = new UnixDomainSocketAddress(cpath);
	nullAddr = new UnixDomainSocketAddress("");
        runTests();
    }

    static boolean supported() {
	try {
	    SocketChannel.open(StandardProtocolFamily.UNIX);
	} catch (UnsupportedAddressTypeException e) {
	    return false;
	} catch (Exception e) {
	    return true; // continue test to see what problem is
	}
	return true;
    }

    static interface ThrowingRunnable {
	public void run() throws Exception;
    }

    static void init() throws IOException {
	Files.deleteIfExists(cpath);
	Files.deleteIfExists(spath);
	client = null; server = null; accept1 = null;
    }
	
    static void checkNormal(ThrowingRunnable r) {
	try {
	    init();
	    r.run();
	    System.out.println("PASS:");
	} catch (Exception e) {
	    throw new RuntimeException(e);
	} finally {
	    cleanup();
	}
    }

    static void checkException(Class<? extends Exception> expected, ThrowingRunnable r) {
	try {
	    init();
	    r.run();
	    throw new RuntimeException("Exception expected");
	} catch (Exception e) {
	    if (!expected.isAssignableFrom(e.getClass())) {
		String msg = "Expected: " + expected + " Got: " + e.getClass();
	    	throw new RuntimeException(msg);
	    }
	    System.out.println("PASS: Got " + e);
	} finally {
	    cleanup();
	}
    }

    static void cleanup() {
	try {
	    if (server != null)
		server.close();
	    if (client != null)
		client.close();
	    if (accept1 != null)
		accept1.close();
	} catch (IOException e) {}
    }

    static void assertClientAddress(SocketAddress a) {
	assertAddress(a, cAddr, "client");
    }

    static void assertServerAddress(SocketAddress a) {
	assertAddress(a, sAddr, "server");
    }

    static void assertAddress(SocketAddress a, UnixDomainSocketAddress a1, String s) {
	if (!(a instanceof UnixDomainSocketAddress))
	    throw new RuntimeException("wrong address type");
	UnixDomainSocketAddress ua = (UnixDomainSocketAddress)a;
	if (!a.equals(a1))
	    throw new RuntimeException("this is not the " + s + " address");
    }

    public static void runTests() throws IOException {
	checkNormal(() -> {
	    client = SocketChannel.open(StandardProtocolFamily.UNIX);
	    client.bind(cAddr);
	});
	checkNormal(() -> {
	    server = ServerSocketChannel.open(StandardProtocolFamily.UNIX);
	    server.bind(sAddr);
	});
	// Repeat first two to make sure they are repeatable
        checkNormal(() -> {
            client = SocketChannel.open(StandardProtocolFamily.UNIX);
            client.bind(cAddr);
        });
        checkNormal(() -> {
            server = ServerSocketChannel.open(StandardProtocolFamily.UNIX);
            server.bind(sAddr);
        });
	// client bind to null: allowed
	checkNormal(() -> {
	    client = SocketChannel.open(StandardProtocolFamily.UNIX);
	    client.bind(null);
	    assertAddress(client.getLocalAddress(), nullAddr, "null address");
	});
	// server bind to null: not allowed
	checkException(
	    BindException.class, () -> {
	        server = ServerSocketChannel.open(StandardProtocolFamily.UNIX);
	        server.bind(null);
	    }
	);
	// server no bind : not allowed
	checkException(
	    NotYetBoundException.class, () -> {
	        server = ServerSocketChannel.open(StandardProtocolFamily.UNIX);
		server.accept();
	    }
	);
	// client implicit bind and connect
	checkNormal(() -> {
            server = ServerSocketChannel.open(StandardProtocolFamily.UNIX);
            client = SocketChannel.open(StandardProtocolFamily.UNIX);
            server.bind(sAddr);
	    client.connect(sAddr);
	    assertAddress(client.getLocalAddress(), nullAddr, "null address");
	    assertServerAddress(server.getLocalAddress());
	});
	// client null bind and connect (check all addresses)
	checkNormal(() -> {
            server = ServerSocketChannel.open(StandardProtocolFamily.UNIX);
            client = SocketChannel.open(StandardProtocolFamily.UNIX);
            server.bind(sAddr);
	    client.bind(null);
	    client.connect(sAddr);
	    assertAddress(client.getLocalAddress(), nullAddr, "null address");
	    assertServerAddress(server.getLocalAddress());
	});
        // client explicit bind and connect (check all addresses)
        checkNormal(() -> {
            server = ServerSocketChannel.open(StandardProtocolFamily.UNIX);
            client = SocketChannel.open(StandardProtocolFamily.UNIX);
            server.bind(sAddr);
            client.bind(cAddr);
            client.connect(sAddr);
	    accept1 = server.accept();
            assertClientAddress(client.getLocalAddress());
            assertServerAddress(server.getLocalAddress());
	    assertAddress(client.getRemoteAddress(), sAddr, "client's remote server address");
	    assertAddress(accept1.getLocalAddress(), sAddr, "accepted local address (server)");
	    assertAddress(accept1.getRemoteAddress(), cAddr, "accepted remote address (client)");
        });
        // server multiple bind : not allowed
        checkException(
            AlreadyBoundException.class, () -> {
                server = ServerSocketChannel.open(StandardProtocolFamily.UNIX);
                server.bind(sAddr);
                server.bind(sAddr);
            }
        );
        // client multiple bind : not allowed
        checkException(
            AlreadyBoundException.class, () -> {
                client = SocketChannel.open(StandardProtocolFamily.UNIX);
                client.bind(cAddr);
                client.bind(cAddr);
            }
        );
    }
}