jdk-sandbox: comparison test/jdk/java/net/httpclient/DigestEchoClient.java

equal deleted inserted replaced

-:8588095e95b0
+:352e845ae744
 import jdk.incubator.http.HttpClient;
 import jdk.incubator.http.HttpClient.Version;
 import jdk.incubator.http.HttpRequest;
 import jdk.incubator.http.HttpResponse;
 import jdk.testlibrary.SimpleSSLContext;
+import sun.net.NetProperties;
 import sun.net.www.HeaderParser;
 import static java.lang.System.out;
 import static java.lang.String.format;
 import static jdk.incubator.http.HttpResponse.BodyHandler.asLines;
 * @bug 8087112
 * @library /lib/testlibrary
 * @build jdk.testlibrary.SimpleSSLContext DigestEchoServer DigestEchoClient
 * @modules jdk.incubator.httpclient
 *          java.base/sun.net.www
+*          java.base/sun.net
 * @run main/othervm DigestEchoClient
+* @run main/othervm -Djdk.http.auth.proxying.disabledSchemes=
+*                   -Djdk.http.auth.tunneling.disabledSchemes=
+*                   DigestEchoClient
 */
 public class DigestEchoClient {
 static final String data[] = {
 }
 }
 private static final ConcurrentMap<String, EchoServers> servers = new ConcurrentHashMap<>();
 }
+final static String PROXY_DISABLED = NetProperties.get("jdk.http.auth.proxying.disabledSchemes");
+final static String TUNNEL_DISABLED = NetProperties.get("jdk.http.auth.tunneling.disabledSchemes");
+static {
+System.out.println("jdk.http.auth.proxying.disabledSchemes=" + PROXY_DISABLED);
+System.out.println("jdk.http.auth.tunneling.disabledSchemes=" + TUNNEL_DISABLED);
+}
 static final AtomicInteger NC = new AtomicInteger();
 static final Random random = new Random();
 static final SSLContext context;
 digestCount.get(), digests.get()));
 System.out.println(" ---------------------------------------------------------- ");
 }
 }
