jdk-sandbox: comparison test/jdk/java/net/HttpURLConnection/SetAuthenticator/HTTPTestServer.java

equal deleted inserted replaced

-:13588c901957
+:9cf78a70fa4f
 final List<B> toClose = new ArrayList<>();
 try {
 for (int i = 1; i <= max; i++) {
 B bindable = createBindable();
 SocketAddress address = getAddress(bindable);
-String key = address.toString();
+String key = toString(address);
 if (addresses.addIfAbsent(key)) {
 System.out.println("Socket bound to: " + key
 + " after " + i + " attempt(s)");
 return bindable;
 }
 try { close(b); } catch (Exception x) { /* ignore */ }
 }
 }
 throw new IOException("Couldn't bind socket after " + max + " attempts: "
 + "addresses used before: " + addresses);
+}
+private static String toString(SocketAddress address) {
+// We don't rely on address.toString(): sometimes it can be
+// "/127.0.0.1:port", sometimes it can be "localhost/127.0.0.1:port"
+// Instead we compose our own string representation:
+InetSocketAddress candidate = (InetSocketAddress) address;
+String hostAddr = candidate.getAddress().getHostAddress();
+if (hostAddr.contains(":")) hostAddr = "[" + hostAddr + "]";
+return hostAddr + ":" + candidate.getPort();
 }
 protected abstract B createBindable() throws IOException;
 protected abstract SocketAddress getAddress(B bindable);
 impl.start();
 return redirectingServer;
 }
 public InetSocketAddress getAddress() {
+return serverImpl.getAddress();
+}
+public InetSocketAddress getProxyAddress() {
 return serverImpl.getAddress();
 }
 public void stop() {
 serverImpl.stop(0);
 // CONNECT and then redirect streams to the real server.
 static class HttpsProxyTunnel extends HTTPTestServer
 implements Runnable {
 final ServerSocket ss;
+private volatile boolean stop;
 public HttpsProxyTunnel(HttpServer server, HTTPTestServer target,
 HttpHandler delegate)
 throws IOException {
 super(server, target, delegate);
 System.out.flush();
 t.start();
 }
 @Override
 public void stop() {
-super.stop();
+try (var toClose = ss) {
-try {
+stop = true;
-ss.close();
+System.out.println("Server " + ss + " stop requested");
+super.stop();
 } catch (IOException ex) {
 if (DEBUG) ex.printStackTrace(System.out);
 }
 }
 }
 };
 }
 @Override
