/*

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

 * @library /test/lib

 * @run main/othervm/timeout=6000 BasicAuthenticatorCharset

 * @summary Check for correct use of character sets with BasicAuthenticator() authentication

 */

import com.sun.net.httpserver.*;

import jdk.test.lib.net.URIBuilder;

import java.io.IOException;

import java.io.InputStream;

import java.net.*;

import java.net.http.HttpClient;

import java.net.http.HttpRequest;

import java.net.http.HttpResponse;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.nio.charset.Charset;

import static java.nio.charset.StandardCharsets.UTF_8;

import static java.nio.charset.StandardCharsets.ISO_8859_1;

/**

 * Test authentication

 */

public class BasicAuthenticatorCharset {

    public static volatile int failCount = 0;

    static final String TEST_USER = "test";

    static final String UNICODE_PW = "Selam D\u00fcnya. Ho\u015f\u00e7akal D\u00fcnya";

    static Handler testHandler;

    static HttpServer testHttpServer;

    static java.net.Authenticator clientAuth;

    static HttpClient client;

    static class Handler implements HttpHandler {

        public void handle(HttpExchange t) throws IOException {

            InputStream is = t.getRequestBody();

            while (is.read() != -1) ;

            is.close();

            t.sendResponseHeaders(200, -1);

            t.close();

        }

    }

    static class ClientAuthenticator extends java.net.Authenticator {

        public PasswordAuthentication getPasswordAuthentication() {

            return new PasswordAuthentication(TEST_USER, UNICODE_PW.toCharArray());

        }

    }

    static void setAuthenticationPW(String path, String realm, String testPW, Charset charset) {

        HttpContext ctx = testHttpServer.createContext(path, testHandler);

        BasicAuthenticator auth;

        if (charset != null) {

            auth = new BasicAuthenticator(realm, charset) {

                public boolean checkCredentials(String username, String pw) {

                    return username.equals(TEST_USER) && pw.equals(testPW);

                }

            };

        } else {

            auth = new BasicAuthenticator(realm) {

                public boolean checkCredentials(String username, String pw) {

                    return username.equals(TEST_USER) && pw.equals(testPW);

                }

            };

        }

        ctx.setAuthenticator(auth);

    }

    static void connectAndAuth(String path, int expectedStatus) throws Exception {

        // path is prepended with /old or /new for old and new http client

        URL oldurl = URIBuilder.newBuilder()

                .scheme("http")

                .loopback()

                .port(testHttpServer.getAddress().getPort())

                .path("/old" + path)

                .toURL();

        URI newuri = URIBuilder.newBuilder()

            .scheme("http")

            .loopback()

            .port(testHttpServer.getAddress().getPort())

            .path("/new" + path)

            .build();

        // check old client

        HttpURLConnection testConnection = (HttpURLConnection) oldurl.openConnection(Proxy.NO_PROXY);

        // Check for successful authentication

        int status = testConnection.getResponseCode();

        if (status != 401) {

            InputStream is = testConnection.getInputStream();

            while (is.read() != -1) ;

            is.close();

        }

        if (status != expectedStatus) {

            System.err.println("Error (old): " + path);

            failCount++;

        }

        HttpRequest request = HttpRequest.newBuilder()

            .uri(newuri)

            .GET()

            .build();

        status = -1;

        try {

            HttpResponse<Void> response = client.send(request, HttpResponse.BodyHandlers.discarding());

            status = response.statusCode();

        } catch (IOException e) {

            System.out.println("NEW: " + e);

            status = 401; // limitation in new API.

        }

        if (status != expectedStatus) {

            System.err.println("Error (new): " + path);

            failCount++;

        }

    }

    public static void main(String[] args) throws Exception {

        clientAuth = new ClientAuthenticator();

        client = HttpClient.newBuilder()

            .authenticator(clientAuth)

            .build();

        String defaultCharset = System.getProperty("file.encoding");

        boolean isUTF8 = defaultCharset.equalsIgnoreCase("UTF-8");

        testHandler = new Handler();

        InetSocketAddress addr = new InetSocketAddress(InetAddress.getLoopbackAddress(), 0);

        testHttpServer = HttpServer.create(addr, 0);

        // Set the passing credentials OLD client

        setAuthenticationPW("/old/test1/", "passingCharset@test.realm", UNICODE_PW, UTF_8);

        setAuthenticationPW("/old/test2/", "failingCharset@test.realm", UNICODE_PW, ISO_8859_1);

        setAuthenticationPW("/old/test3/", "defaultCharset@test.realm", UNICODE_PW, null);

        // Set the passing credentials NEW client

        setAuthenticationPW("/new/test1/", "passingCharset@test.realm", UNICODE_PW, UTF_8);

        setAuthenticationPW("/new/test2/", "failingCharset@test.realm", UNICODE_PW, ISO_8859_1);

        setAuthenticationPW("/new/test3/", "defaultCharset@test.realm", UNICODE_PW, null);

        ExecutorService executor = Executors.newCachedThreadPool();

        testHttpServer.setExecutor(executor);

        testHttpServer.start();

        java.net.Authenticator.setDefault(clientAuth);

        connectAndAuth("/test1/passingCharset.html", 200);

        connectAndAuth("/test2/failingCharset.html", 401);

        if (isUTF8) {

            connectAndAuth("/test3/defaultCharset.html", 200);

        }

        testHttpServer.stop(2);

        executor.shutdown();

        // should fail once with UNICODE_PW and unsupporting character set

        if (failCount > 0)

            throw new RuntimeException("Fail count : " + failCount);

    }

}