Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
45 changes: 29 additions & 16 deletions lib/https.js
Original file line number Diff line number Diff line change
Expand Up @@ -224,6 +224,16 @@ function getTunnelConfigForProxiedHttps(agent, reqOptions) {
return result;
};

// Not inlined in establishTunnel(): this listener lives as long as the
// tunneled socket, and closures created there share a context that holds
// `afterSocket`, which leads to the request that created the socket.
function propagateFree(tunneldSocket, socket) {
tunneldSocket.on('free', () => {
debug('Propagate free event from tunneled socket to tunnel socket');
socket.emit('free');
});
}

function establishTunnel(agent, socket, options, tunnelConfig, afterSocket) {
const { proxyTunnelPayload, maxHeaderSize } = tunnelConfig;
// By default, the socket is in paused mode. Read to look for the 200
Expand Down Expand Up @@ -316,10 +326,7 @@ function establishTunnel(agent, socket, options, tunnelConfig, afterSocket) {
}
if (requestOptions[kPerRequestCheckServerIdentity])
tunneldSocket[kPerRequestCheckServerIdentity] = true;
tunneldSocket.on('free', () => {
debug('Propagate free event from tunneled socket to tunnel socket');
socket.emit('free');
});
propagateFree(tunneldSocket, socket);
tunneldSocket.on('error', onTLSHandshakeError);
}
return true;
Expand Down Expand Up @@ -456,22 +463,28 @@ function createConnection(...args) {
if (options[kPerRequestCheckServerIdentity])
socket[kPerRequestCheckServerIdentity] = true;

if (reuseSession) {
// Cache new session for reuse
socket.on('session', (session) => {
this._cacheSession(options._agentKey, session);
});

// Evict session on error
socket.once('close', (err) => {
if (err)
this._evictSession(options._agentKey);
});
}
if (reuseSession)
cacheSessions(this, socket, options._agentKey);

return socket;
}

// Not inlined in createConnection(): these listeners live as long as the
// socket, and closures created there share a context that holds `cb`, which
// leads to the request that created the socket.
function cacheSessions(agent, socket, key) {
// Cache new session for reuse
socket.on('session', (session) => {
agent._cacheSession(key, session);
});

// Evict session on error
socket.once('close', (err) => {
if (err)
agent._evictSession(key);
});
}

/**
* Creates a new `HttpAgent` instance.
* @param {{
Expand Down
51 changes: 51 additions & 0 deletions test/client-proxy/test-https-proxy-request-collectable.mjs
Original file line number Diff line number Diff line change
@@ -0,0 +1,51 @@
// Flags: --expose-gc
// A keep-alive socket tunneled through a proxy must not keep the request
// that created it reachable once it is back in the agent's free pool.

import * as common from '../common/index.mjs';
import assert from 'node:assert';
import { once } from 'events';
import { createProxyServer } from '../common/proxy-server.js';
import fixtures from '../common/fixtures.js';
import { gcUntil } from '../common/gc.js';

if (!common.hasCrypto)
common.skip('missing crypto');

// https must be dynamically imported so that builds without crypto support
// can skip it.
const { default: https } = await import('node:https');

const server = https.createServer({
cert: fixtures.readKey('agent8-cert.pem'),
key: fixtures.readKey('agent8-key.pem'),
}, common.mustCall((req, res) => res.end('ok')));
server.listen(0);
await once(server, 'listening');

const { proxy } = createProxyServer();
proxy.listen(0);
await once(proxy, 'listening');

const agent = new https.Agent({
keepAlive: true,
proxyEnv: {
HTTPS_PROXY: `http://localhost:${proxy.address().port}`,
},
ca: fixtures.readKey('fake-startcom-root-cert.pem'),
});

const ref = new WeakRef(https.get({
hostname: 'localhost',
port: server.address().port,
agent,
}, common.mustCall((res) => res.resume())));

await once(agent, 'free');
await new Promise(setImmediate);
assert.strictEqual(Object.keys(agent.freeSockets).length, 1);
await gcUntil('the first request is collected',
() => ref.deref() === undefined);
agent.destroy();
proxy.close();
server.close();
39 changes: 39 additions & 0 deletions test/parallel/test-https-agent-keepalive-request-collectable.js
Original file line number Diff line number Diff line change
@@ -0,0 +1,39 @@
// Flags: --expose-gc
'use strict';
const common = require('../common');
if (!common.hasCrypto)
common.skip('missing crypto');

// A keep-alive socket in the agent's free pool must not keep the request
// that created it reachable.

const assert = require('assert');
const https = require('https');
const fixtures = require('../common/fixtures');
const { gcUntil } = require('../common/gc');

const server = https.createServer({
key: fixtures.readKey('agent1-key.pem'),
cert: fixtures.readKey('agent1-cert.pem'),
}, (req, res) => res.end('ok'));

server.listen(0, common.mustCall(() => {
const agent = new https.Agent({ keepAlive: true });
let ref;

agent.once('free', common.mustCall(() => {
setImmediate(common.mustCall(async () => {
assert.strictEqual(Object.keys(agent.freeSockets).length, 1);
await gcUntil('the first request is collected',
() => ref.deref() === undefined);
agent.destroy();
server.close();
}));
}));

ref = new WeakRef(https.get({
port: server.address().port,
agent,
rejectUnauthorized: false,
}, common.mustCall((res) => res.resume())));
}));
Loading