@bytecodealliance/preview2-shim 0.14.1 → 0.14.2

package/lib/nodejs/sockets/udp-socket-impl.js

@@ -6,16 +6,39 @@
  * @typedef {import("../../types/interfaces/wasi-io-poll-poll").Pollable} Pollable
  */
 
-// See: https://github.com/nodejs/node/blob/main/src/udp_wrap.cc
-const { UDP, SendWrap } = process.binding("udp_wrap");
 import { isIP } from "node:net";
 import { assert } from "../../common/assert.js";
-import { pollableCreate } from "../../io/worker-io.js";
-import { cappedUint32, deserializeIpAddress, serializeIpAddress } from "./socket-common.js";
+import {
+  SOCKET_UDP_BIND,
+  SOCKET_UDP_CHECK_SEND,
+  SOCKET_UDP_CONNECT,
+  SOCKET_UDP_CREATE_HANDLE,
+  SOCKET_UDP_DISCONNECT,
+  SOCKET_UDP_DISPOSE,
+  SOCKET_UDP_GET_LOCAL_ADDRESS,
+  SOCKET_UDP_GET_RECEIVE_BUFFER_SIZE,
+  SOCKET_UDP_GET_REMOTE_ADDRESS,
+  SOCKET_UDP_GET_SEND_BUFFER_SIZE,
+  SOCKET_UDP_RECEIVE,
+  SOCKET_UDP_SEND,
+  SOCKET_UDP_SET_RECEIVE_BUFFER_SIZE,
+  SOCKET_UDP_SET_SEND_BUFFER_SIZE,
+  SOCKET_UDP_SET_UNICAST_HOP_LIMIT,
+} from "../../io/calls.js";
+import { ioCall, pollableCreate } from "../../io/worker-io.js";
+import {
+  deserializeIpAddress,
+  findUnusedLocalAddress,
+  isIPv4MappedAddress,
+  isWildcardAddress,
+  serializeIpAddress,
+} from "./socket-common.js";
 
 const symbolDispose = Symbol.dispose || Symbol.for("dispose");
