1use crate::models::log_entry::{LogEntry, LogFormat, Severity};
12
13pub fn matches_dhcp_record(line: &str) -> bool {
15 let trimmed = line.trim();
16 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
29fn severity_from_event_id(event_id: u32) -> Severity {
31 match event_id {
32 14 | 15 | 31 | 34 | 35 => Severity::Error,
34 13 | 17 | 33 | 36 => Severity::Warning,
36 _ => Severity::Info,
38 }
39}
40
41fn 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
59pub 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 if !matches_dhcp_record(trimmed) {
74 continue;
75 }
76
77 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 let (timestamp, timestamp_display) = parse_dhcp_datetime(date_str, time_str);
145 let severity = severity_from_event_id(event_id);
146
147 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
206fn 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"); }
310}