postfix-log-parser 0.2.0

//! # SMTPD 邮件接收服务组件解析器
//!
//! SMTPD 是 Postfix 的邮件接收服务组件，负责：
//! - 接收来自客户端的 SMTP 连接
//! - 处理 SMTP 协议命令和会话管理
//! - 执行反垃圾邮件策略和访问控制
//! - 提供 SASL 认证和 TLS 加密支持
//!
//! ## 核心功能
//!
//! - **连接管理**: 处理客户端连接、断开和超时
//! - **协议处理**: 支持 SMTP/ESMTP 命令处理
//! - **安全控制**: SASL 认证、TLS 加密、访问策略
//! - **反垃圾邮件**: RBL 查询、内容过滤、速率限制
//! - **队列管理**: 为接收的邮件分配队列 ID
//!
//! ## 支持的事件类型
//!
//! - **连接事件**: 客户端连接建立和断开
//! - **认证事件**: SASL 认证成功和失败
//! - **拒绝事件**: 各种策略拒绝和过滤
//! - **邮件处理**: 队列 ID 分配和邮件接收
//! - **系统警告**: 配置问题和性能警告
//! - **协议交互**: HELO/EHLO 命令和功能协商
//!
//! ## 示例日志格式
//!
//! ```text
//! # 连接事件
//! connect from client.example.com[192.168.1.100]
//! disconnect from client.example.com[192.168.1.100] ehlo=1 mail=1 rcpt=1 data=1 quit=1 commands=5
//!
//! # 邮件处理
//! queue_id: client=client.example.com[192.168.1.100]
//!
//! # 拒绝事件
//! NOQUEUE: reject: RCPT from client.example.com[192.168.1.100]: 550 5.1.1 User unknown; from=<sender@example.com> to=<user@domain.com>
//!
//! # 认证失败
//! client.example.com[192.168.1.100]: SASL LOGIN authentication failed: Invalid credentials
//! ```

use crate::components::ComponentParser;
use crate::error::ParseError;
use crate::events::smtpd::{CommandStats, RejectType};
use crate::events::{ComponentEvent, SmtpdEvent};
use crate::utils::queue_id::create_queue_id_pattern;
use regex::Regex;

/// SMTPD解析器
pub struct SmtpdParser {
    // 连接管理相关
    connect_regex: Regex,
    disconnect_regex: Regex,
    lost_connection_regex: Regex,
    timeout_regex: Regex,

    // 邮件处理相关
    client_assignment_regex: Regex,
    noqueue_filter_regex: Regex,

        // 认证和安全相关
    sasl_auth_failure_regex: Regex,
    reject_noqueue_regex: Regex,
    
    // 协议相关
    helo_regex: Regex,

    // 系统警告相关
    system_warning_regex: Regex,

    // 命令统计解析
    command_stats_regex: Regex,
}

impl SmtpdParser {
    /// 创建新的SMTPD解析器
    /// 优化了正则表达式性能，使用非贪婪匹配和更精确的模式
    pub fn new() -> Self {
        Self {
            // 连接管理相关 - 使用更高效的非贪婪匹配
            connect_regex: Regex::new(r"^connect from ([^\[]+)\[([^\]]+)\](?::(\d+))?").unwrap(),
            disconnect_regex: Regex::new(r"^disconnect from ([^\[]+)\[([^\]]+)\](?::(\d+))?(.*)?").unwrap(),
            lost_connection_regex: Regex::new(r"^lost connection after (\w+) from ([^\[]+)\[([^\]]+)\]").unwrap(),
            timeout_regex: Regex::new(r"^timeout after (\w+) from ([^\[]+)\[([^\]]+)\]").unwrap(),
            
            // 邮件处理相关 - 优化队列ID格式
            client_assignment_regex: Regex::new(&create_queue_id_pattern(r"^{QUEUE_ID}: client=([^\[]+)\[([^\]]+)\](?::(\d+))?")).unwrap(),
            noqueue_filter_regex: Regex::new(r"^NOQUEUE: filter: RCPT from ([^\[]+)\[([^\]]+)\]: (.+)").unwrap(),
            
            // 认证和安全相关 - 优化SASL匹配
            sasl_auth_failure_regex: Regex::new(r"([^\[]+)\[([^\]]+)\]: SASL (\w+) authentication failed: (.+)").unwrap(),
            reject_noqueue_regex: Regex::new(r"^NOQUEUE: reject: (\w+) from ([^\[]+)\[([^\]]+)\]: (\d{3}) (.+?)(?:; from=<([^>]+)> to=<([^>]+)>)?").unwrap(),
            
            // 协议相关 - 更精确的HELO匹配
            helo_regex: Regex::new(r"client=([^\[]+)\[([^\]]+)\], helo=<([^>]+)>").unwrap(),
            
            // 系统警告相关 - 匹配已剥离warning:前缀的消息，识别常见警告模式
            system_warning_regex: Regex::new(r"^(dict_\w+|hostname \w+|non-SMTP|Illegal|\w+_init|address syntax|TLS|SASL|milter).*").unwrap(),
            
            // 命令统计解析 - 修复空格处理问题
            command_stats_regex: Regex::new(r"\s*(?:ehlo=(\d+))?\s*(?:helo=(\d+))?\s*(?:mail=(\d+))?\s*(?:rcpt=(\d+))?\s*(?:data=(\d+))?\s*(?:bdat=(\d+))?\s*(?:quit=(\d+))?\s*(?:commands=(\d+))?\s*").unwrap(),
        }
    }

