346 lines
11 KiB
Java
346 lines
11 KiB
Java
/*
|
|
* Copyright (c) 2001, 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 4507412
|
|
* @bug 4506998
|
|
* @summary Check that a 304 "Not-Modified" response from a server
|
|
* doesn't cause http client to close a keep-alive
|
|
* connection.
|
|
* Check that a content-length of 0 results in an
|
|
* empty input stream.
|
|
* @library /test/lib
|
|
* @run main ZeroContentLength
|
|
* @run main/othervm -Djava.net.preferIPv6Addresses=true ZeroContentLength
|
|
*/
|
|
|
|
import java.net.*;
|
|
import java.io.*;
|
|
import jdk.test.lib.net.URIBuilder;
|
|
|
|
public class ZeroContentLength {
|
|
|
|
/*
|
|
* Is debugging enabled - start with -d to enable.
|
|
*/
|
|
static boolean debug = false;
|
|
|
|
static void debug(String msg) {
|
|
if (debug)
|
|
System.out.println(msg);
|
|
}
|
|
|
|
/*
|
|
* The response string and content-length that
|
|
* the server should return;
|
|
*/
|
|
static String response;
|
|
static int contentLength;
|
|
|
|
static synchronized void setResponse(String rsp, int cl) {
|
|
response = rsp;
|
|
contentLength = cl;
|
|
}
|
|
|
|
static synchronized String getResponse() {
|
|
return response;
|
|
}
|
|
|
|
static synchronized int getContentLength() {
|
|
return contentLength;
|
|
}
|
|
|
|
/*
|
|
* Worker thread to service single connection - can service
|
|
* multiple http requests on same connection.
|
|
*/
|
|
class Worker extends Thread {
|
|
Socket s;
|
|
int id;
|
|
|
|
Worker(Socket s, int id) {
|
|
this.s = s;
|
|
this.id = id;
|
|
}
|
|
|
|
final int CR = '\r';
|
|
final int LF = '\n';
|
|
|
|
public void run() {
|
|
try {
|
|
|
|
s.setSoTimeout(2000);
|
|
int max = 20; // there should only be 20 connections
|
|
InputStream in = new BufferedInputStream(s.getInputStream());
|
|
|
|
for (;;) {
|
|
// read entire request from client, until CR LF CR LF
|
|
int c, total=0;
|
|
|
|
try {
|
|
while ((c = in.read()) > 0) {
|
|
total++;
|
|
if (c == CR) {
|
|
if ((c = in.read()) > 0) {
|
|
total++;
|
|
if (c == LF) {
|
|
if ((c = in.read()) > 0) {
|
|
total++;
|
|
if (c == CR) {
|
|
if ((c = in.read()) > 0) {
|
|
total++;
|
|
if (c == LF) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
} catch (SocketTimeoutException e) {}
|
|
|
|
debug("worker " + id +
|
|
": Read request from client " +
|
|
"(" + total + " bytes).");
|
|
|
|
if (total == 0) {
|
|
debug("worker: " + id + ": Shutdown");
|
|
return;
|
|
}
|
|
|
|
// response to client
|
|
PrintStream out = new PrintStream(
|
|
new BufferedOutputStream(
|
|
s.getOutputStream() ));
|
|
|
|
out.print("HTTP/1.1 " + getResponse() + "\r\n");
|
|
int clen = getContentLength();
|
|
if (clen >= 0) {
|
|
out.print("Content-Length: " + clen +
|
|
"\r\n");
|
|
}
|
|
out.print("\r\n");
|
|
for (int i=0; i<clen; i++) {
|
|
out.write( (byte)'.' );
|
|
}
|
|
out.flush();
|
|
|
|
debug("worked " + id +
|
|
": Sent response to client, length: " + clen);
|
|
|
|
if (--max == 0) {
|
|
s.close();
|
|
return;
|
|
}
|
|
}
|
|
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
} finally {
|
|
try {
|
|
s.close();
|
|
} catch (Exception e) { }
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Server thread to accept connection and create worker threads
|
|
* to service each connection.
|
|
*/
|
|
class Server extends Thread {
|
|
ServerSocket ss;
|
|
int connectionCount;
|
|
boolean shutdown = false;
|
|
|
|
Server(ServerSocket ss) {
|
|
this.ss = ss;
|
|
}
|
|
|
|
public synchronized int connectionCount() {
|
|
return connectionCount;
|
|
}
|
|
|
|
public synchronized void shutdown() {
|
|
shutdown = true;
|
|
}
|
|
|
|
public void run() {
|
|
try {
|
|
ss.setSoTimeout(2000);
|
|
|
|
for (;;) {
|
|
Socket s;
|
|
try {
|
|
debug("server: Waiting for connections");
|
|
s = ss.accept();
|
|
} catch (SocketTimeoutException te) {
|
|
synchronized (this) {
|
|
if (shutdown) {
|
|
debug("server: Shuting down.");
|
|
return;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
|
|
int id;
|
|
synchronized (this) {
|
|
id = connectionCount++;
|
|
}
|
|
|
|
Worker w = new Worker(s, id);
|
|
w.start();
|
|
debug("server: Started worker " + id);
|
|
}
|
|
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
} finally {
|
|
try {
|
|
ss.close();
|
|
} catch (Exception e) { }
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Make a single http request and return the content length
|
|
* received. Also do sanity check to ensure that the
|
|
* content-length header matches the total received on
|
|
* the input stream.
|
|
*/
|
|
int doRequest(String uri) throws Exception {
|
|
URL url = new URL(uri);
|
|
HttpURLConnection http = (HttpURLConnection)url.openConnection(Proxy.NO_PROXY);
|
|
|
|
int cl = http.getContentLength();
|
|
|
|
InputStream in = http.getInputStream();
|
|
byte b[] = new byte[100];
|
|
int total = 0;
|
|
int n;
|
|
do {
|
|
n = in.read(b);
|
|
if (n > 0) total += n;
|
|
} while (n > 0);
|
|
in.close();
|
|
|
|
if (cl >= 0 && total != cl) {
|
|
System.err.println("content-length header indicated: " + cl);
|
|
System.err.println("Actual received: " + total);
|
|
throw new Exception("Content-length didn't match actual received");
|
|
}
|
|
|
|
return total;
|
|
}
|
|
|
|
|
|
/*
|
|
* Send http requests to "server" and check that they all
|
|
* use the same network connection and that the content
|
|
* length corresponds to the content length expected.
|
|
* stream.
|
|
*/
|
|
ZeroContentLength() throws Exception {
|
|
|
|
/* start the server */
|
|
ServerSocket ss = new ServerSocket();
|
|
ss.bind(new InetSocketAddress(InetAddress.getLoopbackAddress(), 0));
|
|
Server svr = new Server(ss);
|
|
svr.start();
|
|
|
|
String uri = URIBuilder.newBuilder()
|
|
.scheme("http")
|
|
.host(ss.getInetAddress())
|
|
.port(ss.getLocalPort())
|
|
.path("/foo.html")
|
|
.build().toString();
|
|
|
|
int expectedTotal = 0;
|
|
int actualTotal = 0;
|
|
|
|
System.out.println("**********************************");
|
|
System.out.println("200 OK, content-length:1024 ...");
|
|
setResponse("200 OK", 1024);
|
|
for (int i=0; i<5; i++) {
|
|
actualTotal += doRequest(uri);
|
|
expectedTotal += 1024;
|
|
}
|
|
|
|
System.out.println("**********************************");
|
|
System.out.println("200 OK, content-length:0 ...");
|
|
setResponse("200 OK", 0);
|
|
for (int i=0; i<5; i++) {
|
|
actualTotal += doRequest(uri);
|
|
}
|
|
|
|
System.out.println("**********************************");
|
|
System.out.println("304 Not-Modified, (no content-length) ...");
|
|
setResponse("304 Not-Modifed", -1);
|
|
for (int i=0; i<5; i++) {
|
|
actualTotal += doRequest(uri);
|
|
}
|
|
|
|
System.out.println("**********************************");
|
|
System.out.println("204 No-Content, (no content-length) ...");
|
|
setResponse("204 No-Content", -1);
|
|
for (int i=0; i<5; i++) {
|
|
actualTotal += doRequest(uri);
|
|
}
|
|
|
|
// shutdown server - we're done.
|
|
svr.shutdown();
|
|
|
|
System.out.println("**********************************");
|
|
|
|
if (actualTotal == expectedTotal) {
|
|
System.out.println("Passed: Actual total equal to expected total");
|
|
} else {
|
|
throw new Exception("Actual total != Expected total!!!");
|
|
}
|
|
|
|
int cnt = svr.connectionCount();
|
|
if (cnt == 1) {
|
|
System.out.println("Passed: Only 1 connection established");
|
|
} else {
|
|
throw new Exception("Test failed: Number of connections " +
|
|
"established: " + cnt + " - see log for details.");
|
|
}
|
|
}
|
|
|
|
public static void main(String args[]) throws Exception {
|
|
|
|
if (args.length > 0 && args[0].equals("-d")) {
|
|
debug = true;
|
|
}
|
|
|
|
new ZeroContentLength();
|
|
}
|
|
|
|
}
|