node:net, node:tls: socket teardown events that still differ from Node (spurious 'end', ERR_SOCKET_CLOSED in place of the real error) #43381

// Usage: node teardown.js <plain-destroy | no-listener | not-reading>
const net = require("node:net");
const scenario = process.argv[2];
const shape = err => (err ? [err.code, err.syscall].filter(Boolean).join(" ") : "ok");
const events = [];
process.on("uncaughtException", err => events.push("uncaught " + shape(err)));
let client, accepted, ready = 0;
const onReady = () => ++ready === 2 && setImmediate(run);
const server = net.createServer(socket => { accepted = socket; onReady(); });
server.listen(0, "127.0.0.1", () => {
  client = net.connect(server.address().port, "127.0.0.1", () => {
    if (scenario === "not-reading") client.pause(); // Node then never starts the reads of this handle
    onReady();
  });
});
function run() {
  accepted.on("error", () => {});
  if (scenario !== "no-listener") client.on("error", err => events.push("error " + shape(err)));
  client.on("end", () => events.push("end"));
  client.on("close", hadError => {
    events.push("close " + hadError);
    setImmediate(() => { console.log(JSON.stringify(events)); process.exit(0); });
  });
  if (scenario === "plain-destroy") return client.destroy();
  // Write until the kernel stops taking the bytes, then queue one more write.
  const chunk = Buffer.alloc(1024 * 1024, "a");
  let writes = 0;
  while (writes < 256 && client.writableLength === 0) {
    const nth = ++writes;
    client.write(chunk, err => { if (nth === writes) events.push("write " + shape(err)); });
  }
  client.write("b", err => events.push("queued " + shape(err)));
  accepted.resetAndDestroy();
}

// A TLS client writes before the handshake completes. The peer closes the TCP connection when it has the ClientHello.
const net = require("node:net");
const tls = require("node:tls");
const shape = err => (err ? [err.code, err.syscall].filter(Boolean).join(" ") : "ok");
const events = [];
const server = net.createServer(peer => { peer.on("error", () => {}); peer.once("data", () => peer.destroy()); });
server.listen(0, "127.0.0.1", () => {
  const client = tls.connect({ port: server.address().port, host: "127.0.0.1", rejectUnauthorized: false });
  client.on("error", err => events.push("error " + shape(err)));
  client.on("end", () => events.push("end"));
  client.on("close", hadError => {
    events.push("close " + hadError);
    setImmediate(() => { console.log(JSON.stringify(events)); process.exit(0); });
  });
  client.write("hello", err => events.push("write " + shape(err)));
});

// Holder states for a write in flight when the peer closes. One process, the cases run one after the other.
const net = require("node:net");
const shape = err => (err ? [err.code, err.syscall].filter(Boolean).join(" ") : "ok");
const chunk = Buffer.alloc(64 * 1024 * 1024);
const reset = (holder, peer) => peer.resetAndDestroy();
const finThenDestroy = (holder, peer) => {
  peer.end();
  holder.once("end", () => setImmediate(() => peer.destroy()));
};
const cases = {
  "1 reads, peer reset": { teardown: reset },
  "2 client paused in 'connect', peer reset": { pauseInConnect: true, teardown: reset },
  "3 accepted with pauseOnConnect, peer reset": { holderSide: "server", serverOpts: { pauseOnConnect: true }, teardown: reset },
  "4 client paused after 'connect', peer reset": { prep: holder => holder.pause(), teardown: reset },
  "5 paused with 1 MB unread, peer reset": {
    prep: (holder, peer) =>
      new Promise(resolve => {
        holder.pause();
        peer.write(Buffer.alloc(1024 * 1024), () => setTimeout(resolve, 100));
      }),
    teardown: reset,
  },
  "6 client, allowHalfOpen, peer FIN then destroy": {
    serverOpts: { allowHalfOpen: true },
    clientOpts: { allowHalfOpen: true },
    teardown: finThenDestroy,
  },
  "7 client, peer FIN then destroy": { teardown: finThenDestroy },
  "8 accepted, peer FIN then destroy": { holderSide: "server", teardown: finThenDestroy },
  "9 accepted, allowHalfOpen, peer FIN then destroy": {
    holderSide: "server",
    serverOpts: { allowHalfOpen: true },
    teardown: finThenDestroy,
  },
  "10 client, allowHalfOpen, peer FIN then reset": {
    serverOpts: { allowHalfOpen: true },
    clientOpts: { allowHalfOpen: true },
    teardown: (holder, peer) => {
      peer.end();
      holder.once("end", () => setImmediate(() => peer.resetAndDestroy()));
    },
  },
};
const runCase = name =>
  new Promise(resolve => {
    const c = cases[name];
    let client, accepted, ready = 0, done = false;
    const onReady = () => ++ready === 2 && setImmediate(run);
    const server = net.createServer(c.serverOpts || {}, socket => {
      accepted = socket;
      onReady();
    });
    server.listen(0, "127.0.0.1", () => {
      client = net.connect({ port: server.address().port, host: "127.0.0.1", ...c.clientOpts }, () => {
        if (c.pauseInConnect) client.pause();
        onReady();
      });
    });
    async function run() {
      const [holder, peer] = c.holderSide === "server" ? [accepted, client] : [client, accepted];
      const events = [];
      const report = why => {
        if (done) return;
        done = true;
        if (why) events.push(why);
        resolve(events);
        holder.destroy();
        peer.destroy();
        server.close();
      };
      peer.on("error", () => {});
      holder.on("error", err => events.push("error " + shape(err)));
      holder.on("end", () => events.push("end"));
      holder.on("close", hadError => {
        events.push("close " + hadError);
        setImmediate(report);
      });
      if (c.prep) await c.prep(holder, peer);
      let writes = 0;
      while (writes < 8 && holder.writableLength === 0) {
        const nth = ++writes;
        holder.write(chunk, err => {
          if (nth === writes) events.push("write " + shape(err));
        });
      }
      if (holder.writableLength === 0) return report("no write in flight");
      holder.write("b", err => events.push("queued " + shape(err)));
      c.teardown(holder, peer);
      setTimeout(report, 4000, "no 'close' after 4 s");
    }
  });
