Add HTTP/2 support for everything except /echo

pimterry · pimterry · commit 3172d353b022 · 2025-05-02T15:43:28.000+02:00
diff --git a/src/endpoints/http-index.ts b/src/endpoints/http-index.ts
@@ -1,13 +1,17 @@
 import { MaybePromise } from '@httptoolkit/util';
 import * as http from 'http';
+import * as http2 from 'http2';
+
+export type HttpRequest = http.IncomingMessage | http2.Http2ServerRequest;
+export type HttpResponse = http.ServerResponse | http2.Http2ServerResponse;
 
 export type HttpHandler = (
-    req: http.IncomingMessage,
-    res: http.ServerResponse,
+    req: HttpRequest,
+    res: HttpResponse,
     options: {
         path: string;
         query: URLSearchParams;
-        handleRequest: (req: http.IncomingMessage, res: http.ServerResponse) => void;
+        handleRequest: (req: HttpRequest, res: HttpResponse) => void;
     }
 ) => MaybePromise<void>;
 
diff --git a/src/endpoints/http/cookies.ts b/src/endpoints/http/cookies.ts
@@ -42,7 +42,7 @@ export const setCookies: HttpEndpoint = {
                     })
                 ];
             })).flat()
-        ]).end();
+        ] as any).end(); // Any because H2 types don't include string array
     }
 }
 
@@ -57,6 +57,6 @@ export const deleteCookies: HttpEndpoint = {
                 'set-cookie',
                 `${key}=; Expires=Thu, 01-Jan-1970 00:00:00 GMT; Max-Age=0; Path=/`
             ]).flat()
-        ]).end();
+        ] as any).end(); // Any because H2 types don't include string array
     }
 }
diff --git a/src/endpoints/http/echo.ts b/src/endpoints/http/echo.ts
@@ -1,11 +1,19 @@
-import * as http from 'http';
 import * as streamConsumers from 'stream/consumers';
 
-import { HttpEndpoint } from '../http-index.js';
+import {
+    HttpEndpoint,
+    HttpRequest,
+    HttpResponse
+} from '../http-index.js';
 
 const matchPath = ((path: string) => path === '/echo');
 