-public InetSocketAddress getAddress() {
+public InetSocketAddress getProxyAddress() {
 return new InetSocketAddress(ss.getInetAddress(), ss.getLocalPort());
 }
 // This is a bit shaky. It doesn't handle continuation
 // lines, but our client shouldn't send any.
 int c;
 while ((c = r.read()) != -1) {
 if (c == '\n') break;
 b.appendCodePoint(c);
 }
+if (b.length() == 0) {
+return "";
+}
 if (b.codePointAt(b.length() -1) == '\r') {
 b.delete(b.length() -1, b.length());
 }
 return b.toString();
 }
 @Override
 public void run() {
 Socket clientConnection = null;
-try {
+while (!stop) {
-while (true) {
+System.out.println("Tunnel: Waiting for client at: " + ss);
-System.out.println("Tunnel: Waiting for client");
+final Socket previous = clientConnection;
-Socket previous = clientConnection;
+try {
+clientConnection = ss.accept();
+} catch (IOException io) {
 try {
-clientConnection = ss.accept();
+ss.close();
+} catch (IOException ex) {
+if (DEBUG) {
+ex.printStackTrace(System.out);
+}
+}
+// log the reason that caused the server to stop accepting connections
+if (!stop) {
+System.err.println("Server will stop accepting connections due to an exception:");
+io.printStackTrace();
+}
+break;
+} finally {
+// close the previous connection
+if (previous != null) {
+try {
+previous.close();
+} catch (IOException e) {
+// ignore
+if (DEBUG) {
+System.out.println("Ignoring exception that happened while closing " +
+"an older connection:");
+e.printStackTrace(System.out);
+}
+}
+}
+}
+System.out.println("Tunnel: Client accepted");
+try {
+// We have only 1 client... process the current client
+// request and wait until it has finished before
+// accepting a new connection request.
+processRequestAndWaitToComplete(clientConnection);
+} catch (IOException ioe) {
+// close the client connection
+try {
+clientConnection.close();
 } catch (IOException io) {
-if (DEBUG) io.printStackTrace(System.out);
+// ignore
-break;
+if (DEBUG) {
+System.out.println("Ignoring exception that happened during client" +
+" connection close:");
+io.printStackTrace(System.out);
+}
 } finally {
-// close the previous connection
+clientConnection = null;
-if (previous != null) previous.close();
 }
-System.out.println("Tunnel: Client accepted");
+} catch (Throwable t) {
-Socket targetConnection = null;
+// don't close the client connection for non-IOExceptions, instead
-InputStream  ccis = clientConnection.getInputStream();
+// just log it and move on to accept next connection
-OutputStream ccos = clientConnection.getOutputStream();
+if (!stop) {
-Writer w = new OutputStreamWriter(
+t.printStackTrace();
-clientConnection.getOutputStream(), "UTF-8");
-PrintWriter pw = new PrintWriter(w);
-System.out.println("Tunnel: Reading request line");
-String requestLine = readLine(ccis);
-System.out.println("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!
-// Read all headers until we find the empty line that
-// signals the end of all headers.
-while(!requestLine.equals("")) {
-System.out.println("Tunnel: Reading header: "
-+ (requestLine = readLine(ccis)));
-}
-targetConnection = new Socket(
-serverImpl.getAddress().getAddress(),
-serverImpl.getAddress().getPort());
-// Then send the 200 OK response to the client
-System.out.println("Tunnel: Sending "
-+ "HTTP/1.1 200 OK\r\n\r\n");
-pw.print("HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n");
-pw.flush();
-} else {
-// This should not happen. If it does let our serverImpl
-// deal with it.
-throw new IOException("Tunnel: Unexpected status line: "
-+ requestLine);
 }
+}
-// Pipe the input stream of the client connection to the
+}
-// output stream of the target connection and conversely.
+}
-// Now the client and target will just talk to each other.
-System.out.println("Tunnel: Starting tunnel pipes");
+private void processRequestAndWaitToComplete(final Socket clientConnection)
-Thread t1 = pipe(ccis, targetConnection.getOutputStream(), '+');
+throws IOException, InterruptedException {
-Thread t2 = pipe(targetConnection.getInputStream(), ccos, '-');
+final Socket targetConnection;
-t1.start();
+InputStream  ccis = clientConnection.getInputStream();
-t2.start();
+OutputStream ccos = clientConnection.getOutputStream();
+Writer w = new OutputStreamWriter(
-// We have only 1 client... wait until it has finished before
+clientConnection.getOutputStream(), "UTF-8");
-// accepting a new connection request.
+PrintWriter pw = new PrintWriter(w);
-t1.join();
+System.out.println("Tunnel: Reading request line");
-t2.join();
+String requestLine = readLine(ccis);
-}
+System.out.println("Tunnel: Request line: " + requestLine);
-} catch (Throwable ex) {
+if (requestLine.startsWith("CONNECT ")) {
-try {
+// We should probably check that the next word following
-ss.close();
+// CONNECT is the host:port of our HTTPS serverImpl.
-} catch (IOException ex1) {
+// Some improvement for a followup!
-ex.addSuppressed(ex1);
-}
+// Read all headers until we find the empty line that
-ex.printStackTrace(System.err);
+// signals the end of all headers.
-}
+while(!requestLine.equals("")) {
-}
+System.out.println("Tunnel: Reading header: "
++ (requestLine = readLine(ccis)));
+}
+targetConnection = new Socket(
+serverImpl.getAddress().getAddress(),
+serverImpl.getAddress().getPort());
+// Then send the 200 OK response to the client
+System.out.println("Tunnel: Sending "
++ "HTTP/1.1 200 OK\r\n\r\n");
+pw.print("HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n");
+pw.flush();
+} else {
+// This should not happen. If it does then consider it a
+// client error and throw an IOException
+System.out.println("Tunnel: Throwing an IOException due to unexpected" +
+" request line: " + requestLine);
+throw new IOException("Client request error - Unexpected request line");
+}
+// Pipe the input stream of the client connection to the
+// output stream of the target connection and conversely.
+// Now the client and target will just talk to each other.
+System.out.println("Tunnel: Starting tunnel pipes");
+Thread t1 = pipe(ccis, targetConnection.getOutputStream(), '+');
+Thread t2 = pipe(targetConnection.getInputStream(), ccos, '-');
+t1.start();
+t2.start();
+// wait for the request to complete
+t1.join();
+t2.join();
+}
 }
 }

branch	datagramsocketimpl-branch
changeset 58678	9cf78a70fa4f
parent 54086	ccb4a50bee06
child 58679	9c3209ff7550