_ Git - rust-lightning/blob - fuzz/fuzz_targets/msg_targets/utils.rs

   1 #![macro_use]
   2
   3 #[allow(dead_code)]
   4 #[inline]
   5 pub fn slice_to_be16(v: &[u8]) -> u16 {
   6         ((v[0] as u16) << 8*1) |
   7         ((v[1] as u16) << 8*0)
   8 }
   9
  10 #[macro_export]
  11 macro_rules! test_msg {
  12         ($MsgType: path, $data: ident, $read_pos: ident) => {
  13                 {
  14                         let len = slice_to_be16(get_slice!($data, $read_pos, 2));
  15                         let raw = get_slice!($data, $read_pos, len);
  16                         let cb = decode_msg!($MsgType, raw).encode();
  17                         assert_eq!(&raw[..cb.len()], &cb[..]);
  18                 }
  19         }
  20 }
  21
  22 #[macro_export]
  23 macro_rules! decode_msg {
  24         ($MsgType: path, $data: expr) => {
  25                 match <($MsgType)>::decode($data) {
  26                         Ok(msg) => msg,
  27                         Err(e) => match e {
  28                                 msgs::DecodeError::UnknownRealmByte => return,
  29                                 msgs::DecodeError::BadPublicKey => return,
  30                                 msgs::DecodeError::BadSignature => return,
  31                                 msgs::DecodeError::ExtraAddressesPerType => return,
  32                                 msgs::DecodeError::WrongLength => return,
  33                         }
  34                 }
  35         }
  36 }
  37
  38 #[macro_export]
  39 macro_rules! get_slice {
  40         ($data: ident, $read_pos: ident, $len: expr) => {
  41                 {
  42                         let slice_len = $len as usize;
  43                         if $data.len() < $read_pos + slice_len {
  44                                 return;
  45                         }
  46                         $read_pos += slice_len;
  47                         &$data[$read_pos - slice_len..$read_pos]
  48                 }
  49         }
  50 }
  51
  52 #[allow(dead_code)]
  53 #[cfg(test)]
  54 pub fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
  55         let mut b = 0;
  56         for (idx, c) in hex.as_bytes().iter().enumerate() {
  57                 b <<= 4;
  58                 match *c {
  59                         b'A'...b'F' => b |= c - b'A' + 10,
  60                         b'a'...b'f' => b |= c - b'a' + 10,
  61                         b'0'...b'9' => b |= c - b'0',
  62                         _ => panic!("Bad hex"),
  63                 }
  64                 if (idx & 1) == 1 {
  65                         out.push(b);
  66                         b = 0;
  67                 }
  68         }
  69 }