implemented config as builder

Author: sum-catnip

src/config/config.rs

@@ -23,7 +23,7 @@ mod test {
 
     #[test]
     fn test_config_empty() {
-        let c = Config::<()>::new(&mut [0; 0]);
+        let c = ConfigBuilder::new(&mut [0; 0]).finish();
         assert_eq!(c.0.begin, c.0.end);
         assert_eq!(c.0.size, mem::size_of::<pt_config>());
     }
@@ -32,26 +32,26 @@ mod test {
     fn test_config_buf() {
         let mut data = [0; 16];
         let len = data.len();
-        let c = Config::<()>::new(&mut data);
+        let c = ConfigBuilder::new(&mut data).finish();
         assert_eq!(c.0.end as usize - c.0.begin as usize, len);
     }
 
     #[test]
     fn test_config_all() {
         let mut data = [18; 3];
-        let mut c = Config::new(&mut data);
-        c.set_cpu(Cpu::intel(1, 2, 3));
-        c.set_freq(Frequency::new(1, 2, 3, 4));
-        c.set_flags(BlockFlags::END_ON_CALL | BlockFlags::END_ON_JUMP);
-        let mut f = AddrFilter::new();
-        f.set_addr0(AddrRange::new(1, 2, AddrConfig::STOP));
-        f.set_addr1(AddrRange::new(3, 4, AddrConfig::FILTER));
-        f.set_addr2(AddrRange::new(5, 6, AddrConfig::DISABLED));
-        f.set_addr3(AddrRange::new(7, 8, AddrConfig::STOP));
-        c.set_filter(f);
-        c.set_callback(|c, p| {
-            (Unknown::new(c.0.cpu.model + p[0]), 1)
-        });
+        let c = ConfigBuilder::with_callback(
+            &mut data, |c, p| {
+                (Unknown::new(c.0.cpu.model + p[0]), 1) })
+            .filter(AddrFilterBuilder::new()
+                .addr0(AddrRange::new(1, 2, AddrConfig::STOP))
+                .addr1(AddrRange::new(3, 4, AddrConfig::FILTER))
+                .addr2(AddrRange::new(5, 6, AddrConfig::DISABLED))
+                .addr3(AddrRange::new(7, 8, AddrConfig::STOP))
+                .finish())
+            .cpu(Cpu::intel(1, 2, 3))
+            .freq(Frequency::new(1, 2, 3, 4))
+            .flags(BlockFlags::END_ON_CALL | BlockFlags::END_ON_JUMP)
+            .finish();
 
         assert_eq!(c.0.cpu.family, 1);
         assert_eq!(c.0.cpu.model, 2);
@@ -117,39 +117,46 @@ mod test {
     #[test]
     fn test_config_callback_safety() {
         let mut kektop = [10;9];
-        let mut cfg = Config::new(&mut kektop);
-        cfg.set_cpu(Cpu::intel(1, 2, 3));
-        cfg.set_callback(|c, p,| {
-            (Unknown::new(c.0.cpu.stepping + p[8]), 17)
-        });
+        let mut cfg = ConfigBuilder::with_callback(
+            &mut kektop,
+            |c, p,| { (Unknown::new(c.0.cpu.stepping + p[8]), 17) })
+        .cpu(Cpu::intel(1, 2, 3)).finish();
 
         for _ in 0..10 { assert!(check_callback(&mut cfg, 13, 17)) }
-        cfg.set_callback(|c, p| {
-            (Unknown::new(c.0.cpu.model + p[0]), 1)
-        });
-        for _ in 0..10 { assert!(check_callback(&mut cfg, 12, 1)) }
     }
 
     #[test]
     #[should_panic]
     fn test_config_callback_out_of_bounds() {
         let mut kektop = [10;9];
-        let mut cfg = Config::new(&mut kektop);
-        let raw: *const pt_config = cfg.0.as_ref();
-        cfg.set_cpu(Cpu::intel(1, 2, 3));
-        cfg.set_callback(|c, p,| {
+        let cfg = ConfigBuilder::with_callback(&mut kektop, |c, p,| {
             // make sure no move or copy is done
             if let Cow::Owned(_) = c.0 { panic!("BUG!") }
-            assert_eq!(c.0.as_ref() as *const _, raw);
+            // assert_eq!(c.0.as_ref() as *const _, raw);
             (Unknown::new(p[100]), 17)
-        });
+        }).cpu(Cpu::intel(1, 2, 3)).finish();
+
         unsafe {
             let mut ukn: pt_packet_unknown = std::mem::zeroed();
             cfg.0.decode.callback.unwrap()(&mut ukn,
                                            cfg.0.as_ref(), cfg.0.begin,
                                            cfg.0.decode.context);
         }
     }
+
+    #[test]
+    fn test_builder_buf_lifetimes() {
+        let mut x = [10; 10];
+        let a : Config<()>;
+        {
+            let mut c = ConfigBuilder::new(&mut x);
+            a = c.finish();
+            c.cpu(Cpu::intel(1, 2, 3));
+            let b = c.finish();
+            unsafe { assert_eq!(b.buffer(), [10; 10]) };
+        }
+        unsafe { assert_eq!(a.buffer(), [10; 10]) };
+    }
 }
 
 unsafe extern "C" fn decode_callback<'a, F, C>(ukn: *mut pt_packet_unknown,
@@ -175,68 +182,84 @@ unsafe extern "C" fn decode_callback<'a, F, C>(ukn: *mut pt_packet_unknown,
     bytes as i32
 }
 
-/// A libipt configuration
-pub struct Config<'a, C> (pub(crate) Cow<'a, pt_config>, PhantomData<C>);
-impl<'a, C> Config<'a, C> {
-    /// Initializes a Config instance with only a buffer.
-    ///
-    /// Chain this functions with the setter methods to provide the arguments you need
-    pub fn new(buf: &'a mut [u8]) -> Self {
+/// A helper type to create the libipt Configuration instance
+pub struct ConfigBuilder<'a, T> (pt_config, PhantomData<&'a mut T>);
+impl<'a, T> ConfigBuilder<'a, T> {
+    /// Initializes a Config instance with a buffer and decoder callback
+    pub fn with_callback<F>(buf: &'a mut [u8], mut cb: F) -> Self
+        where F: FnMut(&Config<T>, &[u8]) -> (Unknown<T>, u32),
+              F: 'a {
         let mut cfg: pt_config = unsafe { mem::zeroed() };
         cfg.size  = mem::size_of::<pt_config>();
         cfg.begin = buf.as_mut_ptr();
         cfg.end   = unsafe { buf.as_mut_ptr().offset(buf.len() as isize) };
-        Config::<C>(Cow::Owned(cfg), PhantomData)
-    }
-
-    #[inline]
-    fn ensure_owned(&mut self) -> &mut pt_config {
-        match &mut self.0 {
-            Cow::Borrowed(_) => unreachable!(),
-            Cow::Owned(c) => c
-        }
+        cfg.decode.callback = Some(decode_callback::<F, T>);
+        cfg.decode.context  = &mut cb as *mut _ as *mut c_void;
+        ConfigBuilder::<T>(cfg, PhantomData)
     }
 
     /// The cpu used for capturing the data.
     /// It's highly recommended to provide this information.
     /// Processor specific workarounds will be identified this way.
-    #[inline]
-    pub fn set_cpu(&mut self, cpu: Cpu) {
-        let c = self.ensure_owned();
-        c.cpu = cpu.0;
-        c.errata = cpu.determine_errata();
+    pub fn cpu(&mut self, cpu: Cpu) -> &mut Self {
+        self.0.cpu = cpu.0;
+        self.0.errata = cpu.determine_errata();
+
+        self
     }
 
     /// Frequency values used for timing packets (mtc)
-    #[inline]
-    pub fn set_freq(&mut self, freq: Frequency) {
-        let c = self.ensure_owned();
-        c.mtc_freq = freq.mtc;
-        c.nom_freq = freq.nom;
-        c.cpuid_0x15_eax = freq.tsc;
-        c.cpuid_0x15_ebx = freq.ctc;
+    pub fn freq(&mut self, freq: Frequency) -> &mut Self {
+        self.0.mtc_freq = freq.mtc;
+        self.0.nom_freq = freq.nom;
+        self.0.cpuid_0x15_eax = freq.tsc;
+        self.0.cpuid_0x15_ebx = freq.ctc;
+
+        self
     }
 
     /// Decoder specific flags
-    #[inline]
-    pub fn set_flags(&mut self, flags: impl Into<pt_conf_flags>) {
-        self.ensure_owned().flags = flags.into()
+    pub fn flags(&mut self, flags: impl Into<pt_conf_flags>) -> &mut Self {
+        self.0.flags = flags.into();
+        self
     }
 
     /// Address filter configuration
-    #[inline]
-    pub fn set_filter(&mut self, filter: AddrFilter) {
-        self.ensure_owned().addr_filter = filter.0
+    pub fn filter(&mut self, filter: AddrFilter) -> &mut Self {
+        self.0.addr_filter = filter.0;
+        self
     }
 
-    /// A callback for decoding unknown packets
-    #[inline]
-    pub fn set_callback<'b, F>(&mut self, mut cb: F)
-        where F: FnMut(&Config<C>, &[u8]) -> (Unknown<C>, u32),
-              F: 'a {
-        let c = self.ensure_owned();
-        c.decode.callback = Some(decode_callback::<F, C>);
-        c.decode.context  = &mut cb as *mut _ as *mut c_void;
+    /// turn itself into a new `Config`
+    pub fn finish(&self) -> Config<'a, T> {
+        Config(Cow::Owned(self.0), self.1)
+    }
+}
+
+impl<'a> ConfigBuilder<'a, ()> {
+    /// Initializes a Config instance with only a buffer.
+    /// If you want to use a decoder callback,
+    /// use the `with_callback` function
+    pub fn new(buf: &'a mut [u8]) -> ConfigBuilder<()> {
+        let mut cfg: pt_config = unsafe { mem::zeroed() };
+        cfg.size  = mem::size_of::<pt_config>();
+        cfg.begin = buf.as_mut_ptr();
+        cfg.end   = unsafe { buf.as_mut_ptr().offset(buf.len() as isize) };
+        ConfigBuilder::<()>(cfg, PhantomData)
+    }
+}
+
+/// A libipt configuration
+pub struct Config<'a, C> (pub(crate) Cow<'a, pt_config>, PhantomData<&'a mut C>);
+impl<'a, C> Config<'a, C> {
+    /// Gets this configs buffer.
+    /// This operation is unsafe because an encoder might write into the buffer
+    /// at any time
+    pub unsafe fn buffer(&self) -> &'a [u8] {
+        std::slice::from_raw_parts(
+            self.0.begin,
+            self.0.end as usize - self.0.begin as usize
+        )
     }
 }