more

Author: cirospaciari

packages/bun-uws/src/App.h

@@ -249,6 +249,7 @@ struct TemplatedApp {
     }
 
     static TemplatedApp<SSL>* create(SocketContextOptions options = {}) {
+        
         auto* httpContext = HttpContext<SSL>::create(Loop::get(), options);
         if (!httpContext) {
             return nullptr;

src/js/node/_http_client.ts

@@ -372,6 +372,7 @@ function ClientRequest(input, options, cb) {
           this[kFetchRequest] = null;
           this[kClearTimeout]();
           handleResponse = undefined;
+
           const prevIsHTTPS = getIsNextIncomingMessageHTTPS();
           setIsNextIncomingMessageHTTPS(response.url.startsWith("https:"));
           var res = (this.res = new IncomingMessage(response, {
@@ -401,16 +402,16 @@ function ClientRequest(input, options, cb) {
               if (self.aborted || !self.emit("response", res)) {
                 res._dump();
               }
+              maybeEmitClose();
+              if (res.statusCode === 304) {
+                res.complete = true;
+                maybeEmitClose();
+                return;
+              }
             },
             this,
             res,
           );
-          maybeEmitClose();
-          if (res.statusCode === 304) {
-            res.complete = true;
-            maybeEmitClose();
-            return;
-          }
         };
 
         if (!keepOpen) {

src/js/node/_http_server.ts

@@ -509,6 +509,7 @@ const ServerResponsePrototype = {
     if (handle) {
       handle.abort();
     }
+    this?.socket?.destroy();
     return this;
   },
 
@@ -802,7 +803,31 @@ const ServerPrototype = {
     this.listening = false;
     server.stop();
   },
-
+  [EventEmitter.captureRejectionSymbol]: function (err, event, ...args) {
+    switch (event) {
+      case "request": {
+        const { 1: res } = args;
+        if (!res.headersSent && !res.writableEnded) {
+          // Don't leak headers.
+          const names = res.getHeaderNames();
+          for (let i = 0; i < names.length; i++) {
+            res.removeHeader(names[i]);
+          }
+          res.statusCode = 500;
+          res.end(STATUS_CODES[500]);
+        } else {
+          res.destroy();
+        }
+        break;
+      }
+      default:
+        // net.Server.prototype[EventEmitter.captureRejectionSymbol].apply(this, arguments);
+        //   .apply(this, arguments);
+        const { 1: res } = args;
+        res?.socket?.destroy();
+        break;
+    }
+  },
   [Symbol.asyncDispose]() {
     const { resolve, reject, promise } = Promise.withResolvers();
     this.close(function (err, ...args) {
@@ -1220,7 +1245,11 @@ const NodeHTTPServerSocket = class Socket extends Duplex {
     if (req && !req.complete && !req[kHandle]?.upgraded) {
       // At this point the socket is already destroyed; let's avoid UAF
       req[kHandle] = undefined;
-      req.destroy(new ConnResetException("aborted"));
+      if (req.listenerCount("error") > 0) {
+        req.destroy(new ConnResetException("aborted"));
+      } else {
+        req.destroy();
+      }
     }
   }
   #onCloseForDestroy(closeCallback) {

src/js/node/events.ts

@@ -67,7 +67,9 @@ function EventEmitter(opts) {
     this[kCapture] = !!opts.captureRejections;
     this.emit = emitWithRejectionCapture;
   } else {
-    this[kCapture] = EventEmitterPrototype[kCapture];
+    const capture = EventEmitterPrototype[kCapture];
+    this[kCapture] = capture;
+    this.emit = capture ? emitWithRejectionCapture : emitWithoutRejectionCapture;
   }
 }
 Object.defineProperty(EventEmitter, "name", { value: "EventEmitter", configurable: true });

test/js/node/http/node-http.test.ts

@@ -1499,8 +1499,8 @@ it("should emit events in the right order", async () => {
     ["req", "response"],
     "STATUS: 200",
     // TODO: not totally right:
-    ["req", "close"],
     ["res", "resume"],
+    ["req", "close"],
     ["res", "readable"],
     ["res", "end"],
     ["res", "close"],

test/js/node/test/parallel/test-http-server-capture-rejections.js

@@ -0,0 +1,109 @@
+'use strict';
+
+const common = require('../common');
+const events = require('events');
+const { createServer, request } = require('http');
+const assert = require('assert');
+
+events.captureRejections = true;
+
+{
+  const server = createServer(common.mustCall(async (req, res) => {
+    // We will test that this header is cleaned up before forwarding.
+    res.setHeader('content-type', 'application/json');
+    throw new Error('kaboom');
+  }));
+
+  server.listen(0, common.mustCall(() => {
+    const req = request({
+      method: 'GET',
+      host: server.address().host,
+      port: server.address().port
+    });
+
+    req.end();
+
+    req.on('response', common.mustCall((res) => {
+      assert.strictEqual(res.statusCode, 500);
+      assert.strictEqual(Object.hasOwn(res.headers, 'content-type'), false);
+      let data = '';
+      res.setEncoding('utf8');
+      res.on('data', common.mustCall((chunk) => {
+        data += chunk;
+      }));
+      res.on('end', common.mustCall(() => {
+        assert.strictEqual(data, 'Internal Server Error');
+        server.close();
+      }));
+    }));
+  }));
+}
+
+{
+  let resolve;
+  const latch = new Promise((_resolve) => {
+    resolve = _resolve;
+  });
+  const server = createServer(common.mustCall(async (req, res) => {
+    server.close();
+
+    // We will test that this header is cleaned up before forwarding.
+    res.setHeader('content-type', 'application/json');
+    res.write('{');
+    req.resume();
+
+    // Wait so the data is on the wire
+    await latch;
+
+    throw new Error('kaboom');
+  }));
+
+  server.listen(0, common.mustCall(() => {
+    const req = request({
+      method: 'GET',
+      host: server.address().host,
+      port: server.address().port
+    });
+
+    req.end();
+
+    req.on('response', common.mustCall((res) => {
+      assert.strictEqual(res.statusCode, 200);
+      assert.strictEqual(res.headers['content-type'], 'application/json');
+      resolve();
+
+      let data = '';
+      res.setEncoding('utf8');
+      res.on('data', common.mustCall((chunk) => {
+        data += chunk;
+      }));
+
+      req.on('close', common.mustCall(() => {
+        assert.strictEqual(data, '{');
+      }));
+    }));
+  }));
+}
+
+{
+  const server = createServer(common.mustCall(async (req, res) => {
+    // We will test that this header is cleaned up before forwarding.
+    res.writeHead(200);
+    throw new Error('kaboom');
+  }));
+
+  server.listen(0, common.mustCall(() => {
+    const req = request({
+      method: 'GET',
+      host: server.address().host,
+      port: server.address().port
+    });
+
+    req.end();
+
+    req.on('error', common.mustCall((err) => {
+      assert.strictEqual(err.code, 'ECONNRESET');
+      server.close();
+    }));
+  }));
+}