Manual 100 continue handling

src/main/asciidoc/cheatsheet/HttpServerOptions.adoc

@@ -135,4 +135,9 @@ Set the websocket subprotocols supported by the server.+++
 |`Boolean`
 |+++
 Set whether client auth is required+++
+
+|[[handle100ContinueAutomatically]]`handle100ContinueAutomatically`
+|`Boolean`
+|+++
+Set whether 100 Continue should be handled automatically+++
 |===

src/main/asciidoc/java/http.adoc

@@ -1047,6 +1047,17 @@ request.continueHandler(v -> {
 });
 ----
 
+On the server side a Vert.x http server can be configured to automatically send back 100 Continue interim responses
+when it receives an `Expect: 100-Continue` header.
+This is done by setting the option `link:../../apidocs/io/vertx/core/http/HttpServerOptions.html#setHandle100ContinueAutomatically-boolean-[setHandle100ContinueAutomatically]`.
+
+If you'd prefer to decide whether to send back continue responses manually, then this property should be set to
+`false` (the default), then you can inspect the headers and call `link:../../apidocs/io/vertx/core/http/HttpServerResponse.html#writeContinue--[writeContinue]`
+if you wish the client to continue sending the body or you can reject the request by sending back a failure status code
+if you don't want it to send the body. For example:
+
+
+
 === Enabling compression on the client
 
 The http client comes with support for HTTP Compression out of the box.

src/main/java/examples/HTTPExamples.java

@@ -523,6 +523,26 @@ public void example50(HttpClient client) {
     });
   }
 
