/*
 * 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
 * @summary This test will timeout if the ALPN CF is not completed
 *          when a 'Connection reset by peer' exception is raised
 *          during the handshake.
 * @bug 8217094
 * @modules java.net.http
 *          java.logging
 * @build ALPNFailureTest
 * @run main/othervm -Djdk.internal.httpclient.debug=true ALPNFailureTest HTTP_1_1
 * @run main/othervm ALPNFailureTest HTTP_2
 */
import javax.net.ServerSocketFactory;
import javax.net.ssl.SSLContext;
import java.io.Closeable;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.ProxySelector;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.net.StandardSocketOptions;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.HttpTimeoutException;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;

public class ALPNFailureTest {


    public static void main(String[] args) throws Exception{
        if (args == null || args.length == 0) {
            args = new String[] {HttpClient.Version.HTTP_1_1.name()};
        }
        ServerSocket socket = ServerSocketFactory.getDefault()
                .createServerSocket(0, 10, InetAddress.getLoopbackAddress());

        test(socket, null, null, args);
    }

    public static void test(ServerSocket socket, SSLContext context,
                            ProxySelector ps, String... args)
            throws Exception
    {
        System.out.println("Tests a race condition in SSLTube/SSLFlowDelegate");
        System.out.println("This test will timeout if the ALPN CF is not completed" +
                " when a 'Connection reset by peer' exception is raised" +
                " during the handshake - see 8217094.");

        URI uri = new URI("https", null,
                socket.getInetAddress().getHostAddress(), socket.getLocalPort(),
                "/ReadOnlyServer/https_1_1/", null, null);
        HttpRequest request1 = HttpRequest.newBuilder(uri)
                .GET().build();
        HttpRequest request2 = HttpRequest.newBuilder(uri)
                .POST(HttpRequest.BodyPublishers.ofString("foo")).build();

        ReadOnlyServer server = new ReadOnlyServer(socket);
        Thread serverThread = new Thread(server, "ServerThread");
        serverThread.start();
        try {
            for (var arg : args) {
                var version = HttpClient.Version.valueOf(arg);
                HttpClient.Builder builder = HttpClient.newBuilder()
                        .version(version);
                if (ps != null) builder.proxy(ps);
                if (context != null) builder.sslContext(context);

                HttpClient client = builder.build();
                for (var request : List.of(request1, request2)) {
                    System.out.println("Server is " + socket.getLocalSocketAddress()
                            + ", Version is " + version + ", Method is " + request.method()
                            + (ps == null ? ", no proxy"
                            : (", Proxy is " + ps.select(request.uri()))));
                    try {
                        HttpResponse<String> resp =
                                client.send(request, HttpResponse.BodyHandlers.ofString());
                        throw new AssertionError(
                                "Client should not have received any response: " + resp);
                    } catch (HttpTimeoutException x) {
                        System.out.println("Unexpected " + x);
                        x.printStackTrace();
                        throw new AssertionError("Unexpected exception " + x, x);
                    } catch (Exception x) {
                        // We expect IOException("Connection reset by peer"), but
                        // any exception would do: we just don't want to linger
                        // forever.
                        System.err.println("Client got expected exception: " + x);
                        x.printStackTrace(System.out);
                    }
                }
            }
        } finally {
            server.close();
        }
    }

    public static class ReadOnlyServer  implements Runnable, Closeable {
        final ServerSocket socket;
        final AtomicReference<Throwable> errorRef = new AtomicReference<>();
        final AtomicBoolean closing = new AtomicBoolean();
        ReadOnlyServer(ServerSocket socket) {
            this.socket = socket;
        }

        @Override
        public void run() {
            int count = 0;
            int all = 0;
            try {
                System.out.println("Server starting");
                while (!closing.get()) {
                    all += count;
                    count = 0;
                    try (Socket client = socket.accept()) {
                        client.setSoTimeout(1000);
                        client.setOption(StandardSocketOptions.SO_LINGER, 0);
                        InputStream is = client.getInputStream();
                        OutputStream os = client.getOutputStream();
                        boolean drain = true;
                        int timeouts = 0;
                        // now read some byte from the ClientHello
                        // and abruptly close the socket.
                        while (drain) {
                            try {
                                is.read();
                                count++;
                                if (count >= 50) {
                                    drain = false;
                                }
                            } catch (SocketTimeoutException so) {
                                // make sure we read something
                                if (count > 0) timeouts++;
                                if (timeouts == 5) {
                                    // presumably the client is
                                    // waiting for us to answer...
                                    // but we should not reach here.
                                    drain = false;
                                }
                            }
                        }
                        System.out.println("Got " + count + " bytes");
                    }
                }
            } catch (Throwable t) {
                if (!closing.get()) {
                    errorRef.set(t);
                    t.printStackTrace();
                }
            } finally {
                System.out.println("Server existing after reading " + (all + count) + " bytes");
                close();
            }

        }

        @Override
        public void close() {
            if (closing.getAndSet(true))
                return; // already closed
            try {
                socket.close();
            } catch (IOException x) {
                System.out.println("Exception while closing: " + x);
            }
        }
    }
}