Major update: port mapping, vless outbound, and more

.gitignore

@@ -1,6 +1,9 @@
 .DS_Store
-/node_modules
+node_modules
 *-lock.*
 *.lock
 *.log
-dist
+dist
+src/package.json
+node/config.js
+deno/deno.lock

.vscode/launch.json

@@ -0,0 +1,17 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Launch Program",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "program": "${workspaceFolder}/node/index.js"
+        }
+    ]
+}

deno/deno.json

@@ -0,0 +1,5 @@
+{
+  "tasks": {
+    "start": "deno run --allow-net --unstable main.ts"
+  }
+}

deno/denoplatform.ts

@@ -0,0 +1,101 @@
+import {
+	platformAPI,
+
+	NodeJSUDP,
+	NodeJSUDPRemoteInfo,
+} from '../src/worker-neo.js'
+
+platformAPI.connect = async (address, port) => {
+	const tcpSocket = await Deno.connect({
+		hostname: address,
+		port: port,
+		transport: 'tcp',
+	});
+
+	return {
+		// A ReadableStream Object
+		readable: tcpSocket.readable,
+
+		// Contains functions to write to a TCP stream
+		writable: tcpSocket.writable,
+
+		// Handles socket close
+		// Deno does not have a onclose callback!
+		closed: new Promise<void>((resolve, reject) => {})
+	};
+};
+
+platformAPI.newWebSocket = (url) => new WebSocket(url);
+
+// deno-lint-ignore require-await
+platformAPI.associate = async (isIPv6) => {
+	const family = isIPv6 ? 'IPv6' : 'IPv4';
+
+	const UDPSocket = Deno.listenDatagram({
+		transport: 'udp',
+		port: 0,
+		hostname: isIPv6 ? '[::]' : '0.0.0.0',
+	});
+
+	let messageHandler: null | ((msg: Uint8Array, rinfo: NodeJSUDPRemoteInfo) => void) = null;
+	let errorHandler: null | ((err: Error) => void) = null;
+
+	function receivingLoop() {
+		UDPSocket.receive().then(([buffer, from]) => {
+			// We only support UDP datagram here
+			const remoteAddress = <Deno.NetAddr> from;
+
+			if (messageHandler) {
+				messageHandler(buffer, {
+					address: remoteAddress.hostname,
+					family: family,
+					port: remoteAddress.port,
+					size: buffer.byteLength
+				});
+			}
+
+			// Receive more messages
+			receivingLoop();
+		}).catch((err) => {
+			if (errorHandler) {
+				errorHandler(err);
+			}
+		});
+	}
+	receivingLoop();
+
+	return {
+		send: async (datagram, offset, length, port, address, sendDoneCallback) => {
+			const addr: Deno.Addr = {
+				transport: 'udp',
+				hostname: address,
+				port
+			};
+
+			const buffer = new Uint8Array(datagram, offset, length);
+
+			try {
+				const bytesSent = await UDPSocket.send(buffer, addr);
+				sendDoneCallback(null, bytesSent);
+			} catch (err) {
+				sendDoneCallback(err, 0);
+				if (errorHandler) {
+					errorHandler(err);
+				}
+			}
+		},
+		close: () => {
+			UDPSocket.close();
+		},
+		onmessage: (handler) => {
+			messageHandler = handler;
+		},
+		onerror: (handler) => {
+			errorHandler = handler;
+		}
+	} as NodeJSUDP;
+}
+
+export function onDenoStart() {
+
+}

deno/main.ts

@@ -0,0 +1,76 @@
+import {globalConfig, vlessOverWSHandler, getVLESSConfig} from '../src/worker-neo.js'
+import {onDenoStart} from './denoplatform.ts'
+onDenoStart();
+
+const portString = Deno.env.get("PORT") || '8000';
+Deno.serve({port: Number(portString)}, (req) => {
+	if (req.headers.get("upgrade") === "websocket") {
+		const upgradeResult = Deno.upgradeWebSocket(req);
+		upgradeResult.socket.binaryType = 'arraybuffer';
+		upgradeResult.socket.onopen = () => {
+			const earlyData = req.headers.get('sec-websocket-protocol');
+			vlessOverWSHandler(upgradeResult.socket, earlyData || '');
+		};
+		return upgradeResult.response;
+	}
+
+
+	const reqURL = new URL(req.url);
+	const hostname = reqURL.hostname;
+	const path_config = '/' + globalConfig.userID;
+	const path_qrcode = '/' + globalConfig.userID + '.html';
+	console.log(reqURL.pathname);
+	switch (reqURL.pathname) {
+		case path_config:
+			return new Response(getVLESSConfig(hostname), {
+				status: 200,
+				headers: {
+					'content-type': 'text/plain;charset=UTF-8',
+				},
+			});
+		case path_qrcode: {
+			const vlessMain = `vless://${globalConfig.userID}@${hostname}:443?encryption=none&security=tls&sni=${hostname}&fp=randomized&type=ws&host=${hostname}&path=%2F%3Fed%3D2048#${hostname}`
+			const htmlContent = `
+			<!DOCTYPE html>
+			<html>
+				<head>
+					<meta charset="utf-8" />
+					<script src="https://cdn.jsdelivr.net/gh/davidshimjs/qrcodejs/qrcode.js"></script>
+				</head>
+				<body>
+					<div>${vlessMain}</div>
+					<div id="vless_qr"></div>
+					<script type="text/javascript">
+						function createQRCode(elementId, qrText) {
+							new QRCode(document.getElementById(elementId), {
+								text: qrText,
+								correctLevel: QRCode.CorrectLevel.M,
+							});
+						}
+
+						createQRCode("vless_qr", "${vlessMain}");
+					</script>
+				</body>
+			</html>
+			`;
+
+			return new Response(htmlContent, {
+				status: 200,
+				headers: {
+					'content-type': 'text/html; charset=utf-8',
+				},
+			});
+		}
+		case '/':
+			return new Response('Hello from the HTTP server!', {
+				status: 200,
+				headers: {
+					'content-type': 'text/html; charset=utf-8',
+				},
+			});
+		default:
+			return new Response('Not found! (Code 404)', {
+				status: 404
+			});
+	}
+});

