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

equal deleted inserted replaced

-:e2a780d8c6f0
+:249a863b0aca
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
 import com.sun.net.httpserver.BasicAuthenticator;
-import com.sun.net.httpserver.Filter;
-import com.sun.net.httpserver.Headers;
-import com.sun.net.httpserver.HttpContext;
-import com.sun.net.httpserver.HttpExchange;
-import com.sun.net.httpserver.HttpHandler;
 import com.sun.net.httpserver.HttpServer;
 import com.sun.net.httpserver.HttpsConfigurator;
 import com.sun.net.httpserver.HttpsParameters;
 import com.sun.net.httpserver.HttpsServer;
 import java.io.IOException;
 import java.io.PrintWriter;
 import java.io.Writer;
 import java.math.BigInteger;
 import java.net.Authenticator;
 import java.net.HttpURLConnection;
-import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.MalformedURLException;
 import java.net.PasswordAuthentication;
 import java.net.ServerSocket;
 import java.net.Socket;
-import java.net.SocketAddress;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.net.URL;
 import java.nio.charset.StandardCharsets;
 import java.security.MessageDigest;
 import java.util.List;
 import java.util.Locale;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Random;
+import java.util.StringTokenizer;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 * By default this server will echo back whatever is present
 * in the request body. Note that the Digest authentication is
 * a test implementation implemented only for tests purposes.
 * @author danielfuchs
 */
