[tls] add socket parameter, setServername and ALPNprotocols support (#3457)

* add socket parameter support

* refactor #socket

* add test and more fixs

* some fixes

* bump uws

* handlers fix

* more fixes

* fix node net and node tls tests

* fix duplicate port

* fix deinit on CallbackJobs

* cleanup

* add setImmediate repro

* add test to setImmediate

* this is necessary?

* fix prependOnce on native listener

* try to findout the error on nodemailer CI

* show error message

* Update bun.lockb

* prettier

* Use exact versions of packages

* add alpnProtocol support

* update

* emit error when connect fails on net.Socket

* format

* fix _write and cleanup

* fixup

* fix connect, add alpn test

* fix socket.io

* add socket parameter to TLSSocket

* add TLSSocket socket first parameter

* fixup and _start

* remove flask tests

* fmt

---------

Co-authored-by: Jarred Sumner <709451+Jarred-Sumner@users.noreply.github.com>

1 files changed, 84 insertions, 34 deletions

diff --git a/src/js/out/modules/node/net.js b/src/js/out/modules/node/net.js
index 164ec6677..c34f86b04 100644
--- a/src/js/out/modules/node/net.js
+++ b/src/js/out/modules/node/net.js
@@ -26,7 +26,7 @@ var isIPv4 = function(s) {
   self.emit("listening");
 }, createServer = function(options, connectionListener) {
   return new Server(options, connectionListener);
-}, v4Seg = "(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])", v4Str = `(${v4Seg}[.]){3}${v4Seg}`, IPv4Reg = new RegExp(`^${v4Str}$`), v6Seg = "(?:[0-9a-fA-F]{1,4})", IPv6Reg = new RegExp("^(" + `(?:${v6Seg}:){7}(?:${v6Seg}|:)|` + `(?:${v6Seg}:){6}(?:${v4Str}|:${v6Seg}|:)|` + `(?:${v6Seg}:){5}(?::${v4Str}|(:${v6Seg}){1,2}|:)|` + `(?:${v6Seg}:){4}(?:(:${v6Seg}){0,1}:${v4Str}|(:${v6Seg}){1,3}|:)|` + `(?:${v6Seg}:){3}(?:(:${v6Seg}){0,2}:${v4Str}|(:${v6Seg}){1,4}|:)|` + `(?:${v6Seg}:){2}(?:(:${v6Seg}){0,3}:${v4Str}|(:${v6Seg}){1,5}|:)|` + `(?:${v6Seg}:){1}(?:(:${v6Seg}){0,4}:${v4Str}|(:${v6Seg}){1,6}|:)|` + `(?::((?::${v6Seg}){0,5}:${v4Str}|(?::${v6Seg}){1,7}|:))` + ")(%[0-9a-zA-Z-.:]{1,})?$"), { Bun, createFIFO, Object } = globalThis[Symbol.for("Bun.lazy")]("primordials"), { connect: bunConnect } = Bun, { setTimeout } = globalThis, bunTlsSymbol = Symbol.for("::buntls::"), bunSocketServerHandlers = Symbol.for("::bunsocket_serverhandlers::"), bunSocketServerConnections = Symbol.for("::bunnetserverconnections::"), bunSocketServerOptions = Symbol.for("::bunnetserveroptions::"), SocketClass, Socket = function(InternalSocket) {
+}, v4Seg = "(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])", v4Str = `(${v4Seg}[.]){3}${v4Seg}`, IPv4Reg = new RegExp(`^${v4Str}$`), v6Seg = "(?:[0-9a-fA-F]{1,4})", IPv6Reg = new RegExp("^(" + `(?:${v6Seg}:){7}(?:${v6Seg}|:)|` + `(?:${v6Seg}:){6}(?:${v4Str}|:${v6Seg}|:)|` + `(?:${v6Seg}:){5}(?::${v4Str}|(:${v6Seg}){1,2}|:)|` + `(?:${v6Seg}:){4}(?:(:${v6Seg}){0,1}:${v4Str}|(:${v6Seg}){1,3}|:)|` + `(?:${v6Seg}:){3}(?:(:${v6Seg}){0,2}:${v4Str}|(:${v6Seg}){1,4}|:)|` + `(?:${v6Seg}:){2}(?:(:${v6Seg}){0,3}:${v4Str}|(:${v6Seg}){1,5}|:)|` + `(?:${v6Seg}:){1}(?:(:${v6Seg}){0,4}:${v4Str}|(:${v6Seg}){1,6}|:)|` + `(?::((?::${v6Seg}){0,5}:${v4Str}|(?::${v6Seg}){1,7}|:))` + ")(%[0-9a-zA-Z-.:]{1,})?$"), { Bun, createFIFO, Object } = globalThis[Symbol.for("Bun.lazy")]("primordials"), { connect: bunConnect } = Bun, { setTimeout } = globalThis, bunTlsSymbol = Symbol.for("::buntls::"), bunSocketServerHandlers = Symbol.for("::bunsocket_serverhandlers::"), bunSocketServerConnections = Symbol.for("::bunnetserverconnections::"), bunSocketServerOptions = Symbol.for("::bunnetserveroptions::"), bunSocketInternal = Symbol.for("::bunnetsocketinternal::"), SocketClass, Socket = function(InternalSocket) {
   return SocketClass = InternalSocket, Object.defineProperty(SocketClass.prototype, Symbol.toStringTag, {
     value: "Socket",
     enumerable: !1
@@ -62,7 +62,7 @@ var isIPv4 = function(s) {
     },
     open(socket) {
       const self = socket.data;
-      socket.timeout(self.timeout), socket.ref(), self.#socket = socket, self.connecting = !1, self.emit("connect", self), Socket2.#Drain(socket);
+      socket.timeout(self.timeout), socket.ref(), self[bunSocketInternal] = socket, self.connecting = !1, self.emit("connect", self), Socket2.#Drain(socket);
     },
     handshake(socket, success, verifyError) {
       const { data: self } = socket;
@@ -87,7 +87,7 @@ var isIPv4 = function(s) {
     const self = socket.data;
     if (self.#closed)
       return;
-    self.#closed = !0, self.#socket = null;
+    self.#closed = !0, self[bunSocketInternal] = null;
     const queue = self.#readQueue;
     if (queue.isEmpty()) {
       if (self.push(null))
@@ -163,21 +163,27 @@ var isIPv4 = function(s) {
   localAddress = "127.0.0.1";
   #readQueue = createFIFO();
   remotePort;
-  #socket;
+  [bunSocketInternal] = null;
   timeout = 0;
   #writeCallback;
   #writeChunk;
   #pendingRead;
   isServer = !1;
+  _handle;
+  _parent;
+  _parentWrap;
+  #socket;
   constructor(options) {
-    const { signal, write, read, allowHalfOpen = !1, ...opts } = options || {};
+    const { socket, signal, write, read, allowHalfOpen = !1, ...opts } = options || {};
     super({
       ...opts,
       allowHalfOpen,
       readable: !0,
       writable: !0
     });
-    this.#pendingRead = void 0, signal?.once("abort", () => this.destroy()), this.once("connect", () => this.emit("ready"));
+    if (this._handle = this, this._parent = this, this._parentWrap = this, this.#pendingRead = void 0, socket instanceof Socket2)
+      this.#socket = socket;
+    signal?.once("abort", () => this.destroy()), this.once("connect", () => this.emit("ready"));
   }
   address() {
     return {
@@ -190,10 +196,10 @@ var isIPv4 = function(s) {
     return this.writableLength;
   }
   #attach(port, socket) {
-    this.remotePort = port, socket.data = this, socket.timeout(this.timeout), socket.ref(), this.#socket = socket, this.connecting = !1, this.emit("connect", this), Socket2.#Drain(socket);
+    this.remotePort = port, socket.data = this, socket.timeout(this.timeout), socket.ref(), this[bunSocketInternal] = socket, this.connecting = !1, this.emit("connect", this), Socket2.#Drain(socket);
   }
   connect(port, host, connectListener) {
-    var path;
+    var path, connection = this.#socket;
     if (typeof port === "string") {
       if (path = port, port = void 0, typeof host === "function")
         connectListener = host, host = void 0;
@@ -207,6 +213,7 @@ var isIPv4 = function(s) {
         port,
         host,
         path,
+        socket,
         localAddress,
         localPort,
         family,
@@ -220,7 +227,8 @@ var isIPv4 = function(s) {
         pauseOnConnect,
         servername
       } = port;
-      this.servername = servername;
+      if (this.servername = servername, socket)
+        connection = socket;
     }
     if (!pauseOnConnect)
       this.resume();
@@ -228,36 +236,78 @@ var isIPv4 = function(s) {
     const bunTLS = this[bunTlsSymbol];
     var tls = void 0;
     if (typeof bunTLS === "function") {
-      if (tls = bunTLS.call(this, port, host, !0), this._requestCert = !0, this._rejectUnauthorized = rejectUnauthorized, tls)
+      if (tls = bunTLS.call(this, port, host, !0), this._requestCert = !0, this._rejectUnauthorized = rejectUnauthorized, tls) {
         if (typeof tls !== "object")
           tls = {
             rejectUnauthorized,
             requestCert: !0
           };
-        else
-          tls.rejectUnauthorized = rejectUnauthorized, tls.requestCert = !0;
+        else if (tls.rejectUnauthorized = rejectUnauthorized, tls.requestCert = !0, !connection && tls.socket)
+          connection = tls.socket;
+      }
+      if (connection) {
+        if (typeof connection !== "object" || !(connection instanceof Socket2) || typeof connection[bunTlsSymbol] === "function")
+          throw new TypeError("socket must be an instance of net.Socket");
+      }
       if (this.authorized = !1, this.secureConnecting = !0, this._secureEstablished = !1, this._securePending = !0, connectListener)
         this.on("secureConnect", connectListener);
     } else if (connectListener)
       this.on("connect", connectListener);
-    return bunConnect(path ? {
-      data: this,
-      unix: path,
-      socket: Socket2.#Handlers,
-      tls
-    } : {
-      data: this,
-      hostname: host || "localhost",
-      port,
-      socket: Socket2.#Handlers,
-      tls
-    }), this;
+    if (connection) {
+      const socket2 = connection[bunSocketInternal];
+      if (socket2) {
+        const result = socket2.wrapTLS({
+          data: this,
+          tls,
+          socket: Socket2.#Handlers
+        });
+        if (result) {
+          const [raw, tls2] = result;
+          connection[bunSocketInternal] = raw, raw.timeout(raw.timeout), raw.connecting = !1, this[bunSocketInternal] = tls2, tls2.timeout(tls2.timeout), tls2.connecting = !0, this[bunSocketInternal] = socket2, tls2.open();
+        } else
+          throw this[bunSocketInternal] = null, new Error("Invalid socket");
+      } else
+        connection.once("connect", () => {
+          const socket3 = connection[bunSocketInternal];
+          if (!socket3)
+            return;
+          const result = socket3.wrapTLS({
+            data: this,
+            tls,
+            socket: Socket2.#Handlers
+          });
+          if (result) {
+            const [raw, tls2] = result;
+            connection[bunSocketInternal] = raw, raw.timeout(raw.timeout), raw.connecting = !1, this[bunSocketInternal] = tls2, tls2.timeout(tls2.timeout), tls2.connecting = !0, this[bunSocketInternal] = socket3, tls2.open();
+          } else
+            throw this[bunSocketInternal] = null, new Error("Invalid socket");
+        });
+    } else if (path)
+      bunConnect({
+        data: this,
+        unix: path,
+        socket: Socket2.#Handlers,
+        tls
+      }).catch((error) => {
+        this.emit("error", error);
+      });
+    else
+      bunConnect({
+        data: this,
+        hostname: host || "localhost",
+        port,
+        socket: Socket2.#Handlers,
+        tls
+      }).catch((error) => {
+        this.emit("error", error);
+      });
+    return this;
   }
   _destroy(err, callback) {
-    this.#socket?.end(), callback(err);
+    this[bunSocketInternal]?.end(), callback(err);
   }
   _final(callback) {
-    this.#socket?.end(), callback();
+    this[bunSocketInternal]?.end(), callback();
   }
   get localAddress() {
     return "127.0.0.1";
@@ -266,7 +316,7 @@ var isIPv4 = function(s) {
     return "IPv4";
   }
   get localPort() {
-    return this.#socket?.localPort;
+    return this[bunSocketInternal]?.localPort;
   }
   get pending() {
     return this.connecting;
@@ -289,16 +339,16 @@ var isIPv4 = function(s) {
       return this.writable ? "writeOnly" : "closed";
   }
   ref() {
-    this.#socket?.ref();
+    this[bunSocketInternal]?.ref();
   }
   get remoteAddress() {
-    return this.#socket?.remoteAddress;
+    return this[bunSocketInternal]?.remoteAddress;
   }
   get remoteFamily() {
     return "IPv4";
   }
   resetAndDestroy() {
-    this.#socket?.end();
+    this[bunSocketInternal]?.end();
   }
   setKeepAlive(enable = !1, initialDelay = 0) {
     return this;
@@ -307,17 +357,17 @@ var isIPv4 = function(s) {
     return this;
   }
   setTimeout(timeout, callback) {
-    if (this.#socket?.timeout(timeout), this.timeout = timeout, callback)
+    if (this[bunSocketInternal]?.timeout(timeout), this.timeout = timeout, callback)
       this.once("timeout", callback);
     return this;
   }
   unref() {
-    this.#socket?.unref();
+    this[bunSocketInternal]?.unref();
   }
   _write(chunk, encoding, callback) {
-    if (typeof chunk == "string" && encoding !== "utf8")
+    if (typeof chunk == "string" && encoding !== "ascii")
       chunk = Buffer.from(chunk, encoding);
-    var written = this.#socket?.write(chunk);
+    var written = this[bunSocketInternal]?.write(chunk);
     if (written == chunk.length)
       callback();
     else if (this.#writeCallback)