@bytecodealliance/preview2-shim 0.14.2 → 0.15.0

package/lib/io/worker-socket-udp.js

@@ -1,219 +1,576 @@
-/*
- * @typedef {import("../../types/interfaces/wasi-sockets-network").IpAddressFamily} IpAddressFamily
- */
 import { createSocket } from "node:dgram";
+import {
+  createFuture,
+  futureDispose,
+  futureTakeValue,
+  pollStateReady,
+  verifyPollsDroppedForDrop,
+} from "./worker-thread.js";
+import {
+  convertSocketError,
+  convertSocketErrorCode,
+  getDefaultReceiveBufferSize,
+  getDefaultSendBufferSize,
+  ipSocketAddress,
+  isIPv4MappedAddress,
+  isWildcardAddress,
+  noLookup,
+  serializeIpAddress,
+  SOCKET_STATE_BIND,
+  SOCKET_STATE_BOUND,
+  SOCKET_STATE_CLOSED,
+  SOCKET_STATE_CONNECTION,
+  SOCKET_STATE_INIT,
+} from "./worker-sockets.js";
 
-const symbolSocketUdpIpUnspecified =
-  Symbol.symbolSocketUdpIpUnspecified ??
-  Symbol.for("symbolSocketUdpIpUnspecified");
+// Experimental support for batched UDP sends. Set this to true to enable.
+// This is not enabled by default because we need to figure out how to know
+// how many datagrams were sent when there is an error in a batch.
+// See the err path in "handler" in the "doSendBatch" of socketOutgoingDatagramStreamSend.
+const UDP_BATCH_SENDS = false;
 
-/** @type {Map<number, NodeJS.Socket>} */
-export const openedSockets = new Map();
+/**
+ * @typedef {import("../../types/interfaces/wasi-sockets-network.js").IpSocketAddress} IpSocketAddress
+ * @typedef {import("../../../types/interfaces/wasi-sockets-tcp.js").IpAddressFamily} IpAddressFamily
+ *
+ *
+ * @typedef {{
+ *   state: number,
+ *   remoteAddress: string | null,
+ *   remotePort: number | null,
+ *   sendBufferSize: number | null,
+ *   receiveBufferSize: number | null,
+ *   unicastHopLimit: number,
+ *   udpSocket: import('node:dgram').Socket,
+ *   future: number | null,
+ *   serializedLocalAddress: string | null,
+ *   pollState: PollState,
+ *   incomingDatagramStream: number | null,
+ *   outgoingDatagramStream: number | null,
+ * }} UdpSocketRecord
+ *
+ * @typedef {{
+ *   active: bool,
+ *   error: any | null,
+ *   socket: UdpSocketRecord,
+ *   pollState: PollState,
+ *   queue?: Buffer[],
+ *   cleanup: () => void | null,
+ * }} DatagramStreamRecord
+ *
+ */
 
-/** @type {Map<number, Map<string, { data: Buffer, rinfo: { address: string, family: string, port: number, size: number } }>>} */
-const queuedReceivedSocketDatagrams = new Map();
+let udpSocketCnt = 0,
+  datagramStreamCnt = 0;
 
-let socketCnt = 0;
+/**
+ * @type {Map<number, UdpSocketRecord>}
+ */
+export const udpSockets = new Map();
 
-export function getSocketOrThrow(socketId) {
-  const socket = openedSockets.get(socketId);
-  if (!socket) throw "invalid-state";
-  return socket;
-}
+/**
+ * @type {Map<number, DatagramStreamRecord>}
+ */
+export const datagramStreams = new Map();
 
