1use std::collections::BTreeMap;
4
5use base64::{engine::general_purpose::STANDARD as B64, Engine};
6
7use crate::error::{IpatoolError, Result};
8
9#[derive(Debug, Clone, PartialEq)]
10pub enum PlistValue {
11 String(String),
12 Integer(i64),
13 Real(f64),
14 Bool(bool),
15 Data(Vec<u8>),
16 Date(String),
17 Dict(PlistDict),
18 Array(Vec<PlistValue>),
19 Null,
20}
21
22pub type PlistDict = BTreeMap<String, PlistValue>;
23
24pub fn base64_encode(data: &[u8]) -> String {
25 B64.encode(data)
26}
27
28pub fn base64_decode(s: &str) -> Vec<u8> {
29 let mut idx = [-1i8; 256];
31 for (i, c) in b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
32 .iter()
33 .enumerate()
34 {
35 idx[*c as usize] = i as i8;
36 }
37 let mut out = Vec::new();
38 let mut bits: u32 = 0;
39 let mut nbits = 0;
40 for &c in s.as_bytes() {
41 if c == b'=' {
42 break;
43 }
44 let v = idx[c as usize];
45 if v < 0 {
46 continue;
47 }
48 bits = (bits << 6) | (v as u32);
49 nbits += 6;
50 if nbits >= 8 {
51 nbits -= 8;
52 out.push((bits >> nbits) as u8);
53 bits &= (1u32 << nbits) - 1;
54 }
55 }
56 out
57}
58
59fn xml_unescape(s: &str) -> String {
60 let out = s
61 .replace("<", "<")
62 .replace(">", ">")
63 .replace(""", "\"")
64 .replace("'", "'");
65 let bytes = out.as_bytes();
67 let mut res = String::new();
68 let mut i = 0;
69 while i < bytes.len() {
70 if bytes[i] == b'&' && i + 2 < bytes.len() && bytes[i + 1] == b'#' {
71 if let Some(semi) = bytes[i + 2..].iter().position(|&c| c == b';') {
72 let semi = i + 2 + semi;
73 let body = &out[i + 2..semi];
74 let cp =
75 if let Some(hex) = body.strip_prefix('x').or_else(|| body.strip_prefix('X')) {
76 u32::from_str_radix(hex, 16).ok()
77 } else {
78 body.parse::<u32>().ok()
79 };
80 if let Some(cp) = cp {
81 if let Some(ch) = char::from_u32(cp) {
82 res.push(ch);
83 i = semi + 1;
84 continue;
85 }
86 }
87 }
88 }
89 res.push(out[i..].chars().next().unwrap());
90 i += out[i..].chars().next().unwrap().len_utf8();
91 }
92 res.replace("&", "&")
93}
94
95pub fn decode_plist(src: &str) -> PlistDict {
96 let bytes = src.as_bytes();
97 if bytes.len() >= 8 && &bytes[..8] == b"bplist00" {
98 return decode_bplist(bytes).unwrap_or_default();
99 }
100 decode_plist_xml(src).unwrap_or_default()
101}
102
103pub fn decode_plist_bytes(data: &[u8]) -> PlistDict {
104 if data.len() >= 8 && &data[..8] == b"bplist00" {
105 return decode_bplist(data).unwrap_or_default();
106 }
107 match std::str::from_utf8(data) {
108 Ok(s) => decode_plist(s),
109 Err(_) => PlistDict::new(),
110 }
111}
112
113fn decode_bplist(data: &[u8]) -> Result<PlistDict> {
114 let value: plist::Value =
115 plist::from_bytes(data).map_err(|e| IpatoolError::Plist(e.to_string()))?;
116 match plist_crate_to_ours(&value) {
117 PlistValue::Dict(d) => Ok(d),
118 _ => Ok(PlistDict::new()),
119 }
120}
121
122fn plist_crate_to_ours(v: &plist::Value) -> PlistValue {
123 match v {
124 plist::Value::String(s) => PlistValue::String(s.clone()),
125 plist::Value::Integer(i) => PlistValue::Integer(i.as_signed().unwrap_or(0)),
126 plist::Value::Real(r) => PlistValue::Real(*r),
127 plist::Value::Boolean(b) => PlistValue::Bool(*b),
128 plist::Value::Data(d) => PlistValue::Data(d.clone()),
129 plist::Value::Date(d) => PlistValue::Date(d.to_xml_format()),
130 plist::Value::Array(a) => PlistValue::Array(a.iter().map(plist_crate_to_ours).collect()),
131 plist::Value::Dictionary(d) => {
132 let mut out = PlistDict::new();
133 for (k, v) in d {
134 out.insert(k.clone(), plist_crate_to_ours(v));
135 }
136 PlistValue::Dict(out)
137 }
138 _ => PlistValue::Null,
139 }
140}
141
142fn decode_plist_xml(src: &str) -> Result<PlistDict> {
143 let start = src.find("<dict>").or_else(|| src.find("<dict "));
145 let end = src.rfind("</dict>");
146 let (Some(start), Some(end)) = (start, end) else {
147 return Err(IpatoolError::Plist("no dict".into()));
148 };
149 let inner = &src[start..end + "</dict>".len()];
150 match parse_value(inner)? {
151 PlistValue::Dict(d) => Ok(d),
152 _ => Err(IpatoolError::Plist("root not dict".into())),
153 }
154}
155
156fn parse_value(s: &str) -> Result<PlistValue> {
157 let s = s.trim();
158 if s.starts_with("<true") {
159 return Ok(PlistValue::Bool(true));
160 }
161 if s.starts_with("<false") {
162 return Ok(PlistValue::Bool(false));
163 }
164 if let Some(rest) = s.strip_prefix("<string>") {
165 let end = rest
166 .find("</string>")
167 .ok_or_else(|| IpatoolError::Plist("string".into()))?;
168 return Ok(PlistValue::String(xml_unescape(&rest[..end])));
169 }
170 if s.starts_with("<string/>") || s.starts_with("<string />") {
171 return Ok(PlistValue::String(String::new()));
172 }
173 if let Some(rest) = s.strip_prefix("<integer>") {
174 let end = rest
175 .find("</integer>")
176 .ok_or_else(|| IpatoolError::Plist("int".into()))?;
177 let n: i64 = rest[..end].trim().parse().unwrap_or(0);
178 return Ok(PlistValue::Integer(n));
179 }
180 if let Some(rest) = s.strip_prefix("<real>") {
181 let end = rest
182 .find("</real>")
183 .ok_or_else(|| IpatoolError::Plist("real".into()))?;
184 let n: f64 = rest[..end].trim().parse().unwrap_or(0.0);
185 return Ok(PlistValue::Real(n));
186 }
187 if let Some(rest) = s.strip_prefix("<data>") {
188 let end = rest
189 .find("</data>")
190 .ok_or_else(|| IpatoolError::Plist("data".into()))?;
191 return Ok(PlistValue::Data(base64_decode(&rest[..end])));
192 }
193 if let Some(rest) = s.strip_prefix("<date>") {
194 let end = rest
195 .find("</date>")
196 .ok_or_else(|| IpatoolError::Plist("date".into()))?;
197 return Ok(PlistValue::Date(xml_unescape(&rest[..end])));
198 }
199 if s.starts_with("<dict>") {
200 return Ok(PlistValue::Dict(parse_dict(s)?));
201 }
202 if s.starts_with("<array>") {
203 return Ok(PlistValue::Array(parse_array(s)?));
204 }
205 Err(IpatoolError::Plist(format!(
206 "unknown value: {}",
207 &s[..s.len().min(40)]
208 )))
209}
210
211fn parse_dict(s: &str) -> Result<PlistDict> {
212 let inner = strip_tag(s, "dict")?;
213 let mut d = PlistDict::new();
214 let mut rest = inner.as_str();
215 while let Some(ks) = rest.find("<key>") {
216 rest = &rest[ks + 5..];
217 let ke = rest
218 .find("</key>")
219 .ok_or_else(|| IpatoolError::Plist("key".into()))?;
220 let key = xml_unescape(rest[..ke].trim());
221 rest = rest[ke + 6..].trim_start();
222 let (val, consumed) = take_one_value(rest)?;
223 d.insert(key, val);
224 rest = &rest[consumed..];
225 }
226 Ok(d)
227}
228
229fn parse_array(s: &str) -> Result<Vec<PlistValue>> {
230 let inner = strip_tag(s, "array")?;
231 let mut out = Vec::new();
232 let mut rest = inner.trim();
233 while !rest.is_empty() && rest.starts_with('<') {
234 let (val, consumed) = take_one_value(rest)?;
235 out.push(val);
236 rest = rest[consumed..].trim_start();
237 }
238 Ok(out)
239}
240
241fn strip_tag(s: &str, tag: &str) -> Result<String> {
242 let open = format!("<{tag}>");
243 let close = format!("</{tag}>");
244 let s = s.trim();
245 if !s.starts_with(&open) {
246 return Err(IpatoolError::Plist(format!("expected {open}")));
247 }
248 if !s.ends_with(&close) {
249 return Err(IpatoolError::Plist(format!("expected {close}")));
250 }
251 Ok(s[open.len()..s.len() - close.len()].to_string())
252}
253
254fn take_one_value(s: &str) -> Result<(PlistValue, usize)> {
255 let s = s.trim_start();
256 for tag in [
258 "<true/>",
259 "<true />",
260 "<false/>",
261 "<false />",
262 "<string/>",
263 "<string />",
264 ] {
265 if s.starts_with(tag) {
266 let v = parse_value(tag)?;
267 return Ok((v, tag.len()));
268 }
269 }
270 for (tag, v) in [
271 ("<dict/>", PlistValue::Dict(PlistDict::new())),
272 ("<dict />", PlistValue::Dict(PlistDict::new())),
273 ("<array/>", PlistValue::Array(Vec::new())),
274 ("<array />", PlistValue::Array(Vec::new())),
275 ("<data/>", PlistValue::Data(Vec::new())),
276 ("<data />", PlistValue::Data(Vec::new())),
277 ] {
278 if s.starts_with(tag) {
279 return Ok((v, tag.len()));
280 }
281 }
282 if s.starts_with("<dict>") {
284 let end = find_matching(s, "dict")?;
285 let chunk = &s[..end];
286 return Ok((parse_value(chunk)?, end));
287 }
288 if s.starts_with("<array>") {
289 let end = find_matching(s, "array")?;
290 let chunk = &s[..end];
291 return Ok((parse_value(chunk)?, end));
292 }
293 for tag in ["string", "integer", "real", "data", "date"] {
294 let open = format!("<{tag}>");
295 let close = format!("</{tag}>");
296 if s.starts_with(&open) {
297 if let Some(rel) = s[open.len()..].find(&close) {
298 let end = open.len() + rel + close.len();
299 return Ok((parse_value(&s[..end])?, end));
300 }
301 }
302 }
303 Err(IpatoolError::Plist(format!(
304 "cannot parse value at {}",
305 &s[..s.len().min(40)]
306 )))
307}
308
309fn find_matching(s: &str, tag: &str) -> Result<usize> {
310 let open = format!("<{tag}>");
311 let close = format!("</{tag}>");
312 let mut depth = 0usize;
313 let mut i = 0usize;
314 while i < s.len() {
315 if s[i..].starts_with(&open) {
316 depth += 1;
317 i += open.len();
318 continue;
319 }
320 if s[i..].starts_with(&close) {
321 depth -= 1;
322 i += close.len();
323 if depth == 0 {
324 return Ok(i);
325 }
326 continue;
327 }
328 i += s[i..].chars().next().unwrap().len_utf8();
329 }
330 Err(IpatoolError::Plist(format!("unclosed <{tag}>")))
331}
332
333pub fn dict_str(d: &PlistDict, key: &str) -> String {
334 match d.get(key) {
335 Some(PlistValue::String(s)) => s.clone(),
336 Some(PlistValue::Date(s)) => s.clone(),
337 _ => String::new(),
338 }
339}
340