-public class DigestEchoServer implements HttpServerAdapters {
+public abstract class DigestEchoServer implements HttpServerAdapters {
 public static final boolean DEBUG =
 Boolean.parseBoolean(System.getProperty("test.debug", "false"));
 public enum HttpAuthType {
 SERVER, PROXY, SERVER307, PROXY305
 final HttpTestServer       serverImpl; // this server endpoint
 final DigestEchoServer     redirect;   // the target server where to redirect 3xx
 final HttpTestHandler      delegate;   // unused
 final String               key;
-private DigestEchoServer(String key,
+DigestEchoServer(String key,
 HttpTestServer server,
 DigestEchoServer target,
 HttpTestHandler delegate) {
 this.key = key;
 this.serverImpl = server;
 HttpTestServer impl = createHttpServer(version, protocol);
 String key = String.format("DigestEchoServer[PID=%s,PORT=%s]:%s:%s:%s:%s",
 ProcessHandle.current().pid(),
 impl.getAddress().getPort(),
 version, protocol, authType, schemeType);
-final DigestEchoServer server = new DigestEchoServer(key, impl, null, delegate);
+final DigestEchoServer server = new DigestEchoServerImpl(key, impl, null, delegate);
 final HttpTestHandler handler =
 server.createHandler(schemeType, auth, authType, false);
 HttpTestContext context = impl.addHandler(handler, path);
 server.configureAuthentication(context, schemeType, auth, authType);
 impl.start();
 ProcessHandle.current().pid(),
 impl.getAddress().getPort(),
 version, protocol, authType, schemeType);
 final DigestEchoServer server = "https".equalsIgnoreCase(protocol)
 ? new HttpsProxyTunnel(key, impl, null, delegate)
-: new DigestEchoServer(key, impl, null, delegate);
+: new DigestEchoServerImpl(key, impl, null, delegate);
 final HttpTestHandler hh = server.createHandler(HttpAuthSchemeType.NONE,
 null, HttpAuthType.SERVER,
 server instanceof HttpsProxyTunnel);
 HttpTestContext ctxt = impl.addHandler(hh, path);
 impl.getAddress().getPort(),
 version, protocol,
 HttpAuthType.SERVER, code300)
 + "->" + redirectTarget.key;
 final DigestEchoServer redirectingServer =
-new DigestEchoServer(key, impl, redirectTarget, null);
+new DigestEchoServerImpl(key, impl, redirectTarget, null);
 InetSocketAddress redirectAddr = redirectTarget.getAddress();
 URL locationURL = url(targetProtocol, redirectAddr, "/");
 final HttpTestHandler hh = redirectingServer.create300Handler(key, locationURL,
 HttpAuthType.SERVER, code300);
 impl.addHandler(hh,"/");
 impl.start();
 return redirectingServer;
 }
-public InetSocketAddress getAddress() {
+public abstract InetSocketAddress getServerAddress();
-return new InetSocketAddress("127.0.0.1",
+public abstract InetSocketAddress getProxyAddress();
-serverImpl.getAddress().getPort());
+public abstract InetSocketAddress getAddress();
-}
+public abstract void stop();
+public abstract Version getServerVersion();
-public InetSocketAddress getServerAddress() {
-return new InetSocketAddress("127.0.0.1",
+private static class DigestEchoServerImpl extends DigestEchoServer {
-serverImpl.getAddress().getPort());
+DigestEchoServerImpl(String key,
-}
+HttpTestServer server,
+DigestEchoServer target,
-public InetSocketAddress getProxyAddress() {
+HttpTestHandler delegate) {
-return new InetSocketAddress("127.0.0.1",
+super(key, Objects.requireNonNull(server), target, delegate);
-serverImpl.getAddress().getPort());
+}
-}
+public InetSocketAddress getAddress() {
-public Version getServerVersion() { return serverImpl.getVersion(); }
+return new InetSocketAddress("127.0.0.1",
+serverImpl.getAddress().getPort());
-public void stop() {
+}
-serverImpl.stop();
-if (redirect != null) {
+public InetSocketAddress getServerAddress() {
-redirect.stop();
+return new InetSocketAddress("127.0.0.1",
+serverImpl.getAddress().getPort());
+}
+public InetSocketAddress getProxyAddress() {
+return new InetSocketAddress("127.0.0.1",
+serverImpl.getAddress().getPort());
+}
+public Version getServerVersion() {
+return serverImpl.getVersion();
+}
+public void stop() {
+serverImpl.stop();
+if (redirect != null) {
+redirect.stop();
+}
 }
 }
 protected void writeResponse(HttpTestExchange he) throws IOException {
 if (delegate == null) {
 response.append("HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n");
 return true;
 }
 }
+public interface TunnelingProxy {
+InetSocketAddress getProxyAddress();
+void stop();
+}
 // This is a bit hacky: HttpsProxyTunnel is an HTTPTestServer hidden
 // behind a fake proxy that only understands CONNECT requests.
 // The fake proxy is just a server socket that intercept the
 // CONNECT and then redirect streams to the real server.
 static class HttpsProxyTunnel extends DigestEchoServer
-implements Runnable {
+implements Runnable, TunnelingProxy {
 final ServerSocket ss;
 final CopyOnWriteArrayList<CompletableFuture<Void>> connectionCFs
 = new CopyOnWriteArrayList<>();
 volatile ProxyAuthorization authorization;
 t.setDaemon(true);
 t.start();
 }
 @Override
+public Version getServerVersion() {
+// serverImpl is not null when this proxy
+// serves a single server. It will be null
+// if this proxy can serve multiple servers.
+if (serverImpl != null) return serverImpl.getVersion();
+return null;
+}
+@Override
 public void stop() {
 stopped = true;
-super.stop();
+if (serverImpl != null) {
+serverImpl.stop();
+}
+if (redirect != null) {
+redirect.stop();
+}
 try {
 ss.close();
 } catch (IOException ex) {
 if (DEBUG) ex.printStackTrace(System.out);
 }
 };
 }
 @Override
 public InetSocketAddress getAddress() {
-return new InetSocketAddress(ss.getInetAddress(), ss.getLocalPort());
+return new InetSocketAddress("127.0.0.1",
-}
+ss.getLocalPort());
+}
+@Override
 public InetSocketAddress getProxyAddress() {
 return getAddress();
 }
+@Override
 public InetSocketAddress getServerAddress() {
-return new InetSocketAddress("127.0.0.1",
+// serverImpl can be null if this proxy can serve
-serverImpl.getAddress().getPort());
+// multiple servers.
+if (serverImpl != null) {
+return serverImpl.getAddress();
+}
+return null;
 }
 // This is a bit shaky. It doesn't handle continuation
 // lines, but our client shouldn't send any.
 System.out.println(now() + "Tunnel: Request line: " + requestLine);
 if (requestLine.startsWith("CONNECT ")) {
 // We should probably check that the next word following
 // CONNECT is the host:port of our HTTPS serverImpl.
 // Some improvement for a followup!
+StringTokenizer tokenizer = new StringTokenizer(requestLine);
+String connect = tokenizer.nextToken();
+assert connect.equalsIgnoreCase("connect");
+String hostport = tokenizer.nextToken();
+InetSocketAddress targetAddress;
+try {
+URI uri = new URI("https", hostport, "/", null, null);
+int port = uri.getPort();
+port = port == -1 ? 443 : port;
+targetAddress = new InetSocketAddress(uri.getHost(), port);
+if (serverImpl != null) {
+assert targetAddress.getHostString()
+.equalsIgnoreCase(serverImpl.getAddress().getHostString());
+assert targetAddress.getPort() == serverImpl.getAddress().getPort();
+}
+} catch (Throwable x) {
+System.err.printf("Bad target address: \"%s\" in \"%s\"%n",
+hostport, requestLine);
+toClose.close();
+continue;
+}
 // Read all headers until we find the empty line that
 // signals the end of all headers.
 String line = requestLine;
 while(!line.equals("")) {
 pw.print(response.toString());
 pw.flush();
 toClose.close();
 continue;
 }
+System.out.println(now()
++ "Tunnel connecting to target server at "
++ targetAddress.getAddress() + ":" + targetAddress.getPort());
 targetConnection = new Socket(
-serverImpl.getAddress().getAddress(),
+targetAddress.getAddress(),
-serverImpl.getAddress().getPort());
+targetAddress.getPort());
 // Then send the 200 OK response to the client
 System.out.println(now() + "Tunnel: Sending "
 + response);
 pw.print(response);
 connectionCFs.forEach(cf -> cf.complete(null));
 }
 }
 }
+/**
+* Creates a TunnelingProxy that can serve multiple servers.
+* The server address is extracted from the CONNECT request line.
+* @param authScheme The authentication scheme supported by the proxy.
+*                   Typically one of DIGEST, BASIC, NONE.
+* @return A new TunnelingProxy able to serve multiple servers.
+* @throws IOException If the proxy could not be created.
+*/
+public static TunnelingProxy createHttpsProxyTunnel(HttpAuthSchemeType authScheme)
+throws IOException {
+HttpsProxyTunnel result = new HttpsProxyTunnel("", null, null, null);
+if (authScheme != HttpAuthSchemeType.NONE) {
+result.configureAuthentication(null,
+authScheme,
+AUTHENTICATOR,
+HttpAuthType.PROXY);
+}
+return result;
+}
 private static String protocol(String protocol) {
 if ("http".equalsIgnoreCase(protocol)) return "http";
 else if ("https".equalsIgnoreCase(protocol)) return "https";
 else throw new InternalError("Unsupported protocol: " + protocol);
 }

branch	http-client-branch
changeset 56128	249a863b0aca
parent 56104	3420c1bdd254
child 56136	3b58e5bacad6