    /// 解析SMTP命令统计信息
    fn parse_command_stats(&self, stats_text: &str) -> Option<CommandStats> {
        self.command_stats_regex.captures(stats_text).map(|captures| CommandStats {
                ehlo: captures.get(1).and_then(|m| m.as_str().parse().ok()),
                helo: captures.get(2).and_then(|m| m.as_str().parse().ok()),
                mail: captures.get(3).and_then(|m| m.as_str().parse().ok()),
                rcpt: captures.get(4).and_then(|m| m.as_str().parse().ok()),
                data: captures.get(5).and_then(|m| m.as_str().parse().ok()),
                bdat: captures.get(6).and_then(|m| m.as_str().parse().ok()),
                quit: captures.get(7).and_then(|m| m.as_str().parse().ok()),
                commands: captures.get(8).and_then(|m| m.as_str().parse().ok()),
            })
    }
}

impl ComponentParser for SmtpdParser {
    fn parse(&self, message: &str) -> Result<ComponentEvent, ParseError> {
        // 优化解析顺序：按真实日志中出现频率排序
        // 最常见：客户端队列ID分配 -> 连接 -> 断开连接 -> HELO -> 其他
        
        // 1. 尝试匹配客户端队列ID分配事件（最常见）
        if let Some(captures) = self.client_assignment_regex.captures(message) {
            let queue_id = captures.get(1).unwrap().as_str().to_string();
            let client_hostname = captures.get(2).unwrap().as_str().to_string();
            let client_ip = captures.get(3).unwrap().as_str().to_string();
            let port = captures.get(4).and_then(|m| m.as_str().parse::<u16>().ok());

            return Ok(ComponentEvent::Smtpd(SmtpdEvent::ClientAssignment {
                queue_id,
                client_ip,
                client_hostname,
                port,
            }));
        }

        // 2. 尝试匹配连接事件
        if let Some(captures) = self.connect_regex.captures(message) {
            let client_hostname = captures.get(1).unwrap().as_str().to_string();
            let client_ip = captures.get(2).unwrap().as_str().to_string();
            let port = captures.get(3).and_then(|m| m.as_str().parse::<u16>().ok());

            return Ok(ComponentEvent::Smtpd(SmtpdEvent::Connect {
                client_ip,
                client_hostname,
                port,
            }));
        }

        // 3. 尝试匹配断开连接事件
        if let Some(captures) = self.disconnect_regex.captures(message) {
            let client_hostname = captures.get(1).unwrap().as_str().to_string();
            let client_ip = captures.get(2).unwrap().as_str().to_string();
            let port = captures.get(3).and_then(|m| m.as_str().parse::<u16>().ok());
            let stats_part = captures.get(4).map(|m| m.as_str()).unwrap_or("");
            
            let command_stats = if !stats_part.is_empty() {
                self.parse_command_stats(stats_part)
            } else {
                None
            };

            return Ok(ComponentEvent::Smtpd(SmtpdEvent::Disconnect {
                client_ip,
                client_hostname,
                port,
                command_stats,
            }));
        }

        // 4. 尝试匹配连接丢失事件
        if let Some(captures) = self.lost_connection_regex.captures(message) {
            let last_command = Some(captures.get(1).unwrap().as_str().to_string());
            let client_hostname = captures.get(2).unwrap().as_str().to_string();
            let client_ip = captures.get(3).unwrap().as_str().to_string();

            return Ok(ComponentEvent::Smtpd(SmtpdEvent::LostConnection {
                client_ip,
                client_hostname,
                last_command,
            }));
        }

        // 5. 尝试匹配超时事件
        if let Some(captures) = self.timeout_regex.captures(message) {
            let last_command = Some(captures.get(1).unwrap().as_str().to_string());
            let client_hostname = captures.get(2).unwrap().as_str().to_string();
            let client_ip = captures.get(3).unwrap().as_str().to_string();

            return Ok(ComponentEvent::Smtpd(SmtpdEvent::Timeout {
                client_ip,
                client_hostname,
                last_command,
            }));
        }

        // 6. 尝试匹配NOQUEUE拒绝事件
        if let Some(captures) = self.reject_noqueue_regex.captures(message) {
            let _cmd = captures.get(1).unwrap().as_str();
            let client_hostname = captures.get(2).unwrap().as_str().to_string();
            let client_ip = captures.get(3).unwrap().as_str().to_string();
            let code = captures.get(4).unwrap().as_str().parse::<u16>().ok();
            let reason = captures.get(5).unwrap().as_str().to_string();
            let from = captures.get(6).map(|m| m.as_str().to_string());
            let to = captures.get(7).map(|m| m.as_str().to_string());

            return Ok(ComponentEvent::Smtpd(SmtpdEvent::Reject {
                reason,
                code,
                reject_type: RejectType::NoQueue,
                from,
                to,
                client_ip: Some(client_ip),
                client_hostname: Some(client_hostname),
            }));
        }

        // 7. 尝试匹配NOQUEUE过滤器事件
        if let Some(captures) = self.noqueue_filter_regex.captures(message) {
            let client_hostname = captures.get(1).unwrap().as_str().to_string();
            let client_ip = captures.get(2).unwrap().as_str().to_string();
            let filter_info = captures.get(3).unwrap().as_str().to_string();

            return Ok(ComponentEvent::Smtpd(SmtpdEvent::NoQueueFilter {
                client_ip,
                client_hostname,
                filter_info: filter_info.clone(),
                filter_target: filter_info, // 可以进一步解析
            }));
        }

        // 8. 尝试匹配SASL认证失败事件
        if let Some(captures) = self.sasl_auth_failure_regex.captures(message) {
            let _client_hostname = captures.get(1).unwrap().as_str().to_string();
            let _client_ip = captures.get(2).unwrap().as_str().to_string();
            let method = captures.get(3).unwrap().as_str().to_string();
            let failure_reason = Some(captures.get(4).unwrap().as_str().to_string());

            return Ok(ComponentEvent::Smtpd(SmtpdEvent::Auth {
                method,
                username: "unknown".to_string(), // SASL失败时通常没有用户名
                success: false,
                failure_reason,
            }));
        }

        // 9. 尝试匹配HELO事件
        if let Some(captures) = self.helo_regex.captures(message) {
            let client_hostname = Some(captures.get(1).unwrap().as_str().to_string());
            let client_ip = Some(captures.get(2).unwrap().as_str().to_string());
            let hostname = captures.get(3).unwrap().as_str().to_string();

            return Ok(ComponentEvent::Smtpd(SmtpdEvent::Helo {
                hostname,
                client_ip,
                client_hostname,
            }));
        }

        // 10. 尝试匹配系统警告事件
        if let Some(_captures) = self.system_warning_regex.captures(message) {
            let warning_message = message.to_string(); // 整个消息就是警告内容
            
            // 提取警告类型
            let warning_type = if warning_message.contains("dict_nis_init") {
                "nis_config".to_string()
            } else if warning_message.contains("dict_") {
                "dictionary_config".to_string()
            } else if warning_message.contains("non-SMTP command") {
                "protocol_violation".to_string()
            } else if warning_message.contains("Illegal address syntax") {
                "address_syntax".to_string()
            } else if warning_message.contains("hostname") {
                "hostname_config".to_string()
            } else if warning_message.contains("TLS") {
                "tls_config".to_string()
            } else if warning_message.contains("SASL") {
                "sasl_config".to_string()
            } else {
                "general".to_string()
            };

            return Ok(ComponentEvent::Smtpd(SmtpdEvent::SystemWarning {
                warning_type,
                message: warning_message,
                client_info: None, // 系统警告不包含客户端信息
            }));
        }

        // 如果都不匹配，返回错误
        Err(ParseError::ComponentParseError {
            component: "smtpd".to_string(),
            reason: format!("无法解析消息: {}", message),
        })
    }

    fn component_name(&self) -> &'static str {
        "smtpd"
    }

    fn can_parse(&self, message: &str) -> bool {
        self.connect_regex.is_match(message)
            || self.disconnect_regex.is_match(message)
            || self.lost_connection_regex.is_match(message)
            || self.timeout_regex.is_match(message)
            || self.client_assignment_regex.is_match(message)
            || self.reject_noqueue_regex.is_match(message)
            || self.noqueue_filter_regex.is_match(message)
            || self.sasl_auth_failure_regex.is_match(message)
            || self.helo_regex.is_match(message)
            || self.system_warning_regex.is_match(message)
    }
}

impl Default for SmtpdParser {
    fn default() -> Self {
        Self::new()
    }
}