@sstar/embedlink_agent 0.1.0

package/dist/tftp/server.js

@@ -0,0 +1,731 @@
+import dgram from 'node:dgram';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { EventEmitter } from 'node:events';
+import { error, ErrorCodes } from '../core/errors.js';
+import { getAgentLogger, LogLevel } from '../logger.js';
+import { ensureDir } from './index.js';
+// TFTP操作码
+const OPCODES = {
+    RRQ: 1, // 读请求
+    WRQ: 2, // 写请求
+    DATA: 3, // 数据包
+    ACK: 4, // 确认
+    ERROR: 5, // 错误
+    OACK: 6, // 选项确认
+};
+// TFTP错误码
+const ERROR_CODES = {
+    NOT_DEFINED: 0,
+    FILE_NOT_FOUND: 1,
+    ACCESS_VIOLATION: 2,
+    DISK_FULL: 3,
+    ILLEGAL_OPERATION: 4,
+    UNKNOWN_TID: 5,
+    FILE_EXISTS: 6,
+    NO_SUCH_USER: 7,
+};
+// 服务端重试配置
+const SERVER_RETRY_CONFIG = {
+    MAX_RETRIES: 5,
+    INITIAL_BACKOFF_MS: 500,
+    MAX_BACKOFF_MS: 3000,
+};
+export class TftpServer extends EventEmitter {
+    /**
+     * 跨平台安全的路径检查函数
+     */
+    async validateSecurePath(requestedPath, rootDir) {
+        try {
+            // 1. 标准化路径（处理大小写和分隔符）
+            const normalizedRoot = path.resolve(rootDir).toLowerCase();
+            const normalizedRequested = path.resolve(rootDir, requestedPath).toLowerCase();
+            // 2. 检查是否在根目录内（跨平台安全比较）
+            if (!normalizedRequested.startsWith(normalizedRoot)) {
+                return { valid: false, normalizedPath: '' };
+            }
+            // 3. 检查路径是否包含非法字符（Windows限制）
+            const windowsReservedChars = /[<>:"|?*]/;
+            if (process.platform === 'win32' && windowsReservedChars.test(requestedPath)) {
+                return { valid: false, normalizedPath: '' };
+            }
+            // 4. 检查保留名称（Windows限制）
+            const windowsReservedNames = /^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])$/i;
+            const basename = path.basename(requestedPath);
+            if (process.platform === 'win32' && windowsReservedNames.test(basename)) {
+                return { valid: false, normalizedPath: '' };
+            }
+            return { valid: true, normalizedPath: path.resolve(rootDir, requestedPath) };
+        }
+        catch {
+            return { valid: false, normalizedPath: '' };
+        }
+    }
+    /**
+     * 跨平台文件类型检查
+     */
+    async validateFileType(filepath, forRead = true) {
+        try {
+            const stats = await fs.stat(filepath);
+            if (forRead) {
+                if (!stats.isFile()) {
+                    return {
+                        valid: false,
+                        error: process.platform === 'win32'
+                            ? 'Path is a directory, not a file'
+                            : 'Path is not a regular file',
+                    };
+                }
+            }
+            else {
+                if (stats.isDirectory()) {
+                    return {
+                        valid: false,
+                        error: 'Path is a directory, cannot write to directory',
+                    };
+                }
+            }
+            return { valid: true };
+        }
+        catch (err) {
+            // 跨平台错误码映射
+            if (err.code === 'EISDIR') {
+                return { valid: false, error: 'Path is a directory, not a file' };
+            }
+            else if (err.code === 'ENOENT') {
+                return { valid: false, error: 'Path does not exist' };
+            }
+            else if (err.code === 'EACCES' || err.code === 'EPERM') {
+                return { valid: false, error: 'Access denied' };
+            }
+            else {
+                return { valid: false, error: `File system error: ${err.code}` };
+            }
+        }
+    }
+    constructor(config) {
+        super();
+        this.startTime = 0;
+        this.stats = {
+            requestsHandled: 0,
+            errors: 0,
+            activeConnections: 0,
+        };
+        this.running = false;
+        this.sessions = new Map();
+        this.config = {
+            timeout: 5000,
+            retryCount: 3,
+            blockSize: 512,
+            ...config,
+        };
+    }
+    async start() {
+        if (this.running) {
+            throw error(ErrorCodes.EL_TFTP_SERVER_ALREADY_RUNNING, 'TFTP服务器已在运行');
+        }
+        try {
+            // 确保根目录存在
+            await ensureDir(this.config.rootDir);
+            // 创建UDP socket
+            this.socket = dgram.createSocket({
+                type: 'udp4',
+                reuseAddr: true,
+            });
+            // 绑定端口
+            await new Promise((resolve, reject) => {
+                this.socket.on('error', (err) => {
+                    this.stats.errors++;
+                    this.emit('error', err);
+                    reject(err);
+                });
+                this.socket.on('message', (buffer, rinfo) => {
+                    this.handleRequest(buffer, rinfo);
+                });
+                this.socket.bind(this.config.port, this.config.host, () => {
+                    this.startTime = Date.now();
+                    this.running = true;
+                    this.stats.activeConnections = 0;
+                    // 启动会话清理定时器
+                    this.startCleanupTimer();
+                    resolve();
+                });
+            });
+            this.emit('started');
+        }
+        catch (e) {
+            throw error(ErrorCodes.EL_TFTP_SERVER_START_FAILED, e.message);
+        }
+    }
+    async stop() {
+        if (!this.running)
+            return;
+        this.running = false;
+        // 停止清理定时器
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = undefined;
+        }
+        // 关闭所有活动会话
+        for (const session of this.sessions.values()) {
+            try {
+                if (session.fileHandle) {
+                    await session.fileHandle.close();
+                }
+                session.socket.close();
+            }
+            catch (error) {
+                // 忽略关闭错误
+            }
+        }
+        this.sessions.clear();
+        // 关闭主socket
+        if (this.socket) {
+            this.socket.close();
+            this.socket = undefined;
+        }
+        this.emit('stopped');
+    }
+    isRunning() {
+        return this.running;
+    }
+    getStats() {
+        return {
+            enabled: true,
+            mode: 'builtin',
+            port: this.config.port,
+            host: this.config.host || '0.0.0.0',
+            uptime: this.running ? Date.now() - this.startTime : 0,
+            requestsHandled: this.stats.requestsHandled,
+            errors: this.stats.errors,
+            isRunning: this.running,
+            activeConnections: this.stats.activeConnections,
+        };
+    }
+    startCleanupTimer() {
+        this.cleanupInterval = setInterval(() => {
+            this.cleanupExpiredSessions();
+        }, 60000); // 改为60秒清理一次（原30秒）
+    }
+    cleanupExpiredSessions() {
+        const now = Date.now();
+        const timeout = this.config.timeout * 3; // 改为3倍超时时间（原2倍）
+        for (const [sessionId, session] of this.sessions.entries()) {
+            if (now - session.lastActivity > timeout) {
+                this.closeSession(sessionId);
+            }
+        }
+    }
+    async handleRequest(buffer, rinfo) {
+        try {
+            this.stats.requestsHandled++;
+            // 解析请求
+            const opcode = buffer.readUInt16BE(0);
+            const sessionId = `${rinfo.address}:${rinfo.port}`;
+            switch (opcode) {
+                case OPCODES.RRQ:
+                case OPCODES.WRQ:
+                    await this.handleInitialRequest(opcode, buffer, rinfo);
+                    break;
+                case OPCODES.ACK:
+                case OPCODES.DATA:
+                case OPCODES.ERROR:
+                    await this.handleTransferMessage(sessionId, opcode, buffer, rinfo);
+                    break;
+                default:
+                    await this.sendError(rinfo, ERROR_CODES.ILLEGAL_OPERATION, 'Unknown opcode');
+            }
+        }
+        catch (err) {
+            this.stats.errors++;
+            this.emit('error', err);
+        }
+    }
+    async handleInitialRequest(opcode, buffer, rinfo) {
+        let offset = 2;
+        const filename = this.readString(buffer, offset);
+        offset += filename.length + 1;
+        const mode = this.readString(buffer, offset);
+        offset += mode.length + 1;
+        // 解析选项
+        const options = {};
+        while (offset < buffer.length) {
+            const option = this.readString(buffer, offset);
+            offset += option.length + 1;
+            const value = this.readString(buffer, offset);
+            offset += value.length + 1;
+            options[option.toLowerCase()] = value;
+        }
+        // 验证请求
+        if (!filename || !mode) {
+            await this.sendError(rinfo, ERROR_CODES.ILLEGAL_OPERATION, 'Invalid request');
+            return;
+        }
+        if (mode !== 'netascii' && mode !== 'octet') {
+            await this.sendError(rinfo, ERROR_CODES.ILLEGAL_OPERATION, 'Unsupported mode');
+            return;
+        }
+        // 创建会话
+        const sessionId = `${rinfo.address}:${rinfo.port}`;
+        const rootDir = this.config.rootDir;
+        const imagesRootDir = path.join(rootDir, 'images_agent');
+        // 路径解析策略：
+        // - RRQ（读）：images_agent 优先，其次 rootDir；两处同名则报错（冲突）
+        // - WRQ（写）：只允许写 rootDir，且禁止写入 images_agent 子树
+        const operation = opcode === OPCODES.RRQ ? 'read' : 'write';
+        let resolvedPath = '';
+        if (operation === 'read') {
+            const pvImages = await this.validateSecurePath(filename, imagesRootDir);
+            const pvRoot = await this.validateSecurePath(filename, rootDir);
+            if (!pvImages.valid && !pvRoot.valid) {
+                await this.sendError(rinfo, ERROR_CODES.ACCESS_VIOLATION, 'Access denied: path traversal detected');
+                return;
+            }
+            const exists = async (p) => {
+                const r = await this.validateFileType(p, true);
+                return r.valid;
+            };
+            const hitImages = pvImages.valid ? await exists(pvImages.normalizedPath) : false;
+            const hitRoot = pvRoot.valid ? await exists(pvRoot.normalizedPath) : false;
+            if (hitImages && hitRoot) {
+                try {
+                    const logger = getAgentLogger();
+                    logger.write(LogLevel.WARN, 'tftp.rrq.path_conflict', {
+                        filename,
+                        imagesPath: pvImages.normalizedPath,
+                        rootPath: pvRoot.normalizedPath,
+                        remote: `${rinfo.address}:${rinfo.port}`,
+                    });
+                }
+                catch {
+                    // ignore logging failures
+                }
+                await this.sendError(rinfo, ERROR_CODES.ACCESS_VIOLATION, `Path conflict: file exists in both images_agent and rootDir. filename=${filename} images=${pvImages.normalizedPath} root=${pvRoot.normalizedPath}`);
+                return;
+            }
+            if (hitImages)
+                resolvedPath = pvImages.normalizedPath;
+            else if (hitRoot)
+                resolvedPath = pvRoot.normalizedPath;
+            else {
+                await this.sendError(rinfo, ERROR_CODES.FILE_NOT_FOUND, 'File not found');
+                return;
+            }
+        }
+        else {
+            const pv = await this.validateSecurePath(filename, rootDir);
+            if (!pv.valid) {
+                await this.sendError(rinfo, ERROR_CODES.ACCESS_VIOLATION, 'Access denied: path traversal detected');
+                return;
+            }
+            // 禁止写入 images_agent 子树（避免污染固件资产目录）
+            const normalizedTarget = path.resolve(pv.normalizedPath).toLowerCase();
+            const normalizedImagesRoot = path.resolve(imagesRootDir).toLowerCase();
+            const imagesPrefix = normalizedImagesRoot.endsWith(path.sep)
+                ? normalizedImagesRoot
+                : normalizedImagesRoot + path.sep;
+            if (normalizedTarget === normalizedImagesRoot || normalizedTarget.startsWith(imagesPrefix)) {
+                try {
+                    const logger = getAgentLogger();
+                    logger.write(LogLevel.WARN, 'tftp.wrq.images_agent_denied', {
+                        filename,
+                        targetPath: pv.normalizedPath,
+                        remote: `${rinfo.address}:${rinfo.port}`,
+                    });
+                }
+                catch {
+                    // ignore logging failures
+                }
+                await this.sendError(rinfo, ERROR_CODES.ACCESS_VIOLATION, 'Access denied: writes to images_agent are not allowed');
+                return;
+            }
+            resolvedPath = pv.normalizedPath;
+        }
+        const session = {
+            tid: { port: rinfo.port, address: rinfo.address },
+            socket: dgram.createSocket('udp4'),
+            filename,
+            filepath: resolvedPath,
+            mode: mode,
+            operation,
+            blockNumber: operation === 'read' ? 1 : 0,
+            options: {
+                ...options, // 只包含客户端明确请求的选项，不自动添加blksize
+            },
+            createdAt: Date.now(),
+            lastActivity: Date.now(),
+        };
+        await this.bindSessionSocket(session, sessionId);
+        this.sessions.set(sessionId, session);
+        this.stats.activeConnections++;
+        try {
+            if (opcode === OPCODES.RRQ) {
+                await this.handleReadRequest(session);
+            }
+            else {
+                await this.handleWriteRequest(session);
+            }
+        }
+        catch (err) {
+            this.closeSession(sessionId);
+            throw err;
+        }
+    }
+    async bindSessionSocket(session, sessionId) {
+        const address = this.config.host || '0.0.0.0';
+        await new Promise((resolve, reject) => {
+            const onError = (err) => {
+                session.socket.off('error', onError);
+                reject(err);
+            };
+            session.socket.once('error', onError);
+            session.socket.bind({ address, port: 0 }, () => {
+                session.socket.off('error', onError);
+                session.socket.on('message', async (msg, info) => {
+                    if (msg.length < 2)
+                        return;
+                    const opcode = msg.readUInt16BE(0);
+                    if (opcode === OPCODES.ACK || opcode === OPCODES.DATA || opcode === OPCODES.ERROR) {
+                        try {
+                            await this.handleTransferMessage(sessionId, opcode, msg, info);
+                        }
+                        catch (err) {
+                            this.emit('error', err);
+                        }
+                    }
+                });
+                session.socket.on('error', (err) => this.emit('error', err));
+                resolve();
+            });
+        });
+    }
+    async handleReadRequest(session) {
+        try {
+            // 1. 跨平台文件类型检查
+            const fileValidation = await this.validateFileType(session.filepath, true);
+            if (!fileValidation.valid) {
+                await this.sendErrorToSession(session, ERROR_CODES.FILE_NOT_FOUND, fileValidation.error || 'Invalid file path');
+                return;
+            }
+            // 2. 打开文件
+            session.fileHandle = await fs.open(session.filepath, 'r');
+            // 3. 如果有选项协商，发送OACK
+            if (Object.keys(session.options).length > 0) {
+                const oack = this.createOackPacket(session.options);
+                await this.sendPacketWithRetry(session, oack, 'send OACK');
+                session.blockNumber = 0; // 等待ACK后从block 1开始
+            }
+            else {
+                // 直接发送第一个数据块
+                await this.sendNextDataBlock(session);
+            }
+        }
+        catch (err) {
+            // 跨平台错误处理
+            let errorCode = ERROR_CODES.FILE_NOT_FOUND;
+            let errorMessage = 'File access error';
+            if (err.code === 'ENOENT') {
+                errorMessage = 'File not found';
+            }
+            else if (err.code === 'EACCES' || err.code === 'EPERM') {
+                errorMessage = 'Access denied';
+            }
+            else if (err.code === 'EISDIR') {
+                errorMessage = 'Path is a directory, not a file';
+            }
+            else if (err.code === 'EMFILE' || err.code === 'ENFILE') {
+                errorMessage = 'Too many open files';
+            }
+            await this.sendErrorToSession(session, errorCode, errorMessage);
+            throw err;
+        }
+    }
+    async handleWriteRequest(session) {
+        try {
+            // 1. 检查父目录是否存在且可写
+            const parentDir = path.dirname(session.filepath);
+            try {
+                await fs.access(parentDir, fs.constants.W_OK);
+            }
+            catch {
+                await this.sendErrorToSession(session, ERROR_CODES.ACCESS_VIOLATION, 'Parent directory does not exist or is not writable');
+                return;
+            }
+            // 2. 检查目标路径是否已存在且为目录
+            try {
+                const fileValidation = await this.validateFileType(session.filepath, false);
+                if (!fileValidation.valid && fileValidation.error?.includes('directory')) {
+                    await this.sendErrorToSession(session, ERROR_CODES.FILE_NOT_FOUND, fileValidation.error);
+                    return;
+                }
+                // 如果文件存在且是普通文件，检查是否允许覆盖
+                if (fileValidation.valid) {
+                    await this.sendErrorToSession(session, ERROR_CODES.FILE_EXISTS, 'File already exists');
+                    return;
+                }
+            }
+            catch (err) {
+                // 文件不存在是正常情况，继续处理
+                if (err.code !== 'ENOENT') {
+                    let errorMessage = 'Access denied';
+                    if (err.code === 'EACCES' || err.code === 'EPERM') {
+                        errorMessage = 'Permission denied';
+                    }
+                    else if (err.code === 'EISDIR') {
+                        await this.sendErrorToSession(session, ERROR_CODES.FILE_EXISTS, 'Path is a directory');
+                        return;
+                    }
+                    await this.sendErrorToSession(session, ERROR_CODES.ACCESS_VIOLATION, errorMessage);
+                    return;
+                }
+            }
+            // 3. 创建文件
+            session.fileHandle = await fs.open(session.filepath, 'w');
+            // 4. 如果有选项协商，发送OACK
+            if (Object.keys(session.options).length > 0) {
+                const oack = this.createOackPacket(session.options);
+                await this.sendPacketWithRetry(session, oack, 'send OACK');
+            }
+            else {
+                // 发送ACK block 0
+                const ack = this.createAckPacket(0);
+                await this.sendPacketWithRetry(session, ack, 'send ACK block 0');
+            }
+        }
+        catch (err) {
+            // 跨平台错误处理
+            let errorCode = ERROR_CODES.ACCESS_VIOLATION;
+            let errorMessage = 'Access denied';
+            if (err.code === 'ENOENT') {
+                errorMessage = 'Parent directory does not exist';
+            }
+            else if (err.code === 'EACCES' || err.code === 'EPERM') {
+                errorMessage = 'Permission denied';
+            }
+            else if (err.code === 'EISDIR') {
+                await this.sendErrorToSession(session, ERROR_CODES.FILE_EXISTS, 'Path is a directory, cannot write to directory');
+                throw err;
+            }
+            else if (err.code === 'ENOSPC') {
+                await this.sendErrorToSession(session, ERROR_CODES.DISK_FULL, 'Disk full');
+                throw err;
+            }
+            else if (err.code === 'EMFILE' || err.code === 'ENFILE') {
+                errorMessage = 'Too many open files';
+            }
+            await this.sendErrorToSession(session, errorCode, errorMessage);
+            throw err;
+        }
+    }
+    async handleTransferMessage(sessionId, opcode, buffer, rinfo) {
+        const session = this.sessions.get(sessionId);
+        if (!session || session.tid.port !== rinfo.port || session.tid.address !== rinfo.address) {
+            await this.sendError(rinfo, ERROR_CODES.UNKNOWN_TID, 'Unknown transfer ID');
+            return;
+        }
+        session.lastActivity = Date.now();
+        switch (opcode) {
+            case OPCODES.ACK:
+                await this.handleAck(session, buffer);
+                break;
+            case OPCODES.DATA:
+                await this.handleData(session, buffer);
+                break;
+            case OPCODES.ERROR:
+                await this.handleError(session, buffer);
+                break;
+        }
+    }
+    async handleAck(session, buffer) {
+        const blockNumber = buffer.readUInt16BE(2);
+        if (session.operation === 'read') {
+            if (blockNumber === session.blockNumber) {
+                // 收到期望的 ACK 后推进到下一块
+                session.blockNumber++;
+                if (session.pendingEof) {
+                    this.closeSession(`${session.tid.address}:${session.tid.port}`);
+                    return;
+                }
+                await this.sendNextDataBlock(session);
+            }
+            else {
+                // 重复ACK，重新发送数据
+                if (session.lastData) {
+                    await this.sendPacket(session, session.lastData);
+                }
+            }
+        }
+    }
+    async handleData(session, buffer) {
+        if (session.operation !== 'write') {
+            await this.sendErrorToSession(session, ERROR_CODES.ILLEGAL_OPERATION, 'Invalid operation');
+            return;
+        }
+        const blockNumber = buffer.readUInt16BE(2);
+        const data = buffer.slice(4);
+        if (blockNumber === session.blockNumber + 1) {
+            // 写入数据
+            if (session.fileHandle) {
+                await session.fileHandle.write(data);
+            }
+            session.blockNumber = blockNumber;
+            // 发送ACK
+            const ack = this.createAckPacket(blockNumber);
+            await this.sendPacket(session, ack);
+            // 如果数据小于块大小，传输完成
+            if (data.length < this.getBlockSize(session)) {
+                this.closeSession(`${session.tid.address}:${session.tid.port}`);
+            }
+        }
+    }
+    async handleError(session, buffer) {
+        const errorCode = buffer.readUInt16BE(2);
+        const message = this.readString(buffer, 4);
+        this.emit('sessionError', {
+            session,
+            errorCode,
+            message,
+        });
+        this.closeSession(`${session.tid.address}:${session.tid.port}`);
+    }
+    async sendNextDataBlock(session) {
+        if (!session.fileHandle) {
+            throw new Error('No file handle');
+        }
+        if (session.blockNumber < 1) {
+            session.blockNumber = 1; // OACK 之后收到 ACK block 0，首个数据块应从 1 开始
+        }
+        const blockSize = this.getBlockSize(session);
+        const buffer = Buffer.allocUnsafe(blockSize);
+        // 修复：TFTP块号从1开始，但文件位置应从0开始，所以需要减1
+        const filePosition = (session.blockNumber - 1) * blockSize;
+        const { bytesRead } = await session.fileHandle.read(buffer, 0, blockSize, filePosition);
+        // 默认认为还未到 EOF
+        session.pendingEof = false;
+        if (bytesRead === 0) {
+            // 文件结束，发送空数据块表示EOF
+            const packet = this.createDataPacket(session.blockNumber, Buffer.alloc(0));
+            session.lastData = packet;
+            session.pendingEof = true;
+            await this.sendPacketWithRetry(session, packet, `send empty DATA block ${session.blockNumber}`);
+            return;
+        }
+        const data = buffer.slice(0, bytesRead);
+        const packet = this.createDataPacket(session.blockNumber, data);
+        session.lastData = packet;
+        await this.sendPacketWithRetry(session, packet, `send DATA block ${session.blockNumber}`);
+        // 如果数据小于块大小，下一次收到 ACK 后结束
+        session.pendingEof = bytesRead < blockSize;
+    }
+    createDataPacket(blockNumber, data) {
+        const packet = Buffer.allocUnsafe(4 + data.length);
+        packet.writeUInt16BE(OPCODES.DATA, 0);
+        packet.writeUInt16BE(blockNumber, 2);
+        data.copy(packet, 4);
+        return packet;
+    }
+    createAckPacket(blockNumber) {
+        const packet = Buffer.allocUnsafe(4);
+        packet.writeUInt16BE(OPCODES.ACK, 0);
+        packet.writeUInt16BE(blockNumber, 2);
+        return packet;
+    }
+    createOackPacket(options) {
+        const optionsList = [];
+        for (const [key, value] of Object.entries(options)) {
+            optionsList.push(key, value);
+        }
+        const optionsData = Buffer.from(optionsList.join('\0') + '\0');
+        const packet = Buffer.allocUnsafe(2 + optionsData.length);
+        packet.writeUInt16BE(OPCODES.OACK, 0);
+        optionsData.copy(packet, 2);
+        return packet;
+    }
+    createErrorPacket(code, message) {
+        const messageData = Buffer.from(message + '\0');
+        const packet = Buffer.allocUnsafe(4 + messageData.length);
+        packet.writeUInt16BE(OPCODES.ERROR, 0);
+        packet.writeUInt16BE(code, 2);
+        messageData.copy(packet, 4);
+        return packet;
+    }
+    async sendPacket(session, packet) {
+        return new Promise((resolve, reject) => {
+            session.socket.send(packet, session.tid.port, session.tid.address, (err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    async sendPacketWithRetry(session, packet, operation = 'send packet') {
+        let retryCount = 0;
+        let backoffMs = SERVER_RETRY_CONFIG.INITIAL_BACKOFF_MS;
+        while (retryCount < SERVER_RETRY_CONFIG.MAX_RETRIES) {
+            try {
+                await this.sendPacket(session, packet);
+                return; // 发送成功
+            }
+            catch (err) {
+                retryCount++;
+                if (retryCount >= SERVER_RETRY_CONFIG.MAX_RETRIES) {
+                    this.emit('error', new Error(`${operation} failed after ${SERVER_RETRY_CONFIG.MAX_RETRIES} retries: ${err.message}`));
+                    throw err;
+                }
+                // 指数退避
+                await new Promise((resolve) => setTimeout(resolve, backoffMs));
+                backoffMs = Math.min(backoffMs * 2, SERVER_RETRY_CONFIG.MAX_BACKOFF_MS);
+            }
+        }
+    }
+    async sendError(rinfo, code, message) {
+        if (!this.socket)
+            return;
+        const packet = this.createErrorPacket(code, message);
+        return new Promise((resolve, reject) => {
+            this.socket.send(packet, rinfo.port, rinfo.address, (err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    async sendErrorToSession(session, code, message) {
+        await this.sendError(session.tid, code, message);
+        this.closeSession(`${session.tid.address}:${session.tid.port}`);
+    }
+    closeSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            try {
+                if (session.fileHandle) {
+                    session.fileHandle.close();
+                }
+                session.socket.close();
+            }
+            catch (error) {
+                // 忽略关闭错误
+            }
+            this.sessions.delete(sessionId);
+            this.stats.activeConnections--;
+            this.emit('sessionClosed', session);
+        }
+    }
+    readString(buffer, offset) {
+        let end = offset;
+        while (end < buffer.length && buffer[end] !== 0) {
+            end++;
+        }
+        return buffer.toString('ascii', offset, end);
+    }
+    getBlockSize(session) {
+        const blksize = parseInt(session.options['blksize'] || (this.config.blockSize || 512).toString());
+        return Math.min(Math.max(blksize, 8), 65464); // RFC 2348限制
+    }
+}