src/crc.rs

   1 //! Cyclic Redundancy Check
   2
   3 /// polynomial value for 8 bits Cyclic Redundancy Check
   4 pub const POLY8: u8 = 0x31;
   5 /// initialize value for 8 bits Cyclic Redundancy Check
   6 pub const INIT8: u8 = 0x00;
   7 /// Cyclic Redundancy Check for 8 bits
   8 #[repr(C)]
   9 pub struct crc8 {
  10     /// Cyclic Redundancy Check comparison table
  11     table: [u8; 0x100],
  12 }
  13
  14 extern "C" {
  15     fn a_crc8le_init(table: *mut u8, poly: u8);
  16     fn a_crc8be_init(table: *mut u8, poly: u8);
  17     fn a_crc8(table: *const u8, pdate: *const u8, nbyte: usize, value: u8) -> u8;
  18 }
  19
  20 impl crc8 {
  21     /// initialize for little-endian 8 bits Cyclic Redundancy Check
  22     pub fn new_le(poly: u8) -> Self {
  23         let mut ctx: Self = Self { table: [0; 0x100] };
  24         unsafe { a_crc8le_init(ctx.table.as_mut_ptr(), poly) };
  25         ctx
  26     }
  27
  28     /// calculate for little-endian 8 bits Cyclic Redundancy Check
  29     pub fn le(self, data: &[u8], value: u8) -> u8 {
  30         unsafe { a_crc8(self.table.as_ptr(), data.as_ptr(), data.len(), value) }
  31     }
  32
  33     /// initialize for big-endian 8 bits Cyclic Redundancy Check
  34     pub fn new_be(poly: u8) -> Self {
  35         let mut ctx: Self = Self { table: [0; 0x100] };
  36         unsafe { a_crc8be_init(ctx.table.as_mut_ptr(), poly) };
  37         ctx
  38     }
  39
  40     /// calculate for big-endian 8 bits Cyclic Redundancy Check
  41     pub fn be(self, data: &[u8], value: u8) -> u8 {
  42         unsafe { a_crc8(self.table.as_ptr(), data.as_ptr(), data.len(), value) }
  43     }
  44 }
  45
  46 #[test]
  47 fn crc8() {
  48     {
  49         let ctx = crate::crc::crc8::new_le(POLY8);
  50         ctx.le(b"", INIT8);
  51     }
  52     {
  53         let ctx = crate::crc::crc8::new_be(POLY8);
  54         ctx.be(b"", INIT8);
  55     }
  56 }
  57
  58 /// polynomial value for 16 bits Cyclic Redundancy Check
  59 pub const POLY16: u16 = 0xA001;
  60 /// initialize value for 16 bits Cyclic Redundancy Check
  61 pub const INIT16: u16 = 0x0000;
  62 /// Cyclic Redundancy Check for 16 bits
  63 #[repr(C)]
  64 pub struct crc16 {
  65     /// Cyclic Redundancy Check comparison table
  66     table: [u16; 0x100],
  67 }
  68
  69 extern "C" {
  70     fn a_crc16le_init(table: *mut u16, poly: u16);
  71     fn a_crc16be_init(table: *mut u16, poly: u16);
  72     fn a_crc16le(table: *const u16, pdate: *const u8, nbyte: usize, value: u16) -> u16;
  73     fn a_crc16be(table: *const u16, pdate: *const u8, nbyte: usize, value: u16) -> u16;
  74 }
  75
  76 impl crc16 {
  77     /// initialize for little-endian 16 bits Cyclic Redundancy Check
  78     pub fn new_le(poly: u16) -> Self {
  79         let mut ctx: Self = Self { table: [0; 0x100] };
  80         unsafe { a_crc16le_init(ctx.table.as_mut_ptr(), poly) };
  81         ctx
  82     }
  83
  84     /// calculate for little-endian 16 bits Cyclic Redundancy Check
  85     pub fn le(self, data: &[u8], value: u16) -> u16 {
  86         unsafe { a_crc16le(self.table.as_ptr(), data.as_ptr(), data.len(), value) }
  87     }
  88
  89     /// initialize for big-endian 16 bits Cyclic Redundancy Check
  90     pub fn new_be(poly: u16) -> Self {
  91         let mut ctx: Self = Self { table: [0; 0x100] };
  92         unsafe { a_crc16be_init(ctx.table.as_mut_ptr(), poly) };
  93         ctx
  94     }
  95
  96     /// calculate for big-endian 16 bits Cyclic Redundancy Check
  97     pub fn be(self, data: &[u8], value: u16) -> u16 {
  98         unsafe { a_crc16be(self.table.as_ptr(), data.as_ptr(), data.len(), value) }
  99     }
 100 }
 101
 102 #[test]
 103 fn crc16() {
 104     {
 105         let ctx = crate::crc::crc16::new_le(POLY16);
 106         ctx.le(b"", INIT16);
 107     }
 108     {
 109         let ctx = crate::crc::crc16::new_be(POLY16);
 110         ctx.be(b"", INIT16);
 111     }
 112 }
 113
 114 /// polynomial value for 32 bits Cyclic Redundancy Check
 115 pub const POLY32: u32 = 0xEDB88320;
 116 /// initialize value for 32 bits Cyclic Redundancy Check
 117 pub const INIT32: u32 = 0xFFFFFFFF;
 118 /// Cyclic Redundancy Check for 32 bits
 119 #[repr(C)]
 120 pub struct crc32 {
 121     /// Cyclic Redundancy Check comparison table
 122     table: [u32; 0x100],
 123 }
 124
 125 extern "C" {
 126     fn a_crc32le_init(table: *mut u32, poly: u32);
 127     fn a_crc32be_init(table: *mut u32, poly: u32);
 128     fn a_crc32le(table: *const u32, pdate: *const u8, nbyte: usize, value: u32) -> u32;
 129     fn a_crc32be(table: *const u32, pdate: *const u8, nbyte: usize, value: u32) -> u32;
 130 }
 131
 132 impl crc32 {
 133     /// initialize for little-endian 32 bits Cyclic Redundancy Check
 134     pub fn new_le(poly: u32) -> Self {
 135         let mut ctx: Self = Self { table: [0; 0x100] };
 136         unsafe { a_crc32le_init(ctx.table.as_mut_ptr(), poly) };
 137         ctx
 138     }
 139
 140     /// calculate for little-endian 32 bits Cyclic Redundancy Check
 141     pub fn le(self, data: &[u8], value: u32) -> u32 {
 142         unsafe { a_crc32le(self.table.as_ptr(), data.as_ptr(), data.len(), value) }
 143     }
 144
 145     /// initialize for big-endian 32 bits Cyclic Redundancy Check
 146     pub fn new_be(poly: u32) -> Self {
 147         let mut ctx: Self = Self { table: [0; 0x100] };
 148         unsafe { a_crc32be_init(ctx.table.as_mut_ptr(), poly) };
 149         ctx
 150     }
 151
 152     /// calculate for big-endian 32 bits Cyclic Redundancy Check
 153     pub fn be(self, data: &[u8], value: u32) -> u32 {
 154         unsafe { a_crc32be(self.table.as_ptr(), data.as_ptr(), data.len(), value) }
 155     }
 156 }
 157
 158 #[test]
 159 fn crc32() {
 160     {
 161         let ctx = crate::crc::crc32::new_le(POLY32);
 162         ctx.le(b"", INIT32);
 163     }
 164     {
 165         let ctx = crate::crc::crc32::new_be(POLY32);
 166         ctx.be(b"", INIT32);
 167     }
 168 }
 169
 170 /// polynomial value for 64 bits Cyclic Redundancy Check
 171 pub const POLY64: u64 = 0x42F0E1EBA9EA3693;
 172 /// initialize value for 64 bits Cyclic Redundancy Check
 173 pub const INIT64: u64 = 0xFFFFFFFFFFFFFFFF;
 174 /// Cyclic Redundancy Check for 64 bits
 175 #[repr(C)]
 176 pub struct crc64 {
 177     /// Cyclic Redundancy Check comparison table
 178     table: [u64; 0x100],
 179 }
 180
 181 extern "C" {
 182     fn a_crc64le_init(table: *mut u64, poly: u64);
 183     fn a_crc64be_init(table: *mut u64, poly: u64);
 184     fn a_crc64le(table: *const u64, pdate: *const u8, nbyte: usize, value: u64) -> u64;
 185     fn a_crc64be(table: *const u64, pdate: *const u8, nbyte: usize, value: u64) -> u64;
 186 }
 187
 188 impl crc64 {
 189     /// initialize for little-endian 64 bits Cyclic Redundancy Check
 190     pub fn new_le(poly: u64) -> Self {
 191         let mut ctx: Self = Self { table: [0; 0x100] };
 192         unsafe { a_crc64le_init(ctx.table.as_mut_ptr(), poly) };
 193         ctx
 194     }
 195
 196     /// calculate for little-endian 64 bits Cyclic Redundancy Check
 197     pub fn le(self, data: &[u8], value: u64) -> u64 {
 198         unsafe { a_crc64le(self.table.as_ptr(), data.as_ptr(), data.len(), value) }
 199     }
 200
 201     /// initialize for big-endian 64 bits Cyclic Redundancy Check
 202     pub fn new_be(poly: u64) -> Self {
 203         let mut ctx: Self = Self { table: [0; 0x100] };
 204         unsafe { a_crc64be_init(ctx.table.as_mut_ptr(), poly) };
 205         ctx
 206     }
 207
 208     /// calculate for big-endian 64 bits Cyclic Redundancy Check
 209     pub fn be(self, data: &[u8], value: u64) -> u64 {
 210         unsafe { a_crc64be(self.table.as_ptr(), data.as_ptr(), data.len(), value) }
 211     }
 212 }
 213
 214 #[test]
 215 fn crc64() {
 216     {
 217         let ctx = crate::crc::crc64::new_le(POLY64);
 218         ctx.le(b"", INIT64);
 219     }
 220     {
 221         let ctx = crate::crc::crc64::new_be(POLY64);
 222         ctx.be(b"", INIT64);
 223     }
 224 }