-export function getSocketByPort(port) {
-  return Array.from(openedSockets.values()).find(
-    (socket) => socket.address().port === port
-  );
+/**
+ * @param {IpAddressFamily} addressFamily
+ * @returns {number}
+ */
+export function createUdpSocket({ family, unicastHopLimit }) {
+  const udpSocket = createSocket({
+    type: family === "ipv6" ? "udp6" : "udp4",
+    reuseAddr: false,
+    ipv6Only: family === "ipv6",
+    lookup: noLookup,
+  });
+  udpSockets.set(++udpSocketCnt, {
+    state: SOCKET_STATE_INIT,
+    remoteAddress: null,
+    remotePort: null,
+    sendBufferSize: null,
+    receiveBufferSize: null,
+    unicastHopLimit,
+    udpSocket,
+    future: null,
+    serializedLocalAddress: null,
+    pollState: { ready: true, listener: null, polls: [], parentStream: null },
+    incomingDatagramStream: null,
+    outgoingDatagramStream: null,
+  });
+  return udpSocketCnt;
 }
 
-export function getBoundSockets(socketId) {
-  return Array.from(openedSockets.entries())
-    .filter(([id, _socket]) => id !== socketId) // exclude source socket
-    .map(([_id, socket]) => socket.address());
+/**
+ * @param {UdpSocketRecord} socket
+ * @returns {DatagramStreamRecord}
+ */
+function createIncomingDatagramStream(socket) {
+  const id = ++datagramStreamCnt;
+  const pollState = {
+    ready: false,
+    listener: null,
+    polls: [],
+    parentStream: null,
+  };
+  const datagramStream = {
+    id,
+    active: true,
+    error: null,
+    socket,
+    queue: [],
+    cleanup,
+    pollState,
+  };
+  const { udpSocket } = socket;
+  datagramStreams.set(id, datagramStream);
+  function cleanup() {
+    udpSocket.off("message", onMessage);
+    udpSocket.off("error", onError);
+  }
+  function onMessage(data, rinfo) {
+    const family = rinfo.family.toLowerCase();
+    datagramStream.queue.push({
+      data,
+      remoteAddress: ipSocketAddress(family, rinfo.address, rinfo.port),
+    });
+    if (!pollState.ready) pollStateReady(pollState);
+  }
+  function onError(err) {
+    datagramStream.error = err;
+    pollStateReady(datagramStream.pollState);
+  }
+  udpSocket.on("message", onMessage);
+  udpSocket.once("error", onError);
+  return datagramStream;
 }
 
-export function dequeueReceivedSocketDatagram(socketInfo, maxResults) {
-  const key = `PORT:${socketInfo.port}`;
-  const dgrams = queuedReceivedSocketDatagrams
-    .get(key)
-    .splice(0, Number(maxResults));
-  return dgrams;
-}
-export function enqueueReceivedSocketDatagram(socketInfo, { data, rinfo }) {
-  const key = `PORT:${socketInfo.port}`;
-  const chunk = {
-    data,
-    rinfo, // sender/remote socket info (source)
-    socketInfo, // receiver socket info (targeted socket)
+/**
+ * @param {UdpSocketRecord} socket
+ * @returns {DatagramStreamRecord}
+ */
+function createOutgoingDatagramStream(socket) {
+  const id = ++datagramStreamCnt;
+  const datagramStream = {
+    id,
+    active: true,
+    error: null,
+    socket,
+    cleanup,
+    pollState: { ready: true, listener: null, polls: [], parentStream: null },
   };
-
-  // create new queue if not exists
-  if (!queuedReceivedSocketDatagrams.has(key)) {
-    queuedReceivedSocketDatagrams.set(key, []);
+  const { udpSocket } = socket;
+  datagramStreams.set(id, datagramStream);
+  udpSocket.on("error", onError);
+  function onError(err) {
+    datagramStream.error = err;
+    pollStateReady(datagramStream.pollState);
+  }
+  function cleanup() {
+    udpSocket.off("error", onError);
   }
+  return datagramStream;
+}
+
+export function socketUdpBindStart(id, localAddress, family) {
+  const socket = udpSockets.get(id);
 
-  // append to queue
-  const queue = queuedReceivedSocketDatagrams.get(key);
-  queue.push(chunk);
+  if (family !== localAddress.tag || isIPv4MappedAddress(localAddress))
+    throw "invalid-argument";
+
+  const serializedLocalAddress = serializeIpAddress(localAddress);
+
+  if (socket.state !== SOCKET_STATE_INIT) throw "invalid-state";
+  socket.state = SOCKET_STATE_BIND;
+  const { udpSocket } = socket;
+  socket.future = createFuture(
+    new Promise((resolve, reject) => {
+      function bindOk() {
+        resolve();
+        udpSocket.off("error", bindErr);
+      }
+      function bindErr(err) {
+        reject(convertSocketError(err));
+        udpSocket.off("listening", bindOk);
+      }
+      udpSocket.once("listening", bindOk);
+      udpSocket.once("error", bindErr);
+      udpSocket.bind(localAddress.val.port, serializedLocalAddress);
+    }),
+    socket.pollState
+  );
 }
 
-//-----------------------------------------------------
+export function socketUdpBindFinish(id) {
+  const socket = udpSockets.get(id);
+  if (socket.state !== SOCKET_STATE_BIND) throw "not-in-progress";
+  if (!socket.pollState.ready) throw "would-block";
+  const { tag, val } = futureTakeValue(socket.future).val;
+  futureDispose(socket.future, false);
+  socket.future = null;
+  if (tag === "err") {
+    socket.state = SOCKET_STATE_CLOSED;
+    throw val;
+  } else {
+    // once bound, we can now set the options
+    // since Node.js doesn't support setting them until bound
+    socket.udpSocket.setTTL(socket.unicastHopLimit);
+    if (socket.sendBufferSize)
+      socket.udpSocket.setRecvBufferSize(socket.sendBufferSize);
+    if (socket.receieveBufferSize)
+      socket.udpSocket.setSendBufferSize(socket.receiveBufferSize);
+    socket.state = SOCKET_STATE_BOUND;
+    return val;
+  }
+}
 
 /**
- * @param {IpAddressFamily} addressFamily
- * @returns {NodeJS.Socket}
+ * @param {number} id
+ * @returns {IpSocketAddress}
  */
-export function createUdpSocket(addressFamily, reuseAddr) {
-  return new Promise((resolve, reject) => {
-    const type = addressFamily === "ipv6" ? "udp6" : "udp4";
-    try {
-      const socket = createSocket({
-        type,
-        reuseAddr,
-      });
-      openedSockets.set(++socketCnt, socket);
-      resolve({
-        id: socketCnt,
-        socket,
-      });
-    } catch (e) {
-      reject(e);
-    }
-  });
+export function socketUdpGetLocalAddress(id) {
+  const { udpSocket } = udpSockets.get(id);
+  let address, family, port;
+  try {
+    ({ address, family, port } = udpSocket.address());
+  } catch (err) {
+    throw convertSocketError(err);
+  }
+  return ipSocketAddress(family.toLowerCase(), address, port);
 }
 
-export function socketUdpBind(id, payload) {
-  const { localAddress, localPort } = payload;
-  const socket = getSocketOrThrow(id);
-
-  // Note: even if the client has bound to IPV4_UNSPECIFIED/IPV6_UNSPECIFIED (0.0.0.0 // ::),
-  // rinfo.address is resolved to IPV4_LOOPBACK/IPV6_LOOPBACK.
-  // We need to cache the original bound IP type and fix rinfo.address when receiving datagrams (see below)
-  // See https://github.com/WebAssembly/wasi-sockets/issues/86
-  socket[symbolSocketUdpIpUnspecified] = {
-    isUnspecified:
-      localAddress === "0.0.0.0" || localAddress === "0:0:0:0:0:0:0:0",
-    localAddress,
-  };
+/**
+ * @param {number} id
+ * @returns {IpSocketAddress}
+ */
+export function socketUdpGetRemoteAddress(id) {
+  const { udpSocket } = udpSockets.get(id);
+  let address, family, port;
+  try {
+    ({ address, family, port } = udpSocket.remoteAddress());
+  } catch (err) {
+    throw convertSocketError(err);
+  }
+  return ipSocketAddress(family.toLowerCase(), address, port);
+}
 
-  return new Promise((resolve) => {
-    socket.bind(
-      {
-        address: localAddress,
-        port: localPort,
-      },
-      () => {
-        openedSockets.set(id, socket);
-        resolve(0);
-      }
-    );
+export function socketUdpStream(id, remoteAddress) {
+  const socket = udpSockets.get(id);
+  const { udpSocket } = socket;
 
-    socket.on("message", (data, rinfo) => {
-      const remoteSocket = getSocketByPort(rinfo.port);
-      let { address, port } = socket.address();
+  if (
+    socket.state !== SOCKET_STATE_BOUND &&
+    socket.state !== SOCKET_STATE_CONNECTION
+  )
+    throw "invalid-state";
 
-      if (remoteSocket[symbolSocketUdpIpUnspecified].isUnspecified) {
-        // cache original bound address
-        rinfo._address =
-          remoteSocket[symbolSocketUdpIpUnspecified].localAddress;
-      }
+  if (socket.state === SOCKET_STATE_INIT && !remoteAddress)
+    throw "invalid-state";
 
-      const receiverSocket = {
-        address,
-        port,
-        id,
-      };
+  if (
+    remoteAddress &&
+    (remoteAddress.val.port === 0 ||
+      isWildcardAddress(remoteAddress) ||
+      (remoteAddress.tag === "ipv6" && isIPv4MappedAddress(remoteAddress)))
+  )
+    throw "invalid-argument";
 
-      enqueueReceivedSocketDatagram(receiverSocket, { data, rinfo });
-    });
+  if (socket.state === SOCKET_STATE_CONNECTION) {
+    socketDatagramStreamClear(socket.incomingDatagramStream);
+    socketDatagramStreamClear(socket.outgoingDatagramStream);
+    try {
+      udpSocket.disconnect();
+    } catch (e) {
+      throw convertSocketErrorCode(e);
+    }
+  }
 
-    // catch all errors
-    socket.once("error", (err) => {
-      resolve(err.errno);
+  if (remoteAddress) {
+    const serializedRemoteAddress = serializeIpAddress(remoteAddress);
+    socket.remoteAddress = serializedRemoteAddress;
+    socket.remotePort = remoteAddress.val.port;
+    return new Promise((resolve, reject) => {
+      function connectOk() {
+        if (socket.state === SOCKET_STATE_INIT) {
+          socket.udpSocket.setTTL(socket.unicastHopLimit);
+          socket.udpSocket.setRecvBufferSize(socket.sendBufferSize);
+          socket.udpSocket.setSendBufferSize(socket.receiveBufferSize);
+        }
+        udpSocket.off("error", connectErr);
+        socket.state = SOCKET_STATE_CONNECTION;
+        resolve([
+          (socket.incomingDatagramStream = createIncomingDatagramStream(socket))
+            .id,
+          (socket.outgoingDatagramStream = createOutgoingDatagramStream(socket))
+            .id,
+        ]);
+      }
+      function connectErr(err) {
+        udpSocket.off("connect", connectOk);
+        reject(convertSocketError(err));
+      }
+      udpSocket.once("connect", connectOk);
+      udpSocket.once("error", connectErr);
+      udpSocket.connect(remoteAddress.val.port, serializedRemoteAddress);
     });
-  });
+  } else {
+    socket.state = SOCKET_STATE_BOUND;
+    socket.remoteAddress = null;
+    socket.remotePort = null;
+    return [
+      (socket.incomingDatagramStream = createIncomingDatagramStream(socket)).id,
+      (socket.outgoingDatagramStream = createOutgoingDatagramStream(socket)).id,
+    ];
+  }
 }
 
-export function socketUdpCheckSend(id) {
-  const socket = getSocketOrThrow(id);
-  try {
-    return socket.getSendBufferSize() - socket.getSendQueueSize();
-  } catch (err) {
-    return err.errno;
+export function socketUdpSetReceiveBufferSize(id, bufferSize) {
+  const socket = udpSockets.get(id);
+  bufferSize = Number(bufferSize);
+  if (
+    socket.state !== SOCKET_STATE_INIT &&
+    socket.state !== SOCKET_STATE_BIND
+  ) {
+    try {
+      socket.udpSocket.setRecvBufferSize(bufferSize);
+    } catch (err) {
+      throw convertSocketError(err);
+    }
   }
+  socket.receiveBufferSize = bufferSize;
 }
 
-export function socketUdpSend(id, payload) {
-  let { remoteHost, remotePort, data } = payload;
-  const socket = getSocketOrThrow(id);
-
-  return new Promise((resolve) => {
-    const _callback = (err, _byteLength) => {
-      if (err) return resolve(err.errno);
-      resolve(0); // success
-    };
-
-    // Note: when remoteHost/remotePort is None, we broadcast to all bound sockets
-    // except the source socket
-    if (remotePort === undefined || remoteHost === undefined) {
-      getBoundSockets(id).forEach((adr) => {
-        socket.send(data, adr.port, adr.address, _callback);
-      });
-    } else {
-      socket.send(data, remotePort, remoteHost, _callback);
+export function socketUdpSetSendBufferSize(id, bufferSize) {
+  const socket = udpSockets.get(id);
+  bufferSize = Number(bufferSize);
+  if (
+    socket.state !== SOCKET_STATE_INIT &&
+    socket.state !== SOCKET_STATE_BIND
+  ) {
+    try {
+      socket.udpSocket.setSendBufferSize(bufferSize);
+    } catch (err) {
+      throw convertSocketError(err);
     }
+  }
+  socket.sendBufferSize = bufferSize;
+}
 
-    socket.once("error", (err) => {
-      resolve(err.errno);
-    });
-  });
+export function socketUdpSetUnicastHopLimit(id, hopLimit) {
+  const socket = udpSockets.get(id);
+  if (
+    socket.state !== SOCKET_STATE_INIT &&
+    socket.state !== SOCKET_STATE_BIND
+  ) {
+    try {
+      socket.udpSocket.setTTL(hopLimit);
+    } catch (err) {
+      throw convertSocketError(err);
+    }
+  }
+  socket.unicastHopLimit = hopLimit;
 }
 
-export function SocketUdpReceive(id, payload) {
-  const { maxResults } = payload;
-  const socket = getSocketOrThrow(id);
-  const { address, port } = socket.address();
+export async function socketUdpGetReceiveBufferSize(id) {
+  const socket = udpSockets.get(id);
+  if (socket.receiveBufferSize) return BigInt(socket.receiveBufferSize);
+  if (
+    socket.state !== SOCKET_STATE_INIT &&
+    socket.state !== SOCKET_STATE_BIND
+  ) {
+    try {
+      return BigInt(
+        (socket.receiveBufferSize = socket.udpSocket.getRecvBufferSize())
+      );
+    } catch (err) {
+      throw convertSocketError(err);
+    }
+  } else {
+    return BigInt(
+      (socket.receiveBufferSize = await getDefaultReceiveBufferSize())
+    );
+  }
+}
 
-  // set target socket info
-  // we use this to filter out datagrams that are were sent to this socket
-  const targetSocket = {
-    address,
-    port,
-  };
+export async function socketUdpGetSendBufferSize(id) {
+  const socket = udpSockets.get(id);
+  if (socket.sendBufferSize) return BigInt(socket.sendBufferSize);
+  if (
+    socket.state !== SOCKET_STATE_INIT &&
+    socket.state !== SOCKET_STATE_BIND
+  ) {
+    try {
+      return BigInt(
+        (socket.sendBufferSize = socket.udpSocket.getSendBufferSize())
+      );
+    } catch (err) {
+      throw convertSocketError(err);
+    }
+  } else {
+    return BigInt((socket.sendBufferSize = await getDefaultSendBufferSize()));
+  }
+}
 
-  const dgrams = dequeueReceivedSocketDatagram(targetSocket, maxResults);
-  return Promise.resolve(dgrams);
+export function socketUdpGetUnicastHopLimit(id) {
+  const { unicastHopLimit } = udpSockets.get(id);
+  return unicastHopLimit;
 }
 
-export function socketUdpConnect(id, payload) {
-  const socket = getSocketOrThrow(id);
-  const { remoteAddress, remotePort } = payload;
+export function socketUdpDispose(id) {
+  const { udpSocket } = udpSockets.get(id);
   return new Promise((resolve) => {
-    socket.connect(remotePort, remoteAddress, () => {
-      openedSockets.set(id, socket);
+    udpSocket.close(() => {
+      udpSockets.delete(id);
       resolve(0);
     });
-    socket.once("error", (err) => {
-      resolve(err.errno);
-    });
   });
 }
 
-export function socketUdpDisconnect(id) {
-  const socket = getSocketOrThrow(id);
-  return new Promise((resolve) => {
-    socket.disconnect();
-    resolve(0);
-  });
+export function socketIncomingDatagramStreamReceive(id, maxResults) {
+  const datagramStream = datagramStreams.get(id);
+  if (!datagramStream.active)
+    throw new Error(
+      "wasi-io trap: attempt to receive on inactive incoming datagram stream"
+    );
+  if (maxResults === 0n || datagramStream.queue.length === 0) return [];
+  if (datagramStream.error) throw convertSocketError(datagramStream.error);
+  return datagramStream.queue.splice(0, Number(maxResults));
 }
 
-export function socketUdpDispose(id) {
-  const socket = getSocketOrThrow(id);
-  return new Promise((resolve) => {
-    socket.close(() => {
-      openedSockets.delete(id);
-      resolve(0);
+export async function socketOutgoingDatagramStreamSend(id, datagrams) {
+  const { active, socket } = datagramStreams.get(id);
+  if (!active)
+    throw new Error(
+      "wasi-io trap: writing to inactive outgoing datagram stream"
+    );
+
+  const { udpSocket } = socket;
+  let sendQueue = [],
+    sendQueueAddress,
+    sendQueuePort;
+  let datagramsSent = 0;
+  for (const { data, remoteAddress } of datagrams) {
+    const address = remoteAddress
+      ? serializeIpAddress(remoteAddress)
+      : socket.remoteAddress;
+    const port = remoteAddress?.val.port ?? socket.remotePort;
+    let sendLastBatch = !UDP_BATCH_SENDS;
+    if (sendQueue.length > 0) {
+      if (sendQueueAddress === address && sendQueuePort === port) {
+        sendQueue.push(data);
+      } else {
+        sendLastBatch = true;
+      }
+    } else {
+      sendQueueAddress = address;
+      sendQueuePort = port;
+      sendQueue.push(data);
+    }
+    if (sendLastBatch) {
+      const err = await doSendBatch();
+      if (err) return BigInt(datagramsSent);
+      if (UDP_BATCH_SENDS) {
+        sendQueue = [data];
+        sendQueuePort = port;
+        sendQueueAddress = address;
+      } else {
+        sendQueue = [];
+        sendQueuePort = port;
+        sendQueueAddress = address;
+      }
+    }
+  }
+  if (sendQueue.length) {
+    const err = await doSendBatch();
+    if (err) return BigInt(datagramsSent);
+  }
+
+  if (datagramsSent !== datagrams.length)
+    throw new Error("wasi-io trap: expected to have sent all the datagrams");
+  return BigInt(datagramsSent);
+
+  function doSendBatch() {
+    return new Promise((resolve, reject) => {
+      if (socket.remoteAddress) {
+        if (sendQueueAddress !== socket.remoteAddress || sendQueuePort !== socket.remotePort)
+          return void reject("invalid-argument");
+        udpSocket.send(sendQueue, handler);
+      } else {
+        if (!sendQueueAddress)
+          return void reject("invalid-argument");
+        udpSocket.send(sendQueue, sendQueuePort, sendQueueAddress, handler);
+      }
+      function handler(err, _sentBytes) {
+        if (err) {
+          // TODO: update datagramsSent properly on error for multiple sends
+          //       to enable send batching. Perhaps a Node.js PR could
+          //       still set the second sendBytes arg?
+          if (datagramsSent > 0) resolve(datagramsSent);
+          else reject(convertSocketError(err));
+          return;
+        }
+        datagramsSent += sendQueue.length;
+        resolve(false);
+      }
     });
+  }
+}
+
+function checkSend(socket) {
+  try {
+    return Math.floor(
+      (socket.udpSocket.getSendBufferSize() -
+        socket.udpSocket.getSendQueueSize()) /
+        1500
+    );
+  } catch (err) {
+    throw convertSocketError(err);
+  }
+}
+
+function pollSend(socket) {
+  socket.pollState.ready = false;
+  // The only way we have of dealing with getting a backpressure
+  // ready signal in Node.js is to just poll on the queue reducing.
+  // Ideally this should implement backoff on the poll interval,
+  // but that work should be done alongside careful benchmarking
+  // in due course.
+  setTimeout(() => {
+    const remaining = checkSend(socket);
+    if (remaining > 0) {
+      pollStateReady(socket.pollState);
+    } else {
+      pollSend(socket);
+    }
   });
 }
+
+export function socketOutgoingDatagramStreamCheckSend(id) {
+  const { active, socket } = datagramStreams.get(id);
+  if (!active)
+    throw new Error(
+      "wasi-io trap: check send on inactive outgoing datagram stream"
+    );
+  const remaining = checkSend(socket);
+  if (remaining <= 0) pollSend(socket);
+  return BigInt(remaining);
+}
+
+function socketDatagramStreamClear(datagramStream) {
+  datagramStream.active = false;
+  if (datagramStream.cleanup) {
+    datagramStream.cleanup();
+    datagramStream.cleanup = null;
+  }
+}
+
+export function socketDatagramStreamDispose(id) {
+  const datagramStream = datagramStreams.get(id);
+  datagramStream.active = false;
+  if (datagramStream.cleanup) {
+    datagramStream.cleanup();
+    datagramStream.cleanup = null;
+  }
+  verifyPollsDroppedForDrop(datagramStream.pollState, "datagram stream");
+  datagramStreams.delete(id);
+}