feat: support localAddress

src/chain.ts

@@ -21,19 +21,22 @@ interface Options {
     method: string;
     headers: string[];
     path?: string;
+    localAddress?: string;
 }
 
 export interface HandlerOpts {
     upstreamProxyUrlParsed: URL;
+    localAddress?: string;
 }
 
 interface ChainOpts {
-    request: { url?: string },
-    sourceSocket: Socket,
-    head?: Buffer,
-    handlerOpts: HandlerOpts,
-    server: EventEmitter & { log: (...args: any[]) => void; },
-    isPlain: boolean,
+    request: { url?: string };
+    sourceSocket: Socket;
+    head?: Buffer;
+    handlerOpts: HandlerOpts;
+    server: EventEmitter & { log: (...args: any[]) => void; };
+    isPlain: boolean;
+    localAddress?: string;
 }
 
 export const chain = (
@@ -61,6 +64,7 @@ export const chain = (
             'host',
             request.url!,
         ],
+        localAddress: handlerOpts.localAddress,
     };
 
     if (proxy.username || proxy.password) {

src/direct.ts

@@ -5,11 +5,16 @@ import { EventEmitter } from 'events';
 import { countTargetBytes } from './utils/count_target_bytes';
 import { Socket } from './socket';
 
+export interface HandlerOpts {
+    localAddress?: string;
+}
+
 interface DirectOpts {
-    request: { url?: string },
-    sourceSocket: Socket,
-    head: Buffer,
-    server: EventEmitter & { log: (...args: any[]) => void; },
+    request: { url?: string };
+    sourceSocket: Socket;
+    head: Buffer;
+    server: EventEmitter & { log: (...args: any[]) => void; };
+    handlerOpts: HandlerOpts;
 }
 
 export const direct = (
@@ -18,6 +23,7 @@ export const direct = (
         sourceSocket,
         head,
         server,
+        handlerOpts,
     }: DirectOpts,
 ): void => {
     const url = new URL(`connect://${request.url}`);
@@ -37,6 +43,7 @@ export const direct = (
     const options = {
         port: Number(url.port),
         host: url.hostname,
+        localAddress: handlerOpts.localAddress,
     };
 
     if (options.host[0] === '[') {

src/forward.ts

@@ -14,10 +14,12 @@ interface Options {
     headers: string[];
     insecureHTTPParser: boolean;
     path?: string;
+    localAddress?: string;
 }
 
 export interface HandlerOpts {
     upstreamProxyUrlParsed: URL;
+    localAddress?: string;
 }
 
 export const forward = async (
@@ -33,6 +35,7 @@ export const forward = async (
         method: request.method!,
         headers: validHeadersOnly(request.rawHeaders),
         insecureHTTPParser: true,
+        localAddress: handlerOpts.localAddress,
     };
 
     // In case of proxy the path needs to be an absolute URL

src/server.ts

@@ -51,6 +51,7 @@ type HandlerOpts = {
     upstreamProxyUrlParsed: URL | null;
     isHttp: boolean;
     customResponseFunction: CustomResponseOpts['customResponseFunction'] | null;
+    localAddress?: string;
 };
 
 type PrepareRequestFunctionOpts = {
@@ -68,6 +69,7 @@ type PrepareRequestFunctionResult = {
     requestAuthentication?: boolean;
     failMsg?: string;
     upstreamProxyUrl?: string | null;
+    localAddress?: string;
 };
 
 type Promisable<T> = T | Promise<T>;
@@ -343,7 +345,7 @@ export class Server extends EventEmitter {
      * @param request
      * @param handlerOpts
      */
-    async callPrepareRequestFunction(request: http.IncomingMessage, handlerOpts: HandlerOpts): Promise<PrepareRequestFunctionResult | undefined> {
+    async callPrepareRequestFunction(request: http.IncomingMessage, handlerOpts: HandlerOpts): Promise<PrepareRequestFunctionResult> {
         // Authenticate the request using a user function (if provided)
         if (this.prepareRequestFunction) {
             const funcOpts: PrepareRequestFunctionOpts = {
@@ -372,11 +374,11 @@ export class Server extends EventEmitter {
                 funcOpts.password = auth.password!;
             }
 
-            // User function returns a result directly or a promise
-            return this.prepareRequestFunction(funcOpts);
+            const result = await this.prepareRequestFunction(funcOpts);
+            return result ?? {};
         }
 
-        return { requestAuthentication: false, upstreamProxyUrl: null };
+        return {};
     }
 
     /**
@@ -388,12 +390,14 @@ export class Server extends EventEmitter {
         const handlerOpts = this.getHandlerOpts(request);
         const funcResult = await this.callPrepareRequestFunction(request, handlerOpts);
 
+        handlerOpts.localAddress = funcResult.localAddress;
+
         // If not authenticated, request client to authenticate
-        if (funcResult && funcResult.requestAuthentication) {
+        if (funcResult.requestAuthentication) {
             throw new RequestError(funcResult.failMsg || 'Proxy credentials required.', 407);
         }
 
-        if (funcResult && funcResult.upstreamProxyUrl) {
+        if (funcResult.upstreamProxyUrl) {
             try {
                 handlerOpts.upstreamProxyUrlParsed = new URL(funcResult.upstreamProxyUrl);
             } catch (error) {
@@ -408,7 +412,7 @@ export class Server extends EventEmitter {
 
         const { proxyChainId } = request.socket as Socket;
 
-        if (funcResult && funcResult.customResponseFunction) {
+        if (funcResult.customResponseFunction) {
             this.log(proxyChainId, 'Using custom response function');
 
             handlerOpts.customResponseFunction = funcResult.customResponseFunction;

test/server.js

@@ -1200,6 +1200,37 @@ describe('non-200 upstream connect response', () => {
     });
 });
 
+it('supports localAddress', async () => {
+    const target = http.createServer((serverRequest, serverResponse) => {
+        serverResponse.end(serverRequest.socket.remoteAddress);
+    });
+
+    await util.promisify(target.listen.bind(target))(0);
+
+    const server = new Server({
+        port: 0,
+        prepareRequestFunction: () => {
+            return {
+                localAddress: '127.0.0.2',
+            };
+        },
+    });
+
+    await server.listen();
+
+    const response = await requestPromised({
+        url: `http://127.0.0.1:${target.address().port}`,
+        proxy: `http://127.0.0.2:${server.port}`,
+    });
+
+    try {
+        expect(response.body).to.be.equal('::ffff:127.0.0.2');
+    } finally {
+        await server.close();
+        await util.promisify(target.close.bind(target))();
+    }
+});
+
 // Run all combinations of test parameters
 const useSslVariants = [
     false,