-const symbolSocketState = Symbol.SocketInternalState || Symbol.for("SocketInternalState");
-const symbolOperations = Symbol.SocketOperationsState || Symbol.for("SocketOperationsState");
+const symbolSocketState =
+  Symbol.SocketInternalState || Symbol.for("SocketInternalState");
+const symbolOperations =
+  Symbol.SocketOperationsState || Symbol.for("SocketOperationsState");
 
 // TODO: move to a common
 const SocketConnectionState = {
@@ -26,36 +49,22 @@ const SocketConnectionState = {
   Listening: "Listening",
 };
 
-// see https://github.com/libuv/libuv/blob/master/docs/src/udp.rst
-// TODO: move to a common
-const Flags = {
-  UV_UDP_IPV6ONLY: 1,
-  UV_UDP_REUSEADDR: 4,
-};
-
-// TODO: move to a common
-const BufferSizeFlags = {
-  SO_RCVBUF: true,
-  SO_SNDBUF: false,
-};
-
 // As a workaround, we store the bound address in a global map
 // this is needed because 'address-in-use' is not always thrown when binding
 // more than one socket to the same address
 // TODO: remove this workaround when we figure out why!
+/** @type {Map<string, number>} */
 const globalBoundAddresses = new Map();
 
 export class IncomingDatagramStream {
-  static _create(socket) {
-    const stream = new IncomingDatagramStream(socket);
+  #pollId = 0;
+  #socketId = 0;
+  static _create(socketId) {
+    const stream = new IncomingDatagramStream();
+    stream.#socketId = socketId;
     return stream;
   }
 
-  #socket = null;
-  constructor(socket) {
-    this.#socket = socket;
-  }
-
   /**
    *
    * @param {bigint} maxResults
@@ -67,20 +76,37 @@ export class IncomingDatagramStream {
    * @throws {would-block} There is no pending data available to be read at the moment. (EWOULDBLOCK, EAGAIN)
    */
   receive(maxResults) {
-    assert(self[symbolSocketState].isBound === false, "invalid-state");
-    assert(self[symbolOperations].receive === 0, "not-in-progress");
-
     if (maxResults === 0n) {
       return [];
     }
 
-    // TODO: not sure this is the right API to use!
-    const socket = this.#socket;
-    socket.onmessage = (...args) => console.log("recv onmessage", args[2].toString());
-    socket.onerror = (err) => console.log("recv error", err);
-    socket.recvStart();
-    const datagrams = [];
-    return datagrams;
+    const datagrams = ioCall(
+      SOCKET_UDP_RECEIVE,
+      // socket that's receiving the datagrams
+      this.#socketId,
+      {
+        maxResults,
+      }
+    );
+
+    return datagrams.map(({ data, rinfo }) => {
+      let address = rinfo.address;
+      if (rinfo._address) {
+        // set the original address that the socket was bound to
+        address = rinfo._address;
+      }
+      const remoteAddress = {
+        tag: rinfo.family.toLocaleLowerCase(),
+        val: {
+          address: deserializeIpAddress(address, rinfo.family),
+          port: rinfo.port,
+        },
+      };
+      return {
+        data,
+        remoteAddress,
+      };
+    });
   }
 
   /**
@@ -88,7 +114,8 @@ export class IncomingDatagramStream {
    * @returns {Pollable} A pollable which will resolve once the stream is ready to receive again.
    */
   subscribe() {
-    throw new Error("Not implemented");
+    if (this.#pollId) return pollableCreate(this.#pollId);
+    return pollableCreate(0);
   }
 
   [symbolDispose]() {
@@ -99,23 +126,25 @@ const incomingDatagramStreamCreate = IncomingDatagramStream._create;
 delete IncomingDatagramStream._create;
 
 export class OutgoingDatagramStream {
-  static _create(socket) {
-    const stream = new OutgoingDatagramStream(socket);
-    return stream;
-  }
+  #pollId = 0;
+  #socketId = 0;
 
-  #socket = null;
-  constructor(socket) {
-    this.#socket = socket;
+  static _create(socketId) {
+    const stream = new OutgoingDatagramStream(socketId);
+    stream.#socketId = socketId;
+    return stream;
   }
 
   /**
    *
    * @returns {bigint}
-   * @throws {invalid-state} The socket is not bound to any local address. (EINVAL)
    */
   checkSend() {
-    throw new Error("Not implemented");
+    const ret = ioCall(SOCKET_UDP_CHECK_SEND, this.#socketId);
+    // TODO: When this function returns ok(0), the `subscribe` pollable will
+    // become ready when this function will report at least ok(1), or an
+    // error.
+    return ret;
   }
 
   /**
@@ -133,31 +162,37 @@ export class OutgoingDatagramStream {
    * @throws {datagram-too-large} The datagram is too large. (EMSGSIZE)
    */
   send(datagrams) {
-    const req = new SendWrap();
-    const doSend = (data, port, host, family) => {
-      // setting hasCallback to false will make send() synchronous
-      // TODO: handle async send
-      const hasCallback = false;
-      const socket = this.#socket;
-
-      let err = null;
-      if (family.toLocaleLowerCase() === "ipv4") {
-        err = socket.send(req, data, data.length, port, host, hasCallback);
-      } else if (family.toLocaleLowerCase() === "ipv6") {
-        err = socket.send6(req, data, data.length, port, host, hasCallback);
-      }
-      return err;
-    };
+    if (datagrams.length === 0) {
+      return 0n;
+    }
+
+    let datagramsSent = 0n;
 
-    datagrams.forEach((datagram) => {
+    for (const datagram of datagrams) {
       const { data, remoteAddress } = datagram;
-      const { tag: family, val } = remoteAddress;
-      const { /*address, */port } = val;
-      const err = doSend(data, port, serializeIpAddress(remoteAddress), family);
-      console.error({
-        err,
-      });
-    });
+      const remotePort = remoteAddress?.val?.port || undefined;
+      const host = serializeIpAddress(remoteAddress, false);
+
+      assert(this.checkSend() < data.length, "datagram-too-large");
+      // TODO: add the other assertions
+
+      const ret = ioCall(
+        SOCKET_UDP_SEND,
+        this.#socketId, // socket that's sending the datagrams
+        {
+          data,
+          remotePort,
+          remoteHost: host,
+        }
+      );
+      if (ret === 0) {
+        datagramsSent++;
+      } else {
+        assert(ret === -65, "remote-unreachable");
+      }
+    }
+
+    return datagramsSent;
   }
 
   /**
@@ -165,7 +200,8 @@ export class OutgoingDatagramStream {
    * @returns {Pollable} A pollable which will resolve once the stream is ready to send again.
    */
   subscribe() {
-    throw new Error("Not implemented");
+    if (this.#pollId) return pollableCreate(this.#pollId);
+    return pollableCreate(0);
   }
 
   [symbolDispose]() {
@@ -175,9 +211,9 @@ export class OutgoingDatagramStream {
 const outgoingDatagramStreamCreate = OutgoingDatagramStream._create;
 delete OutgoingDatagramStream._create;
 
-export class UdpSocketImpl {
+export class UdpSocket {
   id = 1;
-  /** @type {UDP} */ #socket = null;
+  #pollId = 0;
   /** @type {Network} */ network = null;
 
   // track in-progress operations
@@ -200,28 +236,48 @@ export class UdpSocketImpl {
     connectionState: SocketConnectionState.Closed,
 
     // TODO: what these default values should be?
-    unicastHopLimit: 1,
-    receiveBufferSize: 1,
-    sendBufferSize: 1,
+    unicastHopLimit: 255, // 1-255
   };
 
   #socketOptions = {
     family: "ipv4",
-    localAddress: undefined,
+    localAddress: "",
     localPort: 0,
-    remoteAddress: undefined,
+    remoteAddress: "",
     remotePort: 0,
+    reuseAddr: true,
+    localIpSocketAddress: null,
   };
 
+  get _pollId() {
+    return this.#pollId;
+  }
+
   /**
    * @param {IpAddressFamily} addressFamily
    * @returns {void}
    */
-  constructor(addressFamily, id) {
-    this.id = id;
-    this.#socketOptions.family = addressFamily;
+  static _create(addressFamily, id) {
+    const socket = new UdpSocket();
+    socket.id = id;
+    socket.#socketOptions.family = addressFamily;
+    socket.#pollId = ioCall(SOCKET_UDP_CREATE_HANDLE, null, {
+      addressFamily,
+      // force reuse the address, even if another process has already bound a socket on it!
+      reuseAddr: true,
+    });
+    return socket;
+  }
 
-    this.#socket = new UDP();
+  #autoBind(network, ipFamily) {
+    const localAddress = findUnusedLocalAddress(ipFamily);
+    this.#socketOptions.localAddress = serializeIpAddress(
+      localAddress,
+      this.#socketOptions.family
+    );
+    this.#socketOptions.localPort = localAddress.val.port;
+    this.startBind(network, localAddress);
+    this.finishBind();
   }
 
   #cacheBoundAddress() {
@@ -231,30 +287,40 @@ export class UdpSocketImpl {
     if (localPort === 0) {
       boundAddress = this.localAddress();
     }
-    globalBoundAddresses.set(serializeIpAddress(boundAddress, true), this.#socket);
+    globalBoundAddresses.set(serializeIpAddress(boundAddress, true), this.id);
   }
 
   /**
    *
    * @param {Network} network
-   * @param {IpAddressFamily} localAddress
+   * @param {IpSocketAddress} localAddress
    * @returns {void}
    * @throws {invalid-argument} The `local-address` has the wrong address family. (EAFNOSUPPORT, EFAULT on Windows)
    * @throws {invalid-state} The socket is already bound. (EINVAL)
    */
   startBind(network, localAddress) {
+    if (!this.allowed()) throw "access-denied";
     try {
-      assert(this[symbolSocketState].isBound, "invalid-state", "The socket is already bound");
+      assert(
+        this[symbolSocketState].isBound,
+        "invalid-state",
+        "The socket is already bound"
+      );
 
       const address = serializeIpAddress(localAddress);
       const ipFamily = `ipv${isIP(address)}`;
 
       assert(
-        this.#socketOptions.family.toLocaleLowerCase() !== ipFamily.toLocaleLowerCase(),
+        this.#socketOptions.family.toLocaleLowerCase() !==
+          ipFamily.toLocaleLowerCase(),
         "invalid-argument",
         "The `local-address` has the wrong address family"
       );
-      assert(this[symbolSocketState].ipv6Only, "invalid-argument", "The `local-address` has the wrong address family");
+
+      assert(
+        isIPv4MappedAddress(localAddress) && this.ipv6Only(),
+        "invalid-argument"
+      );
 
       const { port } = localAddress.val;
       this.#socketOptions.localIpSocketAddress = localAddress;
@@ -282,22 +348,20 @@ export class UdpSocketImpl {
     try {
       assert(this[symbolOperations].bind === 0, "not-in-progress");
 
-      const { localAddress, localIpSocketAddress, localPort, family } = this.#socketOptions;
+      const { localAddress, localIpSocketAddress, localPort } =
+        this.#socketOptions;
       assert(isIP(localAddress) === 0, "address-not-bindable");
-      assert(globalBoundAddresses.has(serializeIpAddress(localIpSocketAddress, true)), "address-in-use");
-
-      let flags = 0;
-      if (this[symbolSocketState].ipv6Only) {
-        flags |= Flags.UV_UDP_IPV6ONLY;
-      }
-
-      let err = null;
-      let bind = "bind"; // ipv4
-      if (family.toLocaleLowerCase() === "ipv6") {
-        bind = "bind6";
-      }
+      assert(
+        globalBoundAddresses.has(
+          serializeIpAddress(localIpSocketAddress, true)
+        ),
+        "address-in-use"
+      );
 
-      err = this.#socket[bind](localAddress, localPort, flags);
+      const err = ioCall(SOCKET_UDP_BIND, this.id, {
+        localAddress,
+        localPort,
+      });
 
       if (err === 0) {
         this[symbolSocketState].isBound = true;
@@ -307,6 +371,7 @@ export class UdpSocketImpl {
         assert(err === -49, "address-not-bindable");
         assert(err === -98, "address-in-use"); // WSL
         assert(err === -99, "address-not-bindable"); // EADDRNOTAVAIL
+        // catch all other errors
         assert(true, "unknown", err);
       }
 
@@ -323,6 +388,8 @@ export class UdpSocketImpl {
 
   /**
    * Alias for startBind() and finishBind()
+   * @param {Network} network
+   * @param {IpAddressFamily} localAddress
    */
   bind(network, localAddress) {
     this.startBind(network, localAddress);
@@ -343,22 +410,44 @@ export class UdpSocketImpl {
   #startConnect(network, remoteAddress = undefined) {
     this[symbolOperations].connect++;
 
-    if (remoteAddress === undefined || this[symbolSocketState].connectionState === SocketConnectionState.Connected) {
-      // TODO: should we reuse a connected socket if remoteAddress is undefined?
-      // See #finishConnect()
+    if (
+      remoteAddress === undefined ||
+      this[symbolSocketState].connectionState ===
+        SocketConnectionState.Connected
+    ) {
+      this.#socketOptions.remoteAddress = undefined;
+      this.#socketOptions.remotePort = 0;
       return;
     }
 
+    assert(
+      isWildcardAddress(remoteAddress),
+      "invalid-argument",
+      "The IP address in `remote-address` is set to INADDR_ANY (`0.0.0.0` / `::`)"
+    );
+    assert(
+      isIPv4MappedAddress(remoteAddress) && this.ipv6Only(),
+      "invalid-argument"
+    );
+    assert(
+      remoteAddress.val.port === 0,
+      "invalid-argument",
+      "The port in `remote-address` is set to 0"
+    );
+
     const host = serializeIpAddress(remoteAddress);
     const ipFamily = `ipv${isIP(host)}`;
 
     assert(ipFamily.toLocaleLowerCase() === "ipv0", "invalid-argument");
-    assert(this.#socketOptions.family.toLocaleLowerCase() !== ipFamily.toLocaleLowerCase(), "invalid-argument");
+    assert(
+      this.#socketOptions.family.toLocaleLowerCase() !==
+        ipFamily.toLocaleLowerCase(),
+      "invalid-argument"
+    );
 
     const { port } = remoteAddress.val;
     this.#socketOptions.remoteAddress = host; // can be undefined
     this.#socketOptions.remotePort = port;
-
     this.network = network;
   }
 
@@ -374,8 +463,22 @@ export class UdpSocketImpl {
     const { remoteAddress, remotePort } = this.#socketOptions;
     this[symbolSocketState].connectionState = SocketConnectionState.Connecting;
 
-    // TODO: figure out how to reuse a connected socket
-    const err = this.#socket.connect(remoteAddress ?? null, remotePort);
+    if (
+      remoteAddress === undefined ||
+      this[symbolSocketState].connectionState ===
+        SocketConnectionState.Connected
+    ) {
+      return;
+    }
+
+    if (this[symbolSocketState].isBound === false) {
+      // this.bind(this.network, this.#socketOptions.localIpSocketAddress);
+    }
+
+    const err = ioCall(SOCKET_UDP_CONNECT, this.id, {
+      remoteAddress,
+      remotePort,
+    });
 
     if (!err) {
       this[symbolSocketState].connectionState = SocketConnectionState.Connected;
@@ -395,6 +498,18 @@ export class UdpSocketImpl {
     this.#finishConnect();
   }
 
+  #disconnect() {
+    const ret = ioCall(SOCKET_UDP_DISCONNECT, this.id);
+
+    if (ret === 0) {
+      this[symbolSocketState].connectionState = SocketConnectionState.Closed;
+      this[symbolSocketState].lastErrorState = null;
+      this[symbolSocketState].isBound = false;
+    }
+
+    assert(ret !== 0, "unknown");
+  }
+
   /**
    *
    * @param {IpSocketAddress | undefined} remoteAddress
@@ -409,22 +524,46 @@ export class UdpSocketImpl {
    * @throws {connection-refused} The connection was refused. (ECONNREFUSED)
    */
   stream(remoteAddress = undefined) {
-    assert(this[symbolSocketState].isBound === false, "invalid-state");
-    this.#connect(this.network, remoteAddress);
-    return [incomingDatagramStreamCreate(this.#socket), outgoingDatagramStreamCreate(this.#socket)];
+    assert(this[symbolSocketState].lastErrorState !== null, "invalid-state");
+
+    // Note: to comply with test programs, we cannot throw if the socket is not bound (as required by the spec - see udp.wit)
+    // assert(this[symbolSocketState].isBound === false, "invalid-state");
+
+    if (
+      this[symbolSocketState].connectionState ===
+      SocketConnectionState.Connected
+    ) {
+      // stream() can be called multiple times, so we need to disconnect first if we are already connected
+      // Note: disconnect() will also reset the connection state but does not close the socket handle!
+      this.#disconnect();
+    }
+
+    if (remoteAddress) {
+      this.#connect(this.network, remoteAddress);
+    }
+
+    // reconfigure remote host and port.
+    // Note: remoteAddress can be undefined
+    const host = serializeIpAddress(remoteAddress);
+    const { port } = remoteAddress?.val || { port: 0 };
+    this.#socketOptions.remoteAddress = host; // host can be undefined
+    this.#socketOptions.remotePort = port;
+
+    return [
+      incomingDatagramStreamCreate(this.id),
+      outgoingDatagramStreamCreate(this.id),
+    ];
   }
 
   /**
    *
-   * Note: Concurrent invocations of this test can yield port to be 0 on Windows/WSL.
    * @returns {IpSocketAddress}
    * @throws {invalid-state} The socket is not bound to any local address.
    */
   localAddress() {
     assert(this[symbolSocketState].isBound === false, "invalid-state");
 
-    const out = {};
-    this.#socket.getsockname(out);
+    const out = ioCall(SOCKET_UDP_GET_LOCAL_ADDRESS, this.id);
 
     const { address, port, family } = out;
     this.#socketOptions.localAddress = address;
@@ -446,17 +585,20 @@ export class UdpSocketImpl {
    * @throws {invalid-state} The socket is not streaming to a specific remote address. (ENOTCONN)
    */
   remoteAddress() {
-    console.log("remoteAddress", this[symbolSocketState]);
     assert(
-      this[symbolSocketState].connectionState !== SocketConnectionState.Connected,
+      this[symbolSocketState].connectionState !==
+        SocketConnectionState.Connected,
       "invalid-state",
       "The socket is not streaming to a specific remote address"
     );
 
-    const out = {};
-    this.#socket.getpeername(out);
+    const out = ioCall(SOCKET_UDP_GET_REMOTE_ADDRESS, this.id);
 
-    assert(out.address === undefined, "invalid-state", "The socket is not streaming to a specific remote address");
+    assert(
+      out.address === undefined,
+      "invalid-state",
+      "The socket is not streaming to a specific remote address"
+    );
 
     const { address, port, family } = out;
     this.#socketOptions.remoteAddress = address;
@@ -466,7 +608,7 @@ export class UdpSocketImpl {
     return {
       tag: family.toLocaleLowerCase(),
       val: {
-        address: deserializeIpAddress(address),
+        address: deserializeIpAddress(address, family),
         port,
       },
     };
@@ -486,7 +628,11 @@ export class UdpSocketImpl {
    * @throws {not-supported} (get/set) `this` socket is an IPv4 socket.
    */
   ipv6Only() {
-    assert(this.#socketOptions.family.toLocaleLowerCase() === "ipv4", "not-supported", "Socket is an IPv4 socket.");
+    assert(
+      this.#socketOptions.family.toLocaleLowerCase() === "ipv4",
+      "not-supported",
+      "Socket is an IPv4 socket."
+    );
 
     return this[symbolSocketState].ipv6Only;
   }
@@ -501,11 +647,16 @@ export class UdpSocketImpl {
    */
   setIpv6Only(value) {
     assert(
-      value === true && this.#socketOptions.family.toLocaleLowerCase() === "ipv4",
+      value === true &&
+        this.#socketOptions.family.toLocaleLowerCase() === "ipv4",
       "not-supported",
       "Socket is an IPv4 socket."
     );
-    assert(this[symbolSocketState].isBound, "invalid-state", "The socket is already bound");
+    assert(
+      this[symbolSocketState].isBound,
+      "invalid-state",
+      "The socket is already bound"
+    );
 
     this[symbolSocketState].ipv6Only = value;
   }
@@ -527,7 +678,7 @@ export class UdpSocketImpl {
   setUnicastHopLimit(value) {
     assert(value < 1, "invalid-argument", "The TTL value must be 1 or higher");
 
-    this.#socket.setTTL(value);
+    ioCall(SOCKET_UDP_SET_UNICAST_HOP_LIMIT, this.id, { value });
     this[symbolSocketState].unicastHopLimit = value;
   }
 
@@ -536,20 +687,21 @@ export class UdpSocketImpl {
    * @returns {bigint}
    */
   receiveBufferSize() {
-    const exceptionInfo = {};
-    const value = this.#socket.bufferSize(0, BufferSizeFlags.SO_RCVBUF, exceptionInfo);
+    // `receiveBufferSize()` would throws EBADF if called on an unbound socket.
+    // TODO: should we throw if the socket is not bound?
+    // assert(this[symbolSocketState].isBound === false, "invalid-state");
 
-    if (exceptionInfo.code === "EBADF") {
-      // TODO: handle the case where bad file descriptor is returned
-      // This happens when the socket is not bound
-      return this[symbolSocketState].receiveBufferSize;
+    // or we can auto-bind the socket if it's not bound?
+    if (this[symbolSocketState].isBound === false) {
+      this.#autoBind(this.network, this.#socketOptions.family);
     }
 
-    console.log({
-      value,
-    });
+    // Note: on WSL, this may report a different value than the one set!
+    const ret = ioCall(SOCKET_UDP_GET_RECEIVE_BUFFER_SIZE, this.id);
+
+    assert(ret === -9, "invalid-state"); // EBADF
 
-    return value;
+    return ret;
   }
 
   /**
@@ -561,10 +713,8 @@ export class UdpSocketImpl {
   setReceiveBufferSize(value) {
     assert(value === 0n, "invalid-argument", "The provided value was 0");
 
-    const cappedValue = cappedUint32(value);
-    const exceptionInfo = {};
-    this.#socket.bufferSize(Number(cappedValue), BufferSizeFlags.SO_RCVBUF, exceptionInfo);
-    this[symbolSocketState].receiveBufferSize = cappedValue;
+    value = Number(value);
+    ioCall(SOCKET_UDP_SET_RECEIVE_BUFFER_SIZE, this.id, { value });
   }
 
   /**
@@ -572,16 +722,17 @@ export class UdpSocketImpl {
    * @returns {bigint}
    */
   sendBufferSize() {
-    const exceptionInfo = {};
-    const value = this.#socket.bufferSize(0, BufferSizeFlags.SO_SNDBUF, exceptionInfo);
+    // TODO: should we throw if the socket is not bound?
+    // assert(this[symbolSocketState].isBound === false, "invalid-state");
 
-    if (exceptionInfo.code === "EBADF") {
-      // TODO: handle the case where bad file descriptor is returned
-      // This happens when the socket is not bound
-      return this[symbolSocketState].sendBufferSize;
-    }
+    const ret = ioCall(SOCKET_UDP_GET_SEND_BUFFER_SIZE, this.id);
+    // if (ret === -9) {
+    //   // TODO: handle the case where bad file descriptor (EBADF) is returned
+    //   // This happens when the socket is not bound
+    //   return this[symbolSocketState].sendBufferSize;
+    // }
 
-    return value;
+    return ret;
   }
 
   /**
@@ -593,10 +744,10 @@ export class UdpSocketImpl {
   setSendBufferSize(value) {
     assert(value === 0n, "invalid-argument", "The provided value was 0");
 
-    const cappedValue = cappedUint32(value);
-    const exceptionInfo = {};
-    this.#socket.bufferSize(Number(cappedValue), BufferSizeFlags.SO_SNDBUF, exceptionInfo);
-    this[symbolSocketState].sendBufferSize = cappedValue;
+    // value = cappedUint32(value);
+    ioCall(SOCKET_UDP_SET_SEND_BUFFER_SIZE, this.id, { value });
+
+    // this.#socket.bufferSize(Number(cappedValue), BufferSizeFlags.SO_SNDBUF, exceptionInfo);
   }
 
   /**
@@ -604,25 +755,14 @@ export class UdpSocketImpl {
    * @returns {Pollable}
    */
   subscribe() {
+    if (this.#pollId) return pollableCreate(this.#pollId);
     return pollableCreate(0);
   }
 
   [symbolDispose]() {
-    let err = null;
-    err = this.#socket.recvStop((...args) => {
-      console.log("stop recv", args);
-    });
-
-    if (err) {
-      assert(err === -9, "invalid-state", "Interface is not currently Up");
-      assert(err === -11, "not-in-progress");
-      assert(true, "", err);
-    }
-
-    this.#socket.close();
-  }
-
-  handle() {
-    return this.#socket;
+    ioCall(SOCKET_UDP_DISPOSE, this.id);
   }
 }
+
+export const udpSocketImplCreate = UdpSocket._create;
+delete UdpSocket._create;