pinokiod 8.2.31 → 8.2.32

package/kernel/anywhere/forward.js

@@ -74,8 +74,6 @@ class Forwarders {
     const label = String(dnsName).split('.')[0]
     const target = `${this.scheme}://${dnsName}:${port}`
     const proxy = httpProxy.createProxyServer({ target, agent: this.agent(), changeOrigin: true, secure: true, ws: true })
-    proxy.on('proxyReq', (proxyReq) => { proxyReq.setHeader(FORWARDED_HEADER, '1') })
-    proxy.on('proxyReqWs', (proxyReq) => { proxyReq.setHeader(FORWARDED_HEADER, '1') })
     proxy.on('error', (error, req, res) => {
       const message = `Could not reach ${dnsName}: ${error && error.message ? error.message : error}`
       if (res && typeof res.writeHead === 'function' && !res.headersSent) {
@@ -85,7 +83,13 @@ class Forwarders {
         res.destroy()
       }
     })
-    const strip = (req) => { for (const name of STRIPPED_HEADERS) delete req.headers[name] }
+    // The headers go out as the incoming request's headers. Setting them in http-proxy's proxyReq
+    // hook instead would throw: with the proxy agent the hook fires once the CONNECT completes, and
+    // by then the outgoing headers are already written.
+    const mark = (req) => {
+      for (const name of STRIPPED_HEADERS) delete req.headers[name]
+      req.headers[FORWARDED_HEADER] = '1'
+    }
     const server = http.createServer((req, res) => {
       const url = new URL(req.url, 'http://127.0.0.1')
       if (url.pathname === OPEN_PATH) {
@@ -100,11 +104,11 @@ class Forwarders {
         res.end()
         return
       }
-      strip(req)
+      mark(req)
       proxy.web(req, res)
     })
     server.on('upgrade', (req, socket, head) => {
-      strip(req)
+      mark(req)
       proxy.ws(req, socket, head)
     })
     // every connection on both sides, upgraded ones included, so stopAll can end a stream a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinokiod",
-  "version": "8.2.31",
+  "version": "8.2.32",
   "description": "",
   "main": "index.js",
   "scripts": {

package/test/anywhere-forward.test.js

@@ -55,6 +55,39 @@ test('a forwarder relays requests with the forwarded header, the peer as Host, a
   assert.equal(target.seen[0].headers['x-pinokio-source-host'], undefined)
 })
 
+// A forward proxy for plain http targets: the real ProxyAgent sends it absolute URLs, and
+// connects asynchronously, which is what broke the proxyReq-hook version in production.
+async function forwardProxy(t) {
+  const server = http.createServer((req, res) => {
+    const target = new URL(req.url)
+    const upstream = http.request({ host: target.hostname, port: target.port, path: target.pathname + target.search, method: req.method, headers: req.headers }, (answer) => {
+      res.writeHead(answer.statusCode, answer.headers)
+      answer.pipe(res)
+    })
+    upstream.on('error', (error) => { res.writeHead(502); res.end(error.message) })
+    req.pipe(upstream)
+  })
+  server.listen(0, '127.0.0.1')
+  await once(server, 'listening')
+  t.after(() => { server.closeAllConnections(); server.close() })
+  return `http://127.0.0.1:${server.address().port}`
+}
+
+test('through the real proxy agent, whose connection completes later, the forwarded header still goes out and nothing throws', async (t) => {
+  const target = await peer(t)
+  const proxyUrl = await forwardProxy(t)
+  const forwarders = new Forwarders({ proxyUrl: () => proxyUrl, serverPort: () => 42000, scheme: 'http' })
+  t.after(() => forwarders.stopAll())
+  const local = await forwarders.open('127.0.0.1', target.port)
+  const answer = await get(local, '/ui/?a=1', { 'X-Pinokio-Peer': '1' })
+  assert.equal(answer.status, 200)
+  const body = JSON.parse(answer.body)
+  assert.equal(body.forwarded, '1')
+  assert.equal(body.peer, null)
+  assert.equal(body.host, `127.0.0.1:${target.port}`)
+  assert.equal(target.seen.length, 1)
+})
+
 test('two opens of the same peer and port at once share one forwarder', async (t) => {
   const target = await peer(t)
   const forwarders = new Forwarders({ proxyUrl: () => null, serverPort: () => 42000, scheme: 'http' })