311 lines
9.0 KiB
TypeScript
311 lines
9.0 KiB
TypeScript
/**
|
|
* Socket Handler Functions
|
|
*
|
|
* This module provides pre-built socket handlers for common use cases
|
|
* like echoing, proxying, HTTP responses, and redirects.
|
|
*/
|
|
|
|
import * as plugins from '../../../plugins.js';
|
|
import type { IRouteContext } from '../models/route-types.js';
|
|
import { createSocketTracker } from '../../../core/utils/socket-tracker.js';
|
|
|
|
/**
|
|
* Minimal HTTP request parser for socket handlers.
|
|
* Parses method, path, and optionally headers from a raw buffer.
|
|
*/
|
|
function parseHttpRequest(data: Buffer, extractHeaders: boolean = false): {
|
|
method: string;
|
|
path: string;
|
|
headers: Record<string, string>;
|
|
isComplete: boolean;
|
|
body?: string;
|
|
} | null {
|
|
const str = data.toString('utf8');
|
|
const headerEnd = str.indexOf('\r\n\r\n');
|
|
const isComplete = headerEnd !== -1;
|
|
const headerSection = isComplete ? str.slice(0, headerEnd) : str;
|
|
const lines = headerSection.split('\r\n');
|
|
const requestLine = lines[0];
|
|
if (!requestLine) return null;
|
|
|
|
const parts = requestLine.split(' ');
|
|
if (parts.length < 2) return null;
|
|
|
|
const method = parts[0];
|
|
const path = parts[1];
|
|
|
|
// Quick check: valid HTTP method
|
|
const validMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS', 'CONNECT', 'TRACE'];
|
|
if (!validMethods.includes(method)) return null;
|
|
|
|
const headers: Record<string, string> = {};
|
|
if (extractHeaders) {
|
|
for (let i = 1; i < lines.length; i++) {
|
|
const colonIdx = lines[i].indexOf(':');
|
|
if (colonIdx > 0) {
|
|
const name = lines[i].slice(0, colonIdx).trim().toLowerCase();
|
|
const value = lines[i].slice(colonIdx + 1).trim();
|
|
headers[name] = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
const body = isComplete ? str.slice(headerEnd + 4) : undefined;
|
|
|
|
return { method, path, headers, isComplete, body };
|
|
}
|
|
|
|
/**
|
|
* Pre-built socket handlers for common use cases
|
|
*/
|
|
export const SocketHandlers = {
|
|
/**
|
|
* Simple echo server handler
|
|
*/
|
|
echo: (socket: plugins.net.Socket, context: IRouteContext) => {
|
|
socket.write('ECHO SERVER READY\n');
|
|
socket.on('data', data => socket.write(data));
|
|
},
|
|
|
|
/**
|
|
* TCP proxy handler
|
|
*/
|
|
proxy: (targetHost: string, targetPort: number) => (socket: plugins.net.Socket, context: IRouteContext) => {
|
|
const target = plugins.net.connect(targetPort, targetHost);
|
|
socket.pipe(target);
|
|
target.pipe(socket);
|
|
socket.on('close', () => target.destroy());
|
|
target.on('close', () => socket.destroy());
|
|
target.on('error', (err) => {
|
|
console.error('Proxy target error:', err);
|
|
socket.destroy();
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Line-based protocol handler
|
|
*/
|
|
lineProtocol: (handler: (line: string, socket: plugins.net.Socket) => void) => (socket: plugins.net.Socket, context: IRouteContext) => {
|
|
let buffer = '';
|
|
socket.on('data', (data) => {
|
|
buffer += data.toString();
|
|
const lines = buffer.split('\n');
|
|
buffer = lines.pop() || '';
|
|
lines.forEach(line => {
|
|
if (line.trim()) {
|
|
handler(line.trim(), socket);
|
|
}
|
|
});
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Simple HTTP response handler (for testing)
|
|
*/
|
|
httpResponse: (statusCode: number, body: string) => (socket: plugins.net.Socket, context: IRouteContext) => {
|
|
const response = [
|
|
`HTTP/1.1 ${statusCode} ${statusCode === 200 ? 'OK' : 'Error'}`,
|
|
'Content-Type: text/plain',
|
|
`Content-Length: ${body.length}`,
|
|
'Connection: close',
|
|
'',
|
|
body
|
|
].join('\r\n');
|
|
|
|
socket.write(response);
|
|
socket.end();
|
|
},
|
|
|
|
/**
|
|
* Block connection immediately
|
|
*/
|
|
block: (message?: string) => (socket: plugins.net.Socket, context: IRouteContext) => {
|
|
const finalMessage = message || `Connection blocked from ${context.clientIp}`;
|
|
if (finalMessage) {
|
|
socket.write(finalMessage);
|
|
}
|
|
socket.end();
|
|
},
|
|
|
|
/**
|
|
* HTTP block response
|
|
*/
|
|
httpBlock: (statusCode: number = 403, message?: string) => (socket: plugins.net.Socket, context: IRouteContext) => {
|
|
const defaultMessage = `Access forbidden for ${context.domain || context.clientIp}`;
|
|
const finalMessage = message || defaultMessage;
|
|
|
|
const response = [
|
|
`HTTP/1.1 ${statusCode} ${finalMessage}`,
|
|
'Content-Type: text/plain',
|
|
`Content-Length: ${finalMessage.length}`,
|
|
'Connection: close',
|
|
'',
|
|
finalMessage
|
|
].join('\r\n');
|
|
|
|
socket.write(response);
|
|
socket.end();
|
|
},
|
|
|
|
/**
|
|
* HTTP redirect handler
|
|
*/
|
|
httpRedirect: (locationTemplate: string, statusCode: number = 301) => (socket: plugins.net.Socket, context: IRouteContext) => {
|
|
const tracker = createSocketTracker(socket);
|
|
|
|
const handleData = (data: Buffer) => {
|
|
const parsed = parseHttpRequest(data);
|
|
|
|
if (parsed) {
|
|
const path = parsed.path || '/';
|
|
const domain = context.domain || 'localhost';
|
|
const port = context.port;
|
|
|
|
const finalLocation = locationTemplate
|
|
.replace('{domain}', domain)
|
|
.replace('{port}', String(port))
|
|
.replace('{path}', path)
|
|
.replace('{clientIp}', context.clientIp);
|
|
|
|
const message = `Redirecting to ${finalLocation}`;
|
|
const response = [
|
|
`HTTP/1.1 ${statusCode} ${statusCode === 301 ? 'Moved Permanently' : 'Found'}`,
|
|
`Location: ${finalLocation}`,
|
|
'Content-Type: text/plain',
|
|
`Content-Length: ${message.length}`,
|
|
'Connection: close',
|
|
'',
|
|
message
|
|
].join('\r\n');
|
|
|
|
socket.write(response);
|
|
} else {
|
|
socket.write('HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n');
|
|
}
|
|
|
|
socket.end();
|
|
tracker.cleanup();
|
|
};
|
|
|
|
socket.once('data', handleData);
|
|
|
|
tracker.addListener('error', (err) => {
|
|
tracker.safeDestroy(err);
|
|
});
|
|
|
|
tracker.addListener('close', () => {
|
|
tracker.cleanup();
|
|
});
|
|
},
|
|
|
|
/**
|
|
* HTTP server handler for ACME challenges and other HTTP needs
|
|
*/
|
|
httpServer: (handler: (req: { method: string; url: string; headers: Record<string, string>; body?: string }, res: { status: (code: number) => void; header: (name: string, value: string) => void; send: (data: string) => void; end: () => void }) => void) => (socket: plugins.net.Socket, context: IRouteContext) => {
|
|
const tracker = createSocketTracker(socket);
|
|
let requestParsed = false;
|
|
let responseTimer: NodeJS.Timeout | null = null;
|
|
|
|
const processData = (data: Buffer) => {
|
|
if (requestParsed) return;
|
|
|
|
const parsed = parseHttpRequest(data, true);
|
|
|
|
if (!parsed || !parsed.isComplete) {
|
|
return; // Not a complete HTTP request yet
|
|
}
|
|
|
|
requestParsed = true;
|
|
socket.removeListener('data', processData);
|
|
|
|
const req = {
|
|
method: parsed.method,
|
|
url: parsed.path,
|
|
headers: parsed.headers,
|
|
body: parsed.body || ''
|
|
};
|
|
|
|
let statusCode = 200;
|
|
const responseHeaders: Record<string, string> = {};
|
|
let ended = false;
|
|
|
|
const res = {
|
|
status: (code: number) => {
|
|
statusCode = code;
|
|
},
|
|
header: (name: string, value: string) => {
|
|
responseHeaders[name] = value;
|
|
},
|
|
send: (data: string) => {
|
|
if (ended) return;
|
|
ended = true;
|
|
|
|
if (responseTimer) {
|
|
clearTimeout(responseTimer);
|
|
responseTimer = null;
|
|
}
|
|
|
|
if (!responseHeaders['content-type']) {
|
|
responseHeaders['content-type'] = 'text/plain';
|
|
}
|
|
responseHeaders['content-length'] = String(data.length);
|
|
responseHeaders['connection'] = 'close';
|
|
|
|
const statusText = statusCode === 200 ? 'OK' :
|
|
statusCode === 404 ? 'Not Found' :
|
|
statusCode === 500 ? 'Internal Server Error' : 'Response';
|
|
|
|
let response = `HTTP/1.1 ${statusCode} ${statusText}\r\n`;
|
|
for (const [name, value] of Object.entries(responseHeaders)) {
|
|
response += `${name}: ${value}\r\n`;
|
|
}
|
|
response += '\r\n';
|
|
response += data;
|
|
|
|
socket.write(response);
|
|
socket.end();
|
|
},
|
|
end: () => {
|
|
if (ended) return;
|
|
ended = true;
|
|
socket.write('HTTP/1.1 200 OK\r\nContent-Length: 0\r\nConnection: close\r\n\r\n');
|
|
socket.end();
|
|
}
|
|
};
|
|
|
|
try {
|
|
handler(req, res);
|
|
responseTimer = setTimeout(() => {
|
|
if (!ended) {
|
|
res.send('');
|
|
}
|
|
responseTimer = null;
|
|
}, 1000);
|
|
tracker.addTimer(responseTimer);
|
|
} catch (error) {
|
|
if (!ended) {
|
|
res.status(500);
|
|
res.send('Internal Server Error');
|
|
}
|
|
tracker.safeDestroy(error instanceof Error ? error : new Error('Handler error'));
|
|
}
|
|
};
|
|
|
|
tracker.addListener('data', processData);
|
|
|
|
tracker.addListener('error', (err) => {
|
|
if (!requestParsed) {
|
|
tracker.safeDestroy(err);
|
|
}
|
|
});
|
|
|
|
tracker.addListener('close', () => {
|
|
if (responseTimer) {
|
|
clearTimeout(responseTimer);
|
|
responseTimer = null;
|
|
}
|
|
tracker.cleanup();
|
|
});
|
|
}
|
|
};
|