node/index.js

@@ -0,0 +1,63 @@
+// Run this on NodeJS to test edgeworker without wrangler.
+// The only dependency is the ws package from npm
+// To run, first run "setup.sh", then "node index.js"
+
+import http from 'http';
+import WebSocket from 'ws';
+
+import {globalConfig, setConfigFromEnv, vlessOverWSHandler, getVLESSConfig} from '../src/worker-neo.js';
+import {onNodeStart} from './nodeplatform.js';
+
+onNodeStart();
+
+// Create an HTTP server
+const server = http.createServer((req, res) => {
+	switch (req.url) {
+		case '/':
+			res.write('Hello from the HTTP server!');
+			break;
+		case '/vless_config':
+			res.write(getVLESSConfig('YOUR-HOSTNAME'));
+			break;
+		default:
+			res.statusCode = 404;
+	}
+	res.end();
+});
+
+// Create a WebSocket server and attach it to the HTTP server
+const wss = new WebSocket.Server({ server });
+
+// Define what should happen when a new WebSocket connection is established
+wss.on('connection', (ws, req) => {
+	vlessOverWSHandler(ws, req.headers['sec-websocket-protocol'] || '');
+});
+
+// Start the server on port 8000
+server.listen(8000);
+
+function buf2hex(buffer) { // buffer is an ArrayBuffer
+	return [...new Uint8Array(buffer)]
+		.map(x => x.toString(16).padStart(2, '0'))
+		.join(' ');
+}
+
+async function loadModule() {
+	try {
+		const customConfig = await import('./config.js');
+
+		if (customConfig.useCustomOutbound) {
+			globalConfig.outbounds = customConfig.outbounds;
+		} else {
+			setConfigFromEnv(customConfig.env);
+			if (customConfig.forceProxy) {
+				globalConfig.outbounds = globalConfig.outbounds.filter(obj => obj.protocol !== "freedom");
+			}
+		}
+		console.log(JSON.stringify(globalConfig.outbounds));
+	} catch (err) {
+	  console.error('Failed to load the module', err);
+	}
+}
+
+loadModule();

node/nodeplatform.js

@@ -0,0 +1,113 @@
+import {platformAPI} from '../src/worker-neo.js';
+
+import net from 'net';
+import WebSocket from 'ws';
+import {createSocket as createUDPSocket} from 'dgram';
+
+
+/**
+ * Portable function for creating a outbound TCP connections.
+ * Has to be "async" because some platforms open TCP connection asynchronously.
+ * 
+ * @param {string} address The remote address to connect to.
+ * @param {number} port The remote port to connect to.
+ * @returns {object} The wrapped TCP connection, to be compatible with Cloudflare Workers
+ */
+platformAPI.connect = async (address, port) => {
+	const socket = net.createConnection(port, address);
+
+	let readableStreamCancel = false;
+	const readableStream = new ReadableStream({
+		start(controller) {
+			socket.on('data', (data) => {
+				if (readableStreamCancel) {
+					return;
+				}
+				controller.enqueue(data);
+			});
+
+			socket.on('close', () => {
+				socket.destroy();
+				if (readableStreamCancel) {
+					return;
+				}
+				controller.close();
+			});
+		},
+
+		pull(controller) {
+			// if ws can stop read if stream is full, we can implement backpressure
+			// https://streams.spec.whatwg.org/#example-rs-push-backpressure
+		},
+		cancel(reason) {
+			// 1. pipe WritableStream has error, this cancel will called, so ws handle server close into here
+			// 2. if readableStream is cancel, all controller.close/enqueue need skip,
+			// 3. but from testing controller.error still work even if readableStream is cancel
+			if (readableStreamCancel) {
+				return;
+			}
+			readableStreamCancel = true;
+			socket.destroy();
+		}
+	});
+
+	const onSocketCloses = new Promise((resolve, reject) => {
+		socket.on('close', (err) => {
+			if (err) {
+				reject(socket.errored);
+			} else {
+				resolve();
+			}
+		});
+
+		socket.on('error', (err) => {
+			reject(err);
+		});
+	});
+
+	return {
+		// A ReadableStream Object
+		readable: readableStream,
+
+		// Contains functions to write to a TCP stream
+		writable: {
+			getWriter: () => {
+				return {
+					write: (data) => {
+						socket.write(data);
+					},
+					releaseLock: () => {
+						// console.log('Dummy writer.releaseLock()');
+					}
+				};
+			}
+		},
+
+		// Handles socket close
+		closed: onSocketCloses
+	};
+};
+
+platformAPI.newWebSocket = (url) => new WebSocket(url);
+
+platformAPI.associate = async (isIPv6) => {
+	const UDPSocket = createUDPSocket(isIPv6 ? 'udp6' : 'udp4');
+	return {
+		send: (datagram, offset, length, port, address, sendDoneCallback) => {
+			UDPSocket.send(datagram, offset, length, port, address, sendDoneCallback);
+		},
+		close: () => {
+			UDPSocket.close();
+		},
+		onmessage: (handler) => {
+			UDPSocket.on('message', handler);
+		},
+		onerror: (handler) => {
+			UDPSocket.on('error', handler);
+		}
+	};
+}
+
+export function onNodeStart() {
+
+}