add ssr

Author: Rain Liu

src/extended_report/mod.rs

@@ -5,8 +5,8 @@ pub mod dlrr;
 pub mod prt;
 pub mod rle;
 pub mod rrt;
-/*pub mod ssr;
-pub mod vm;*/
+pub mod ssr;
+//pub mod vm;
 pub mod unknown;
 
 pub use unknown::UnknownReportBlock;

src/extended_report/prt.rs

@@ -1,6 +1,6 @@
 use super::*;
 
-const PRT_REPORT_BLOCK_MIN_LENGTH: u16 = 9;
+const PRT_REPORT_BLOCK_MIN_LENGTH: u16 = 8;
 
 /// PacketReceiptTimesReportBlock represents a Packet Receipt Times
 /// report block, as described in RFC 3611 section 4.3.
@@ -24,7 +24,10 @@ const PRT_REPORT_BLOCK_MIN_LENGTH: u16 = 9;
 /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 #[derive(Debug, Default, PartialEq, Clone)]
 pub struct PacketReceiptTimesReportBlock {
+    //not included in marshal/unmarshal
     pub t: u8,
+
+    //marshal/unmarshal
     pub ssrc: u32,
     pub begin_seq: u16,
     pub end_seq: u16,
@@ -92,7 +95,6 @@ impl Marshal for PacketReceiptTimesReportBlock {
         let n = h.marshal_to(buf)?;
         buf = &mut buf[n..];
 
-        buf.put_u8(self.t);
         buf.put_u32(self.ssrc);
         buf.put_u16(self.begin_seq);
         buf.put_u16(self.end_seq);
@@ -124,7 +126,8 @@ impl Unmarshal for PacketReceiptTimesReportBlock {
             return Err(error::Error::PacketTooShort.into());
         }
 
-        let t = raw_packet.get_u8();
+        let t = xr_header.type_specific & 0x0F;
+
         let ssrc = raw_packet.get_u32();
         let begin_seq = raw_packet.get_u16();
         let end_seq = raw_packet.get_u16();
@@ -137,6 +140,7 @@ impl Unmarshal for PacketReceiptTimesReportBlock {
 
         Ok(PacketReceiptTimesReportBlock {
             t,
+
             ssrc,
             begin_seq,
             end_seq,

src/extended_report/rle.rs

@@ -1,6 +1,6 @@
 use super::*;
 
-const RLE_REPORT_BLOCK_MIN_LENGTH: u16 = 9;
+const RLE_REPORT_BLOCK_MIN_LENGTH: u16 = 8;
 
 /// ChunkType enumerates the three kinds of chunks described in RFC 3611 section 4.1.
 #[derive(Debug, Copy, Clone, PartialEq)]
@@ -104,8 +104,11 @@ impl Chunk {
 /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 #[derive(Debug, Default, PartialEq, Clone)]
 pub struct RLEReportBlock {
+    //not included in marshal/unmarshal
     pub is_loss_rle: bool,
     pub t: u8,
+
+    //marshal/unmarshal
     pub ssrc: u32,
     pub begin_seq: u16,
     pub end_seq: u16,
@@ -187,7 +190,6 @@ impl Marshal for RLEReportBlock {
         let n = h.marshal_to(buf)?;
         buf = &mut buf[n..];
 
-        buf.put_u8(self.t);
         buf.put_u32(self.ssrc);
         buf.put_u16(self.begin_seq);
         buf.put_u16(self.end_seq);
@@ -220,7 +222,8 @@ impl Unmarshal for RLEReportBlock {
         }
 
         let is_loss_rle = xr_header.block_type == BlockType::LossRLE;
-        let t = raw_packet.get_u8();
+        let t = xr_header.type_specific & 0x0F;
+
         let ssrc = raw_packet.get_u32();
         let begin_seq = raw_packet.get_u16();
         let end_seq = raw_packet.get_u16();

src/extended_report/rrt.rs

@@ -1,6 +1,6 @@
 use super::*;
 
-const RRT_REPORT_BLOCK_MIN_LENGTH: u16 = 8;
+const RRT_REPORT_BLOCK_LENGTH: u16 = 8;
 
 /// ReceiverReferenceTimeReportBlock encodes a Receiver Reference Time
 /// report block as described in RFC 3611 section 4.4.
@@ -46,7 +46,7 @@ impl Packet for ReceiverReferenceTimeReportBlock {
     }
 
     fn raw_size(&self) -> usize {
-        XR_HEADER_LENGTH + RRT_REPORT_BLOCK_MIN_LENGTH as usize
+        XR_HEADER_LENGTH + RRT_REPORT_BLOCK_LENGTH as usize
     }
 
     fn as_any(&self) -> &(dyn Any + Send + Sync) {
@@ -99,7 +99,7 @@ impl Unmarshal for ReceiverReferenceTimeReportBlock {
 
         let xr_header = XRHeader::unmarshal(raw_packet)?;
 
-        if xr_header.block_length != RRT_REPORT_BLOCK_MIN_LENGTH
+        if xr_header.block_length != RRT_REPORT_BLOCK_LENGTH
             || raw_packet.remaining() < xr_header.block_length as usize
         {
             return Err(error::Error::PacketTooShort.into());

src/extended_report/ssr.rs

@@ -1,5 +1,7 @@
 use super::*;
 
+const SSR_REPORT_BLOCK_LENGTH: u16 = 4 + 2 * 2 + 4 * 6 + 4;
+
 /// StatisticsSummaryReportBlock encodes a Statistics Summary Report
 /// Block as described in RFC 3611, section 4.6.
 ///
@@ -28,11 +30,13 @@ use super::*;
 /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 #[derive(Debug, Default, PartialEq, Clone)]
 pub struct StatisticsSummaryReportBlock {
-    pub xr_header: XRHeader,
+    //not included in marshal/unmarshal
     pub loss_reports: bool,
     pub duplicate_reports: bool,
     pub jitter_reports: bool,
     pub ttl_or_hop_limit: TTLorHopLimitType,
+
+    //marshal/unmarshal
     pub ssrc: u32,
     pub begin_seq: u16,
     pub end_seq: u16,
@@ -90,49 +94,148 @@ impl fmt::Display for TTLorHopLimitType {
     }
 }
 
-impl ReportBlock for StatisticsSummaryReportBlock {
-    /// destination_ssrc returns an array of ssrc values that this report block refers to.
-    fn destination_ssrc(&self) -> Vec<u32> {
-        vec![self.ssrc]
-    }
-
-    fn setup_block_header(&mut self) {
-        self.xr_header.block_type = ReportBlockType::StatisticsSummary;
-        self.xr_header.type_specific = 0x00;
+impl StatisticsSummaryReportBlock {
+    pub fn xr_header(&self) -> XRHeader {
+        let mut type_specific = 0x00;
         if self.loss_reports {
-            self.xr_header.type_specific |= 0x80;
+            type_specific |= 0x80;
         }
         if self.duplicate_reports {
-            self.xr_header.type_specific |= 0x40;
+            type_specific |= 0x40;
         }
         if self.jitter_reports {
-            self.xr_header.type_specific |= 0x20;
+            type_specific |= 0x20;
+        }
+        type_specific |= (self.ttl_or_hop_limit as u8 & 0x03) << 3;
+
+        XRHeader {
+            block_type: BlockType::StatisticsSummary,
+            type_specific,
+            block_length: (self.raw_size() / 4 - 1) as u16,
         }
-        self.xr_header.type_specific |= (self.ttl_or_hop_limit as u8 & 0x03) << 3;
-        self.xr_header.block_length = (self.raw_size() / 4 - 1) as u16;
     }
+}
 
-    fn unpack_block_header(&mut self) {
-        self.loss_reports = self.xr_header.type_specific & 0x80 != 0;
-        self.duplicate_reports = self.xr_header.type_specific & 0x40 != 0;
-        self.jitter_reports = self.xr_header.type_specific & 0x20 != 0;
-        self.ttl_or_hop_limit = ((self.xr_header.type_specific & 0x18) >> 3).into();
+impl Packet for StatisticsSummaryReportBlock {
+    fn header(&self) -> Header {
+        Header::default()
+    }
+
+    /// destination_ssrc returns an array of ssrc values that this report block refers to.
+    fn destination_ssrc(&self) -> Vec<u32> {
+        vec![self.ssrc]
     }
 
     fn raw_size(&self) -> usize {
-        4 + 3 + 1 + 4 + 2 * 2 + 4 * 6 + 4
+        XR_HEADER_LENGTH + SSR_REPORT_BLOCK_LENGTH as usize
     }
 
     fn as_any(&self) -> &(dyn Any + Send + Sync) {
         self
     }
-    fn equal(&self, other: &(dyn ReportBlock + Send + Sync)) -> bool {
+    fn equal(&self, other: &(dyn Packet + Send + Sync)) -> bool {
         other
             .as_any()
             .downcast_ref::<StatisticsSummaryReportBlock>()
             .map_or(false, |a| self == a)
     }
-    fn cloned(&self) -> Box<dyn ReportBlock + Send + Sync> {
+    fn cloned(&self) -> Box<dyn Packet + Send + Sync> {
         Box::new(self.clone())
     }
 }
+
+impl MarshalSize for StatisticsSummaryReportBlock {
+    fn marshal_size(&self) -> usize {
+        self.raw_size()
+    }
+}
+
+impl Marshal for StatisticsSummaryReportBlock {
+    /// marshal_to encodes the StatisticsSummaryReportBlock in binary
+    fn marshal_to(&self, mut buf: &mut [u8]) -> Result<usize> {
+        if buf.remaining_mut() < self.marshal_size() {
+            return Err(error::Error::BufferTooShort.into());
+        }
+
+        let h = self.xr_header();
+        let n = h.marshal_to(buf)?;
+        buf = &mut buf[n..];
+
+        buf.put_u32(self.ssrc);
+        buf.put_u16(self.begin_seq);
+        buf.put_u16(self.end_seq);
+        buf.put_u32(self.lost_packets);
+        buf.put_u32(self.dup_packets);
+        buf.put_u32(self.min_jitter);
+        buf.put_u32(self.max_jitter);
+        buf.put_u32(self.mean_jitter);
+        buf.put_u32(self.dev_jitter);
+        buf.put_u8(self.min_ttl_or_hl);
+        buf.put_u8(self.max_ttl_or_hl);
+        buf.put_u8(self.mean_ttl_or_hl);
+        buf.put_u8(self.dev_ttl_or_hl);
+
+        Ok(self.marshal_size())
+    }
+}
+
+impl Unmarshal for StatisticsSummaryReportBlock {
+    /// Unmarshal decodes the StatisticsSummaryReportBlock from binary
+    fn unmarshal<B>(raw_packet: &mut B) -> Result<Self>
+    where
+        Self: Sized,
+        B: Buf,
+    {
+        if raw_packet.remaining() < XR_HEADER_LENGTH {
+            return Err(error::Error::PacketTooShort.into());
+        }
+
+        let xr_header = XRHeader::unmarshal(raw_packet)?;
+
+        if xr_header.block_length != SSR_REPORT_BLOCK_LENGTH
+            || raw_packet.remaining() < xr_header.block_length as usize
+        {
+            return Err(error::Error::PacketTooShort.into());
+        }
+
+        let loss_reports = xr_header.type_specific & 0x80 != 0;
+        let duplicate_reports = xr_header.type_specific & 0x40 != 0;
+        let jitter_reports = xr_header.type_specific & 0x20 != 0;
+        let ttl_or_hop_limit: TTLorHopLimitType = ((xr_header.type_specific & 0x18) >> 3).into();
+
+        let ssrc = raw_packet.get_u32();
+        let begin_seq = raw_packet.get_u16();
+        let end_seq = raw_packet.get_u16();
+        let lost_packets = raw_packet.get_u32();
+        let dup_packets = raw_packet.get_u32();
+        let min_jitter = raw_packet.get_u32();
+        let max_jitter = raw_packet.get_u32();
+        let mean_jitter = raw_packet.get_u32();
+        let dev_jitter = raw_packet.get_u32();
+        let min_ttl_or_hl = raw_packet.get_u8();
+        let max_ttl_or_hl = raw_packet.get_u8();
+        let mean_ttl_or_hl = raw_packet.get_u8();
+        let dev_ttl_or_hl = raw_packet.get_u8();
+
+        Ok(StatisticsSummaryReportBlock {
+            loss_reports,
+            duplicate_reports,
+            jitter_reports,
+            ttl_or_hop_limit,
+
+            ssrc,
+            begin_seq,
+            end_seq,
+            lost_packets,
+            dup_packets,
+            min_jitter,
+            max_jitter,
+            mean_jitter,
+            dev_jitter,
+            min_ttl_or_hl,
+            max_ttl_or_hl,
+            mean_ttl_or_hl,
+            dev_ttl_or_hl,
+        })
+    }
+}