(async () => {
  for (const name in cases) console.log(name.padEnd(50) + JSON.stringify(await runCase(name)));
  process.exit(0);
})();

// Usage: WHERE=write-cb|drain node write-throw.js
// An accepted socket writes two 4 MB chunks to a client that does not read yet, so the first write waits for the socket.
const net = require("node:net");
const WHERE = process.env.WHERE;
const ev = [];
process.on("uncaughtException", e => ev.push("uncaught:" + e.message));
const boom = tag => {
  throw new Error("boom-" + tag);
};
const BIG = Buffer.alloc(4 * 1024 * 1024, "a");
let client;
const server = net.createServer(s => {
  s.on("error", e => ev.push("error:" + e.message));
  s.on("close", had => {
    ev.push("close:" + had);
    server.close(() => console.log(JSON.stringify(ev)));
  });
  if (WHERE === "drain") {
    s.once("drain", () => setImmediate(() => s.end(() => ev.push("end cb"))));
    s.once("drain", () => (ev.push("drain"), boom("drain")));
  }
  const waited = !s.write(BIG, () => {
    ev.push("write#1");
    if (WHERE === "write-cb") boom("cb");
  });
  s.write(BIG, () => ev.push("write#2"));
  ev.push("waited:" + waited);
  if (WHERE !== "drain") s.end(() => ev.push("end cb"));
  client.resume();
});
server.listen(0, "127.0.0.1", () => {
  client = net.connect(server.address().port, "127.0.0.1");
  client.pause();
  client.on("end", () => client.end());
  client.on("error", () => {});
});

// flush-fails.js. Usage: [HTTP=1] bun-debug flush-fails.js
// The first send takes 1 byte, so the write waits. The flush on the next writable event fails with EPIPE.
const { socketFaultInjection: fault } = require("bun:internal-for-testing");
const net = require("node:net");
const http = require("node:http");
const ev = [];
const shape = e => (e ? [e.code, e.syscall].filter(Boolean).join(" ") : "ok");
let client, accepted, ready = 0;
const onReady = () => ++ready === 2 && setImmediate(run);
const server = net.createServer(s => { accepted = s; onReady(); });
server.listen(0, "127.0.0.1", () => { client = net.connect(server.address().port, "127.0.0.1", onReady); });
function run() {
  client.on("error", () => {});
  accepted.on("error", e => ev.push("error " + shape(e)));
  accepted.on("close", had => {
    ev.push("close " + had);
    setImmediate(() => { fault.clear(); console.log(JSON.stringify(ev)); client.destroy(); server.close(); });
  });
  const fd = accepted._handle.fd;
  fault.set({ syscall: "send", action: "short", bytes: 1, repeat: 1, fd });
  if (process.env.HTTP) {
    const res = new http.ServerResponse({ method: "GET", httpVersionMajor: 1, httpVersionMinor: 1 });
    res.assignSocket(accepted);
    res.on("finish", () => ev.push("res finish"));
    res.end("hello", () => ev.push("res end cb"));
  } else {
    accepted.write("hello", e => ev.push("write " + shape(e) + " _hadError=" + accepted._hadError));
  }
  fault.set({ syscall: "send", action: "errno", errno: "EPIPE", repeat: -1, fd });
}