+boolean isSchemeDisabled() {
+String disabledSchemes;
+if (isProxy(authType)) {
+disabledSchemes = useSSL
+? TUNNEL_DISABLED
+: PROXY_DISABLED;
+} else return false;
+if (disabledSchemes == null
+|| disabledSchemes.isEmpty()) {
+return false;
+}
+String scheme;
+switch (authScheme) {
+case DIGEST:
+scheme = "Digest";
+break;
+case BASIC:
+scheme = "Basic";
+break;
+case BASICSERVER:
+scheme = "Basic";
+break;
+case NONE:
+return false;
+default:
+throw new InternalError("Unknown auth scheme: " + authScheme);
+}
+return Stream.of(disabledSchemes.split(","))
+.map(String::trim)
+.filter(scheme::equalsIgnoreCase)
+.findAny()
+.isPresent();
+}
 final static AtomicLong basics = new AtomicLong();
 final static AtomicLong basicCount = new AtomicLong();
 // @Test
 void testBasic(HttpClient.Version version, boolean async,
 boolean expectContinue, boolean preemptive)
 if (addHeaders) {
 // handle authentication ourselves
 assert !client.authenticator().isPresent();
 if (auth == null) auth = "Basic " + getBasicAuth("arthur");
 try {
-if ((i > 0 || preemptive) && (!isTunnel || i == 0)) {
+if ((i > 0 || preemptive)
+&& (!isTunnel || i == 0 || isSchemeDisabled())) {
 // In case of a SSL tunnel through proxy then only the
 // first request should require proxy authorization
 // Though this might be invalidated if the server decides
 // to close the connection...
 out.println(String.format("%s adding %s: %s",
 t = t.getCause();
 }
 throw new RuntimeException("Unexpected exception: " + t, t);
 }
-if (addHeaders && !preemptive && i==0) {
+if (addHeaders && !preemptive && (i==0 || isSchemeDisabled())) {
 assert resp.statusCode() == 401 || resp.statusCode() == 407;
 request = HttpRequest.newBuilder(uri).version(version)
 .POST(reqBody).header(authorizationKey(authType), auth).build();
 if (async) {
 resp = client.sendAsync(request, asLines()).join();
 } else {
 resp = client.send(request, asLines());
 }
 }
-assert resp.statusCode() == 200;
+final List<String> respLines;
-List<String> respLines = resp.body().collect(Collectors.toList());
+try {
-long stop = System.nanoTime();
+if (isSchemeDisabled()) {
-synchronized (basicCount) {
+if (resp.statusCode() != 407) {
-long n = basicCount.getAndIncrement();
+throw new RuntimeException("expected 407 not received");
-basics.set((basics.get() * n + (stop - start)) / (n + 1));
+}
+System.out.println("Scheme disabled for [" + authType
++ ", " + authScheme
++ ", " + (useSSL ? "HTTP" : "HTTPS")
++ "]: Received expected " + resp.statusCode());
+continue;
+} else {
+System.out.println("Scheme enabled for [" + authType
++ ", " + authScheme
++ ", " + (useSSL ? "HTTPS" : "HTTP")
++ "]: Expecting 200");
+assert resp.statusCode() == 200;
+respLines = resp.body().collect(Collectors.toList());
+}
+} finally {
+long stop = System.nanoTime();
+synchronized (basicCount) {
+long n = basicCount.getAndIncrement();
+basics.set((basics.get() * n + (stop - start)) / (n + 1));
+}
 }
 if (!lines.equals(respLines)) {
 throw new RuntimeException("Unexpected response: " + respLines);
 }
 }
 String digestMethod = isTunnel ? "CONNECT" : "POST";
 // In case of a tunnel connection only the first request
 // which establishes the tunnel needs to authenticate with
 // the proxy.
-if (challenge != null && !isTunnel) {
+if (challenge != null && (!isTunnel || isSchemeDisabled())) {
 assert cnonceStr != null;
 String auth = digestResponse(uri, digestMethod, challenge, cnonceStr);
 try {
 reqBuilder = reqBuilder.header(authorizationKey(authType), auth);
 } catch (IllegalArgumentException x) {
 assert challenge != null || resp.statusCode() == 401 || resp.statusCode() == 407;
 if (resp.statusCode() == 401 || resp.statusCode() == 407) {
 // This assert may need to be relaxed if our server happened to
 // decide to close the tunnel connection, in which case we would
 // receive 407 again...
-assert challenge == null || !isTunnel
+assert challenge == null || !isTunnel || isSchemeDisabled()
 : "No proxy auth should be required after establishing an SSL tunnel";
 System.out.println("Received " + resp.statusCode() + " answering challenge...");
 random.nextBytes(cnonce);
 cnonceStr = new BigInteger(1, cnonce).toString(16);
 } else {
 resp = client.send(request, asLines());
 }
 System.out.println(resp);
 }
-assert resp.statusCode() == 200;
+final List<String> respLines;
-List<String> respLines = resp.body().collect(Collectors.toList());
+try {
-long stop = System.nanoTime();
+if (isSchemeDisabled()) {
-synchronized (digestCount) {
+if (resp.statusCode() != 407) {
-long n = digestCount.getAndIncrement();
+throw new RuntimeException("expected 407 not received");
-digests.set((digests.get() * n + (stop - start)) / (n + 1));
+}
+System.out.println("Scheme disabled for [" + authType
++ ", " + authScheme +
+", " + (useSSL ? "HTTP" : "HTTPS")
++ "]: Received expected " + resp.statusCode());
+continue;
+} else {
+assert resp.statusCode() == 200;
+respLines = resp.body().collect(Collectors.toList());
+}
+} finally {
+long stop = System.nanoTime();
+synchronized (basicCount) {
+long n = basicCount.getAndIncrement();
+basics.set((basics.get() * n + (stop - start)) / (n + 1));
+}
 }
 if (!lines.equals(respLines)) {
 throw new RuntimeException("Unexpected response: " + respLines);
 }
 }

branch	http-client-branch
changeset 56054	352e845ae744
parent 56041	b4b5e09ef3cc
child 56070	66a9c3185028