bgpkit_parser/parser/
utils.rs

1/*!
2Provides IO utility functions for read bytes of different length and converting to corresponding structs.
3*/
4use ipnet::{IpNet, Ipv4Net, Ipv6Net};
5use std::convert::TryFrom;
6use std::{
7    io,
8    net::{Ipv4Addr, Ipv6Addr},
9};
10
11use crate::error::ParserError;
12use crate::models::*;
13use crate::ParserError::TruncatedMsg;
14use bytes::{Buf, BufMut, Bytes, BytesMut};
15use log::debug;
16use regex::Regex;
17use std::net::IpAddr;
18
19impl ReadUtils for Bytes {}
20
21// Allow reading IPs from Reads
22pub trait ReadUtils: Buf {
23    #[inline]
24    fn has_n_remaining(&self, n: usize) -> Result<(), ParserError> {
25        let remaining = self.remaining();
26        if remaining < n {
27            Err(TruncatedMsg(format!(
28                "not enough bytes to read. remaining: {}, required: {}",
29                remaining, n
30            )))
31        } else {
32            Ok(())
33        }
34    }
35
36    #[inline]
37    fn read_u8(&mut self) -> Result<u8, ParserError> {
38        self.has_n_remaining(1)?;
39        Ok(self.get_u8())
40    }
41
42    #[inline]
43    fn read_u16(&mut self) -> Result<u16, ParserError> {
44        self.has_n_remaining(2)?;
45        Ok(self.get_u16())
46    }
47
48    #[inline]
49    fn read_u32(&mut self) -> Result<u32, ParserError> {
50        self.has_n_remaining(4)?;
51        Ok(self.get_u32())
52    }
53
54    #[inline]
55    fn read_u64(&mut self) -> Result<u64, ParserError> {
56        self.has_n_remaining(8)?;
57        Ok(self.get_u64())
58    }
59
60    fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), ParserError> {
61        self.has_n_remaining(buf.len())?;
62        self.copy_to_slice(buf);
63        Ok(())
64    }
65
66    fn read_address(&mut self, afi: &Afi) -> io::Result<IpAddr> {
67        match afi {
68            Afi::Ipv4 => match self.read_ipv4_address() {
69                Ok(ip) => Ok(IpAddr::V4(ip)),
70                _ => Err(io::Error::new(
71                    io::ErrorKind::Other,
72                    "Cannot parse IPv4 address".to_string(),
73                )),
74            },
75            Afi::Ipv6 => match self.read_ipv6_address() {
76                Ok(ip) => Ok(IpAddr::V6(ip)),
77                _ => Err(io::Error::new(
78                    io::ErrorKind::Other,
79                    "Cannot parse IPv6 address".to_string(),
80                )),
81            },
82        }
83    }
84
85    fn read_ipv4_address(&mut self) -> Result<Ipv4Addr, ParserError> {
86        let addr = self.read_u32()?;
87        Ok(Ipv4Addr::from(addr))
88    }
89
90    fn read_ipv6_address(&mut self) -> Result<Ipv6Addr, ParserError> {
91        self.has_n_remaining(16)?;
92        let buf = self.get_u128();
93        Ok(Ipv6Addr::from(buf))
94    }
95
96    fn read_ipv4_prefix(&mut self) -> Result<Ipv4Net, ParserError> {
97        let addr = self.read_ipv4_address()?;
98        let mask = self.read_u8()?;
99        match Ipv4Net::new(addr, mask) {
100            Ok(n) => Ok(n),
101            Err(_) => Err(io::Error::new(io::ErrorKind::Other, "Invalid prefix mask").into()),
102        }
103    }
104
105    fn read_ipv6_prefix(&mut self) -> Result<Ipv6Net, ParserError> {
106        let addr = self.read_ipv6_address()?;
107        let mask = self.read_u8()?;
108        match Ipv6Net::new(addr, mask) {
109            Ok(n) => Ok(n),
110            Err(_) => Err(io::Error::new(io::ErrorKind::Other, "Invalid prefix mask").into()),
111        }
112    }
113
114    #[inline]
115    fn read_asn(&mut self, as_length: AsnLength) -> Result<Asn, ParserError> {
116        match as_length {
117            AsnLength::Bits16 => self.read_u16().map(Asn::new_16bit),
118            AsnLength::Bits32 => self.read_u32().map(Asn::new_32bit),
119        }
120    }
121
122    fn read_asns(&mut self, as_length: &AsnLength, count: usize) -> Result<Vec<Asn>, ParserError> {
123        let mut path = Vec::with_capacity(count);
124
125        match as_length {
126            AsnLength::Bits16 => {
127                self.has_n_remaining(count * 2)?; // 2 bytes for 16-bit ASN
128                for _ in 0..count {
129                    path.push(Asn::new_16bit(self.read_u16()?));
130                }
131            }
132            AsnLength::Bits32 => {
133                self.has_n_remaining(count * 4)?; // 4 bytes for 32-bit ASN
134                for _ in 0..count {
135                    path.push(Asn::new_32bit(self.read_u32()?));
136                }
137            }
138        }
139
140        Ok(path)
141    }
142
143    fn read_afi(&mut self) -> Result<Afi, ParserError> {
144        Afi::try_from(self.read_u16()?).map_err(ParserError::from)
145    }
146
147    fn read_safi(&mut self) -> Result<Safi, ParserError> {
148        Safi::try_from(self.read_u8()?).map_err(ParserError::from)
149    }
150
151    /// Read announced/withdrawn prefix.
152    ///
153    /// The length in bits is 1 byte, and then based on the IP version it reads different number of bytes.
154    /// If the `add_path` is true, it will also first read a 4-byte path id first; otherwise, a path-id of 0
155    /// is automatically set.
156    fn read_nlri_prefix(
157        &mut self,
158        afi: &Afi,
159        add_path: bool,
160    ) -> Result<NetworkPrefix, ParserError> {
161        let path_id = if add_path { self.read_u32()? } else { 0 };
162
163        // Length in bits
164        let bit_len = self.read_u8()?;
165
166        // Convert to bytes
167        let byte_len: usize = (bit_len as usize + 7) / 8;
168        let addr: IpAddr = match afi {
169            Afi::Ipv4 => {
170                // 4 bytes -- u32
171                if byte_len > 4 {
172                    return Err(ParserError::ParseError(format!(
173                        "Invalid byte length for IPv4 prefix. byte_len: {}, bit_len: {}",
174                        byte_len, bit_len
175                    )));
176                }
177                let mut buff = [0; 4];
178                self.has_n_remaining(byte_len)?;
179                for i in 0..byte_len {
180                    buff[i] = self.get_u8();
181                }
182                IpAddr::V4(Ipv4Addr::from(buff))
183            }
184            Afi::Ipv6 => {
185                // 16 bytes
186                if byte_len > 16 {
187                    return Err(ParserError::ParseError(format!(
188                        "Invalid byte length for IPv6 prefix. byte_len: {}, bit_len: {}",
189                        byte_len, bit_len
190                    )));
191                }
192                self.has_n_remaining(byte_len)?;
193                let mut buff = [0; 16];
194                for i in 0..byte_len {
195                    buff[i] = self.get_u8();
196                }
197                IpAddr::V6(Ipv6Addr::from(buff))
198            }
199        };
200        let prefix = match IpNet::new(addr, bit_len) {
201            Ok(p) => p,
202            Err(_) => {
203                return Err(ParserError::ParseError(format!(
204                    "Invalid network prefix length: {}",
205                    bit_len
206                )))
207            }
208        };
209
210        Ok(NetworkPrefix::new(prefix, path_id))
211    }
212
213    fn read_n_bytes(&mut self, n_bytes: usize) -> Result<Vec<u8>, ParserError> {
214        self.has_n_remaining(n_bytes)?;
215        Ok(self.copy_to_bytes(n_bytes).into())
216    }
217
218    fn read_n_bytes_to_string(&mut self, n_bytes: usize) -> Result<String, ParserError> {
219        let buffer = self.read_n_bytes(n_bytes)?;
220        Ok(buffer
221            .into_iter()
222            .map(|x: u8| x as char)
223            .collect::<String>())
224    }
225}
226
227pub fn parse_nlri_list(
228    mut input: Bytes,
229    add_path: bool,
230    afi: &Afi,
231) -> Result<Vec<NetworkPrefix>, ParserError> {
232    let mut is_add_path = add_path;
233    let mut prefixes = vec![];
234
235    let mut retry = false;
236    let mut guessed = false;
237
238    let mut input_copy = None;
239
240    while input.remaining() > 0 {
241        if !is_add_path && input[0] == 0 {
242            // it's likely that this is a add-path wrongfully wrapped in non-add-path msg
243            debug!("not add-path but with NLRI size to be 0, likely add-path msg in wrong msg type, treat as add-path now");
244            // cloning the data bytes
245            is_add_path = true;
246            guessed = true;
247            input_copy = Some(input.clone());
248        }
249        let prefix = match input.read_nlri_prefix(afi, is_add_path) {
250            Ok(p) => p,
251            Err(e) => {
252                if guessed {
253                    retry = true;
254                    break;
255                } else {
256                    return Err(e);
257                }
258            }
259        };
260        prefixes.push(prefix);
261    }
262
263    if retry {
264        prefixes.clear();
265        // try again without attempt to guess add-path
266        // if we reach here (retry==true), input_copy must be Some
267        let mut input_2 = input_copy.unwrap();
268        while input_2.remaining() > 0 {
269            let prefix = input_2.read_nlri_prefix(afi, add_path)?;
270            prefixes.push(prefix);
271        }
272    }
273
274    Ok(prefixes)
275}
276
277pub fn encode_asn(asn: &Asn, asn_len: &AsnLength) -> Bytes {
278    let mut bytes = BytesMut::new();
279    match asn_len {
280        AsnLength::Bits16 => bytes.put_u16(asn.into()),
281        AsnLength::Bits32 => {
282            bytes.put_u32(asn.into());
283        }
284    }
285    bytes.freeze()
286}
287
288pub fn encode_ipaddr(addr: &IpAddr) -> Vec<u8> {
289    match addr {
290        IpAddr::V4(addr) => addr.octets().to_vec(),
291        IpAddr::V6(addr) => addr.octets().to_vec(),
292    }
293}
294
295pub fn encode_nlri_prefixes(prefixes: &[NetworkPrefix], add_path: bool) -> Bytes {
296    let mut bytes = BytesMut::new();
297    for prefix in prefixes {
298        bytes.extend(prefix.encode(add_path));
299    }
300    bytes.freeze()
301}
302
303/// A CRC32 implementation that converts a string to a hex string.
304///
305/// CRC32 is a checksum algorithm that is used to verify the integrity of data. It is short in
306/// length and sufficient for generating unique file names based on remote URLs.
307pub fn crc32(input: &str) -> String {
308    let input_bytes = input.as_bytes();
309    let mut table = [0u32; 256];
310    let polynomial = 0xedb88320u32;
311
312    for i in 0..256 {
313        let mut crc = i as u32;
314        for _ in 0..8 {
315            if crc & 1 == 1 {
316                crc = (crc >> 1) ^ polynomial;
317            } else {
318                crc >>= 1;
319            }
320        }
321        table[i as usize] = crc;
322    }
323
324    let mut crc = !0u32;
325    for byte in input_bytes.iter() {
326        let index = ((crc ^ (*byte as u32)) & 0xff) as usize;
327        crc = (crc >> 8) ^ table[index];
328    }
329
330    format!("{:08x}", !crc)
331}
332
333/// Convert a f64 timestamp into u32 seconds and u32 microseconds.
334///
335/// # Arguments
336///
337/// * `timestamp` - The timestamp to convert.
338///
339/// # Returns
340///
341/// A tuple containing the converted seconds and microseconds.
342///
343/// # Example
344///
345/// ```rust
346/// use bgpkit_parser::utils::convert_timestamp;
347///
348/// let timestamp = 1609459200.123456;
349/// let (seconds, microseconds) = convert_timestamp(timestamp);
350/// assert_eq!(seconds, 1609459200);
351/// assert_eq!(microseconds, 123456);
352/// ```
353// convert f64 timestamp into u32 seconds and u32 microseconds
354pub fn convert_timestamp(timestamp: f64) -> (u32, u32) {
355    let seconds = timestamp as u32;
356    let microseconds = ((timestamp - seconds as f64) * 1_000_000.0) as u32;
357    (seconds, microseconds)
358}
359
360#[derive(Debug, Clone)]
361pub struct ComparableRegex {
362    pattern: String,
363    regex: Regex,
364}
365
366impl PartialEq for ComparableRegex {
367    fn eq(&self, other: &Self) -> bool {
368        self.pattern == other.pattern
369    }
370}
371
372impl ComparableRegex {
373    pub fn new(pattern: &str) -> Result<Self, ParserError> {
374        let regex = match Regex::new(pattern) {
375            Ok(r) => r,
376            Err(_) => {
377                return Err(ParserError::FilterError(format!(
378                    "Invalid regex pattern: {}",
379                    pattern
380                )))
381            }
382        };
383        Ok(ComparableRegex {
384            pattern: pattern.to_string(),
385            regex,
386        })
387    }
388
389    pub fn is_match<S: AsRef<str>>(&self, text: S) -> bool {
390        self.regex.is_match(text.as_ref())
391    }
392}
393
394#[cfg(test)]
395mod tests {
396    use super::*;
397    use bytes::Bytes;
398
399    #[test]
400    fn test_read_u8() {
401        let mut buf = Bytes::from_static(&[0x12]);
402        assert_eq!(buf.read_u8().unwrap(), 0x12);
403    }
404
405    #[test]
406    fn test_read_u16() {
407        let mut buf = Bytes::from_static(&[0x12, 0x34]);
408        assert_eq!(buf.read_u16().unwrap(), 0x1234);
409    }
410
411    #[test]
412    fn test_read_u32() {
413        let mut buf = Bytes::from_static(&[0x12, 0x34, 0x56, 0x78]);
414        assert_eq!(buf.read_u32().unwrap(), 0x12345678);
415    }
416
417    #[test]
418    fn test_read_u64() {
419        let mut buf = Bytes::from_static(&[0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0]);
420        assert_eq!(buf.read_u64().unwrap(), 0x123456789ABCDEF0);
421    }
422
423    #[test]
424    fn test_read_ipv4_address() {
425        let mut buf = Bytes::from_static(&[0xC0, 0xA8, 0x01, 0x01]);
426        assert_eq!(
427            buf.read_ipv4_address().unwrap(),
428            Ipv4Addr::new(192, 168, 1, 1)
429        );
430    }
431
432    #[test]
433    fn test_read_ipv6_address() {
434        let mut buf = Bytes::from_static(&[
435            0x20, 0x01, 0x0D, 0xB8, 0x85, 0xA3, 0x00, 0x00, 0x00, 0x00, 0x8A, 0x2E, 0x03, 0x70,
436            0x73, 0x34,
437        ]);
438        assert_eq!(
439            buf.read_ipv6_address().unwrap(),
440            Ipv6Addr::new(0x2001, 0x0DB8, 0x85A3, 0x0000, 0x0000, 0x8A2E, 0x0370, 0x7334)
441        );
442    }
443
444    #[test]
445    fn test_read_address() {
446        let mut buf = Bytes::from_static(&[0xC0, 0xA8, 0x01, 0x01]);
447        assert_eq!(
448            buf.read_address(&Afi::Ipv4).unwrap(),
449            IpAddr::V4(Ipv4Addr::new(192, 168, 1, 1))
450        );
451
452        let mut buf = Bytes::from_static(&[
453            0x20, 0x01, 0x0D, 0xB8, 0x85, 0xA3, 0x00, 0x00, 0x00, 0x00, 0x8A, 0x2E, 0x03, 0x70,
454            0x73, 0x34,
455        ]);
456        assert_eq!(
457            buf.read_address(&Afi::Ipv6).unwrap(),
458            IpAddr::V6(Ipv6Addr::new(
459                0x2001, 0x0DB8, 0x85A3, 0x0000, 0x0000, 0x8A2E, 0x0370, 0x7334
460            ))
461        );
462    }
463
464    #[test]
465    fn test_read_asn() {
466        let mut buf = Bytes::from_static(&[0x00, 0x01]);
467        assert_eq!(buf.read_asn(AsnLength::Bits16).unwrap(), Asn::new_16bit(1));
468
469        let mut buf = Bytes::from_static(&[0x00, 0x00, 0x01, 0x00]);
470        assert_eq!(
471            buf.read_asn(AsnLength::Bits32).unwrap(),
472            Asn::new_32bit(256)
473        );
474    }
475
476    #[test]
477    fn read_asns() {
478        let mut buf = Bytes::from_static(&[0x00, 0x01, 0x00, 0x00]);
479        assert_eq!(
480            buf.read_asns(&AsnLength::Bits16, 2).unwrap(),
481            vec![Asn::new_16bit(1), Asn::new_16bit(0)]
482        );
483    }
484
485    #[test]
486    fn test_read_afi() {
487        let mut buf = Bytes::from_static(&[0x00, 0x01]);
488        assert_eq!(buf.read_afi().unwrap(), Afi::Ipv4);
489
490        let mut buf = Bytes::from_static(&[0x00, 0x02]);
491        assert_eq!(buf.read_afi().unwrap(), Afi::Ipv6);
492    }
493
494    #[test]
495    fn test_read_safi() {
496        let mut buf = Bytes::from_static(&[0x01]);
497        assert_eq!(buf.read_safi().unwrap(), Safi::Unicast);
498
499        let mut buf = Bytes::from_static(&[0x02]);
500        assert_eq!(buf.read_safi().unwrap(), Safi::Multicast);
501    }
502
503    #[test]
504    fn test_has_n_remaining() {
505        let mut buf = Bytes::from_static(&[0x12, 0x34, 0x56, 0x78]);
506        assert!(buf.has_n_remaining(4).is_ok());
507        assert!(buf.has_n_remaining(5).is_err());
508
509        let _ = buf.read_u8().unwrap();
510        assert!(buf.has_n_remaining(3).is_ok());
511        assert!(buf.has_n_remaining(4).is_err());
512    }
513
514    #[test]
515    fn test_read_ipv4_prefix() {
516        let mut buf = Bytes::from_static(&[0xC0, 0xA8, 0x01, 0x01, 0x18]);
517        assert_eq!(
518            buf.read_ipv4_prefix().unwrap(),
519            Ipv4Net::new(Ipv4Addr::new(192, 168, 1, 1), 24).unwrap()
520        );
521    }
522
523    #[test]
524    fn test_read_ipv6_prefix() {
525        let mut buf = Bytes::from_static(&[
526            0x20, 0x01, 0x0D, 0xB8, 0x85, 0xA3, 0x00, 0x00, 0x00, 0x00, 0x8A, 0x2E, 0x03, 0x70,
527            0x73, 0x34, 0x40,
528        ]);
529        assert_eq!(
530            buf.read_ipv6_prefix().unwrap(),
531            Ipv6Net::new(
532                Ipv6Addr::new(0x2001, 0x0DB8, 0x85A3, 0x0000, 0x0000, 0x8A2E, 0x0370, 0x7334),
533                64
534            )
535            .unwrap()
536        );
537    }
538
539    #[test]
540    fn test_read_n_bytes() {
541        let mut buf = Bytes::from_static(&[0x12, 0x34, 0x56, 0x78]);
542        assert_eq!(buf.read_n_bytes(4).unwrap(), vec![0x12, 0x34, 0x56, 0x78]);
543    }
544
545    #[test]
546    fn test_read_n_bytes_to_string() {
547        let mut buf = Bytes::from_static(&[0x48, 0x65, 0x6C, 0x6C, 0x6F]); // "Hello" in ASCII
548        assert_eq!(buf.read_n_bytes_to_string(5).unwrap(), "Hello");
549    }
550
551    #[test]
552    fn test_crc32() {
553        assert_eq!(crc32("Hello, World!"), "ec4ac3d0");
554    }
555
556    #[test]
557    fn test_read_nlri_prefix() {
558        let mut buf = Bytes::from_static(&[0x18, 0xC0, 0xA8, 0x01]);
559        let expected = NetworkPrefix::new(
560            IpNet::V4(Ipv4Net::new(Ipv4Addr::new(192, 168, 1, 0), 24).unwrap()),
561            0,
562        );
563        assert_eq!(buf.read_nlri_prefix(&Afi::Ipv4, false).unwrap(), expected);
564
565        let mut buf = Bytes::from_static(&[0x00, 0x00, 0x00, 0x01, 0x18, 0xC0, 0xA8, 0x01]);
566        let expected = NetworkPrefix::new(
567            IpNet::V4(Ipv4Net::new(Ipv4Addr::new(192, 168, 1, 0), 24).unwrap()),
568            1,
569        );
570        assert_eq!(buf.read_nlri_prefix(&Afi::Ipv4, true).unwrap(), expected);
571    }
572
573    #[test]
574    fn test_encode_asn() {
575        let asn = Asn::new_32bit(1);
576        let asn_len = AsnLength::Bits32;
577        let expected = Bytes::from_static(&[0x00, 0x00, 0x00, 0x01]);
578        assert_eq!(encode_asn(&asn, &asn_len), expected);
579
580        let asn = Asn::new_16bit(1);
581        let asn_len = AsnLength::Bits16;
582        let expected = Bytes::from_static(&[0x00, 0x01]);
583        assert_eq!(encode_asn(&asn, &asn_len), expected);
584    }
585
586    #[test]
587    fn test_encode_ipaddr() {
588        let addr = IpAddr::V4(Ipv4Addr::new(192, 168, 1, 1));
589        let expected = vec![192, 168, 1, 1];
590        assert_eq!(encode_ipaddr(&addr), expected);
591
592        let addr = IpAddr::V6(Ipv6Addr::new(
593            0x2001, 0x0DB8, 0x85A3, 0x0000, 0x0000, 0x8A2E, 0x0370, 0x7334,
594        ));
595        let expected = vec![
596            0x20, 0x01, 0x0D, 0xB8, 0x85, 0xA3, 0x00, 0x00, 0x00, 0x00, 0x8A, 0x2E, 0x03, 0x70,
597            0x73, 0x34,
598        ];
599        assert_eq!(encode_ipaddr(&addr), expected);
600    }
601
602    #[test]
603    fn test_encode_nlri_prefixes() {
604        let prefixes = vec![
605            NetworkPrefix::new(
606                IpNet::V4(Ipv4Net::new(Ipv4Addr::new(192, 168, 1, 0), 24).unwrap()),
607                0,
608            ),
609            NetworkPrefix::new(
610                IpNet::V4(Ipv4Net::new(Ipv4Addr::new(192, 168, 2, 0), 24).unwrap()),
611                0,
612            ),
613        ];
614        let expected = Bytes::from_static(&[0x18, 0xC0, 0xA8, 0x01, 0x18, 0xC0, 0xA8, 0x02]);
615        assert_eq!(encode_nlri_prefixes(&prefixes, false), expected);
616
617        let prefixes = vec![
618            NetworkPrefix::new(
619                IpNet::V4(Ipv4Net::new(Ipv4Addr::new(192, 168, 1, 0), 24).unwrap()),
620                1,
621            ),
622            NetworkPrefix::new(
623                IpNet::V4(Ipv4Net::new(Ipv4Addr::new(192, 168, 2, 0), 24).unwrap()),
624                1,
625            ),
626        ];
627        let expected = Bytes::from_static(&[
628            0x00, 0x00, 0x00, 0x01, 0x18, 0xC0, 0xA8, 0x01, 0x00, 0x00, 0x00, 0x01, 0x18, 0xC0,
629            0xA8, 0x02,
630        ]);
631        assert_eq!(encode_nlri_prefixes(&prefixes, true), expected);
632    }
633
634    #[test]
635    fn test_comparable_regex_functionality() {
636        // Test valid pattern creation
637        let regex1 = ComparableRegex::new(r"\d+").unwrap();
638        let regex2 = ComparableRegex::new(r"\d+").unwrap();
639        let regex3 = ComparableRegex::new(r"\w+").unwrap();
640
641        // Verify pattern storage
642        assert_eq!(regex1.pattern, r"\d+");
643        assert_eq!(regex3.pattern, r"\w+");
644
645        // Verify equality with same pattern
646        assert_eq!(regex1, regex2);
647
648        // Verify inequality with different patterns
649        assert_ne!(regex1, regex3);
650
651        // Verify regex matching functionality
652        assert!(regex1.regex.is_match("123"));
653        assert!(!regex1.regex.is_match("abc"));
654    }
655
656    #[test]
657    #[should_panic(expected = "Invalid regex pattern")]
658    fn test_comparable_regex_invalid_pattern_panic() {
659        // Test invalid pattern creation
660        ComparableRegex::new(r"(\d+").unwrap(); // Unclosed parenthesis should panic
661    }
662}
bgpkit_parser/parser/utils.rs

bgpkit_parser/parser/
utils.rs