+  public void example50_1(HttpServer httpServer) {
+
+    httpServer.requestHandler(request -> {
+      if (request.getHeader("Expect").equalsIgnoreCase("100-Continue")) {
+        // Now decide if you want to accept the request
+
+        boolean accept = true;
+        if (accept) {
+          request.response().writeContinue();
+          request.bodyHandler(body -> {
+            // Do something with body
+          });
+        } else {
+          // Reject with a failure code
+          request.response().setStatusCode(405).end();
+        }
+      }
+    });
+  }
+
   public void example51(HttpServer server) {
 
     server.websocketHandler(websocket -> {

src/main/java/io/vertx/core/http/HttpServerOptions.java

@@ -19,12 +19,7 @@
 import io.vertx.codegen.annotations.DataObject;
 import io.vertx.core.buffer.Buffer;
 import io.vertx.core.json.JsonObject;
-import io.vertx.core.net.JksOptions;
-import io.vertx.core.net.PemTrustOptions;
-import io.vertx.core.net.PemKeyCertOptions;
-import io.vertx.core.net.NetServerOptions;
-import io.vertx.core.net.PfxOptions;
-import io.vertx.core.net.TCPSSLOptions;
+import io.vertx.core.net.*;
 
 /**
  * Represents options used by an {@link io.vertx.core.http.HttpServer} instance
@@ -49,9 +44,15 @@ public class HttpServerOptions extends NetServerOptions {
    */
   public static final int DEFAULT_MAX_WEBSOCKET_FRAME_SIZE = 65536;
 
+  /**
+   * Default value of whether 100-Continue should be handled automatically
+   */
+  public static final boolean DEFAULT_HANDLE_100_CONTINE_AUTOMATICALLY = false;
+
   private boolean compressionSupported;
   private int maxWebsocketFrameSize;
   private String websocketSubProtocols;
+  private boolean handle100ContinueAutomatically;
 
   /**
    * Default constructor
@@ -61,6 +62,7 @@ public HttpServerOptions() {
     setPort(DEFAULT_PORT); // We override the default for port
     compressionSupported = DEFAULT_COMPRESSION_SUPPORTED;
     maxWebsocketFrameSize = DEFAULT_MAX_WEBSOCKET_FRAME_SIZE;
+    handle100ContinueAutomatically = DEFAULT_HANDLE_100_CONTINE_AUTOMATICALLY;
   }
 
   /**
@@ -73,6 +75,7 @@ public HttpServerOptions(HttpServerOptions other) {
     this.compressionSupported = other.isCompressionSupported();
     this.maxWebsocketFrameSize = other.getMaxWebsocketFrameSize();
     this.websocketSubProtocols = other.getWebsocketSubProtocols();
+    this.handle100ContinueAutomatically = other.handle100ContinueAutomatically;
   }
 
   /**
@@ -85,6 +88,8 @@ public HttpServerOptions(JsonObject json) {
     this.compressionSupported = json.getBoolean("compressionSupported", DEFAULT_COMPRESSION_SUPPORTED);
     this.maxWebsocketFrameSize = json.getInteger("maxWebsocketFrameSize", DEFAULT_MAX_WEBSOCKET_FRAME_SIZE);
     this.websocketSubProtocols = json.getString("websocketSubProtocols", null);
+    this.handle100ContinueAutomatically = json.getBoolean("handle100ContinueAutomatically",
+      DEFAULT_HANDLE_100_CONTINE_AUTOMATICALLY);
     setPort(json.getInteger("port", DEFAULT_PORT));
   }
 
@@ -273,19 +278,36 @@ public HttpServerOptions setClientAuthRequired(boolean clientAuthRequired) {
     return this;
   }
 
+  /**
+   * @return whether 100 Continue should be handled automatically
+   */
+  public boolean isHandle100ContinueAutomatically() {
+    return handle100ContinueAutomatically;
+  }
+
+  /**
+   * Set whether 100 Continue should be handled automatically
+   * @param handle100ContinueAutomatically true if it should be handled automatically
+   * @return a reference to this, so the API can be used fluently
+   */
+  public HttpServerOptions setHandle100ContinueAutomatically(boolean handle100ContinueAutomatically) {
+    this.handle100ContinueAutomatically = handle100ContinueAutomatically;
+    return this;
+  }
+
   @Override
   public boolean equals(Object o) {
     if (this == o) return true;
-    if (!(o instanceof HttpServerOptions)) return false;
+    if (o == null || getClass() != o.getClass()) return false;
     if (!super.equals(o)) return false;
 
     HttpServerOptions that = (HttpServerOptions) o;
 
     if (compressionSupported != that.compressionSupported) return false;
     if (maxWebsocketFrameSize != that.maxWebsocketFrameSize) return false;
-    if (websocketSubProtocols != null ? !websocketSubProtocols.equals(that.websocketSubProtocols) : that.websocketSubProtocols != null) return false;
+    if (handle100ContinueAutomatically != that.handle100ContinueAutomatically) return false;
+    return !(websocketSubProtocols != null ? !websocketSubProtocols.equals(that.websocketSubProtocols) : that.websocketSubProtocols != null);
 
-    return true;
   }
 
   @Override
@@ -294,6 +316,7 @@ public int hashCode() {
     result = 31 * result + (compressionSupported ? 1 : 0);
     result = 31 * result + maxWebsocketFrameSize;
     result = 31 * result + (websocketSubProtocols != null ? websocketSubProtocols.hashCode() : 0);
+    result = 31 * result + (handle100ContinueAutomatically ? 1 : 0);
     return result;
   }
 }

src/main/java/io/vertx/core/http/HttpServerResponse.java

@@ -212,6 +212,14 @@ public interface HttpServerResponse extends WriteStream<Buffer> {
   @Fluent
   HttpServerResponse write(String chunk);
 
+  /**
+   * Used to write an interim 100 Continue response to signify that the client should send the rest of the request.
+   * Must only be used if the request contains an "Expect:100-Continue" header
+   * @return a reference to this, so the API can be used fluently
+   */
+  @Fluent
+  HttpServerResponse writeContinue();
+
   /**
    * Same as {@link #end(Buffer)} but writes a String in UTF-8 encoding before ending the response.
    *

src/main/java/io/vertx/core/http/impl/HttpServerResponseImpl.java

@@ -279,6 +279,12 @@ public HttpServerResponseImpl write(String chunk) {
     return write(Buffer.buffer(chunk).getByteBuf(), null);
   }
 
+  @Override
+  public HttpServerResponse writeContinue() {
+    conn.write100Continue();
+    return this;
+  }
+
   @Override
   public void end(String chunk) {
     end(Buffer.buffer(chunk));

src/main/java/io/vertx/core/http/impl/ServerConnection.java

@@ -69,15 +69,12 @@ class ServerConnection extends ConnectionBase {
   private static final Logger log = LoggerFactory.getLogger(ServerConnection.class);
 
   private static final int CHANNEL_PAUSE_QUEUE_SIZE = 5;
-  public static final String HANDLE_100_CONTINUE_PROP_NAME = "vertx.handle100Continue";
-  private static final boolean HANDLE_100_CONTINUE = Boolean.getBoolean(HANDLE_100_CONTINUE_PROP_NAME);
 
   private final Queue<Object> pending = new ArrayDeque<>(8);
   private final String serverOrigin;
   private final HttpServerImpl server;
   private WebSocketServerHandshaker handshaker;
   private final HttpServerMetrics metrics;
-
   private Object requestMetric;
   private Handler<HttpServerRequest> requestHandler;
   private Handler<ServerWebSocket> wsHandler;
@@ -320,6 +317,10 @@ synchronized void handleWebsocketConnect(ServerWebSocketImpl ws) {
     }
   }
 
+  void write100Continue() {
+    channel.writeAndFlush(new DefaultFullHttpResponse(HTTP_1_1, CONTINUE));
+  }
+
   synchronized private void handleWsFrame(WebSocketFrameInternal frame) {
     if (ws != null) {
       ws.handleFrame(frame);
@@ -380,12 +381,11 @@ private void processMessage(Object msg) {
         channel.pipeline().fireExceptionCaught(result.cause());
         return;
       }
-      if (HANDLE_100_CONTINUE) {
+      if (server.options().isHandle100ContinueAutomatically()) {
         if (HttpHeaders.is100ContinueExpected(request)) {
-          channel.writeAndFlush(new DefaultFullHttpResponse(HTTP_1_1, CONTINUE));
+          write100Continue();
         }
       }
-
       HttpServerResponseImpl resp = new HttpServerResponseImpl(vertx, this, request);
       HttpServerRequestImpl req = new HttpServerRequestImpl(this, request, resp);
       handleRequest(req, resp);

src/main/java/io/vertx/core/http/package-info.java

@@ -831,6 +831,17 @@
  * {@link examples.HTTPExamples#example50}
  * ----
  *
+ * On the server side a Vert.x http server can be configured to automatically send back 100 Continue interim responses
+ * when it receives an `Expect: 100-Continue` header.
+ * This is done by setting the option {@link io.vertx.core.http.HttpServerOptions#setHandle100ContinueAutomatically(boolean)}.
+ *
+ * If you'd prefer to decide whether to send back continue responses manually, then this property should be set to
+ * `false` (the default), then you can inspect the headers and call {@link io.vertx.core.http.HttpServerResponse#writeContinue()}
+ * if you wish the client to continue sending the body or you can reject the request by sending back a failure status code
+ * if you don't want it to send the body. For example:
+ *
+ *
+ *
  * === Enabling compression on the client
  *
  * The http client comes with support for HTTP Compression out of the box.

src/test/java/io/vertx/test/core/HttpTest.java

@@ -68,7 +68,8 @@ public class HttpTest extends HttpTestBase {
   public void setUp() throws Exception {
     super.setUp();
     testDir = testFolder.newFolder();
-    server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT).setHost(DEFAULT_HTTP_HOST));
+    server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT).setHost(DEFAULT_HTTP_HOST)
+                                        .setHandle100ContinueAutomatically(true));
     client = vertx.createHttpClient(new HttpClientOptions());
   }
 
@@ -291,6 +292,10 @@ public void testServerOptions() {
     assertTrue(options.getEnabledCipherSuites().contains("foo"));
     assertTrue(options.getEnabledCipherSuites().contains("bar"));
 
+    assertFalse(options.isHandle100ContinueAutomatically());
+    assertEquals(options, options.setHandle100ContinueAutomatically(true));
+    assertTrue(options.isHandle100ContinueAutomatically());
+
     testComplete();
   }
 
@@ -526,6 +531,7 @@ public void testCopyServerOptions() {
     boolean compressionSupported = rand.nextBoolean();
     int maxWebsocketFrameSize = TestUtils.randomPositiveInt();
     String wsSubProtocol = TestUtils.randomAlphaString(10);
+    boolean is100ContinueHandledAutomatically = rand.nextBoolean();
     options.setSendBufferSize(sendBufferSize);
     options.setReceiveBufferSize(receiverBufferSize);
     options.setReuseAddress(reuseAddress);
@@ -547,6 +553,7 @@ public void testCopyServerOptions() {
     options.setCompressionSupported(compressionSupported);
     options.setMaxWebsocketFrameSize(maxWebsocketFrameSize);
     options.setWebsocketSubProtocol(wsSubProtocol);
+    options.setHandle100ContinueAutomatically(is100ContinueHandledAutomatically);
     HttpServerOptions copy = new HttpServerOptions(options);
     assertEquals(sendBufferSize, copy.getSendBufferSize());
     assertEquals(receiverBufferSize, copy.getReceiveBufferSize());
@@ -572,8 +579,9 @@ public void testCopyServerOptions() {
     assertEquals(host, copy.getHost());
     assertEquals(acceptBacklog, copy.getAcceptBacklog());
     assertEquals(compressionSupported, copy.isCompressionSupported());
-    assertEquals(maxWebsocketFrameSize, options.getMaxWebsocketFrameSize());
-    assertEquals(wsSubProtocol, options.getWebsocketSubProtocols());
+    assertEquals(maxWebsocketFrameSize, copy.getMaxWebsocketFrameSize());
+    assertEquals(wsSubProtocol, copy.getWebsocketSubProtocols());
+    assertEquals(is100ContinueHandledAutomatically, copy.isHandle100ContinueAutomatically());
   }
 
   @Test
@@ -594,6 +602,7 @@ public void testDefaultServerOptionsJson() {
     assertEquals(def.getSoLinger(), json.getSoLinger());
     assertEquals(def.isUsePooledBuffers(), json.isUsePooledBuffers());
     assertEquals(def.isSsl(), json.isSsl());
+    assertEquals(def.isHandle100ContinueAutomatically(), json.isHandle100ContinueAutomatically());
   }
 
   @Test
@@ -627,6 +636,7 @@ public void testServerOptionsJson() {
     boolean compressionSupported = rand.nextBoolean();
     int maxWebsocketFrameSize = TestUtils.randomPositiveInt();
     String wsSubProtocol = TestUtils.randomAlphaString(10);
+    boolean is100ContinueHandledAutomatically = rand.nextBoolean();
 
     JsonObject json = new JsonObject();
     json.put("sendBufferSize", sendBufferSize)
@@ -648,7 +658,8 @@ public void testServerOptionsJson() {
       .put("acceptBacklog", acceptBacklog)
       .put("compressionSupported", compressionSupported)
       .put("maxWebsocketFrameSize", maxWebsocketFrameSize)
-      .put("websocketSubProtocols", wsSubProtocol);
+      .put("websocketSubProtocols", wsSubProtocol)
+      .put("handle100ContinueAutomatically", is100ContinueHandledAutomatically);
 
     HttpServerOptions options = new HttpServerOptions(json);
     assertEquals(sendBufferSize, options.getSendBufferSize());
@@ -677,6 +688,7 @@ public void testServerOptionsJson() {
     assertEquals(compressionSupported, options.isCompressionSupported());
     assertEquals(maxWebsocketFrameSize, options.getMaxWebsocketFrameSize());
     assertEquals(wsSubProtocol, options.getWebsocketSubProtocols());
+    assertEquals(is100ContinueHandledAutomatically, options.isHandle100ContinueAutomatically());
 
     // Test other keystore/truststore types
     json.put("pfxKeyCertOptions", new JsonObject().put("password", ksPassword))
@@ -2268,7 +2280,7 @@ public void testSendFileDirectoryWithHandler() throws Exception {
   }
 
   @Test
-  public void test100ContinueDefault() throws Exception {
+  public void test100ContinueHandledAutomatically() throws Exception {
     Buffer toSend = TestUtils.randomBuffer(1000);
 
     server.requestHandler(req -> {
@@ -2295,10 +2307,15 @@ public void test100ContinueDefault() throws Exception {
   }
 
   @Test
-  public void test100ContinueHandled() throws Exception {
+  public void test100ContinueHandledManually() throws Exception {
+
+    server.close();
+    server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT).setHost(DEFAULT_HTTP_HOST));
+
     Buffer toSend = TestUtils.randomBuffer(1000);
     server.requestHandler(req -> {
-      req.response().headers().set("HTTP/1.1", "100 Continue");
+      assertEquals("100-continue", req.getHeader("expect"));
+      req.response().writeContinue();
       req.bodyHandler(data -> {
         assertEquals(toSend, data);
         req.response().end();
@@ -2321,6 +2338,35 @@ public void test100ContinueHandled() throws Exception {
     await();
   }
 
+  @Test
+  public void test100ContinueRejectedManually() throws Exception {
+
+    server.close();
+    server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT).setHost(DEFAULT_HTTP_HOST));
+
+    server.requestHandler(req -> {
+      req.response().setStatusCode(405).end();
+      req.bodyHandler(data -> {
+        fail("body should not be received");
+      });
+    });
+
+    server.listen(onSuccess(s -> {
+      HttpClientRequest req = client.request(HttpMethod.PUT, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> {
+        assertEquals(405, resp.statusCode());
+        testComplete();
+      });
+      req.headers().set("Expect", "100-continue");
+      req.setChunked(true);
+      req.continueHandler(v -> {
+        fail("should not be called");
+      });
+      req.sendHead();
+    }));
+
+    await();
+  }
+
   @Test
   public void testClientDrainHandler() {
     pausingServer(s -> {