ftpd-lite 0.0.0-stage → 1.0.2

package/src/core/FtpServer.js

@@ -0,0 +1,502 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FtpServer = void 0;
+const fs = __importStar(require("fs"));
+const net = __importStar(require("net"));
+const path = __importStar(require("path"));
+const types_1 = require("../types");
+const userManager_1 = require("../userManager");
+const logger_1 = require("../utils/logger");
+const Commands = __importStar(require("../commands"));
+const DEFAULT_CONFIG = {
+    port: 21,
+    dataPort: 20,
+    userFile: path.join(__dirname, '../users.json'),
+    maxConnections: 100,
+    logLevel: 'info',
+    banner: '',
+    passivePortRange: { min: 50000, max: 50050 },
+};
+class FtpServer {
+    constructor(config = {}) {
+        this.server = null;
+        this.dataServer = null;
+        this.connections = new Map();
+        this.dataConnections = new Map();
+        this.userManager = null;
+        this.connectionCount = 0;
+        this.passiveMode = false;
+        this.passiveIp = '127.0.0.1';
+        this.passiveDataServer = null;
+        this.passiveDataPort = 50000;
+        this.passivePortCursor = 0;
+        this.pendingListData = null;
+        this.pendingListConnId = null;
+        this.pendingRetrFile = null;
+        this.pendingRetrConnId = null;
+        this.pendingStorFile = null;
+        this.pendingStorConnId = null;
+        this.inputBuffers = new Map();
+        this.commandQueues = new Map();
+        this.pendingDataSocket = null;
+        this.passiveConnId = null;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.maxConnections = this.config.maxConnections || DEFAULT_CONFIG.maxConnections;
+        const banner = typeof this.config.banner === 'string' ? this.config.banner.trim() : '';
+        this.config.banner = banner !== '' ? banner : `${this.config.port} FTP Server Ready`;
+        this.config.passivePortRange = this.normalizePortRange(this.config.passivePortRange);
+        let logLevelEnum = logger_1.LogLevel.INFO;
+        if (this.config.logLevel === 'debug') {
+            logLevelEnum = logger_1.LogLevel.DEBUG;
+        }
+        else if (this.config.logLevel === 'warn') {
+            logLevelEnum = logger_1.LogLevel.WARN;
+        }
+        else if (this.config.logLevel === 'error') {
+            logLevelEnum = logger_1.LogLevel.ERROR;
+        }
+        logger_1.Logger.setLevel(logLevelEnum);
+        this.userManager = new userManager_1.UserManager(this.config.userFile);
+        logger_1.Logger.info(`[FtpServer] FTP Sunucusu başlatılıyor...`);
+        logger_1.Logger.info(`[FtpServer] Kontrol portu: ${this.config.port}`);
+        logger_1.Logger.info(`[FtpServer] Veri portu: ${this.config.dataPort}`);
+        logger_1.Logger.info(`[FtpServer] Maksimum bağlantı: ${this.maxConnections}`);
+        logger_1.Logger.info(`[FtpServer] Banner: ${this.config.banner}`);
+        logger_1.Logger.info(`[FtpServer] PASV port aralığı: ${this.config.passivePortRange.min}-${this.config.passivePortRange.max}`);
+    }
+    normalizePortRange(range) {
+        const fallback = { ...DEFAULT_CONFIG.passivePortRange };
+        if (!range) {
+            return fallback;
+        }
+        const min = Math.floor(Number(range.min));
+        const max = Math.floor(Number(range.max));
+        if (!Number.isFinite(min) || !Number.isFinite(max) || min < 1 || max > 65535 || min > max) {
+            logger_1.Logger.warn(`[FtpServer] Geçersiz PASV port aralığı: ${range.min}-${range.max}, varsayılan ${fallback.min}-${fallback.max} kullanılacak`);
+            return fallback;
+        }
+        return { min, max };
+    }
+    nextPassivePort() {
+        const { min, max } = this.config.passivePortRange;
+        const span = max - min + 1;
+        const port = min + (this.passivePortCursor % span);
+        this.passivePortCursor = (this.passivePortCursor + 1) % span;
+        return port;
+    }
+    async ensurePassiveListener(port) {
+        if (this.passiveDataServer && this.passiveDataServer.listening && this.passiveDataPort === port) {
+            return true;
+        }
+        if (this.passiveDataServer) {
+            const oldServer = this.passiveDataServer;
+            this.passiveDataServer = null;
+            oldServer.close();
+        }
+        const server = net.createServer((dataSocket) => {
+            const ownerId = this.passiveConnId || '';
+            logger_1.Logger.info(`[FtpServer] Pasif data bağlantısı kuruldu: port ${port} (${ownerId})`);
+            this.handlePassiveDataConnection(dataSocket, ownerId);
+        });
+        return new Promise((resolve) => {
+            server.once('error', (err) => {
+                logger_1.Logger.error(`[FtpServer] Pasif port ${port} açılamadı: ${err.message}`);
+                resolve(false);
+            });
+            server.listen(port, () => {
+                this.passiveDataServer = server;
+                this.passiveDataPort = port;
+                logger_1.Logger.info(`[FtpServer] Pasif data sunucusu başlatıldı: port ${port}`);
+                resolve(true);
+            });
+        });
+    }
+    start() {
+        try {
+            this.server = net.createServer((socket) => {
+                this.handleConnection(socket);
+            });
+            this.server.listen(this.config.port, () => {
+                logger_1.Logger.info(`[+] FTP sunucusu başlatıldı: http://localhost:${this.config.port}`);
+                logger_1.Logger.info(`[+] Kullanıcı bilgileri: ${this.config.userFile}`);
+                logger_1.Logger.info(`[+] Komutlar: USER, PASS, CWD, PWD, LIST, RETR, STOR, DELE, QUIT, NOOP`);
+            });
+            this.server.on('error', (err) => {
+                logger_1.Logger.error(`[FtpServer] Sunucu hatası: ${err.message}`);
+            });
+            this.server.on('close', () => {
+                logger_1.Logger.info(`[FtpServer] FTP sunucusu kapandı`);
+            });
+            this.dataServer = net.createServer((dataSocket) => {
+                this.handleDataConnection(dataSocket);
+            });
+            this.dataServer.listen(this.config.dataPort, () => {
+                logger_1.Logger.info(`[+] Data sunucusu başlatıldı: port ${this.config.dataPort}`);
+            });
+            this.dataServer.on('error', (err) => {
+                logger_1.Logger.error(`[FtpServer] Data sunucu hatası: ${err.message}`);
+            });
+        }
+        catch (error) {
+            logger_1.Logger.error('[FtpServer] Başlatma hatası:', error);
+        }
+    }
+    handleConnection(socket) {
+        const connId = `conn_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        logger_1.Logger.info(`[FtpServer] Yeni bağlantı: ${connId} (IP: ${socket.remoteAddress})`);
+        if (this.connectionCount >= this.maxConnections) {
+            socket?.write(`503 Service not available\r\n`);
+            socket.end();
+            return;
+        }
+        this.connectionCount++;
+        const connection = {
+            socket,
+            user: null,
+            pass: null,
+            homeDir: '',
+            currentDir: '',
+            permissions: {},
+            transferMode: null,
+            transferSize: 0,
+            lastReply: 0,
+            lastMessage: '',
+        };
+        this.connections.set(connId, connection);
+        socket?.write(`220 ${this.config.banner}\r\n`);
+        socket.on('data', (data) => {
+            this.handleControlData(connId, data);
+        });
+        socket.on('error', (err) => {
+            logger_1.Logger.error(`[FtpServer] Bağlantı hatası (${connId}): ${err.message}`);
+            this.closeConnection(connId, 'error');
+        });
+        socket.on('close', () => {
+            logger_1.Logger.info(`[FtpServer] Bağlantı kapandı: ${connId}`);
+            this.closeConnection(connId);
+        });
+        socket.on('timeout', () => {
+            logger_1.Logger.info(`[FtpServer] Bağlantı zaman aşımı: ${connId}`);
+            this.closeConnection(connId, 'timeout');
+        });
+    }
+    handleControlData(connId, data) {
+        const buffer = (this.inputBuffers.get(connId) || '') + data.toString('utf-8');
+        const lines = buffer.split(/\r\n|\n|\r/);
+        this.inputBuffers.set(connId, lines.pop() ?? '');
+        for (const line of lines) {
+            this.enqueueCommand(connId, line);
+        }
+    }
+    enqueueCommand(connId, line) {
+        const previous = this.commandQueues.get(connId) || Promise.resolve();
+        const next = previous
+            .then(() => this.processCommand(connId, line))
+            .catch((err) => logger_1.Logger.error(`[FtpServer] Komut işlenemedi (${connId}):`, err));
+        this.commandQueues.set(connId, next);
+    }
+    async processCommand(connId, rawLine) {
+        try {
+            const conn = this.connections.get(connId);
+            const socket = conn?.socket;
+            if (!conn) {
+                logger_1.Logger.error(`[FtpServer] Bağlantı bulunamadı: ${connId}`);
+                return;
+            }
+            const line = rawLine.trim();
+            if (line === '') {
+                return;
+            }
+            const separatorIndex = line.search(/\s/);
+            const command = (separatorIndex === -1 ? line : line.slice(0, separatorIndex)).toUpperCase();
+            const args = separatorIndex === -1 ? '' : line.slice(separatorIndex).trim();
+            logger_1.Logger.info(`[FtpServer] Komut: ${command} (conn: ${connId})`);
+            if (command === 'USER') {
+                await Commands.handleUser(connId, conn, args, this.userManager);
+            }
+            else if (command === 'PASS') {
+                await Commands.handlePass(connId, conn, args, this.userManager);
+            }
+            else if (command === 'QUIT') {
+                await Commands.handleQuit(connId, conn, (id, reason) => this.closeConnection(id, reason));
+            }
+            else if (command === 'NOOP') {
+                await Commands.handleNoop(connId, conn);
+            }
+            else if (command === 'PWD') {
+                await Commands.handlePwd(connId, conn);
+            }
+            else if (command === 'CWD') {
+                await Commands.handleCwd(connId, conn, args, this.userManager);
+            }
+            else if (command === 'LIST' || command === 'NLST') {
+                const listResult = await Commands.handleList(connId, conn, this.userManager, socket);
+                const resultObj = listResult;
+                if (resultObj && resultObj.data && typeof resultObj.data === 'object' && resultObj.data !== null) {
+                    const listData = resultObj.data;
+                    this.pendingListData = listData.output;
+                    this.pendingListConnId = connId;
+                    logger_1.Logger.info(`[FtpServer] LIST data bekleniyor: ${listData.output ? listData.output.length : 0} bytes`);
+                    this.ensureDataConnection(connId);
+                }
+            }
+            else if (command === 'RETR') {
+                const retrResult = await Commands.handleRetr(connId, conn, args, this.userManager, socket);
+                const resultObj = retrResult;
+                if (resultObj && resultObj.data && typeof resultObj.data === 'object' && resultObj.data !== null) {
+                    const retrData = resultObj.data;
+                    this.pendingRetrFile = retrData.filePath;
+                    this.pendingRetrConnId = connId;
+                    logger_1.Logger.info(`[FtpServer] RETR dosya bekleniyor: ${retrData.filePath}`);
+                    this.ensureDataConnection(connId);
+                }
+            }
+            else if (command === 'STOR') {
+                const storResult = await Commands.handleStor(connId, conn, args, this.userManager, socket);
+                const resultObj = storResult;
+                if (resultObj && resultObj.data && typeof resultObj.data === 'object' && resultObj.data !== null) {
+                    const storData = resultObj.data;
+                    this.pendingStorFile = storData.filePath;
+                    this.pendingStorConnId = connId;
+                    logger_1.Logger.info(`[FtpServer] STOR dosya bekleniyor: ${storData.filePath}`);
+                    this.ensureDataConnection(connId);
+                }
+            }
+            else if (command === 'DELE') {
+                await Commands.handleDele(connId, conn, args, this.userManager);
+            }
+            else if (command === 'PASV') {
+                this.passiveConnId = connId;
+                this.clearPendingTransfers(connId);
+                const port = this.nextPassivePort();
+                const listening = await this.ensurePassiveListener(port);
+                if (listening) {
+                    await Commands.handlePasv(connId, conn, this.passiveIp, port);
+                }
+                else {
+                    socket?.write(`425 Cannot open data connection\r\n`);
+                }
+            }
+            else if (command === 'PORT') {
+                await Commands.handlePort(conn, args);
+            }
+            else if (command === 'FEAT') {
+                await Commands.handleFeat(connId, conn);
+            }
+            else if (command === 'SYST') {
+                await Commands.handleSyst(connId, conn);
+            }
+            else if (command === 'TYPE') {
+                await Commands.handleType(conn, args);
+            }
+            else if (command === 'MKD') {
+                await Commands.handleMkd(connId, conn, args, this.userManager);
+            }
+            else if (command === 'RMD') {
+                await Commands.handleRmd(connId, conn, args, this.userManager);
+            }
+            else if (command === 'RNFR') {
+                await Commands.handleRnfr(connId, conn, args, this.userManager);
+            }
+            else if (command === 'RNTO') {
+                await Commands.handleRnto(connId, conn, args, this.userManager);
+            }
+            else {
+                socket?.write(`502 Command not implemented: ${command}\r\n`);
+            }
+        }
+        catch (error) {
+            logger_1.Logger.error(`[FtpServer] Veri işleme hatası (${connId}):`, error);
+            const conn = this.connections.get(connId);
+            const socket = conn?.socket;
+            socket?.write(`500 Internal server error\r\n`);
+        }
+    }
+    handleDataConnection(socket) {
+        logger_1.Logger.info(`[FtpServer] Data bağlantısı kuruldu`);
+        socket.on('data', (data) => {
+        });
+        socket.on('error', (err) => {
+            logger_1.Logger.error(`[FtpServer] Data bağlantı hatası: ${err.message}`);
+        });
+        socket.on('close', () => {
+            logger_1.Logger.info(`[FtpServer] Data bağlantısı kapandı`);
+        });
+    }
+    handlePassiveDataConnection(socket, connId) {
+        logger_1.Logger.info(`[FtpServer] Data bağlantısı kabul edildi: ${connId}`);
+        socket.on('error', (err) => {
+            logger_1.Logger.error(`[FtpServer] Data bağlantı hatası: ${err.message}`);
+            if (this.pendingDataSocket === socket) {
+                this.pendingDataSocket = null;
+            }
+            socket.destroy();
+        });
+        socket.on('close', () => {
+            if (this.pendingDataSocket === socket) {
+                this.pendingDataSocket = null;
+            }
+        });
+        if (this.pendingDataSocket && this.pendingDataSocket !== socket && !this.pendingDataSocket.destroyed) {
+            this.pendingDataSocket.destroy();
+        }
+        this.pendingDataSocket = socket;
+        this.tryServeData();
+    }
+    ensureDataConnection(connId) {
+        if (this.pendingDataSocket && !this.pendingDataSocket.destroyed) {
+            this.tryServeData();
+            return;
+        }
+        const conn = this.connections.get(connId);
+        if (!conn || conn.dataMode !== 'active' || !conn.activeDataTarget) {
+            return;
+        }
+        const target = conn.activeDataTarget;
+        const socket = net.createConnection(target.port, target.ip, () => {
+            logger_1.Logger.info(`[FtpServer] Aktif data bağlantısı kuruldu: ${target.ip}:${target.port}`);
+            this.handlePassiveDataConnection(socket, connId);
+        });
+        socket.on('error', (err) => {
+            logger_1.Logger.error(`[FtpServer] Aktif data bağlantı hatası: ${err.message}`);
+            if (this.pendingDataSocket === socket) {
+                this.pendingDataSocket = null;
+            }
+            socket.destroy();
+        });
+    }
+    tryServeData() {
+        const socket = this.pendingDataSocket;
+        if (!socket || socket.destroyed) {
+            return;
+        }
+        if (this.pendingListData !== null && this.pendingListConnId !== null) {
+            const data = this.pendingListData;
+            const connId = this.pendingListConnId;
+            this.pendingListData = null;
+            this.pendingListConnId = null;
+            this.pendingDataSocket = null;
+            logger_1.Logger.info(`[FtpServer] LIST data gönderiliyor: ${data.length} bytes`);
+            socket.once('finish', () => {
+                this.writeControl(connId, types_1.ReplyCode.LIST_END, 'Directory listing complete');
+            });
+            socket.write(data, () => socket.end());
+            return;
+        }
+        if (this.pendingRetrFile !== null && this.pendingRetrConnId !== null) {
+            const file = this.pendingRetrFile;
+            const connId = this.pendingRetrConnId;
+            this.pendingRetrFile = null;
+            this.pendingRetrConnId = null;
+            this.pendingDataSocket = null;
+            logger_1.Logger.info(`[FtpServer] RETR dosya gönderiliyor: ${file}`);
+            const readStream = fs.createReadStream(file);
+            readStream.on('error', (err) => {
+                logger_1.Logger.error(`[FtpServer] RETR okuma hatası: ${err.message}`);
+                this.writeControl(connId, types_1.ReplyCode.FILE_NOT_FOUND, 'Cannot read file');
+                socket.destroy();
+            });
+            socket.once('finish', () => {
+                this.writeControl(connId, types_1.ReplyCode.RETR_OK, 'Retr complete');
+            });
+            readStream.pipe(socket);
+            return;
+        }
+        if (this.pendingStorFile !== null && this.pendingStorConnId !== null) {
+            const file = this.pendingStorFile;
+            const connId = this.pendingStorConnId;
+            this.pendingStorFile = null;
+            this.pendingStorConnId = null;
+            this.pendingDataSocket = null;
+            logger_1.Logger.info(`[FtpServer] STOR dosya alınıyor: ${file}`);
+            const writeStream = fs.createWriteStream(file);
+            writeStream.on('error', (err) => {
+                logger_1.Logger.error(`[FtpServer] STOR yazma hatası: ${err.message}`);
+                this.writeControl(connId, types_1.ReplyCode.INTERNAL_ERR, 'Cannot write file');
+                socket.destroy();
+            });
+            writeStream.on('finish', () => {
+                this.writeControl(connId, types_1.ReplyCode.STOR_OK, 'Stor complete');
+            });
+            socket.pipe(writeStream);
+            return;
+        }
+    }
+    clearPendingTransfers(connId) {
+        if (this.pendingListConnId === connId) {
+            this.pendingListData = null;
+            this.pendingListConnId = null;
+        }
+        if (this.pendingRetrConnId === connId) {
+            this.pendingRetrFile = null;
+            this.pendingRetrConnId = null;
+        }
+        if (this.pendingStorConnId === connId) {
+            this.pendingStorFile = null;
+            this.pendingStorConnId = null;
+        }
+    }
+    writeControl(connId, code, message) {
+        const conn = this.connections.get(connId);
+        if (conn && conn.socket) {
+            conn.lastReply = code;
+            conn.lastMessage = message;
+            conn.socket.write(`${code} ${message}` + '\r\n');
+        }
+    }
+    closeConnection(connId, reason) {
+        this.inputBuffers.delete(connId);
+        this.commandQueues.delete(connId);
+        this.clearPendingTransfers(connId);
+        if (this.passiveConnId === connId) {
+            this.passiveConnId = null;
+        }
+        const conn = this.connections.get(connId);
+        if (conn) {
+            conn.socket?.end();
+            this.connections.delete(connId);
+            this.connectionCount--;
+            if (reason) {
+                logger_1.Logger.info(`[FtpServer] Bağlantı kapatıldı: ${connId} (seçenek: ${reason})`);
+            }
+            else {
+                logger_1.Logger.info(`[FtpServer] Bağlantı kapatıldı: ${connId}`);
+            }
+        }
+    }
+}
+exports.FtpServer = FtpServer;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FtpServer.js","sourceRoot":"","sources":["../../src/core/FtpServer.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as net from 'net';\nimport * as path from 'path';\nimport { ReplyCode, FtpConnection, CommandResult, ServerConfig } from '../types';\nimport { UserManager } from '../userManager';\nimport { normalizeDirPath, ensureDirectoryExists } from '../utils/pathUtils';\nimport { Logger, LogLevel } from '../utils/logger';\nimport * as Commands from '../commands';\n\n/**\n * Default ayarlar\n */\nconst DEFAULT_CONFIG: ServerConfig = {\n  port: 21,\n  dataPort: 20,\n  userFile: path.join(__dirname, '../users.json'),\n  maxConnections: 100,\n  logLevel: 'info',\n  // 220 karşılama mesajı; boş bırakılırsa \"<port> FTP Server Ready\" üretilir\n  banner: '',\n  // PASV veri bağlantı portları bu aralıktan seçilir\n  passivePortRange: { min: 50000, max: 50050 },\n};\n\n/**\n * FTP Sunucusu class\n */\nexport class FtpServer {\n  private server: net.Server | null = null;\n  private dataServer: net.Server | null = null;\n  private connections: Map<string, FtpConnection> = new Map();\n  private dataConnections: Map<string, any> = new Map();\n  private config: typeof DEFAULT_CONFIG;\n  private userManager: UserManager | null = null;\n  private connectionCount: number = 0;\n  private maxConnections: number;\n  private passiveMode: boolean = false;\n  private passiveIp: string = '127.0.0.1';\n  private passiveDataServer: net.Server | null = null;\n  private passiveDataPort: number = 50000;\n  /** PASV port aralığı üzerinde dolaşan imleç */\n  private passivePortCursor: number = 0;\n  private pendingListData: string | null = null;\n  private pendingListConnId: string | null = null;\n  private pendingRetrFile: string | null = null;\n  private pendingRetrConnId: string | null = null;\n  private pendingStorFile: string | null = null;\n  private pendingStorConnId: string | null = null;\n  /** Kontrol bağlantısına gelen yarım (tamamlanmamış) komut satırları */\n  private inputBuffers: Map<string, string> = new Map();\n  /** Bağlantı başına komutların sırayla işlenmesi için kuyruk */\n  private commandQueues: Map<string, Promise<void>> = new Map();\n  /** Henüz kullanılmamış pasif/aktif data bağlantısı */\n  private pendingDataSocket: net.Socket | null = null;\n  /** Son PASV komutunu veren bağlantı (data bağlantısı sahibi) */\n  private passiveConnId: string | null = null;\n\n  constructor(config: Partial<typeof DEFAULT_CONFIG> = {}) {\n    this.config = { ...DEFAULT_CONFIG, ...config } as ServerConfig;\n    this.maxConnections = this.config.maxConnections || DEFAULT_CONFIG.maxConnections;\n\n    // Banner: boş bırakılırsa \"<port> FTP Server Ready\"\n    const banner = typeof this.config.banner === 'string' ? this.config.banner.trim() : '';\n    this.config.banner = banner !== '' ? banner : `${this.config.port} FTP Server Ready`;\n\n    // PASV port aralığını doğrula\n    this.config.passivePortRange = this.normalizePortRange(this.config.passivePortRange);\n    // Logger seviyesini ayarla\n    let logLevelEnum: LogLevel = LogLevel.INFO;\n    if (this.config.logLevel === 'debug') {\n      logLevelEnum = LogLevel.DEBUG;\n    } else if (this.config.logLevel === 'warn') {\n      logLevelEnum = LogLevel.WARN;\n    } else if (this.config.logLevel === 'error') {\n      logLevelEnum = LogLevel.ERROR;\n    }\n    Logger.setLevel(logLevelEnum);\n    // UserManager'ı başlat\n    this.userManager = new UserManager(this.config.userFile);\n    Logger.info(`[FtpServer] FTP Sunucusu başlatılıyor...`);\n    Logger.info(`[FtpServer] Kontrol portu: ${this.config.port}`);\n    Logger.info(`[FtpServer] Veri portu: ${this.config.dataPort}`);\n    Logger.info(`[FtpServer] Maksimum bağlantı: ${this.maxConnections}`);\n    Logger.info(`[FtpServer] Banner: ${this.config.banner}`);\n    Logger.info(\n      `[FtpServer] PASV port aralığı: ${this.config.passivePortRange.min}-${this.config.passivePortRange.max}`\n    );\n  }\n\n  /**\n   * PASV port aralığını doğrula; geçersizse varsayılan aralığa dön\n   */\n  private normalizePortRange(range: { min?: number; max?: number } | undefined): { min: number; max: number } {\n    const fallback = { ...DEFAULT_CONFIG.passivePortRange };\n    if (!range) {\n      return fallback;\n    }\n    const min = Math.floor(Number(range.min));\n    const max = Math.floor(Number(range.max));\n    if (!Number.isFinite(min) || !Number.isFinite(max) || min < 1 || max > 65535 || min > max) {\n      Logger.warn(\n        `[FtpServer] Geçersiz PASV port aralığı: ${range.min}-${range.max}, varsayılan ${fallback.min}-${fallback.max} kullanılacak`\n      );\n      return fallback;\n    }\n    return { min, max };\n  }\n\n  /**\n   * Yapılandırılan PASV port aralığından sırayla (yuvarlak usul) bir port seç\n   */\n  private nextPassivePort(): number {\n    const { min, max } = this.config.passivePortRange;\n    const span = max - min + 1;\n    const port = min + (this.passivePortCursor % span);\n    this.passivePortCursor = (this.passivePortCursor + 1) % span;\n    return port;\n  }\n\n  /**\n   * PASV portunu dinlemeye al (dinleyici zaten o porttaysa yeniden kurulmaz).\n   * 227 yanıtı ancak port gerçekten dinledikten sonra gönderilir.\n   */\n  private async ensurePassiveListener(port: number): Promise<boolean> {\n    if (this.passiveDataServer && this.passiveDataServer.listening && this.passiveDataPort === port) {\n      return true;\n    }\n\n    // Eski dinleyiciyi kapat (kabul edilmiş veri bağlantıları etkilenmez)\n    if (this.passiveDataServer) {\n      const oldServer = this.passiveDataServer;\n      this.passiveDataServer = null;\n      oldServer.close();\n    }\n\n    const server = net.createServer((dataSocket) => {\n      const ownerId = this.passiveConnId || '';\n      Logger.info(`[FtpServer] Pasif data bağlantısı kuruldu: port ${port} (${ownerId})`);\n      this.handlePassiveDataConnection(dataSocket, ownerId);\n    });\n\n    return new Promise<boolean>((resolve) => {\n      server.once('error', (err) => {\n        Logger.error(`[FtpServer] Pasif port ${port} açılamadı: ${err.message}`);\n        resolve(false);\n      });\n      server.listen(port, () => {\n        this.passiveDataServer = server;\n        this.passiveDataPort = port;\n        Logger.info(`[FtpServer] Pasif data sunucusu başlatıldı: port ${port}`);\n        resolve(true);\n      });\n    });\n  }\n\n  /**\n   * FTP sunucusunu başlat\n   */\n  public start(): void {\n    try {\n      this.server = net.createServer((socket) => {\n        this.handleConnection(socket);\n      });\n\n      this.server.listen(this.config.port, () => {\n        Logger.info(`[+] FTP sunucusu başlatıldı: http://localhost:${this.config.port}`);\n        Logger.info(`[+] Kullanıcı bilgileri: ${this.config.userFile}`);\n        Logger.info(`[+] Komutlar: USER, PASS, CWD, PWD, LIST, RETR, STOR, DELE, QUIT, NOOP`);\n      });\n\n      this.server.on('error', (err) => {\n        Logger.error(`[FtpServer] Sunucu hatası: ${err.message}`);\n      });\n\n      this.server.on('close', () => {\n        Logger.info(`[FtpServer] FTP sunucusu kapandı`);\n      });\n\n      // Data server başlat\n      this.dataServer = net.createServer((dataSocket) => {\n        this.handleDataConnection(dataSocket);\n      });\n\n      this.dataServer.listen(this.config.dataPort, () => {\n        Logger.info(`[+] Data sunucusu başlatıldı: port ${this.config.dataPort}`);\n      });\n\n      this.dataServer.on('error', (err) => {\n        Logger.error(`[FtpServer] Data sunucu hatası: ${err.message}`);\n      });\n    } catch (error) {\n      Logger.error('[FtpServer] Başlatma hatası:', error);\n    }\n  }\n\n  /**\n   * Yeni bağlantıyı işle\n   */\n  private handleConnection(socket: net.Socket): void {\n    const connId = `conn_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;\n    Logger.info(`[FtpServer] Yeni bağlantı: ${connId} (IP: ${socket.remoteAddress})`);\n\n    // Maksimum bağlantı kontrolü\n    if (this.connectionCount >= this.maxConnections) {\n      socket?.write(`503 Service not available\\r\\n`);\n      socket.end();\n      return;\n    }\n\n    this.connectionCount++;\n\n    const connection: FtpConnection = {\n      socket,\n      user: null,\n      pass: null,\n      homeDir: '',\n      currentDir: '',\n      permissions: {},\n      transferMode: null,\n      transferSize: 0,\n      lastReply: 0,\n      lastMessage: '',\n    };\n\n    this.connections.set(connId, connection);\n\n    // Bağlantı başlatma mesajı\n    socket?.write(`220 ${this.config.banner}\\r\\n`);\n\n    // Bağlantı olayları\n    socket.on('data', (data: Buffer) => {\n      this.handleControlData(connId, data);\n    });\n\n    socket.on('error', (err) => {\n      Logger.error(`[FtpServer] Bağlantı hatası (${connId}): ${err.message}`);\n      this.closeConnection(connId, 'error');\n    });\n\n    socket.on('close', () => {\n      Logger.info(`[FtpServer] Bağlantı kapandı: ${connId}`);\n      this.closeConnection(connId);\n    });\n\n    socket.on('timeout', () => {\n      Logger.info(`[FtpServer] Bağlantı zaman aşımı: ${connId}`);\n      this.closeConnection(connId, 'timeout');\n    });\n  }\n\n  /**\n   * Kontrol bağlantısına gelen veriyi satır satır ayrıştır.\n   * Tek pakette birden çok komut gelebilir, yarım kalan satır sonraki pakette tamamlanır.\n   */\n  private handleControlData(connId: string, data: Buffer): void {\n    const buffer = (this.inputBuffers.get(connId) || '') + data.toString('utf-8');\n    const lines = buffer.split(/\\r\\n|\\n|\\r/);\n    // Son parça yarım satır olabilir: bir sonraki pakete kadar sakla\n    this.inputBuffers.set(connId, lines.pop() ?? '');\n\n    for (const line of lines) {\n      this.enqueueCommand(connId, line);\n    }\n  }\n\n  /**\n   * Komutları bağlantı başına sırayla işle (async komutlar sırayı bozmasın)\n   */\n  private enqueueCommand(connId: string, line: string): void {\n    const previous = this.commandQueues.get(connId) || Promise.resolve();\n    const next = previous\n      .then(() => this.processCommand(connId, line))\n      .catch((err) => Logger.error(`[FtpServer] Komut işlenemedi (${connId}):`, err));\n    this.commandQueues.set(connId, next);\n  }\n\n  /**\n   * Tek bir komut satırını işle\n   */\n  private async processCommand(connId: string, rawLine: string): Promise<void> {\n    try {\n      const conn = this.connections.get(connId);\n      const socket = conn?.socket;\n      if (!conn) {\n        Logger.error(`[FtpServer] Bağlantı bulunamadı: ${connId}`);\n        return;\n      }\n\n      const line = rawLine.trim();\n      if (line === '') {\n        return;\n      }\n\n      // Komutu ilk boşluktan böl: dosya/ dizin adlarındaki boşluklar korunur\n      const separatorIndex = line.search(/\\s/);\n      const command = (separatorIndex === -1 ? line : line.slice(0, separatorIndex)).toUpperCase();\n      const args = separatorIndex === -1 ? '' : line.slice(separatorIndex).trim();\n      Logger.info(`[FtpServer] Komut: ${command} (conn: ${connId})`);\n\n      if (command === 'USER') {\n        await Commands.handleUser(connId, conn, args, this.userManager!);\n      } else if (command === 'PASS') {\n        await Commands.handlePass(connId, conn, args, this.userManager!);\n      } else if (command === 'QUIT') {\n        await Commands.handleQuit(connId, conn, (id, reason) => this.closeConnection(id, reason));\n      } else if (command === 'NOOP') {\n        await Commands.handleNoop(connId, conn);\n      } else if (command === 'PWD') {\n        await Commands.handlePwd(connId, conn);\n      } else if (command === 'CWD') {\n        await Commands.handleCwd(connId, conn, args, this.userManager!);\n      } else if (command === 'LIST' || command === 'NLST') {\n        const listResult = await Commands.handleList(connId, conn, this.userManager!, socket);\n        const resultObj = listResult as any;\n        if (resultObj && resultObj.data && typeof resultObj.data === 'object' && resultObj.data !== null) {\n          const listData = resultObj.data as { output: string, directory: string };\n          this.pendingListData = listData.output;\n          this.pendingListConnId = connId;\n          Logger.info(`[FtpServer] LIST data bekleniyor: ${listData.output ? listData.output.length : 0} bytes`);\n          this.ensureDataConnection(connId);\n        }\n      } else if (command === 'RETR') {\n        const retrResult = await Commands.handleRetr(connId, conn, args, this.userManager!, socket);\n        const resultObj = retrResult as any;\n        if (resultObj && resultObj.data && typeof resultObj.data === 'object' && resultObj.data !== null) {\n          const retrData = resultObj.data as { filePath: string };\n          this.pendingRetrFile = retrData.filePath;\n          this.pendingRetrConnId = connId;\n          Logger.info(`[FtpServer] RETR dosya bekleniyor: ${retrData.filePath}`);\n          this.ensureDataConnection(connId);\n        }\n      } else if (command === 'STOR') {\n        const storResult = await Commands.handleStor(connId, conn, args, this.userManager!, socket);\n        const resultObj = storResult as any;\n        if (resultObj && resultObj.data && typeof resultObj.data === 'object' && resultObj.data !== null) {\n          const storData = resultObj.data as { filePath: string };\n          this.pendingStorFile = storData.filePath;\n          this.pendingStorConnId = connId;\n          Logger.info(`[FtpServer] STOR dosya bekleniyor: ${storData.filePath}`);\n          this.ensureDataConnection(connId);\n        }\n      } else if (command === 'DELE') {\n        await Commands.handleDele(connId, conn, args, this.userManager!);\n      } else if (command === 'PASV') {\n        // Pasif mod: data bağlantısının sahibi bu komutu veren bağlantıdır\n        this.passiveConnId = connId;\n        this.clearPendingTransfers(connId);\n\n        // Yapılandırılan aralıktan port seç ve dinlemeye al\n        const port = this.nextPassivePort();\n        const listening = await this.ensurePassiveListener(port);\n        if (listening) {\n          await Commands.handlePasv(connId, conn, this.passiveIp, port);\n        } else {\n          socket?.write(`425 Cannot open data connection\\r\\n`);\n        }\n      } else if (command === 'PORT') {\n        await Commands.handlePort(conn, args);\n      } else if (command === 'FEAT') {\n        await Commands.handleFeat(connId, conn);\n      } else if (command === 'SYST') {\n        await Commands.handleSyst(connId, conn);\n      } else if (command === 'TYPE') {\n        await Commands.handleType(conn, args);\n      } else if (command === 'MKD') {\n        await Commands.handleMkd(connId, conn, args, this.userManager!);\n      } else if (command === 'RMD') {\n        await Commands.handleRmd(connId, conn, args, this.userManager!);\n      } else if (command === 'RNFR') {\n        await Commands.handleRnfr(connId, conn, args, this.userManager!);\n      } else if (command === 'RNTO') {\n        await Commands.handleRnto(connId, conn, args, this.userManager!);\n      } else {\n        // Bilinmeyen komut\n        socket?.write(`502 Command not implemented: ${command}\\r\\n`);\n      }\n    } catch (error) {\n      Logger.error(`[FtpServer] Veri işleme hatası (${connId}):`, error);\n      const conn = this.connections.get(connId);\n      const socket = conn?.socket;\n      socket?.write(`500 Internal server error\\r\\n`);\n    }\n  }\n\n  /**\n   * Veri bağlantısını işle\n   */\n  private handleDataConnection(socket: net.Socket): void {\n    Logger.info(`[FtpServer] Data bağlantısı kuruldu`);\n    // Data connection için işlemler\n    socket.on('data', (data: Buffer) => {\n      // Data transfer işlemleri\n    });\n\n    socket.on('error', (err) => {\n      Logger.error(`[FtpServer] Data bağlantı hatası: ${err.message}`);\n    });\n\n    socket.on('close', () => {\n      Logger.info(`[FtpServer] Data bağlantısı kapandı`);\n    });\n  }\n\n  /**\n   * Data bağlantısını (PASV/PORT) kabul et ve bekleyen aktarımı bağla.\n   * Veri aktarımı komut (LIST/RETR/STOR) geldiğinde başlar; istemci veri\n   * bağlantısını komuttan önce açtığında bağlantı bekletilir.\n   */\n  private handlePassiveDataConnection(socket: net.Socket, connId: string): void {\n    Logger.info(`[FtpServer] Data bağlantısı kabul edildi: ${connId}`);\n\n    socket.on('error', (err) => {\n      Logger.error(`[FtpServer] Data bağlantı hatası: ${err.message}`);\n      if (this.pendingDataSocket === socket) {\n        this.pendingDataSocket = null;\n      }\n      socket.destroy();\n    });\n\n    socket.on('close', () => {\n      if (this.pendingDataSocket === socket) {\n        this.pendingDataSocket = null;\n      }\n    });\n\n    // Aynı anda yalnızca bir data bağlantısı kullanılır\n    if (this.pendingDataSocket && this.pendingDataSocket !== socket && !this.pendingDataSocket.destroyed) {\n      this.pendingDataSocket.destroy();\n    }\n    this.pendingDataSocket = socket;\n    this.tryServeData();\n  }\n\n  /**\n   * LIST/RETR/STOR için veri bağlantısını hazırla:\n   * pasif modda istemcinin bağlanması beklenir, aktif modda (PORT) sunucu bağlanır.\n   */\n  private ensureDataConnection(connId: string): void {\n    if (this.pendingDataSocket && !this.pendingDataSocket.destroyed) {\n      this.tryServeData();\n      return;\n    }\n\n    const conn = this.connections.get(connId);\n    if (!conn || conn.dataMode !== 'active' || !conn.activeDataTarget) {\n      // Pasif mod: istemcinin bağlanması beklenir (bağlantı gelince tryServeData çağrılır)\n      return;\n    }\n\n    const target = conn.activeDataTarget;\n    const socket = net.createConnection(target.port, target.ip, () => {\n      Logger.info(`[FtpServer] Aktif data bağlantısı kuruldu: ${target.ip}:${target.port}`);\n      this.handlePassiveDataConnection(socket, connId);\n    });\n    socket.on('error', (err) => {\n      Logger.error(`[FtpServer] Aktif data bağlantı hatası: ${err.message}`);\n      if (this.pendingDataSocket === socket) {\n        this.pendingDataSocket = null;\n      }\n      socket.destroy();\n    });\n  }\n\n  /**\n   * Bekleyen LIST/RETR/STOR aktarımını, veri bağlantısı hazırsa başlat.\n   * 226 yanıtını veri gerçekten gönderildikten / alındıktan sonra gönder.\n   */\n  private tryServeData(): void {\n    const socket = this.pendingDataSocket;\n    if (!socket || socket.destroyed) {\n      return;\n    }\n\n    // LIST / NLST\n    if (this.pendingListData !== null && this.pendingListConnId !== null) {\n      const data = this.pendingListData;\n      const connId = this.pendingListConnId;\n      this.pendingListData = null;\n      this.pendingListConnId = null;\n      this.pendingDataSocket = null;\n\n      Logger.info(`[FtpServer] LIST data gönderiliyor: ${data.length} bytes`);\n      socket.once('finish', () => {\n        this.writeControl(connId, ReplyCode.LIST_END, 'Directory listing complete');\n      });\n      socket.write(data, () => socket.end());\n      return;\n    }\n\n    // RETR\n    if (this.pendingRetrFile !== null && this.pendingRetrConnId !== null) {\n      const file = this.pendingRetrFile;\n      const connId = this.pendingRetrConnId;\n      this.pendingRetrFile = null;\n      this.pendingRetrConnId = null;\n      this.pendingDataSocket = null;\n\n      Logger.info(`[FtpServer] RETR dosya gönderiliyor: ${file}`);\n      const readStream = fs.createReadStream(file);\n      readStream.on('error', (err) => {\n        Logger.error(`[FtpServer] RETR okuma hatası: ${err.message}`);\n        this.writeControl(connId, ReplyCode.FILE_NOT_FOUND, 'Cannot read file');\n        socket.destroy();\n      });\n      socket.once('finish', () => {\n        this.writeControl(connId, ReplyCode.RETR_OK, 'Retr complete');\n      });\n      readStream.pipe(socket);\n      return;\n    }\n\n    // STOR\n    if (this.pendingStorFile !== null && this.pendingStorConnId !== null) {\n      const file = this.pendingStorFile;\n      const connId = this.pendingStorConnId;\n      this.pendingStorFile = null;\n      this.pendingStorConnId = null;\n      this.pendingDataSocket = null;\n\n      Logger.info(`[FtpServer] STOR dosya alınıyor: ${file}`);\n      const writeStream = fs.createWriteStream(file);\n      writeStream.on('error', (err) => {\n        Logger.error(`[FtpServer] STOR yazma hatası: ${err.message}`);\n        this.writeControl(connId, ReplyCode.INTERNAL_ERR, 'Cannot write file');\n        socket.destroy();\n      });\n      writeStream.on('finish', () => {\n        this.writeControl(connId, ReplyCode.STOR_OK, 'Stor complete');\n      });\n      socket.pipe(writeStream);\n      return;\n    }\n\n    // Henüz bekleyen aktarım yok: bağlantı bir sonraki komut için açık tutulur\n  }\n\n  /**\n   * Bağlantının bekleyen aktarımını temizle (yeni PASV gelince eskisi geçersiz olur)\n   */\n  private clearPendingTransfers(connId: string): void {\n    if (this.pendingListConnId === connId) {\n      this.pendingListData = null;\n      this.pendingListConnId = null;\n    }\n    if (this.pendingRetrConnId === connId) {\n      this.pendingRetrFile = null;\n      this.pendingRetrConnId = null;\n    }\n    if (this.pendingStorConnId === connId) {\n      this.pendingStorFile = null;\n      this.pendingStorConnId = null;\n    }\n  }\n\n  /**\n   * Kontrol bağlantısına yanıt gönder\n   */\n  private writeControl(connId: string, code: number, message: string): void {\n    const conn = this.connections.get(connId);\n    if (conn && conn.socket) {\n      conn.lastReply = code;\n      conn.lastMessage = message;\n      conn.socket.write(`${code} ${message}` + '\\r\\n');\n    }\n  }\n  /**\n   * Bağlantıyı kapat\n   */\n  public closeConnection(connId: string, reason?: string): void {\n    // Bağlantıya ait tampon, kuyruk ve bekleyen aktarım kayıtlarını temizle\n    this.inputBuffers.delete(connId);\n    this.commandQueues.delete(connId);\n    this.clearPendingTransfers(connId);\n    if (this.passiveConnId === connId) {\n      this.passiveConnId = null;\n    }\n\n    const conn = this.connections.get(connId);\n    if (conn) {\n      conn.socket?.end();\n      this.connections.delete(connId);\n      this.connectionCount--;\n      if (reason) {\n        Logger.info(`[FtpServer] Bağlantı kapatıldı: ${connId} (seçenek: ${reason})`);\n      } else {\n        Logger.info(`[FtpServer] Bağlantı kapatıldı: ${connId}`);\n      }\n    }\n  }\n}\n"]}

package/src/core/index.d.ts

@@ -0,0 +1,2 @@
+export * from './FtpServer';
+export * from './DataServer';

package/src/core/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./FtpServer"), exports);
+__exportStar(require("./DataServer"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29yZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsOENBQTRCO0FBQzVCLCtDQUE2QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vRnRwU2VydmVyJztcbmV4cG9ydCAqIGZyb20gJy4vRGF0YVNlcnZlcic7XG4iXX0=

package/src/fileTransfer.d.ts

@@ -0,0 +1,15 @@
+import { FtpConnection } from './types';
+export declare class FileTransfer {
+    private userManager;
+    constructor();
+    private getUserManager;
+    private checkPermission;
+    uploadFile(conn: FtpConnection, remotePath: string, data: Buffer): Promise<void>;
+    downloadFile(conn: FtpConnection, remotePath: string): Promise<void>;
+    deleteFile(conn: FtpConnection, remotePath: string): Promise<void>;
+    createDirectory(conn: FtpConnection, remotePath: string): Promise<void>;
+    removeDirectory(conn: FtpConnection, remotePath: string): Promise<void>;
+    renameFile(conn: FtpConnection, oldPath: string, newPath: string): Promise<void>;
+    changeFileMode(conn: FtpConnection, remotePath: string, mode: number): Promise<void>;
+}
+export declare const fileTransfer: FileTransfer;