Skip to main content

cmtraceopen_parser/parser/
dhcp.rs

1//! Windows DHCP Server log parser.
2//!
3//! Parses CSV-format DHCP server logs (DhcpSrvLog-*.log and DhcpV6SrvLog-*.log).
4//!
5//! Format (after header block):
6//!   ID,Date,Time,Description,IP Address,Host Name,MAC Address,User Name,
7//!   TransactionID,QResult,Probationtime,CorrelationID,Dhcid,
8//!   VendorClass(Hex),VendorClass(ASCII),UserClass(Hex),UserClass(ASCII),
9//!   RelayAgentInformation,DnsRegError
10
11use crate::models::log_entry::{LogEntry, LogFormat, Severity};
12
13/// Check if a line looks like a DHCP data row (starts with a number followed by comma and date).
14pub fn matches_dhcp_record(line: &str) -> bool {
15    let trimmed = line.trim();
16    // Must start with digits, then comma, then MM/DD/YY date
17    if let Some(comma_pos) = trimmed.find(',') {
18        let id_part = &trimmed[..comma_pos];
19        let after = &trimmed[comma_pos + 1..];
20        id_part.chars().all(|c| c.is_ascii_digit())
21            && !id_part.is_empty()
22            && after.len() >= 8
23            && after.as_bytes()[2] == b'/'
24    } else {
25        false
26    }
27}
28
29/// Derive severity from DHCP event ID.
30fn severity_from_event_id(event_id: u32) -> Severity {
31    match event_id {
32        // Errors: pool exhausted, lease denied, DNS update failed
33        14 | 15 | 31 | 34 | 35 => Severity::Error,
34        // Warnings: IP in use, lease expired, packet dropped
35        13 | 17 | 33 | 36 => Severity::Warning,
36        // Everything else is info (started, renewed, released, DNS success, etc.)
37        _ => Severity::Info,
38    }
39}
40
41/// Format a MAC address with colons: AABBCCDDEEFF → AA:BB:CC:DD:EE:FF
42fn format_mac(raw: &str) -> String {
43    let clean: String = raw.chars().filter(|c| c.is_ascii_hexdigit()).collect();
44    if clean.len() == 12 {
45        format!(
46            "{}:{}:{}:{}:{}:{}",
47            &clean[0..2],
48            &clean[2..4],
49            &clean[4..6],
50            &clean[6..8],
51            &clean[8..10],
52            &clean[10..12]
53        )
54    } else {
55        raw.to_string()
56    }
57}
58
59/// Parse all lines of a DHCP log file.
60/// Skips the header block (non-CSV preamble lines).
61pub fn parse_lines(lines: &[&str], file_path: &str) -> (Vec<LogEntry>, u32) {
62    let mut entries = Vec::with_capacity(lines.len());
63    let mut parse_errors: u32 = 0;
64    let mut id: u64 = 0;
65
66    for (i, line) in lines.iter().enumerate() {
67        let trimmed = line.trim();
68        if trimmed.is_empty() {
69            continue;
70        }
71
72        // Skip header lines (non-CSV preamble)
73        if !matches_dhcp_record(trimmed) {
74            continue;
75        }
76
77        // Split CSV fields
78        let fields: Vec<&str> = trimmed.splitn(19, ',').collect();
79        if fields.len() < 4 {
80            parse_errors += 1;
81            entries.push(LogEntry {
82                id,
83                line_number: (i + 1) as u32,
84                message: trimmed.to_string(),
85                component: None,
86                timestamp: None,
87                timestamp_display: None,
88                severity: Severity::Info,
89                thread: None,
90                thread_display: None,
91                source_file: None,
92                format: LogFormat::Plain,
93                file_path: file_path.to_string(),
94                timezone_offset: None,
95                error_code_spans: Vec::new(),
96                ip_address: None,
97                host_name: None,
98                mac_address: None,
99                result_code: None,
100                gle_code: None,
101                setup_phase: None,
102                operation_name: None,
103                http_method: None,
104                uri_stem: None,
105                uri_query: None,
106                status_code: None,
107                sub_status: None,
108                time_taken_ms: None,
109                client_ip: None,
110                server_ip: None,
111                user_agent: None,
112                server_port: None,
113                username: None,
114                win32_status: None,
115                query_name: None,
116                query_type: None,
117                response_code: None,
118                dns_direction: None,
119                dns_protocol: None,
120                source_ip: None,
121                dns_flags: None,
122                dns_event_id: None,
123                zone_name: None,
124                entry_kind: None,
125                whatif: None,
126                section_name: None,
127                section_color: None,
128                iteration: None,
129                tags: None,
130            });
131            id += 1;
132            continue;
133        }
134
135        let event_id: u32 = fields[0].trim().parse().unwrap_or(0);
136        let date_str = fields[1].trim();
137        let time_str = fields[2].trim();
138        let description = fields[3].trim();
139        let ip_address = fields.get(4).map(|s| s.trim()).filter(|s| !s.is_empty());
140        let host_name = fields.get(5).map(|s| s.trim()).filter(|s| !s.is_empty());
141        let mac_address = fields.get(6).map(|s| s.trim()).filter(|s| !s.is_empty());
142
143        // Parse date: MM/DD/YY
144        let (timestamp, timestamp_display) = parse_dhcp_datetime(date_str, time_str);
145        let severity = severity_from_event_id(event_id);
146
147        // Build message: "EventID - Description"
148        let message = format!("{} - {}", event_id, description);
149
150        entries.push(LogEntry {
151            id,
152            line_number: (i + 1) as u32,
153            message,
154            component: None,
155            timestamp,
156            timestamp_display,
157            severity,
158            thread: None,
159            thread_display: None,
160            source_file: None,
161            format: LogFormat::Timestamped,
162            file_path: file_path.to_string(),
163            timezone_offset: None,
164            error_code_spans: Vec::new(),
165            ip_address: ip_address.map(|s| s.to_string()),
166            host_name: host_name.map(|s| s.to_string()),
167            mac_address: mac_address.map(format_mac),
168            result_code: None,
169            gle_code: None,
170            setup_phase: None,
171            operation_name: None,
172            http_method: None,
173            uri_stem: None,
174            uri_query: None,
175            status_code: None,
176            sub_status: None,
177            time_taken_ms: None,
178            client_ip: None,
179            server_ip: None,
180            user_agent: None,
181            server_port: None,
182            username: None,
183            win32_status: None,
184            query_name: None,
185            query_type: None,
186            response_code: None,
187            dns_direction: None,
188            dns_protocol: None,
189            source_ip: None,
190            dns_flags: None,
191            dns_event_id: None,
192            zone_name: None,
193            entry_kind: None,
194            whatif: None,
195            section_name: None,
196            section_color: None,
197            iteration: None,
198            tags: None,
199        });
200        id += 1;
201    }
202
203    (entries, parse_errors)
204}
205
206/// Parse DHCP date (MM/DD/YY) and time (HH:MM:SS) into timestamp.
207fn parse_dhcp_datetime(date: &str, time: &str) -> (Option<i64>, Option<String>) {
208    let date_parts: Vec<&str> = date.split('/').collect();
209    let time_parts: Vec<&str> = time.split(':').collect();
210
211    if date_parts.len() != 3 || time_parts.len() < 3 {
212        return (None, Some(format!("{} {}", date, time)));
213    }
214
215    let mon: u32 = date_parts[0].parse().unwrap_or(1);
216    let day: u32 = date_parts[1].parse().unwrap_or(1);
217    let yr_short: i32 = date_parts[2].parse().unwrap_or(0);
218    let yr = if yr_short < 100 {
219        2000 + yr_short
220    } else {
221        yr_short
222    };
223
224    let h: u32 = time_parts[0].parse().unwrap_or(0);
225    let m: u32 = time_parts[1].parse().unwrap_or(0);
226    let s: u32 = time_parts[2].parse().unwrap_or(0);
227
228    let timestamp = chrono::NaiveDate::from_ymd_opt(yr, mon, day)
229        .and_then(|d| d.and_hms_opt(h, m, s))
230        .map(|dt| dt.and_utc().timestamp_millis());
231
232    let display = Some(format!(
233        "{:04}-{:02}-{:02} {:02}:{:02}:{:02}",
234        yr, mon, day, h, m, s
235    ));
236
237    (timestamp, display)
238}
239
240#[cfg(test)]
241mod tests {
242    use super::*;
243
244    #[test]
245    fn test_parse_dhcp_renew() {
246        let lines = vec![
247            "11,03/23/26,18:31:38,Renew,192.168.2.116,deco-XE75.home.gell.one,54AF97F8352B,,79241796,0,,,,0x756468637020312E32322E31,udhcp 1.22.1,,,,0",
248        ];
249        let (entries, errors) = parse_lines(&lines, "test.log");
250        assert_eq!(errors, 0);
251        assert_eq!(entries.len(), 1);
252        assert_eq!(entries[0].message, "11 - Renew");
253        assert_eq!(entries[0].severity, Severity::Info);
254        assert_eq!(entries[0].ip_address.as_deref(), Some("192.168.2.116"));
255        assert_eq!(
256            entries[0].host_name.as_deref(),
257            Some("deco-XE75.home.gell.one")
258        );
259        assert_eq!(entries[0].mac_address.as_deref(), Some("54:AF:97:F8:35:2B"));
260    }
261
262    #[test]
263    fn test_parse_dhcp_dns_failure() {
264        let lines = vec![
265            "31,03/23/26,18:31:28,DNS Update Failed,192.168.2.69,Fi Series 3 Base.home,10B41DB40CC0,,3978033648,0,6,,,,,,,,,9560",
266        ];
267        let (entries, _) = parse_lines(&lines, "test.log");
268        assert_eq!(entries[0].severity, Severity::Error);
269        assert_eq!(entries[0].message, "31 - DNS Update Failed");
270    }
271
272    #[test]
273    fn test_parse_dhcp_pool_exhausted() {
274        let lines = vec!["14,03/23/26,10:00:00,Pool exhausted,,,,,0,6,,,,,,,,,0"];
275        let (entries, _) = parse_lines(&lines, "test.log");
276        assert_eq!(entries[0].severity, Severity::Error);
277        assert!(entries[0].ip_address.is_none());
278    }
279
280    #[test]
281    fn test_skip_header_lines() {
282        let lines = vec![
283            "\t\tMicrosoft DHCP Service Activity Log",
284            "",
285            "Event ID  Meaning",
286            "00\tThe log was started.",
287            "ID,Date,Time,Description,IP Address,Host Name,...",
288            "11,03/23/26,18:00:00,Renew,192.168.1.1,test,,,,0,6,,,,,,,,,0",
289        ];
290        let (entries, _) = parse_lines(&lines, "test.log");
291        assert_eq!(entries.len(), 1);
292        assert_eq!(entries[0].ip_address.as_deref(), Some("192.168.1.1"));
293    }
294
295    #[test]
296    fn test_matches_dhcp_record() {
297        assert!(matches_dhcp_record(
298            "11,03/23/26,18:31:38,Renew,192.168.2.116,test,AABB,,0,6,,,,,,,,,0"
299        ));
300        assert!(!matches_dhcp_record("Event ID  Meaning"));
301        assert!(!matches_dhcp_record("ID,Date,Time,Description,IP Address"));
302        assert!(!matches_dhcp_record(""));
303    }
304
305    #[test]
306    fn test_format_mac() {
307        assert_eq!(format_mac("54AF97F8352B"), "54:AF:97:F8:35:2B");
308        assert_eq!(format_mac("AABB"), "AABB"); // too short, return as-is
309    }
310}