visaljs 0.0.9 → 0.0.11

package/node/prelude/dgram.js

@@ -0,0 +1,1169 @@
+// node:dgram, Node 24's lib/dgram.js and lib/internal/dgram.js over Node's UDP binding
+// (internal/udp.js, on src/host_udp.c). A compiled program is never a cluster worker, so a bind is
+// always its own; async_hooks' ids are the handle's own count.
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
+
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+import { errnoName, netGuessHandle } from "visaljs:host";
+import { Buffer } from "./buffer.js";
+import { channel } from "./diagnostics_channel.js";
+import dns from "./dns.js";
+import { EventEmitter } from "./events.js";
+import { codeError, errnoException } from "./internal/errors.js";
+import { isIP } from "./internal/net.js";
+import { BlockList } from "./internal/socketaddress.js";
+import { codes, determineSpecificType, fsSystemError } from "./internal/streams/errors.js";
+import {
+  addAbortListener, kEmptyObject, validateAbortSignal, validateFunction, validateObject, validateString, validateUint32,
+} from "./internal/streams/validators.js";
+import { SendWrap, UDP } from "./internal/udp.js";
+import { deprecate } from "./util.js";
+
+const { ERR_INVALID_ARG_TYPE, ERR_INVALID_ARG_VALUE, ERR_MISSING_ARGS } = codes;
+
+/* ---- the errors dgram throws, as Node's lib/internal/errors.js makes them ---------------------- */
+
+const ERR_BUFFER_OUT_OF_BOUNDS = (name) =>
+  codeError(RangeError, "ERR_BUFFER_OUT_OF_BOUNDS", name ? `"${name}" is outside of buffer bounds` : "Attempt to access memory outside buffer bounds");
+const ERR_INVALID_FD_TYPE = (type) => codeError(TypeError, "ERR_INVALID_FD_TYPE", `Unsupported fd type: ${type}`);
+const ERR_IP_BLOCKED = (ip) => codeError(Error, "ERR_IP_BLOCKED", `IP(${ip}) is blocked by net.BlockList`);
+const ERR_SOCKET_ALREADY_BOUND = () => codeError(Error, "ERR_SOCKET_ALREADY_BOUND", "Socket is already bound");
+const ERR_SOCKET_BAD_BUFFER_SIZE = () => codeError(TypeError, "ERR_SOCKET_BAD_BUFFER_SIZE", "Buffer size must be a positive integer");
+const ERR_SOCKET_BAD_PORT = (name, port, allowZero) =>
+  codeError(RangeError, "ERR_SOCKET_BAD_PORT", `${name} should be ${allowZero ? ">=" : ">"} 0 and < 65536. Received ${determineSpecificType(port)}.`);
+const ERR_SOCKET_BAD_TYPE = () => codeError(TypeError, "ERR_SOCKET_BAD_TYPE", "Bad socket type specified. Valid types are: udp4, udp6");
+const ERR_SOCKET_BUFFER_SIZE = (ctx) => fsSystemError("ERR_SOCKET_BUFFER_SIZE", "Could not get or set buffer size", ctx);
+const ERR_SOCKET_DGRAM_IS_CONNECTED = () => codeError(Error, "ERR_SOCKET_DGRAM_IS_CONNECTED", "Already connected");
+const ERR_SOCKET_DGRAM_NOT_CONNECTED = () => codeError(Error, "ERR_SOCKET_DGRAM_NOT_CONNECTED", "Not connected");
+const ERR_SOCKET_DGRAM_NOT_RUNNING = () => codeError(Error, "ERR_SOCKET_DGRAM_NOT_RUNNING", "Not running");
+
+const ErrnoException = errnoException;
+
+/* Node's ExceptionWithHostPort: `send EINVAL 127.0.0.1:41234` */
+function ExceptionWithHostPort(err, syscall, address, port) {
+  const code = errnoName(err);
+  const details = port && port > 0 ? ` ${address}:${port}` : address ? ` ${address}` : "";
+  const ex = new Error(`${syscall} ${code}${details}`);
+  ex.errno = err;
+  ex.code = code;
+  ex.syscall = syscall;
+  ex.address = address;
+  if (port) ex.port = port;
+  return ex;
+}
+
+function isInt32(value) {
+  return value === (value | 0);
+}
+
+function validateNumber(value, name) {
+  if (typeof value !== "number") throw new ERR_INVALID_ARG_TYPE(name, "number", value);
+}
+
+function validatePort(port, name = "Port", allowZero = true) {
+  if ((typeof port !== "number" && typeof port !== "string") ||
+      (typeof port === "string" && port.trim().length === 0) ||
+      +port !== (+port >>> 0) ||
+      port > 0xFFFF ||
+      (port === 0 && !allowZero)) {
+    throw ERR_SOCKET_BAD_PORT(name, port, allowZero);
+  }
+  return port | 0;
+}
+
+function guessHandleType(fd) {
+  return netGuessHandle(fd);
+}
+
+/* ---- lib/internal/dgram.js ---------------------------------------------------------------------- */
+
+const UV_EINVAL = -22;
+/* libuv's uv_udp_flags */
+const UV_UDP_IPV6ONLY = 1, UV_UDP_REUSEADDR = 4, UV_UDP_REUSEPORT = 64;
+
+const kStateSymbol = Symbol("state symbol");
+const owner_symbol = Symbol("owner_symbol");
+const async_id_symbol = Symbol("async_id_symbol");
+
+function lookup4(lookup, address, callback) {
+  return lookup(address || "127.0.0.1", 4, callback);
+}
+
+function lookup6(lookup, address, callback) {
+  return lookup(address || "::1", 6, callback);
+}
+
+function defaultLookup(address, family, callback) {
+  if (isIP(address) === family) {
+    process.nextTick(callback, null, address, family);
+    return;
+  }
+  return dns.lookup(address, family, callback);  /* the module's, as a program may replace it */
+}
+
+function newHandle(type, lookup) {
+  if (lookup === undefined) {
+    lookup = defaultLookup;
+  } else {
+    validateFunction(lookup, "lookup");
+  }
+
+  if (type === "udp4") {
+    const handle = new UDP();
+
+    handle.lookup = lookup4.bind(handle, lookup);
+    return handle;
+  }
+
+  if (type === "udp6") {
+    const handle = new UDP();
+
+    handle.lookup = lookup6.bind(handle, lookup);
+    handle.bind = handle.bind6;
+    handle.connect = handle.connect6;
+    handle.send = handle.send6;
+    return handle;
+  }
+
+  throw ERR_SOCKET_BAD_TYPE();
+}
+
+function _createSocketHandle(address, port, addressType, fd, flags) {
+  const handle = newHandle(addressType);
+  let err;
+
+  if (isInt32(fd) && fd > 0) {
+    const type = guessHandleType(fd);
+    if (type !== "UDP") {
+      err = UV_EINVAL;
+    } else {
+      err = handle.open(fd);
+    }
+  } else if (port || address) {
+    err = handle.bind(address, port || 0, flags);
+  }
+
+  if (err) {
+    handle.close();
+    return err;
+  }
+
+  return handle;
+}
+
+/* ---- lib/dgram.js ------------------------------------------------------------------------------- */
+
+const udpSocketChannel = channel("udp.socket");
+
+const BIND_STATE_UNBOUND = 0;
+const BIND_STATE_BINDING = 1;
+const BIND_STATE_BOUND = 2;
+
+const CONNECT_STATE_DISCONNECTED = 0;
+const CONNECT_STATE_CONNECTING = 1;
+const CONNECT_STATE_CONNECTED = 2;
+
+const RECV_BUFFER = true;
+const SEND_BUFFER = false;
+
+export function Socket(type, listener) {
+  EventEmitter.call(this);
+  let lookup;
+  let recvBufferSize;
+  let sendBufferSize;
+  let receiveBlockList;
+  let sendBlockList;
+
+  let options;
+  if (type !== null && typeof type === "object") {
+    options = type;
+    type = options.type;
+    lookup = options.lookup;
+    if (options.recvBufferSize) {
+      validateUint32(options.recvBufferSize, "options.recvBufferSize");
+    }
+    if (options.sendBufferSize) {
+      validateUint32(options.sendBufferSize, "options.sendBufferSize");
+    }
+    recvBufferSize = options.recvBufferSize;
+    sendBufferSize = options.sendBufferSize;
+    if (options.receiveBlockList) {
+      if (!BlockList.isBlockList(options.receiveBlockList)) {
+        throw new ERR_INVALID_ARG_TYPE("options.receiveBlockList", "net.BlockList", options.receiveBlockList);
+      }
+      receiveBlockList = options.receiveBlockList;
+    }
+    if (options.sendBlockList) {
+      if (!BlockList.isBlockList(options.sendBlockList)) {
+        throw new ERR_INVALID_ARG_TYPE("options.sendBlockList", "net.BlockList", options.sendBlockList);
+      }
+      sendBlockList = options.sendBlockList;
+    }
+  }
+
+  const handle = newHandle(type, lookup);
+  handle[owner_symbol] = this;
+
+  this[async_id_symbol] = handle.getAsyncId();
+  this.type = type;
+
+  if (typeof listener === "function")
+    this.on("message", listener);
+
+  this[kStateSymbol] = {
+    handle,
+    receiving: false,
+    bindState: BIND_STATE_UNBOUND,
+    connectState: CONNECT_STATE_DISCONNECTED,
+    queue: undefined,
+    reuseAddr: options?.reuseAddr, // Use UV_UDP_REUSEADDR if true.
+    reusePort: options?.reusePort,
+    ipv6Only: options?.ipv6Only,
+    recvBufferSize,
+    sendBufferSize,
+    receiveBlockList,
+    sendBlockList,
+  };
+
+  if (options?.signal !== undefined) {
+    const { signal } = options;
+    validateAbortSignal(signal, "options.signal");
+    const onAborted = () => {
+      if (this[kStateSymbol].handle) this.close();
+    };
+    if (signal.aborted) {
+      onAborted();
+    } else {
+      const disposable = addAbortListener(signal, onAborted);
+      this.once("close", disposable[Symbol.dispose]);
+    }
+  }
+  if (udpSocketChannel.hasSubscribers) {
+    udpSocketChannel.publish({
+      socket: this,
+    });
+  }
+}
+Object.setPrototypeOf(Socket.prototype, EventEmitter.prototype);
+Object.setPrototypeOf(Socket, EventEmitter);
+
+export function createSocket(type, listener) {
+  return new Socket(type, listener);
+}
+
+function startReceiving(socket) {
+  const state = socket[kStateSymbol];
+
+  state.handle.onmessage = onMessage;
+  state.handle.onerror = onError;
+  state.handle.recvStart();
+  state.receiving = true;
+  state.bindState = BIND_STATE_BOUND;
+
+  if (state.recvBufferSize)
+    bufferSize(socket, state.recvBufferSize, RECV_BUFFER);
+
+  if (state.sendBufferSize)
+    bufferSize(socket, state.sendBufferSize, SEND_BUFFER);
+}
+
+function startListening(socket) {
+  startReceiving(socket);
+  socket.emit("listening");
+}
+
+function emitListeningNT(socket) {
+  // Ensure the socket was not closed before the next tick.
+  if (socket[kStateSymbol].handle)
+    socket.emit("listening");
+}
+
+function emitConnectNT(socket) {
+  // Ensure the socket was not closed before the next tick.
+  if (socket[kStateSymbol].handle)
+    socket.emit("connect");
+}
+
+function replaceHandle(self, newHandle) {
+  const state = self[kStateSymbol];
+  const oldHandle = state.handle;
+  // Sync the old handle state to new handle
+  if (!oldHandle.hasRef() && typeof newHandle.unref === "function") {
+    newHandle.unref();
+  }
+  // Set up the handle that we got from primary.
+  newHandle.lookup = oldHandle.lookup;
+  newHandle.bind = oldHandle.bind;
+  newHandle.send = oldHandle.send;
+  newHandle[owner_symbol] = self;
+
+  // Replace the existing handle by the handle we got from primary.
+  oldHandle.close();
+  state.handle = newHandle;
+}
+
+function bufferSize(self, size, buffer) {
+  if (size >>> 0 !== size)
+    throw ERR_SOCKET_BAD_BUFFER_SIZE();
+
+  const ctx = {};
+  const ret = self[kStateSymbol].handle.bufferSize(size, buffer, ctx);
+  if (ret === undefined) {
+    throw ERR_SOCKET_BUFFER_SIZE(ctx);
+  }
+  return ret;
+}
+
+Socket.prototype.bind = function(port_, address_ /* , callback */) {
+  let port = port_;
+
+  healthCheck(this);
+  const state = this[kStateSymbol];
+
+  if (state.bindState !== BIND_STATE_UNBOUND)
+    throw ERR_SOCKET_ALREADY_BOUND();
+
+  state.bindState = BIND_STATE_BINDING;
+
+  const cb = arguments.length && arguments[arguments.length - 1];
+  if (typeof cb === "function") {
+    function removeListeners() {
+      this.removeListener(EventEmitter.errorMonitor, removeListeners);
+      this.removeListener("listening", onListening);
+    }
+
+    function onListening() {
+      removeListeners.call(this);
+      cb.call(this);
+    }
+
+    this.on(EventEmitter.errorMonitor, removeListeners);
+    this.on("listening", onListening);
+  }
+
+  if (port !== null &&
+      typeof port === "object" &&
+      typeof port.recvStart === "function") {
+    replaceHandle(this, port);
+    startListening(this);
+    return this;
+  }
+
+  // Open an existing fd instead of creating a new one.
+  if (port !== null && typeof port === "object" &&
+      isInt32(port.fd) && port.fd > 0) {
+    const fd = port.fd;
+    const state = this[kStateSymbol];
+
+    const type = guessHandleType(fd);
+    if (type !== "UDP")
+      throw ERR_INVALID_FD_TYPE(type);
+    const err = state.handle.open(fd);
+
+    if (err)
+      throw ErrnoException(err, "open");
+
+    startListening(this);
+    return this;
+  }
+
+  let address;
+
+  if (port !== null && typeof port === "object") {
+    address = port.address || "";
+    port = port.port;
+  } else {
+    address = typeof address_ === "function" ? "" : address_;
+  }
+
+  // Defaulting address for bind to all interfaces
+  if (!address) {
+    if (this.type === "udp4")
+      address = "0.0.0.0";
+    else
+      address = "::";
+  }
+
+  // Resolve address first
+  state.handle.lookup(address, (err, ip) => {
+    if (!state.handle)
+      return; // Handle has been closed in the mean time
+
+    if (err) {
+      state.bindState = BIND_STATE_UNBOUND;
+      this.emit("error", err);
+      return;
+    }
+
+    let flags = 0;
+    if (state.reuseAddr)
+      flags |= UV_UDP_REUSEADDR;
+    if (state.ipv6Only)
+      flags |= UV_UDP_IPV6ONLY;
+    if (state.reusePort)
+      flags |= UV_UDP_REUSEPORT;
+
+    const bindErr = state.handle.bind(ip, port || 0, flags);
+    if (bindErr) {
+      const ex = ExceptionWithHostPort(bindErr, "bind", ip, port);
+      state.bindState = BIND_STATE_UNBOUND;
+      this.emit("error", ex);
+      // Todo: close?
+      return;
+    }
+
+    startListening(this);
+  });
+
+  return this;
+};
+
+// Synchronous counterpart of bind(): bind(2) is a local, non-blocking system call, so this binds
+// inline and returns the resolved address. The address must be a numeric IP literal.
+Socket.prototype.bindSync = function(options = kEmptyObject) {
+  healthCheck(this);
+  validateObject(options, "options");
+  const state = this[kStateSymbol];
+
+  if (state.bindState !== BIND_STATE_UNBOUND)
+    throw ERR_SOCKET_ALREADY_BOUND();
+
+  // Validate arguments before mutating state so a bad argument leaves the
+  // socket unbound and reusable.
+  const port = validatePort(options.port ?? 0, "options.port");
+  let { address } = options;
+  if (!address) {
+    address = this.type === "udp4" ? "0.0.0.0" : "::";
+  } else {
+    validateString(address, "options.address");
+    if (isIP(address) === 0) {
+      throw new ERR_INVALID_ARG_VALUE(
+        "options.address", address,
+        "must be a numeric IP address; bindSync does not perform DNS resolution");
+    }
+  }
+
+  state.bindState = BIND_STATE_BINDING;
+
+  let flags = 0;
+  if (state.reuseAddr)
+    flags |= UV_UDP_REUSEADDR;
+  if (state.ipv6Only)
+    flags |= UV_UDP_IPV6ONLY;
+  if (state.reusePort)
+    flags |= UV_UDP_REUSEPORT;
+
+  const err = state.handle.bind(address, port, flags);
+  if (err) {
+    state.bindState = BIND_STATE_UNBOUND;
+    throw ExceptionWithHostPort(err, "bind", address, port);
+  }
+
+  startReceiving(this);
+  process.nextTick(emitListeningNT, this);
+  return this.address();
+};
+
+Socket.prototype.connect = function(port, address, callback) {
+  port = validatePort(port, "Port", false);
+  if (typeof address === "function") {
+    callback = address;
+    address = "";
+  } else if (address === undefined) {
+    address = "";
+  }
+
+  validateString(address, "address");
+
+  const state = this[kStateSymbol];
+
+  if (state.connectState !== CONNECT_STATE_DISCONNECTED)
+    throw ERR_SOCKET_DGRAM_IS_CONNECTED();
+
+  state.connectState = CONNECT_STATE_CONNECTING;
+  if (state.bindState === BIND_STATE_UNBOUND)
+    this.bind({ port: 0, exclusive: true }, null);
+
+  if (state.bindState !== BIND_STATE_BOUND) {
+    enqueue(this, _connect.bind(this, port, address, callback));
+    return;
+  }
+
+  _connect.call(this, port, address, callback);
+};
+
+// Synchronous counterpart of connect(): connect(2) on a UDP socket only records the default peer
+// locally. The address must be a numeric IP literal since DNS resolution is async.
+Socket.prototype.connectSync = function(port, address) {
+  healthCheck(this);
+  port = validatePort(port, "Port", false);
+
+  const state = this[kStateSymbol];
+
+  if (state.connectState !== CONNECT_STATE_DISCONNECTED)
+    throw ERR_SOCKET_DGRAM_IS_CONNECTED();
+
+  // Validate arguments before mutating state so a bad argument leaves the
+  // socket reusable.
+  if (address == null || address === "") {
+    address = this.type === "udp4" ? "127.0.0.1" : "::1";
+  } else {
+    validateString(address, "address");
+    if (isIP(address) === 0) {
+      throw new ERR_INVALID_ARG_VALUE(
+        "address", address,
+        "must be a numeric IP address; connectSync does not perform DNS resolution");
+    }
+  }
+
+  if (state.bindState === BIND_STATE_UNBOUND)
+    this.bindSync();
+  else if (state.bindState !== BIND_STATE_BOUND)
+    throw ERR_SOCKET_ALREADY_BOUND();
+
+  state.connectState = CONNECT_STATE_CONNECTING;
+
+  if (state.sendBlockList?.check(address, `ipv${isIP(address)}`)) {
+    state.connectState = CONNECT_STATE_DISCONNECTED;
+    throw ERR_IP_BLOCKED(address);
+  }
+
+  const err = state.handle.connect(address, port);
+  if (err) {
+    state.connectState = CONNECT_STATE_DISCONNECTED;
+    throw ExceptionWithHostPort(err, "connect", address, port);
+  }
+
+  state.connectState = CONNECT_STATE_CONNECTED;
+  process.nextTick(emitConnectNT, this);
+};
+
+function _connect(port, address, callback) {
+  const state = this[kStateSymbol];
+  if (callback)
+    this.once("connect", callback);
+
+  const afterDns = (ex, ip) => {
+    doConnect(ex, this, ip, address, port, callback);
+  };
+
+  state.handle.lookup(address, afterDns);
+}
+
+function doConnect(ex, self, ip, address, port, callback) {
+  const state = self[kStateSymbol];
+  if (!state.handle)
+    return;
+  if (!ex && state.sendBlockList?.check(ip, `ipv${isIP(ip)}`)) {
+    ex = ERR_IP_BLOCKED(ip);
+  }
+  if (!ex) {
+    const err = state.handle.connect(ip, port);
+    if (err) {
+      ex = ExceptionWithHostPort(err, "connect", address, port);
+    }
+  }
+
+  if (ex) {
+    state.connectState = CONNECT_STATE_DISCONNECTED;
+    return process.nextTick(() => {
+      if (callback) {
+        self.removeListener("connect", callback);
+        callback(ex);
+      } else {
+        self.emit("error", ex);
+      }
+    });
+  }
+
+  state.connectState = CONNECT_STATE_CONNECTED;
+  process.nextTick(() => self.emit("connect"));
+}
+
+Socket.prototype.disconnect = function() {
+  const state = this[kStateSymbol];
+  if (state.connectState !== CONNECT_STATE_CONNECTED)
+    throw ERR_SOCKET_DGRAM_NOT_CONNECTED();
+
+  const err = state.handle.disconnect();
+  if (err)
+    throw ErrnoException(err, "connect");
+  else
+    state.connectState = CONNECT_STATE_DISCONNECTED;
+};
+
+// Thin wrapper around `send`, here for compatibility with dgram_legacy.js
+Socket.prototype.sendto = function(buffer,
+                                   offset,
+                                   length,
+                                   port,
+                                   address,
+                                   callback) {
+  validateNumber(offset, "offset");
+  validateNumber(length, "length");
+  validateNumber(port, "port");
+  validateString(address, "address");
+
+  this.send(buffer, offset, length, port, address, callback);
+};
+
+function sliceBuffer(buffer, offset, length) {
+  if (typeof buffer === "string") {
+    buffer = Buffer.from(buffer);
+  } else if (!ArrayBuffer.isView(buffer)) {
+    throw new ERR_INVALID_ARG_TYPE("buffer",
+                                   ["Buffer",
+                                    "TypedArray",
+                                    "DataView",
+                                    "string"],
+                                   buffer);
+  }
+
+  offset = offset >>> 0;
+  length = length >>> 0;
+  if (offset > buffer.byteLength) {
+    throw ERR_BUFFER_OUT_OF_BOUNDS("offset");
+  }
+
+  if (offset + length > buffer.byteLength) {
+    throw ERR_BUFFER_OUT_OF_BOUNDS("length");
+  }
+
+  return Buffer.from(buffer.buffer, buffer.byteOffset + offset, length);
+}
+
+function fixBufferList(list) {
+  const newlist = new Array(list.length);
+
+  for (let i = 0, l = list.length; i < l; i++) {
+    const buf = list[i];
+    if (typeof buf === "string")
+      newlist[i] = Buffer.from(buf);
+    else if (Buffer.isBuffer(buf))
+      newlist[i] = buf;
+    else if (!ArrayBuffer.isView(buf))
+      return null;
+    else
+      newlist[i] = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+  }
+
+  return newlist;
+}
+
+function enqueue(self, toEnqueue) {
+  const state = self[kStateSymbol];
+
+  // If the send queue hasn't been initialized yet, do it, and install an
+  // event handler that flushes the send queue after binding is done.
+  if (state.queue === undefined) {
+    state.queue = [];
+    self.once(EventEmitter.errorMonitor, onListenError);
+    self.once("listening", onListenSuccess);
+  }
+  state.queue.push(toEnqueue);
+}
+
+function onListenSuccess() {
+  this.removeListener(EventEmitter.errorMonitor, onListenError);
+  clearQueue.call(this);
+}
+
+function onListenError() {
+  this.removeListener("listening", onListenSuccess);
+  this[kStateSymbol].queue = undefined;
+}
+
+function clearQueue() {
+  const state = this[kStateSymbol];
+  const queue = state.queue;
+  state.queue = undefined;
+
+  // Flush the send queue.
+  for (const queueEntry of queue)
+    queueEntry();
+}
+
+// valid combinations
+// For connectionless sockets
+// send(buffer, offset, length, port, address, callback)
+// send(buffer, offset, length, port, address)
+// send(buffer, offset, length, port, callback)
+// send(buffer, offset, length, port)
+// send(bufferOrList, port, address, callback)
+// send(bufferOrList, port, address)
+// send(bufferOrList, port, callback)
+// send(bufferOrList, port)
+// For connected sockets
+// send(buffer, offset, length, callback)
+// send(buffer, offset, length)
+// send(bufferOrList, callback)
+// send(bufferOrList)
+Socket.prototype.send = function(buffer,
+                                 offset,
+                                 length,
+                                 port,
+                                 address,
+                                 callback) {
+
+  let list;
+  const state = this[kStateSymbol];
+  const connected = state.connectState === CONNECT_STATE_CONNECTED;
+  if (!connected) {
+    if (address || (port && typeof port !== "function")) {
+      buffer = sliceBuffer(buffer, offset, length);
+    } else {
+      callback = port;
+      port = offset;
+      address = length;
+    }
+  } else {
+    if (typeof length === "number") {
+      buffer = sliceBuffer(buffer, offset, length);
+      if (typeof port === "function") {
+        callback = port;
+        port = null;
+      }
+    } else {
+      callback = offset;
+    }
+
+    if (port || address)
+      throw ERR_SOCKET_DGRAM_IS_CONNECTED();
+  }
+
+  if (!Array.isArray(buffer)) {
+    if (typeof buffer === "string") {
+      list = [ Buffer.from(buffer) ];
+    } else if (!ArrayBuffer.isView(buffer)) {
+      throw new ERR_INVALID_ARG_TYPE("buffer",
+                                     ["Buffer",
+                                      "TypedArray",
+                                      "DataView",
+                                      "string"],
+                                     buffer);
+    } else {
+      list = [ buffer ];
+    }
+  } else if (!(list = fixBufferList(buffer))) {
+    throw new ERR_INVALID_ARG_TYPE("buffer list arguments",
+                                   ["Buffer",
+                                    "TypedArray",
+                                    "DataView",
+                                    "string"],
+                                   buffer);
+  }
+
+  if (!connected)
+    port = validatePort(port, "Port", false);
+
+  // Normalize callback so it's either a function or undefined but not anything
+  // else.
+  if (typeof callback !== "function")
+    callback = undefined;
+
+  if (typeof address === "function") {
+    callback = address;
+    address = undefined;
+  } else if (address != null) {
+    validateString(address, "address");
+  }
+
+  healthCheck(this);
+
+  if (state.bindState === BIND_STATE_UNBOUND)
+    this.bind({ port: 0, exclusive: true }, null);
+
+  if (list.length === 0)
+    list.push(Buffer.alloc(0));
+
+  // If the socket hasn't been bound yet, push the outbound packet onto the
+  // send queue and send after binding is complete.
+  if (state.bindState !== BIND_STATE_BOUND) {
+    enqueue(this, this.send.bind(this, list, port, address, callback));
+    return;
+  }
+
+  const afterDns = (ex, ip) => {
+    doSend(ex, this, ip, list, address, port, callback);
+  };
+
+  if (!connected) {
+    state.handle.lookup(address, afterDns);
+  } else {
+    afterDns(null, null);
+  }
+};
+
+function doSend(ex, self, ip, list, address, port, callback) {
+  const state = self[kStateSymbol];
+
+  if (ex) {
+    if (typeof callback === "function") {
+      process.nextTick(callback, ex);
+      return;
+    }
+
+    process.nextTick(() => self.emit("error", ex));
+    return;
+  } else if (!state.handle) {
+    return;
+  }
+
+  if (ip && state.sendBlockList?.check(ip, `ipv${isIP(ip)}`)) {
+    if (callback) {
+      process.nextTick(callback, ERR_IP_BLOCKED(ip));
+    }
+    return;
+  }
+
+  const req = new SendWrap();
+  req.list = list;  // Keep reference alive.
+  req.address = address;
+  req.port = port;
+  if (callback) {
+    req.callback = callback;
+    req.oncomplete = afterSend;
+  }
+
+  let err;
+  if (port)
+    err = state.handle.send(req, list, list.length, port, ip, !!callback);
+  else
+    err = state.handle.send(req, list, list.length, !!callback);
+
+  if (err >= 1) {
+    // Synchronous finish. The return code is msg_length + 1 so that we can
+    // distinguish between synchronous success and asynchronous success.
+    if (callback)
+      process.nextTick(callback, null, err - 1);
+    return;
+  }
+
+  if (err && callback) {
+    // Don't emit as error, dgram_legacy.js compatibility
+    const ex = ExceptionWithHostPort(err, "send", address, port);
+    process.nextTick(callback, ex);
+  }
+}
+
+function afterSend(err, sent) {
+  if (err) {
+    err = ExceptionWithHostPort(err, "send", this.address, this.port);
+  } else {
+    err = null;
+  }
+
+  this.callback(err, sent);
+}
+
+Socket.prototype.close = function(callback) {
+  const state = this[kStateSymbol];
+  const queue = state.queue;
+
+  if (typeof callback === "function")
+    this.on("close", callback);
+
+  if (queue !== undefined) {
+    queue.push(this.close.bind(this));
+    return this;
+  }
+
+  healthCheck(this);
+  stopReceiving(this);
+  state.handle.close();
+  state.handle = null;
+  process.nextTick(socketCloseNT, this);
+
+  return this;
+};
+
+Socket.prototype[Symbol.asyncDispose] = async function() {
+  if (!this[kStateSymbol].handle) {
+    return;
+  }
+  await new Promise((resolve) => this.close(resolve));
+};
+
+function socketCloseNT(self) {
+  self.emit("close");
+}
+
+Socket.prototype.address = function() {
+  healthCheck(this);
+
+  const out = {};
+  const err = this[kStateSymbol].handle.getsockname(out);
+  if (err) {
+    throw ErrnoException(err, "getsockname");
+  }
+
+  return out;
+};
+
+Socket.prototype.remoteAddress = function() {
+  healthCheck(this);
+
+  const state = this[kStateSymbol];
+  if (state.connectState !== CONNECT_STATE_CONNECTED)
+    throw ERR_SOCKET_DGRAM_NOT_CONNECTED();
+
+  const out = {};
+  const err = state.handle.getpeername(out);
+  if (err)
+    throw ErrnoException(err, "getpeername");
+
+  return out;
+};
+
+Socket.prototype.setBroadcast = function(arg) {
+  const err = this[kStateSymbol].handle.setBroadcast(arg ? 1 : 0);
+  if (err) {
+    throw ErrnoException(err, "setBroadcast");
+  }
+};
+
+Socket.prototype.setTTL = function(ttl) {
+  validateNumber(ttl, "ttl");
+
+  const err = this[kStateSymbol].handle.setTTL(ttl);
+  if (err) {
+    throw ErrnoException(err, "setTTL");
+  }
+
+  return ttl;
+};
+
+Socket.prototype.setMulticastTTL = function(ttl) {
+  validateNumber(ttl, "ttl");
+
+  const err = this[kStateSymbol].handle.setMulticastTTL(ttl);
+  if (err) {
+    throw ErrnoException(err, "setMulticastTTL");
+  }
+
+  return ttl;
+};
+
+Socket.prototype.setMulticastLoopback = function(arg) {
+  const err = this[kStateSymbol].handle.setMulticastLoopback(arg ? 1 : 0);
+  if (err) {
+    throw ErrnoException(err, "setMulticastLoopback");
+  }
+
+  return arg; // 0.4 compatibility
+};
+
+Socket.prototype.setMulticastInterface = function(interfaceAddress) {
+  healthCheck(this);
+  validateString(interfaceAddress, "interfaceAddress");
+
+  const err = this[kStateSymbol].handle.setMulticastInterface(interfaceAddress);
+  if (err) {
+    throw ErrnoException(err, "setMulticastInterface");
+  }
+};
+
+Socket.prototype.addMembership = function(multicastAddress,
+                                          interfaceAddress) {
+  healthCheck(this);
+
+  if (!multicastAddress) {
+    throw new ERR_MISSING_ARGS("multicastAddress");
+  }
+
+  const { handle } = this[kStateSymbol];
+  const err = handle.addMembership(multicastAddress, interfaceAddress);
+  if (err) {
+    throw ErrnoException(err, "addMembership");
+  }
+};
+
+Socket.prototype.dropMembership = function(multicastAddress,
+                                           interfaceAddress) {
+  healthCheck(this);
+
+  if (!multicastAddress) {
+    throw new ERR_MISSING_ARGS("multicastAddress");
+  }
+
+  const { handle } = this[kStateSymbol];
+  const err = handle.dropMembership(multicastAddress, interfaceAddress);
+  if (err) {
+    throw ErrnoException(err, "dropMembership");
+  }
+};
+
+Socket.prototype.addSourceSpecificMembership = function(sourceAddress,
+                                                        groupAddress,
+                                                        interfaceAddress) {
+  healthCheck(this);
+
+  validateString(sourceAddress, "sourceAddress");
+  validateString(groupAddress, "groupAddress");
+
+  const err =
+    this[kStateSymbol].handle.addSourceSpecificMembership(sourceAddress,
+                                                          groupAddress,
+                                                          interfaceAddress);
+  if (err) {
+    throw ErrnoException(err, "addSourceSpecificMembership");
+  }
+};
+
+Socket.prototype.dropSourceSpecificMembership = function(sourceAddress,
+                                                         groupAddress,
+                                                         interfaceAddress) {
+  healthCheck(this);
+
+  validateString(sourceAddress, "sourceAddress");
+  validateString(groupAddress, "groupAddress");
+
+  const err =
+    this[kStateSymbol].handle.dropSourceSpecificMembership(sourceAddress,
+                                                           groupAddress,
+                                                           interfaceAddress);
+  if (err) {
+    throw ErrnoException(err, "dropSourceSpecificMembership");
+  }
+};
+
+function healthCheck(socket) {
+  if (!socket[kStateSymbol].handle) {
+    // Error message from dgram_legacy.js.
+    throw ERR_SOCKET_DGRAM_NOT_RUNNING();
+  }
+}
+
+function stopReceiving(socket) {
+  const state = socket[kStateSymbol];
+
+  if (!state.receiving)
+    return;
+
+  state.handle.recvStop();
+  state.receiving = false;
+}
+
+function onMessage(nread, handle, buf, rinfo) {
+  const self = handle[owner_symbol];
+  if (nread < 0) {
+    return self.emit("error", ErrnoException(nread, "recvmsg"));
+  }
+  if (self[kStateSymbol]?.receiveBlockList?.check(rinfo.address,
+                                                  rinfo.family?.toLocaleLowerCase())) {
+    return;
+  }
+  rinfo.size = buf.length; // compatibility
+  self.emit("message", buf, rinfo);
+}
+
+function onError(nread, handle, error) {
+  const self = handle[owner_symbol];
+  return self.emit("error", error);
+}
+
+Socket.prototype.ref = function() {
+  const handle = this[kStateSymbol].handle;
+
+  if (handle)
+    handle.ref();
+
+  return this;
+};
+
+Socket.prototype.unref = function() {
+  const handle = this[kStateSymbol].handle;
+
+  if (handle)
+    handle.unref();
+
+  return this;
+};
+
+Socket.prototype.setRecvBufferSize = function(size) {
+  bufferSize(this, size, RECV_BUFFER);
+};
+
+Socket.prototype.setSendBufferSize = function(size) {
+  bufferSize(this, size, SEND_BUFFER);
+};
+
+Socket.prototype.getRecvBufferSize = function() {
+  return bufferSize(this, 0, RECV_BUFFER);
+};
+
+Socket.prototype.getSendBufferSize = function() {
+  return bufferSize(this, 0, SEND_BUFFER);
+};
+
+Socket.prototype.getSendQueueSize = function() {
+  return this[kStateSymbol].handle.getSendQueueSize();
+};
+
+Socket.prototype.getSendQueueCount = function() {
+  return this[kStateSymbol].handle.getSendQueueCount();
+};
+
+// Deprecated private APIs.
+for (const [name, key] of [["_handle", "handle"], ["_receiving", "receiving"], ["_bindState", "bindState"], ["_queue", "queue"],
+  ["_reuseAddr", "reuseAddr"]]) {
+  Object.defineProperty(Socket.prototype, name, {
+    __proto__: null,
+    get: deprecate(function() {
+      return this[kStateSymbol][key];
+    }, `Socket.prototype.${name} is deprecated`, "DEP0112"),
+    set: deprecate(function(val) {
+      this[kStateSymbol][key] = val;
+    }, `Socket.prototype.${name} is deprecated`, "DEP0112"),
+  });
+}
+
+Socket.prototype._healthCheck = deprecate(function() {
+  healthCheck(this);
+}, "Socket.prototype._healthCheck() is deprecated", "DEP0112");
+
+Socket.prototype._stopReceiving = deprecate(function() {
+  stopReceiving(this);
+}, "Socket.prototype._stopReceiving() is deprecated", "DEP0112");
+
+// Legacy alias on the C++ wrapper object. This is not public API, so we may
+// want to runtime-deprecate it at some point. There's no hurry, though.
+Object.defineProperty(UDP.prototype, "owner", {
+  __proto__: null,
+  get() { return this[owner_symbol]; },
+  set(v) { this[owner_symbol] = v; },
+});
+
+const _createSocketHandleDeprecated = deprecate(
+  _createSocketHandle,
+  "dgram._createSocketHandle() is deprecated",
+  "DEP0112",
+);
+
+export { _createSocketHandleDeprecated as _createSocketHandle };
+
+export default {
+  _createSocketHandle: _createSocketHandleDeprecated,
+  createSocket,
+  Socket,
+};