1use crate::cper::section::{CperSectionBody, fer};
7use crate::error::Error;
8use crate::header::{Header, record_types};
9use crate::record::Record;
10#[cfg(not(feature = "std"))]
11use alloc::vec::Vec;
12
13const MAX_NESTED_BOXES: usize = 4;
14
15#[derive(Default)]
20pub struct Region {
21 pub records: Vec<Record>,
22 depth: usize,
23}
24
25impl Region {
26 pub(crate) fn from_cper_section(section: &CperSectionBody) -> Option<Self> {
27 match section {
28 CperSectionBody::FirmwareErrorRecord(fer) => {
29 let guid = fer.header.guid;
30 if guid == fer::guids::RECORD_ID_CRASHLOG {
31 Region::from_slice(&fer.payload).ok()
32 } else {
33 log::info!("Ignoring unknown Firmware Error Record: {}", guid);
34 None
35 }
36 }
37 _ => None,
38 }
39 }
40
41 pub(crate) fn get_children(&self) -> Vec<Self> {
42 let mut children = Vec::new();
43
44 if self.depth >= MAX_NESTED_BOXES {
45 return children;
46 }
47
48 for record in self.records.iter() {
49 let errata = record.header.version.errata();
50 let is_box = record.header.version.record_type == record_types::BOX
51 || errata.type0_legacy_server_box;
52
53 if !is_box {
54 continue;
55 }
56
57 let Some(payload) = record.data.get(record.header.header_size()..) else {
58 log::error!("The Box record has an empty payload");
59 continue;
60 };
61
62 match Region::from_slice(payload) {
63 Ok(mut child) => {
64 for child_record in child.records.iter_mut() {
65 child_record.context.parent_header = Some(record.header.clone());
66 }
67
68 child.depth = self.depth + 1;
69
70 children.push(child)
71 }
72 Err(err) => log::warn!("Invalid region in Box record: {err}"),
73 }
74 }
75
76 children
77 }
78
79 pub fn from_slice(bytes: &[u8]) -> Result<Self, Error> {
80 let mut region = Region::default();
81 let mut cursor = 0;
82
83 while cursor < bytes.len() {
84 let header = match Header::from_slice(&bytes[cursor..]) {
85 Ok(Some(header)) => header,
86 Ok(None) => {
87 log::debug!("Found termination marker at offset {cursor}");
88 break;
89 }
90 Err(err) => {
91 log::warn!("Cannot decode record header: {err}");
92 if region.records.is_empty() {
93 return Err(err);
95 }
96 break;
97 }
98 };
99
100 log::debug!("Record version: {0}", header);
101
102 let record_size = header.record_size();
103 log::debug!("Record size: 0x{record_size:04x}");
104
105 if record_size == 0 {
106 log::warn!(
107 "{} record has an empty size. Skipping.",
108 header.record_type().unwrap_or("UNKNOWN")
109 );
110 break;
111 }
112
113 let limit = cursor + record_size;
114 if limit > bytes.len() {
115 log::warn!(
116 "Truncated record detected: record is expected to be {}B but is {}B",
117 record_size,
118 bytes.len() - cursor
119 )
120 }
121
122 region.records.push(Record {
123 header,
124 data: bytes[cursor..limit.min(bytes.len())].into(),
125 ..Default::default()
126 });
127
128 cursor += record_size;
129 }
130
131 if region.records.is_empty() {
132 return Err(Error::EmptyRegion);
133 }
134
135 Ok(region)
136 }
137
138 pub fn to_bytes(&self) -> Vec<u8> {
139 let mut bytes = Vec::new();
140 for record in self.records.iter() {
141 bytes.append(&mut record.data.clone());
142 }
143 bytes
144 }
145}