-async function handle(req: http.IncomingMessage, res: http.ServerResponse) {
+async function handle(req: HttpRequest, res: HttpResponse) {
+    if (req.httpVersion === '2.0') {
+        res.writeHead(400);
+        res.end('Echo endpoint does not yet support HTTP/2');
+        return;
+    }
     await streamConsumers.buffer(req); // Wait for all request data
     const input = Buffer.concat(req.socket.receivedData ?? []);
     res.writeHead(200, {
diff --git a/src/http-handler.ts b/src/http-handler.ts
@@ -1,10 +1,12 @@
 import * as http from 'http';
+import * as http2 from 'http2';
 
 import { clearArray } from './util.js';
 
 import { httpEndpoints } from './endpoints/endpoint-index.js';
+import { HttpRequest, HttpResponse } from './endpoints/http-index.js';
 
-const allowCORS = (req: http.IncomingMessage, res: http.ServerResponse) => {
+const allowCORS = (req: HttpRequest, res: HttpResponse) => {
     const origin = req.headers['origin'];
     if (!origin) return;
 
@@ -24,10 +26,15 @@ const allowCORS = (req: http.IncomingMessage, res: http.ServerResponse) => {
     }
 }
 
-export function createHttpHandler(options: {
+type RequestHandler = (
+    req: HttpRequest,
+    res: HttpResponse
+) => Promise<void>;
+
+function createHttpRequestHandler(options: {
     acmeChallengeCallback: (token: string) => string | undefined
-}) {
-    async function handleRequest(req: http.IncomingMessage, res: http.ServerResponse) {
+}): RequestHandler {
+    return async function handleRequest(req, res) {
         const url = new URL(req.url!, `http://${req.headers.host}`);
         const path = url.pathname;
 
@@ -84,10 +91,44 @@ export function createHttpHandler(options: {
             res.end(`No handler for ${req.url}`);
         }
     }
+}
 
+export function createHttp1Handler(options: {
+    acmeChallengeCallback: (token: string) => string | undefined
+}) {
+    const handleRequest = createHttpRequestHandler(options);
     const handler = new http.Server(async (req, res) => {
         try {
-            console.log(`Handling request to ${req.url}`);
+            console.log(`Handling H1 request to ${req.url}`);
+            await handleRequest(req, res);
+        } catch (e) {
+            console.error(e);
+
+            if (res.closed) return;
+            else if (res.headersSent) {
+                res.destroy();
+            } else {
+                res.writeHead(500);
+                res.end('HTTP handler failed');
+            }
+        } finally {
+            // We have to clear this, as we might get multiple requests on the same
+            // socket with keep-alive etc.
+            clearArray(req.socket.receivedData);
+        }
+    });
+
+    handler.on('error', (err) => console.error('HTTP handler error', err));
+
+    return handler;
+}
+
+export function createHttp2Handler(options: {
+    acmeChallengeCallback: (token: string) => string | undefined
+}) {
+    const handleRequest = createHttpRequestHandler(options);
+    const handler = http2.createServer(async (req, res) => {
+        try {
             await handleRequest(req, res);
         } catch (e) {
             console.error(e);
diff --git a/src/httpbin-compat.ts b/src/httpbin-compat.ts
@@ -1,12 +1,12 @@
 import _ from 'lodash';
-import * as http from 'http';
 import * as streamConsumers from 'stream/consumers';
 
 import * as querystring from 'querystring';
 import * as multipart from 'parse-multipart-data';
 
 import { TLSSocket } from 'tls';
 import { serializeJson } from './util.js';
+import { HttpRequest, HttpResponse } from './endpoints/http-index.js';
 
 const utf8Decoder = new TextDecoder('utf8', { fatal: true });
 
@@ -40,7 +40,7 @@ const entriesToMultidict = (entries: Array<[string, string]>) =>
 // Matches Flask's req.args multi-dict values
 const getUrlArgs = (url: URL) => entriesToMultidict([...url.searchParams.entries()]);
 
-const getFiles = (body: Buffer, req: http.IncomingMessage) => {
+const getFiles = (body: Buffer, req: HttpRequest) => {
     const contentType = req.headers["content-type"];
     if (!contentType?.includes("multipart/form-data")) return {};
 
@@ -62,11 +62,13 @@ const getFiles = (body: Buffer, req: http.IncomingMessage) => {
 // interoperability since this is widely used (and it's generally a reasonable format for this).
 export const buildHttpBinAnythingEndpoint = (options: {
     fieldFilter?: string[]
-}) => async (req: http.IncomingMessage, res: http.ServerResponse) => {
+}) => async (req: HttpRequest, res: HttpResponse) => {
     const input = await streamConsumers.buffer(req); // Wait for all request data
 
     const isHTTPS = req.socket instanceof TLSSocket;
-    const url = new URL(req.url as string, `${isHTTPS ? 'https' : 'http'}://${req.headers.host}`);
+    const url = new URL(req.url as string, `${isHTTPS ? 'https' : 'http'}://${
+        req.headers[':authority'] || req.headers.host
+    }`);
 
     let jsonValue: any = null;
     try {
diff --git a/src/process-connection.ts b/src/process-connection.ts
@@ -5,6 +5,15 @@ import * as http from 'http';
 const TLS_HANDSHAKE_BYTE = 0x16; // SSLv3+ or TLS handshake
 const isTLS = (initialData: Uint8Array) => initialData[0] === TLS_HANDSHAKE_BYTE;
 
+const HTTP2_PREFACE = 'PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n';
+const HTTP2_PREFACE_BUFFER = Buffer.from(HTTP2_PREFACE);
+const HTTP2_PREFACE_LENGTH = HTTP2_PREFACE_BUFFER.byteLength;
+const isHTTP2 = (initialData: Uint8Array) => {
+    const comparisonLength = Math.min(HTTP2_PREFACE_LENGTH, initialData.length);
+    return Buffer.from(initialData.subarray(0, comparisonLength))
+        .equals(HTTP2_PREFACE_BUFFER.subarray(0, comparisonLength));
+};
+
 // We guess at HTTP by checking the initial bytes match a known HTTP method + following space.
 // Not super precise, but generally pretty good (rules out TLS, proxy protocol, etc).
 const METHOD_PREFIXES = http.METHODS.map(m => m + ' ');
@@ -28,7 +37,8 @@ export class ConnectionProcessor {
 
     constructor(
         private tlsHandler: ConnectionHandler,
-        private httpHandler: ConnectionHandler
+        private httpHandler: ConnectionHandler,
+        private http2Handler: ConnectionHandler
     ) {}
 
     readonly processConnection = (connection: stream.Duplex) => {
@@ -38,7 +48,7 @@ export class ConnectionProcessor {
 
         const initialData: Buffer | null = connection.read();
         if (initialData === null) {
-            // Wait until this is actually readable
+            // Wait until we have more bytes available (at least 3 to differentiate H2 & H1):
             connection.once('readable', () => this.processConnection(connection));
             return;
         } else {
@@ -56,8 +66,9 @@ export class ConnectionProcessor {
 
         if (isTLS(initialData)) {
             this.tlsHandler(connection);
+        } else if (isHTTP2(initialData)) {
+            this.http2Handler(connection);
         } else if (couldBeHttp(initialData)) {
-            // Assume it's otherwise HTTP (for now)
             this.httpHandler(connection);
         } else {
             console.error('Got unrecognized connection data:', initialData);
diff --git a/src/server.ts b/src/server.ts
@@ -1,6 +1,6 @@
 import * as net from 'net';
 
-import { createHttpHandler } from './http-handler.js';
+import { createHttp1Handler, createHttp2Handler } from './http-handler.js';
 import { createTlsHandler } from './tls-handler.js';
 import { ConnectionProcessor } from './process-connection.js';
 
@@ -81,16 +81,23 @@ async function generateTlsConfig(options: ServerOptions) {
 
 const createTcpHandler = async (options: ServerOptions = {}) => {
     const connProcessor = new ConnectionProcessor(
-        (conn) => tlsHandler.emit('connection', conn),
-        (conn) => httpHandler.emit('connection', conn)
+        (conn) => {
+            conn.pause();
+            tlsHandler.emit('connection', conn);
+        },
+        (conn) => httpHandler.emit('connection', conn),
+        (conn) => http2Handler.emit('connection', conn)
     );
 
     const tlsConfig = await generateTlsConfig(options);
     const tlsHandler = await createTlsHandler(tlsConfig, connProcessor);
 
-    const httpHandler = createHttpHandler({
+    const httpConfig = {
         acmeChallengeCallback: tlsConfig.acmeChallenge
-    });
+    };
+
+    const httpHandler = createHttp1Handler(httpConfig);
+    const http2Handler = createHttp2Handler(httpConfig);
 
     return (conn: net.Socket) => {
         try {
diff --git a/src/tls-handler.ts b/src/tls-handler.ts
@@ -21,6 +21,7 @@ export async function createTlsHandler(
         key: tlsConfig.key,
         cert: tlsConfig.cert,
         ca: [tlsConfig.ca],
+        ALPNProtocols: ['h2', 'http/1.1'],
         SNICallback: (domain: string, cb: Function) => {
             try {
                 const generatedCert = tlsConfig.generateCertificate(domain);
diff --git a/test/anything.spec.ts b/test/anything.spec.ts
@@ -1,4 +1,6 @@
 import * as net from 'net';
+import * as http2 from 'http2';
+import * as streamConsumers from 'stream/consumers';
 import { expect } from 'chai';
 import { DestroyableServer, makeDestroyable } from 'destroyable-server';
 
@@ -93,4 +95,42 @@ describe("Anything endpoint", () => {
         });
     });
 
+    it("returns request details for HTTP/2", async () => {
+            const client = http2.connect(`http://localhost:${serverPort}`);
+            const request = client.request({
+                ':path': '/anything?&&&&',
+                ':method': 'PUT',
+                'test-HEADER': 'abc',
+                'content-type': 'application/json'
+            });
+            request.end(JSON.stringify({ "hello": "world" }));
+            const response = await new Promise<
+                http2.IncomingHttpHeaders & http2.IncomingHttpStatusHeader
+            >((resolve) =>
+                request.on('response', resolve)
+            );
+
+            expect(response[':status']).to.equal(200);
+
+            const body: any = await streamConsumers.json(request);
+            expect(body).to.deep.equal({
+                args: {},
+                data: '{"hello":"world"}',
+                files: {},
+                form: {},
+                headers: {
+                    ":authority": `localhost:${serverPort}`,
+                    ":method": "PUT",
+                    ":path": "/anything?&&&&",
+                    ":scheme": "http",
+                    "Content-Type": "application/json",
+                    "Test-Header": "abc",
+                },
+                json: { "hello": "world" },
+                method: "PUT",
+                origin: body.origin ?? 'fail', // Skip testing the exact value since it varies a lot
+                url: `http://localhost:${serverPort}/anything?&&&&`
+            });
+    });
+
 });
diff --git a/test/status.spec.ts b/test/status.spec.ts
@@ -1,4 +1,6 @@
 import * as net from 'net';
+import * as http2 from 'http2';
+
 import { expect } from 'chai';
 import { DestroyableServer, makeDestroyable } from 'destroyable-server';
 

Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ export const setCookies: HttpEndpoint = {`
`42`	`42`	`})`
`43`	`43`	`];`
`44`	`44`	`})).flat()`
`45`		`- ]).end();`
	`45`	`+ ] as any).end(); // Any because H2 types don't include string array`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`
`@@ -57,6 +57,6 @@ export const deleteCookies: HttpEndpoint = {`
`57`	`57`	`'set-cookie',`
`58`	`58`	`${key}=; Expires=Thu, 01-Jan-1970 00:00:00 GMT; Max-Age=0; Path=/`
`59`	`59`	`]).flat()`
`60`		`- ]).end();`
	`60`	`+ ] as any).end(); // Any because H2 types don't include string array`
`61`	`61`	`}`
`62`	`62`	`}`