Writing new Uint8Array() causes server freeze with quic_bug_10586_6: span.empty() && !fin

[guest271314]

During testing.

Server. bun build --target=browser --packages=bundle ./node_modules/@fails-components/webtransport/lib/index.node.js --outfile=webtransport-bundle.js. Add node: specifiers where they don't exist in

import { Http3Server } from "./webtransport-bundle.js";
import certificates from "../cert.json" with { type: "json" };

let requests = 0;
const server = new Http3Server({
  port: 8080,
  host: "127.0.0.1",
  secret: certificates[0].secret,
  cert: certificates[0].pem,
  privKey: certificates[0].privateKey,
});

await server.startServer();
await server.ready;

console.info("server started");

const address = server.address();

const sessionStream = server.sessionStream("/");
const sessionReader = sessionStream.getReader();

while (true) {
  const { value: session, done } = await sessionReader.read();
  if (done) {
    break;
  }
  console.log(session.closed);
  let incomingTotalLength = 0;
  let incomingCurrentLength = 0;
  const buffer = new ArrayBuffer(0, { maxByteLength: 4 });
  const view = new DataView(buffer);
  const encoder = new TextEncoder();
  const decoder = new TextDecoder();
  for await (
    const { readable, writable } of session.incomingBidirectionalStreams
  ) {
    const writer = writable.getWriter();
    await readable
      .pipeTo(
        new WritableStream({
          async write(value) {
            if (incomingTotalLength === 0 && incomingCurrentLength === 0) {
              buffer.resize(4);
              for (let i = 0; i < 4; i++) {
                view.setUint8(i, value[i]);
              }
              incomingTotalLength = view.getUint32(0, true);
              console.log(value.length, incomingTotalLength);
              value = value.subarray(4);
            }
            const encoded = encoder.encode(
              decoder.decode(value).toUpperCase(),
            );
            await writer.ready;
            await writer.write(encoded);
            await writer.ready; //.then(() => console.log(`Done writing ${encoded.length} to writable, ${} total bytes written.`));
            incomingCurrentLength += encoded.length;
            console.log(
              `Done writing ${encoded.length} bytes to writable, ${incomingCurrentLength} of ${incomingTotalLength} bytes written.`,
            );
          },
          close() {
            console.log("readable closed");
          },
        }),
      ).then(() => console.log("pipeTo() done"))
      .catch((e) => console.log(e));

    buffer.resize(0);
    incomingTotalLength = 0;
    incomingCurrentLength = 0;
  }
  await session.closed.then(() => ({
    code: 5000,
    reason: `Done streaming request ${requests++}`,
  })).then((res) => console.log(res)).catch((e) => e.message);
}

Client (Chromium 137). One session, multiple streams. Starting with 7 MB. When done with session execute client.close({ closeCode: 5000, reason: "Done streaming" });

const serverCertificateHashes = [{
  "algorithm": "sha-256",
  "value": Uint8Array.of(1,2,3,4,... ), // Hard coded, once
}, ];
// Use Deno's WebTransport client in Deno, which doesn't support webtransport.node
if (!/Deno|Chrome|Firefox/i.test(navigator.userAgent)) {
  let {WebTransport, quicheLoaded} = await import("./node_modules/@fails-components/webtransport/lib/index.node.js");
  await quicheLoaded;
  globalThis.WebTransport = WebTransport;
}

async function createStream(wt, data) {
  const abortable = new AbortController();
  const {signal} = abortable;
  const {readable, writable} = await wt.createBidirectionalStream();
  let header = new Uint8Array(Uint32Array.from({
    length: 4,
  }, (_, index) => (data.length >> (index * 8)) & 0xff, ));
  let view = new DataView(header.buffer);
  let outgoingTotalLength = view.getUint32(0, true);
  console.log({
    outgoingTotalLength
  });
  let incomingTotalLength = 0;
  const writer = writable.getWriter();
  await writer.ready;
  await writer.write(header).then( () => console.log(`Outgoing total length ${outgoingTotalLength} written.`));
  await writer.ready;
  await writer.write(data).then( () => console.log(`${data.length} bytes written.`)).catch( (e) => console.log(e));
  await writer.ready;
  for await(const value of readable.pipeThrough(new TextDecoderStream())) {
    console.log(incomingTotalLength += value.length);
    if (incomingTotalLength === outgoingTotalLength) {
      await writer.ready;
      await writer.close().catch( (e) => {}
      );
      await writer.closed;
      writer.releaseLock();
      break;
    }
  }
  console.log(readable.locked);
  return "Session done";
}

const client = new WebTransport(`https://127.0.0.1:8080`,{
  serverCertificateHashes,
},);
client.closed.then(console.log).catch(console.log);
await client.ready;
const encoder = new TextEncoder();

var data = encoder.encode("x".repeat((1024 ** 2) * 7)); // 7MB

var res = await createStream(client, data); // "Session done"
// client.close({ closeCode: 5000, reason: "Done streaming" });
console.log(res);

Everything works as expected.

Write an empty Uint8Array

var res = await createStream(client, new Uint8Array());
// client.close({ closeCode: 5000, reason: "Done streaming" });
console.log(res);

What happens in the server

E0418 03:33:32.101059   46669 quic_stream.cc:823] quic_bug_10586_6: span.empty() && !fin

Thereafter the session is frozen.

Write 1 MB

var res = await createStream(client, new Uint8Array(1024**2));
// client.close({ closeCode: 5000, reason: "Done streaming" });
console.log(res);

Nothing happens in the server

[guest271314]