// not-reading.js. Usage: [HTTP=1] node not-reading.js
// The accepted socket does not read (pauseOnConnect), so Node learns of the peer's reset from the write.
const net = require("node:net");
const http = require("node:http");
const ev = [];
const shape = e => (e ? [e.code, e.syscall].filter(Boolean).join(" ") : "ok");
let client;
const server = net.createServer({ pauseOnConnect: true }, s => {
  s.on("error", e => ev.push("error " + shape(e)));
  s.on("close", had => {
    ev.push("close " + had);
    setImmediate(() => { console.log(JSON.stringify(ev)); server.close(); });
  });
  const chunk = Buffer.alloc(64 * 1024 * 1024, "a");
  if (process.env.HTTP) {
    const res = new http.ServerResponse({ method: "GET", httpVersionMajor: 1, httpVersionMinor: 1 });
    res.assignSocket(s);
    res.on("finish", () => ev.push("res finish"));
    res.writeHead(200, { "content-length": String(chunk.length) });
    res.end(chunk, () => ev.push("res end cb"));
  } else {
    s.write(chunk, e => ev.push("write " + shape(e) + " _hadError=" + s._hadError));
  }
  setImmediate(() => client.resetAndDestroy());
});
server.listen(0, "127.0.0.1", () => {
  client = net.connect(server.address().port, "127.0.0.1");
  client.pause();
  client.on("error", () => {});
});

// Usage: node https-cert.js cert.json
// An https request with a body, to a server whose certificate the client rejects.
const CERT = JSON.parse(require("node:fs").readFileSync(process.argv[2], "utf8"));
const tls = require("node:tls");
const https = require("node:https");
const shape = err => (err ? [err.code, err.syscall].filter(Boolean).join(" ") : "ok");
const events = [];
const server = tls.createServer(CERT, socket => socket.on("error", () => {}));
server.on("tlsClientError", () => {});
server.listen(0, "127.0.0.1", () => {
  const req = https.request({ port: server.address().port, host: "127.0.0.1", method: "POST", agent: false });
  req.on("finish", () => events.push("finish"));
  req.on("error", err => events.push("error " + err.code));
  req.on("close", () => {
    events.push("close");
    setImmediate(() => {
      console.log(JSON.stringify(events));
      server.close();
    });
  });
  req.write("hello", err => events.push("write " + shape(err)));
  req.end("world");
});

// The socket that node:http's server hands out (req.socket) holds a write in flight. Then: destroy(), destroy(err), or a peer reset.
const http = require("node:http");
const net = require("node:net");
const shape = err => (err ? [err.code, err.syscall].filter(Boolean).join(" ") : "ok");
const boom = Object.assign(new Error("boom"), { code: "EBOOM" });
const chunk = Buffer.alloc(64 * 1024 * 1024);
const runCase = teardown =>
  new Promise(resolve => {
    const events = [];
    let client;
    const server = http.createServer((req, res) => {
      const socket = req.socket;
      socket.on("error", err => events.push("error " + shape(err)));
      socket.on("end", () => events.push("end"));
      socket.on("close", hadError => {
        events.push("close " + hadError);
        setImmediate(() => {
          resolve(events);
          client.destroy();
          server.close();
        });
      });
      let writes = 0;
      while (writes < 8 && socket.writableLength === 0) {
        const nth = ++writes;
        socket.write(chunk, err => {
          if (nth === writes) events.push("write " + shape(err));
        });
      }
      if (socket.writableLength === 0) events.push("no write in flight");
      socket.write("b", err => events.push("queued " + shape(err)));
      setImmediate(() => {
        if (teardown === "destroy()") socket.destroy();
        else if (teardown === "destroy(err)") socket.destroy(boom);
        else client.resetAndDestroy();
      });
    });
    server.listen(0, "127.0.0.1", () => {
      client = net.connect(server.address().port, "127.0.0.1", () => client.write("GET / HTTP/1.1\r\nHost: x\r\n\r\n"));
      client.on("error", () => {});
      client.pause();
    });
    setTimeout(() => resolve(events.concat("no 'close' after 5 s")), 5000).unref();
  });
(async () => {
  for (const teardown of ["destroy()", "destroy(err)", "peer reset"]) {
    console.log(teardown.padEnd(14) + JSON.stringify(await runCase(teardown)));
  }
  process.exit(0);
})();