@serve.zone/dcrouter 13.17.0 → 13.17.3

package/dist_ts/radius/classes.accounting.manager.js

@@ -0,0 +1,449 @@
+import * as plugins from '../plugins.js';
+import { logger } from '../logger.js';
+import { AccountingSessionDoc } from '../db/index.js';
+/**
+ * Manages RADIUS accounting data including:
+ * - Session tracking (start/stop/interim)
+ * - Data usage tracking (bytes in/out)
+ * - Session history and retention
+ * - Billing reports and summaries
+ */
+export class AccountingManager {
+    activeSessions = new Map();
+    config;
+    staleSessionSweepTimer;
+    // Counters for statistics
+    stats = {
+        totalSessionsStarted: 0,
+        totalSessionsStopped: 0,
+        totalInputBytes: 0,
+        totalOutputBytes: 0,
+        interimUpdatesReceived: 0,
+    };
+    constructor(config) {
+        this.config = {
+            retentionDays: config?.retentionDays ?? 30,
+            detailedLogging: config?.detailedLogging ?? false,
+            maxActiveSessions: config?.maxActiveSessions ?? 10000,
+            staleSessionTimeoutHours: config?.staleSessionTimeoutHours ?? 24,
+        };
+    }
+    /**
+     * Initialize the accounting manager
+     */
+    async initialize() {
+        await this.loadActiveSessions();
+        // Start periodic sweep to evict stale sessions (every 15 minutes)
+        this.staleSessionSweepTimer = setInterval(() => {
+            this.sweepStaleSessions();
+        }, 15 * 60 * 1000);
+        // Allow the process to exit even if the timer is pending
+        if (this.staleSessionSweepTimer.unref) {
+            this.staleSessionSweepTimer.unref();
+        }
+        logger.log('info', `AccountingManager initialized with ${this.activeSessions.size} active sessions`);
+    }
+    /**
+     * Stop the accounting manager and clean up timers
+     */
+    stop() {
+        if (this.staleSessionSweepTimer) {
+            clearInterval(this.staleSessionSweepTimer);
+            this.staleSessionSweepTimer = undefined;
+        }
+    }
+    /**
+     * Sweep stale active sessions that have not received any update
+     * within the configured timeout. These are orphaned sessions where
+     * the Stop packet was never received.
+     */
+    sweepStaleSessions() {
+        const timeoutMs = this.config.staleSessionTimeoutHours * 60 * 60 * 1000;
+        const cutoff = Date.now() - timeoutMs;
+        let swept = 0;
+        for (const [sessionId, session] of this.activeSessions) {
+            if (session.lastUpdateTime < cutoff) {
+                session.status = 'terminated';
+                session.terminateCause = 'StaleSessionTimeout';
+                session.endTime = Date.now();
+                session.sessionTime = Math.floor((session.endTime - session.startTime) / 1000);
+                this.persistSession(session).catch(() => { });
+                this.activeSessions.delete(sessionId);
+                swept++;
+            }
+        }
+        if (swept > 0) {
+            logger.log('info', `Swept ${swept} stale RADIUS sessions (no update for ${this.config.staleSessionTimeoutHours}h)`);
+        }
+    }
+    /**
+     * Handle accounting start request
+     */
+    async handleAccountingStart(data) {
+        const now = Date.now();
+        const session = {
+            sessionId: data.sessionId,
+            username: data.username,
+            macAddress: data.macAddress,
+            nasIpAddress: data.nasIpAddress,
+            nasPort: data.nasPort,
+            nasPortType: data.nasPortType,
+            nasIdentifier: data.nasIdentifier,
+            vlanId: data.vlanId,
+            framedIpAddress: data.framedIpAddress,
+            calledStationId: data.calledStationId,
+            callingStationId: data.callingStationId,
+            serviceType: data.serviceType,
+            startTime: now,
+            endTime: 0,
+            lastUpdateTime: now,
+            status: 'active',
+            inputOctets: 0,
+            outputOctets: 0,
+            inputPackets: 0,
+            outputPackets: 0,
+            sessionTime: 0,
+        };
+        // Check if we're at capacity
+        if (this.activeSessions.size >= this.config.maxActiveSessions) {
+            // Remove oldest session
+            const oldest = this.findOldestSession();
+            if (oldest) {
+                await this.evictSession(oldest);
+            }
+        }
+        this.activeSessions.set(data.sessionId, session);
+        this.stats.totalSessionsStarted++;
+        if (this.config.detailedLogging) {
+            logger.log('info', `Accounting Start: session=${data.sessionId}, user=${data.username}, NAS=${data.nasIpAddress}`);
+        }
+        // Persist session
+        await this.persistSession(session);
+    }
+    /**
+     * Handle accounting interim update request
+     */
+    async handleAccountingUpdate(data) {
+        const session = this.activeSessions.get(data.sessionId);
+        if (!session) {
+            logger.log('warn', `Interim update for unknown session: ${data.sessionId}`);
+            return;
+        }
+        // Update session metrics
+        if (data.inputOctets !== undefined) {
+            session.inputOctets = data.inputOctets;
+        }
+        if (data.outputOctets !== undefined) {
+            session.outputOctets = data.outputOctets;
+        }
+        if (data.inputPackets !== undefined) {
+            session.inputPackets = data.inputPackets;
+        }
+        if (data.outputPackets !== undefined) {
+            session.outputPackets = data.outputPackets;
+        }
+        if (data.sessionTime !== undefined) {
+            session.sessionTime = data.sessionTime;
+        }
+        session.lastUpdateTime = Date.now();
+        this.stats.interimUpdatesReceived++;
+        if (this.config.detailedLogging) {
+            logger.log('debug', `Accounting Interim: session=${data.sessionId}, in=${data.inputOctets}, out=${data.outputOctets}`);
+        }
+        // Update persisted session
+        await this.persistSession(session);
+    }
+    /**
+     * Handle accounting stop request
+     */
+    async handleAccountingStop(data) {
+        const session = this.activeSessions.get(data.sessionId);
+        if (!session) {
+            logger.log('warn', `Stop for unknown session: ${data.sessionId}`);
+            return;
+        }
+        // Update final metrics
+        if (data.inputOctets !== undefined) {
+            session.inputOctets = data.inputOctets;
+        }
+        if (data.outputOctets !== undefined) {
+            session.outputOctets = data.outputOctets;
+        }
+        if (data.inputPackets !== undefined) {
+            session.inputPackets = data.inputPackets;
+        }
+        if (data.outputPackets !== undefined) {
+            session.outputPackets = data.outputPackets;
+        }
+        if (data.sessionTime !== undefined) {
+            session.sessionTime = data.sessionTime;
+        }
+        session.endTime = Date.now();
+        session.lastUpdateTime = session.endTime;
+        session.status = 'stopped';
+        session.terminateCause = data.terminateCause;
+        // Update global stats
+        this.stats.totalSessionsStopped++;
+        this.stats.totalInputBytes += session.inputOctets;
+        this.stats.totalOutputBytes += session.outputOctets;
+        if (this.config.detailedLogging) {
+            logger.log('info', `Accounting Stop: session=${data.sessionId}, duration=${session.sessionTime}s, in=${session.inputOctets}, out=${session.outputOctets}`);
+        }
+        // Update status in the database (single collection, no active->archive move needed)
+        await this.persistSession(session);
+        // Remove from active sessions
+        this.activeSessions.delete(data.sessionId);
+    }
+    /**
+     * Get an active session by ID
+     */
+    getSession(sessionId) {
+        return this.activeSessions.get(sessionId);
+    }
+    /**
+     * Get all active sessions
+     */
+    getActiveSessions() {
+        return Array.from(this.activeSessions.values());
+    }
+    /**
+     * Get active sessions by username
+     */
+    getSessionsByUsername(username) {
+        return Array.from(this.activeSessions.values()).filter(s => s.username === username);
+    }
+    /**
+     * Get active sessions by NAS IP
+     */
+    getSessionsByNas(nasIpAddress) {
+        return Array.from(this.activeSessions.values()).filter(s => s.nasIpAddress === nasIpAddress);
+    }
+    /**
+     * Get active sessions by VLAN
+     */
+    getSessionsByVlan(vlanId) {
+        return Array.from(this.activeSessions.values()).filter(s => s.vlanId === vlanId);
+    }
+    /**
+     * Get accounting summary for a time period
+     */
+    async getSummary(startTime, endTime) {
+        // Get archived sessions for the time period
+        const archivedSessions = await this.getArchivedSessions(startTime, endTime);
+        // Combine with active sessions that started within the period
+        const activeSessions = Array.from(this.activeSessions.values()).filter(s => s.startTime >= startTime && s.startTime <= endTime);
+        const allSessions = [...archivedSessions, ...activeSessions];
+        // Calculate summary
+        let totalInputBytes = 0;
+        let totalOutputBytes = 0;
+        let totalSessionTime = 0;
+        const uniqueUsers = new Set();
+        const sessionsByVlan = {};
+        const userTraffic = {};
+        for (const session of allSessions) {
+            totalInputBytes += session.inputOctets;
+            totalOutputBytes += session.outputOctets;
+            totalSessionTime += session.sessionTime;
+            uniqueUsers.add(session.username);
+            if (session.vlanId !== undefined) {
+                sessionsByVlan[session.vlanId] = (sessionsByVlan[session.vlanId] || 0) + 1;
+            }
+            const userBytes = session.inputOctets + session.outputOctets;
+            userTraffic[session.username] = (userTraffic[session.username] || 0) + userBytes;
+        }
+        // Top users by traffic
+        const topUsersByTraffic = Object.entries(userTraffic)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 10)
+            .map(([username, totalBytes]) => ({ username, totalBytes }));
+        return {
+            periodStart: startTime,
+            periodEnd: endTime,
+            totalSessions: allSessions.length,
+            activeSessions: activeSessions.length,
+            totalInputBytes,
+            totalOutputBytes,
+            totalSessionTime,
+            averageSessionDuration: allSessions.length > 0 ? totalSessionTime / allSessions.length : 0,
+            uniqueUsers: uniqueUsers.size,
+            sessionsByVlan,
+            topUsersByTraffic,
+        };
+    }
+    /**
+     * Get statistics
+     */
+    getStats() {
+        return {
+            activeSessions: this.activeSessions.size,
+            ...this.stats,
+        };
+    }
+    /**
+     * Disconnect a session (admin action)
+     */
+    async disconnectSession(sessionId, reason = 'AdminReset') {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+            return false;
+        }
+        await this.handleAccountingStop({
+            sessionId,
+            terminateCause: reason,
+            sessionTime: Math.floor((Date.now() - session.startTime) / 1000),
+        });
+        return true;
+    }
+    /**
+     * Clean up old archived sessions based on retention policy
+     */
+    async cleanupOldSessions() {
+        const cutoffTime = Date.now() - this.config.retentionDays * 24 * 60 * 60 * 1000;
+        let deletedCount = 0;
+        try {
+            const oldDocs = await AccountingSessionDoc.findStoppedBefore(cutoffTime);
+            for (const doc of oldDocs) {
+                try {
+                    await doc.delete();
+                    deletedCount++;
+                }
+                catch (error) {
+                    // Ignore individual errors
+                }
+            }
+            if (deletedCount > 0) {
+                logger.log('info', `Cleaned up ${deletedCount} old accounting sessions`);
+            }
+        }
+        catch (error) {
+            logger.log('error', `Failed to cleanup old sessions: ${error.message}`);
+        }
+        return deletedCount;
+    }
+    /**
+     * Find the oldest active session
+     */
+    findOldestSession() {
+        let oldestTime = Infinity;
+        let oldestSessionId = null;
+        for (const [sessionId, session] of this.activeSessions) {
+            if (session.lastUpdateTime < oldestTime) {
+                oldestTime = session.lastUpdateTime;
+                oldestSessionId = sessionId;
+            }
+        }
+        return oldestSessionId;
+    }
+    /**
+     * Evict a session from memory
+     */
+    async evictSession(sessionId) {
+        const session = this.activeSessions.get(sessionId);
+        if (session) {
+            session.status = 'terminated';
+            session.terminateCause = 'SessionEvicted';
+            session.endTime = Date.now();
+            await this.persistSession(session);
+            this.activeSessions.delete(sessionId);
+            logger.log('warn', `Evicted session ${sessionId} due to capacity limit`);
+        }
+    }
+    /**
+     * Load active sessions from database
+     */
+    async loadActiveSessions() {
+        try {
+            const docs = await AccountingSessionDoc.findActive();
+            for (const doc of docs) {
+                const session = {
+                    sessionId: doc.sessionId,
+                    username: doc.username,
+                    macAddress: doc.macAddress,
+                    nasIpAddress: doc.nasIpAddress,
+                    nasPort: doc.nasPort,
+                    nasPortType: doc.nasPortType,
+                    nasIdentifier: doc.nasIdentifier,
+                    vlanId: doc.vlanId,
+                    framedIpAddress: doc.framedIpAddress,
+                    calledStationId: doc.calledStationId,
+                    callingStationId: doc.callingStationId,
+                    startTime: doc.startTime,
+                    endTime: doc.endTime,
+                    lastUpdateTime: doc.lastUpdateTime,
+                    status: doc.status,
+                    terminateCause: doc.terminateCause,
+                    inputOctets: doc.inputOctets,
+                    outputOctets: doc.outputOctets,
+                    inputPackets: doc.inputPackets,
+                    outputPackets: doc.outputPackets,
+                    sessionTime: doc.sessionTime,
+                    serviceType: doc.serviceType,
+                };
+                this.activeSessions.set(session.sessionId, session);
+            }
+        }
+        catch (error) {
+            logger.log('warn', `Failed to load active sessions: ${error.message}`);
+        }
+    }
+    /**
+     * Persist a session to the database (create or update)
+     */
+    async persistSession(session) {
+        try {
+            let doc = await AccountingSessionDoc.findBySessionId(session.sessionId);
+            if (!doc) {
+                doc = new AccountingSessionDoc();
+            }
+            Object.assign(doc, session);
+            await doc.save();
+        }
+        catch (error) {
+            logger.log('error', `Failed to persist session ${session.sessionId}: ${error.message}`);
+        }
+    }
+    /**
+     * Get archived (stopped/terminated) sessions for a time period
+     */
+    async getArchivedSessions(startTime, endTime) {
+        const sessions = [];
+        try {
+            const docs = await AccountingSessionDoc.getInstances({
+                status: { $in: ['stopped', 'terminated'] },
+                endTime: { $gt: 0, $gte: startTime },
+                startTime: { $lte: endTime },
+            });
+            for (const doc of docs) {
+                sessions.push({
+                    sessionId: doc.sessionId,
+                    username: doc.username,
+                    macAddress: doc.macAddress,
+                    nasIpAddress: doc.nasIpAddress,
+                    nasPort: doc.nasPort,
+                    nasPortType: doc.nasPortType,
+                    nasIdentifier: doc.nasIdentifier,
+                    vlanId: doc.vlanId,
+                    framedIpAddress: doc.framedIpAddress,
+                    calledStationId: doc.calledStationId,
+                    callingStationId: doc.callingStationId,
+                    startTime: doc.startTime,
+                    endTime: doc.endTime,
+                    lastUpdateTime: doc.lastUpdateTime,
+                    status: doc.status,
+                    terminateCause: doc.terminateCause,
+                    inputOctets: doc.inputOctets,
+                    outputOctets: doc.outputOctets,
+                    inputPackets: doc.inputPackets,
+                    outputPackets: doc.outputPackets,
+                    sessionTime: doc.sessionTime,
+                    serviceType: doc.serviceType,
+                });
+            }
+        }
+        catch (error) {
+            logger.log('warn', `Failed to get archived sessions: ${error.message}`);
+        }
+        return sessions;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.accounting.manager.js","sourceRoot":"","sources":["../../../ts/radius/classes.accounting.manager.ts"],"names":[],"mappings":"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"}

package/dist_ts/radius/classes.radius.server.d.ts

@@ -0,0 +1,169 @@
+import { VlanManager, type IMacVlanMapping, type IVlanManagerConfig } from './classes.vlan.manager.js';
+import { AccountingManager, type IAccountingManagerConfig } from './classes.accounting.manager.js';
+/**
+ * RADIUS client (NAS) configuration
+ */
+export interface IRadiusClient {
+    /** Client name for identification */
+    name: string;
+    /** IP address or CIDR range */
+    ipRange: string;
+    /** Shared secret for this client */
+    secret: string;
+    /** Optional description */
+    description?: string;
+    /** Whether this client is enabled */
+    enabled: boolean;
+}
+/**
+ * RADIUS server configuration
+ */
+export interface IRadiusServerConfig {
+    /** Authentication port (default: 1812) */
+    authPort?: number;
+    /** Accounting port (default: 1813) */
+    acctPort?: number;
+    /** Bind address (default: 0.0.0.0) */
+    bindAddress?: string;
+    /** NAS clients configuration */
+    clients: IRadiusClient[];
+    /** VLAN assignment configuration */
+    vlanAssignment?: IVlanManagerConfig & {
+        /** Static MAC to VLAN mappings */
+        mappings?: Array<Omit<IMacVlanMapping, 'createdAt' | 'updatedAt'>>;
+    };
+    /** Accounting configuration */
+    accounting?: IAccountingManagerConfig & {
+        /** Whether accounting is enabled */
+        enabled: boolean;
+    };
+}
+/**
+ * RADIUS authentication result
+ */
+export interface IRadiusAuthResult {
+    /** Whether authentication was successful */
+    success: boolean;
+    /** Reject reason (if not successful) */
+    rejectReason?: string;
+    /** Reply message to send to client */
+    replyMessage?: string;
+    /** Session timeout in seconds */
+    sessionTimeout?: number;
+    /** Idle timeout in seconds */
+    idleTimeout?: number;
+    /** VLAN to assign */
+    vlanId?: number;
+    /** Framed IP address to assign */
+    framedIpAddress?: string;
+}
+/**
+ * Authentication request data from RADIUS
+ */
+export interface IAuthRequestData {
+    username: string;
+    password?: string;
+    nasIpAddress: string;
+    nasPort?: number;
+    nasPortType?: string;
+    nasIdentifier?: string;
+    calledStationId?: string;
+    callingStationId?: string;
+    serviceType?: string;
+    framedMtu?: number;
+}
+/**
+ * RADIUS Server wrapper that provides:
+ * - MAC Authentication Bypass (MAB) for network devices
+ * - VLAN assignment based on MAC address
+ * - Accounting for session tracking and billing
+ * - Integration with SmartProxy routing
+ */
+export declare class RadiusServer {
+    private radiusServer?;
+    private vlanManager;
+    private accountingManager;
+    private config;
+    private clientSecrets;
+    private running;
+    private stats;
+    constructor(config: IRadiusServerConfig);
+    /**
+     * Start the RADIUS server
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the RADIUS server
+     */
+    stop(): Promise<void>;
+    /**
+     * Handle authentication request
+     */
+    private handleAuthentication;
+    /**
+     * Handle accounting request
+     */
+    private handleAccounting;
+    /**
+     * Perform MAC Authentication Bypass
+     */
+    private performMabAuthentication;
+    /**
+     * Extract MAC address from authentication data
+     */
+    private extractMacAddress;
+    /**
+     * Check if a string looks like a MAC address
+     */
+    private looksLikeMac;
+    /**
+     * Normalize MAC address format
+     */
+    private normalizeMac;
+    /**
+     * Build client secrets map from configuration
+     */
+    private buildClientSecretsMap;
+    /**
+     * Get default secret for unknown clients
+     */
+    private getDefaultSecret;
+    /**
+     * Add a RADIUS client
+     */
+    addClient(client: IRadiusClient): Promise<void>;
+    /**
+     * Remove a RADIUS client
+     */
+    removeClient(name: string): boolean;
+    /**
+     * Get configured clients
+     */
+    getClients(): IRadiusClient[];
+    /**
+     * Get VLAN manager for direct access to VLAN operations
+     */
+    getVlanManager(): VlanManager;
+    /**
+     * Get accounting manager for direct access to accounting operations
+     */
+    getAccountingManager(): AccountingManager;
+    /**
+     * Get server statistics
+     */
+    getStats(): {
+        running: boolean;
+        uptime: number;
+        authRequests: number;
+        authAccepts: number;
+        authRejects: number;
+        accountingRequests: number;
+        activeSessions: number;
+        vlanMappings: number;
+        clients: number;
+    };
+    /**
+     * Check if server is running
+     */
+    isRunning(): boolean;
+}