Looks like the error is from here https://source.chromium.org/chromium/chromium/src/+/main:net/third_party/quiche/src/quiche/quic/core/quic_stream.cc;l=899?q=quic_bug_10586_6&sq=.

Is there an issue with send 0-length data in QUIC?

[guest271314]

@martenrichter The Uint8Array should be handledd just like any other data. Echo back the 0-length Uint8Array. It's definitely not an error. And definitely should not be ignored. It's a data structure.

[martenrichter]

No, it will never echo back. It is, in the best case, a noop. The stream does not transmit the Uint8Arrays, only its content, so no content is sent. Your buffers can be split, joined, or combined in any way.

Anyway, I am just now try to make a test case in my test harness and try to reproduce it.

[guest271314]

No, it will never echo back.

Anyway, I am just now try to make a test case in my test harness and try to reproduce it.

If you have not tested this how sure can you be?

What happens when you upload a ReadableStream to an HTTP/2 server and send an empty Uint8Array? What happens when you send an empty Uint8Array using WebSocket? What happens when you send an empty Uint8Array through UDP?

HTTP/3 can't be so divergent that it just ignore the empty data structure or error.

[martenrichter]

No, it will never echo back.

Anyway, I am just now try to make a test case in my test harness and try to reproduce it.

If you have not tested this how sure can you be?

Because I have read the spec of the http/3 webtransport protocol.
There is no mechanism to transmit borders of arrays, only just data. It is in this way very different from WebSocke.t

What happens when you upload a ReadableStream to an HTTP/2 server and send an empty Uint8Array?

In this way, it is possible that I have sent an empty capsule. But this is actually, also something, that should result into a noop.

What happens when you send an empty Uint8Array using WebSocket?

In WebSocket, the Uint8Array is converted to a data structure that indicates its boundaries, so it's a completely different story.

What happens when you send an empty Uint8Array through UDP?

??? UDP does not know anything about Uint8Array, it is just a packet with byte payload within MTU,.

HTTP/3 can't be so divergent that it just ignore the empty data structure or error.

It is a stream, if you append nothing, nothing changes.

[guest271314]

This works just fine. No error thrown. No ignoring of empty data.

deno -A --unstable-net deno-udp-server.js

const encoder = new TextEncoder();
const config = {
  port: 10001,
  transport: "udp",
};
const listener = Deno.listenDatagram(config);
for await (const [data, address] of listener) {
  const message = decoder.decode(data);
  console.log("Server - received information from", address);
  console.log("Server - received:", { message });
  await listener.send(data, address);
}

deno -A --unstable-net deno-udp.js

const listener = Deno.listenDatagram({
  port: 44818,
  transport: "udp",
});
const peerAddress = {
  transport: "udp",
  hostname: "0.0.0.0",
  port: 10001,
};
await listener.send(new Uint8Array(), peerAddress);

Server - received information from [Object: null prototype] {
  hostname: "127.0.0.1",
  port: 44818,
  transport: "udp"
}
Server - received: { message: "" }

[martenrichter]

But these are simple UDP packets, so you are sending packets with a payload, and one payload is empty. Quick and http/3 add a lot more complexity, including encryption, and probably ways to disguise how long your message was. So that is unrelated.

[guest271314]

Empty payload shouln't matter. Let's not decode the message in the server.

Server - received information from [Object: null prototype] {
  hostname: "127.0.0.1",
  port: 44818,
  transport: "udp"
}
Server - received: { data: Uint8Array(0) [] }

[martenrichter]

Please look at (quick readthrough, should suffice):
https://datatracker.ietf.org/doc/rfc9000/
https://datatracker.ietf.org/doc/rfc9114/
https://datatracker.ietf.org/doc/draft-ietf-webtrans-http3/
to get an idea of what is behind these protocols. Otherwise. the conversation will not be productive, as there is a big difference to plain UDP.

[guest271314]

If you already knew the answer to this you wouldn't have to ask for reassurance over on WebTransport.

This thing is new and all kinds of details are being worked out as we move along. E.g. headers, CORS, empty Uint8Array.

Just send the empty Uint8Array through.

Let's say you're using WebTransport (HTTP/3/QUIC) for media server.

What happens when you stream silence?

The HTTP/3 server just dies?

[guest271314]

I'm pretty sure in any case you are not expecting your WebTransport server implementation to halt, and stop working thereafter just because an empty Uint8Array is sent. That's what happens with your implementation. Send an empty Uint8Array and your code breaks.

[martenrichter]

If you already knew the answer to this you wouldn't have to ask for reassurance over on WebTransport.

Well, I want to know, if it would be worth to present the user with an error, in order to prevent misconceptions about the protocol.
As people coming from WebSocket (and this included me, when I started), may assume that the Uint8Array with its size is transmitted. So erroring in this case may help

This thing is new and all kinds of details are being worked out as we move along. E.g. headers, CORS, empty Uint8Array.

But the protocol beneath does not support it.

Just send the empty Uint8Array through.

Let's say you're using WebTransport (HTTP/3/QUIC) for media server.

What happens when you stream silence?

You actually send encoded audio data, which have some length even for silence.

The HTTP/3 server just dies?
No, there are other mechanisms in quic, read the spec.

[martenrichter]

I'm pretty sure in any case you are not expecting your WebTransport server implementation to halt, and stop working thereafter just because an empty Uint8Array is sent. That's what happens with your implementation. Send an empty Uint8Array and your code breaks.

This is true and I am working on a patch, which is almost done. I only need input, if I should error, first attempt is to just do a noop.