Update quiche version to a specific commit (java-native-access#143)

Motivation:

To allow us to move faster we should just not depend on a specific release of quiche but pin to a specific commit. This will allow us to have everything ready once they cut a new release.

Modifications:

- Update to the current head of quiche and adjust code to make use of the new changes
- Remove workaround for bug that was fixed by quiche

Result:

Use recent quiche development version

pom.xml

@@ -76,7 +76,8 @@
     <jniUtilIncludeDir>${project.build.directory}/netty-jni-util/</jniUtilIncludeDir>
     <quicheCheckoutDir>${project.build.directory}/quiche</quicheCheckoutDir>
     <quicheBuildDir>${quicheCheckoutDir}/target/release</quicheBuildDir>
-    <quiche.version>0.6.0</quiche.version>
+    <quicheBranch>master</quicheBranch>
+    <quicheCommitSha>5403e54c40caf70f096a2a08c50c9d71c149da6f</quicheCommitSha>
     <generatedSourcesDir>${project.build.directory}/generated-sources</generatedSourcesDir>
     <cflags>-Werror -fno-omit-frame-pointer -fvisibility=hidden -Wunused -Wno-unused-value -O3 -I${quicheCheckoutDir}/include</cflags>
     <ldflags>-L${quicheBuildDir} -lquiche</ldflags>
@@ -218,11 +219,17 @@
                   <exec executable="git" failonerror="true" dir="${project.build.directory}" resolveexecutable="true">
                     <arg value="clone" />
                     <arg value="--branch" />
-                    <arg value="${quiche.version}" />
+                    <arg value="${quicheBranch}" />
                     <arg value="--recursive" />
                     <arg value="https://github.com/cloudflare/quiche" />
                     <arg value="${quicheCheckoutDir}" />
                   </exec>
+
+                  <!-- Use the known SHA of the commit -->
+                  <exec executable="git" failonerror="true" dir="${quicheCheckoutDir}" resolveexecutable="true">
+                    <arg value="checkout" />
+                    <arg value="${quicheCommitSha}" />
+                  </exec>
                 </else>
               </if>
               <if>
@@ -238,6 +245,8 @@
                     <then>
                       <exec executable="cargo" failonerror="true" dir="${quicheCheckoutDir}" resolveexecutable="true">
                         <arg value="build" />
+                        <arg value="--features" />
+                        <arg value="ffi" />
                         <arg value="--release" />
                         <env key="MACOSX_DEPLOYMENT_TARGET" value="${macosxDeploymentTarget}" />
                         <env key="CFLAGS" value="-O3 -fno-omit-frame-pointer -DOPENSSL_C11_ATOMIC" />

src/main/c/netty_quic_quiche.c

@@ -369,8 +369,12 @@ static void netty_quiche_config_set_max_idle_timeout(JNIEnv* env, jclass clazz,
     quiche_config_set_max_idle_timeout((quiche_config*) config, (uint64_t) value);
 }
 
-static void netty_quiche_config_set_max_udp_payload_size(JNIEnv* env, jclass clazz, jlong config, jlong value) {
-    quiche_config_set_max_udp_payload_size((quiche_config*) config, (uint64_t) value);
+static void netty_quiche_config_set_max_recv_udp_payload_size(JNIEnv* env, jclass clazz, jlong config, jlong value) {
+    quiche_config_set_max_recv_udp_payload_size((quiche_config*) config, (uint64_t) value);
+}
+
+static void netty_quiche_config_set_max_send_udp_payload_size(JNIEnv* env, jclass clazz, jlong config, jlong value) {
+    quiche_config_set_max_send_udp_payload_size((quiche_config*) config, (uint64_t) value);
 }
 
 static void netty_quiche_config_set_initial_max_data(JNIEnv* env, jclass clazz, jlong config, jlong value) {
@@ -520,7 +524,8 @@ static const JNINativeMethod fixed_method_table[] = {
   { "quiche_config_enable_early_data", "(J)V", (void *) netty_quiche_config_enable_early_data },
   { "quiche_config_set_application_protos", "(J[B)I", (void *) netty_quiche_config_set_application_protos },
   { "quiche_config_set_max_idle_timeout", "(JJ)V", (void *) netty_quiche_config_set_max_idle_timeout },
-  { "quiche_config_set_max_udp_payload_size", "(JJ)V", (void *) netty_quiche_config_set_max_udp_payload_size },
+  { "quiche_config_set_max_recv_udp_payload_size", "(JJ)V", (void *) netty_quiche_config_set_max_recv_udp_payload_size },
+  { "quiche_config_set_max_send_udp_payload_size", "(JJ)V", (void *) netty_quiche_config_set_max_send_udp_payload_size },
   { "quiche_config_set_initial_max_data", "(JJ)V", (void *) netty_quiche_config_set_initial_max_data },
   { "quiche_config_set_initial_max_stream_data_bidi_local", "(JJ)V", (void *) netty_quiche_config_set_initial_max_stream_data_bidi_local },
   { "quiche_config_set_initial_max_stream_data_bidi_remote", "(JJ)V", (void *) netty_quiche_config_set_initial_max_stream_data_bidi_remote },

src/main/java/io/netty/incubator/codec/quic/QuicCodecBuilder.java

@@ -42,7 +42,8 @@ public abstract class QuicCodecBuilder<B extends QuicCodecBuilder<B>> {
     private boolean earlyData;
     private byte[] protos;
     private Long maxIdleTimeout;
-    private Long maxUdpPayloadSize;
+    private Long maxRecvUdpPayloadSize;
+    private Long maxSendUdpPayloadSize;
     private Long initialMaxData;
     private Long initialMaxStreamDataBidiLocal;
     private Long initialMaxStreamDataBidiRemote;
@@ -195,16 +196,30 @@ public final B maxIdleTimeout(long amount, TimeUnit unit) {
     }
 
     /**
-     * See <a href="https://docs.rs/quiche/0.6.0/quiche/struct.Config.html#method.set_max_udp_payload_size">
-     *     set_max_udp_payload_size</a>.
+     * See <a href="https://github.com/cloudflare/quiche/blob/35e38d987c1e53ef2bd5f23b754c50162b5adac8/src/lib.rs#L669">
+     *     set_max_send_udp_payload_size</a>.
+     *
+     * The default and minimum value is 1200.
+     *
+     * @param size    the maximum payload size that is advertised to the remote peer.
+     * @return        the instance itself.
+     */
+    public final B maxSendUdpPayloadSize(long size) {
+        this.maxSendUdpPayloadSize = checkPositiveOrZero(size, "value");
+        return self();
+    }
+
+    /**
+     * See <a href="https://github.com/cloudflare/quiche/blob/35e38d987c1e53ef2bd5f23b754c50162b5adac8/src/lib.rs#L662">
+     *     set_max_recv_udp_payload_size</a>.
      *
      * The default value is 65527.
      *
      * @param size    the maximum payload size that is advertised to the remote peer.
      * @return        the instance itself.
      */
-    public final B maxUdpPayloadSize(long size) {
-        this.maxUdpPayloadSize = checkPositiveOrZero(size, "value");
+    public final B maxRecvUdpPayloadSize(long size) {
+        this.maxRecvUdpPayloadSize = checkPositiveOrZero(size, "value");
         return self();
     }
 
@@ -392,7 +407,7 @@ public final B datagram(int recvQueueLen, int sendQueueLen) {
 
     private QuicheConfig createConfig() {
         return new QuicheConfig(certPath, keyPath, verifyPeer, grease, earlyData,
-                protos, maxIdleTimeout, maxUdpPayloadSize, initialMaxData,
+                protos, maxIdleTimeout, maxSendUdpPayloadSize, maxRecvUdpPayloadSize, initialMaxData,
                 initialMaxStreamDataBidiLocal, initialMaxStreamDataBidiRemote,
                 initialMaxStreamDataUni, initialMaxStreamsBidi, initialMaxStreamsUni,
                 ackDelayExponent, maxAckDelay, disableActiveMigration, enableHystart,

src/main/java/io/netty/incubator/codec/quic/Quiche.java

@@ -415,10 +415,19 @@ static native int quiche_retry(long scidAddr, int scidLen, long dcidAddr, int dc
 
     /**
      * See
-     * <a href="https://github.com/cloudflare/quiche/blob/0.6.0/include/quiche.h#146">
-     *     quiche_config_set_max_udp_payload_size</a>.
+     * <a href="https://github.com/cloudflare/quiche/blob/
+     * 35e38d987c1e53ef2bd5f23b754c50162b5adac8/include/quiche.h#L150">
+     *     quiche_config_set_max_recv_udp_payload_size</a>.
      */
-    static native void quiche_config_set_max_udp_payload_size(long configAddr, long value);
+    static native void quiche_config_set_max_recv_udp_payload_size(long configAddr, long value);
+
+    /**
+     * See
+     * <a href="https://github.com/cloudflare/quiche/blob/
+     * 35e38d987c1e53ef2bd5f23b754c50162b5adac8/include/quiche.h#L153">
+     *     quiche_config_set_max_recv_udp_payload_size</a>.
+     */
+    static native void quiche_config_set_max_send_udp_payload_size(long configAddr, long value);
 
     /**
      * See

src/main/java/io/netty/incubator/codec/quic/QuicheConfig.java

@@ -20,8 +20,8 @@ final class QuicheConfig {
     private final long config;
 
     QuicheConfig(String certPath, String keyPath, Boolean verifyPeer, Boolean grease, boolean earlyData,
-                        byte[] protos, Long maxIdleTimeout, Long maxUdpPayloadSize, Long initialMaxData,
-                        Long initialMaxStreamDataBidiLocal, Long initialMaxStreamDataBidiRemote,
+                        byte[] protos, Long maxIdleTimeout, Long maxSendUdpPayloadSize, Long maxRecvUdpPayloadSize,
+                        Long initialMaxData, Long initialMaxStreamDataBidiLocal, Long initialMaxStreamDataBidiRemote,
                         Long initialMaxStreamDataUni, Long initialMaxStreamsBidi, Long initialMaxStreamsUni,
                         Long ackDelayExponent, Long maxAckDelay, Boolean disableActiveMigration, Boolean enableHystart,
                         QuicCongestionControlAlgorithm congestionControlAlgorithm,
@@ -50,8 +50,11 @@ final class QuicheConfig {
             if (maxIdleTimeout != null) {
                 Quiche.quiche_config_set_max_idle_timeout(config, maxIdleTimeout);
             }
-            if (maxUdpPayloadSize != null) {
-                Quiche.quiche_config_set_max_udp_payload_size(config, maxUdpPayloadSize);
+            if (maxSendUdpPayloadSize != null) {
+                Quiche.quiche_config_set_max_send_udp_payload_size(config, maxSendUdpPayloadSize);
+            }
+            if (maxRecvUdpPayloadSize != null) {
+                Quiche.quiche_config_set_max_recv_udp_payload_size(config, maxRecvUdpPayloadSize);
             }
             if (initialMaxData != null) {
                 Quiche.quiche_config_set_initial_max_data(config, initialMaxData);

src/main/java/io/netty/incubator/codec/quic/QuicheQuicChannel.java

@@ -767,13 +767,6 @@ StreamRecvResult streamRecv(long streamId, ByteBuf buffer) throws Exception {
         long memoryAddress = Quiche.memoryAddress(buffer);
         int recvLen = Quiche.quiche_conn_stream_recv(connectionAddressChecked(), streamId,
                 memoryAddress + writerIndex, buffer.writableBytes(), Quiche.memoryAddress(finBuffer));
-        if (recvLen == Quiche.QUICHE_ERR_INVALID_STREAM_STATE) {
-            // Remove this workaround as soon there is a quiche release that pulled in:
-            // https://github.com/cloudflare/quiche/pull/742
-            assert isStreamFinished(streamId);
-            return StreamRecvResult.FIN;
-        }
-
         if (Quiche.throwIfError(recvLen)) {
             return StreamRecvResult.DONE;
         } else {

src/test/java/io/netty/incubator/codec/quic/QuicTestUtils.java

@@ -65,7 +65,6 @@ static QuicClientCodecBuilder newQuicClientBuilder() {
                 .privateKey("./src/test/resources/cert.key")
                 .applicationProtocols(PROTOS)
                 .maxIdleTimeout(5000, TimeUnit.MILLISECONDS)
-                .maxUdpPayloadSize(Quic.MAX_DATAGRAM_SIZE)
                 .initialMaxData(10000000)
                 .initialMaxStreamDataBidirectionalLocal(1000000)
                 .initialMaxStreamDataBidirectionalRemote(1000000)
@@ -82,7 +81,6 @@ static QuicServerCodecBuilder newQuicServerBuilder() {
                 .privateKey("./src/test/resources/cert.key")
                 .applicationProtocols(PROTOS)
                 .maxIdleTimeout(5000, TimeUnit.MILLISECONDS)
-                .maxUdpPayloadSize(Quic.MAX_DATAGRAM_SIZE)
                 .initialMaxData(10000000)
                 .initialMaxStreamDataBidirectionalLocal(1000000)
                 .initialMaxStreamDataBidirectionalRemote(1000000)