Allow frag to create raw packets

Author: gtedesco-r7

docs/ipv4/IpFrag.md

@@ -13,17 +13,22 @@
 ## datagram
 ```resynth
 resynth fn datagram (
+    raw: bool = false,
     =>
     *collect_args: bytes,
 ) -> Pkt;
 ```
  Return the entire datagram without fragmenting it
 
+ ### Arguments
+ * 'raw' If true, then omit ethernet header
+
 ## fragment
 ```resynth
 resynth fn fragment (
     frag_off: u16,
     len: u16,
+    raw: bool = false,
     =>
     *collect_args: bytes,
 ) -> Pkt;
@@ -33,11 +38,13 @@ resynth fn fragment (
  ### Arguments
  * `frag_off` Offset in 8-byte blocks
  * `len` Length in bytes
+ * 'raw' If true, then omit ethernet header
 
 ## tail
 ```resynth
 resynth fn tail (
     frag_off: u16,
+    raw: bool = false,
     =>
     *collect_args: bytes,
 ) -> Pkt;
@@ -47,3 +54,4 @@ resynth fn tail (
 
  ### Arguments
  * `frag_off` Offset in 8-byte blocks
+ * 'raw' If true, then omit ethernet header

ezpkt/src/ip4.rs

@@ -15,14 +15,16 @@ pub struct IpDgram {
 
 impl IpDgram {
     #[must_use]
-    pub fn new(mut iph: ip_hdr, payload: &[u8]) -> Self {
+    pub fn new(mut iph: ip_hdr, payload: &[u8], raw: bool) -> Self {
         let pkt = Packet::with_capacity(IP_DGRAM_OVERHEAD + payload.len());
 
-        pkt.push(eth_hdr::new(
-            iph.get_saddr().into(),
-            iph.get_saddr().into(),
-            ethertype::IPV4,
-        ));
+        if !raw {
+            pkt.push(eth_hdr::new(
+                iph.get_saddr().into(),
+                iph.get_saddr().into(),
+                ethertype::IPV4,
+            ));
+        }
 
         iph.set_tot_len(payload.len() as u16 + IPH_LEN as u16);
 
@@ -64,26 +66,26 @@ impl IpFrag {
     }
 
     /// Offset is in 8-byte blocks, len is in bytes
-    pub fn fragment(&self, off: u16, len: u16) -> Packet {
+    pub fn fragment(&self, off: u16, len: u16, raw: bool) -> Packet {
         let byte_off = (off as usize) << 3;
         let byte_len = (len as usize) << 3;
         let byte_end = byte_off + byte_len;
         let end = min(byte_end, self.payload.len());
         let content = &self.payload[byte_off..end];
 
-        IpDgram::new(self.hdr, content)
+        IpDgram::new(self.hdr, content, raw)
             .frag(off, end != self.payload.len())
             .into()
     }
 
     /// Offset is in 8-byte blocks, include all bytes until the end
-    pub fn tail(&self, off: u16) -> Packet {
-        self.fragment(off, self.payload.len() as u16)
+    pub fn tail(&self, off: u16, raw: bool) -> Packet {
+        self.fragment(off, self.payload.len() as u16, raw)
     }
 
     /// The whole payload in one unfragmented datagram
-    pub fn datagram(&self) -> Packet {
-        IpDgram::new(self.hdr, &self.payload[..])
+    pub fn datagram(&self, raw: bool) -> Packet {
+        IpDgram::new(self.hdr, &self.payload[..], raw)
             .frag(0, false)
             .into()
     }

src/stdlib/ipv4/mod.rs

@@ -99,10 +99,12 @@ const FRAG_FRAGMENT: FuncDef = func!(
     /// ### Arguments
     /// * `frag_off` Offset in 8-byte blocks
     /// * `len` Length in bytes
+    /// * 'raw' If true, then omit ethernet header
     resynth fn fragment(
         frag_off: U16,
         len: U16,
         =>
+        raw: Bool = false,
         =>
         Str
     ) -> Pkt
@@ -113,8 +115,9 @@ const FRAG_FRAGMENT: FuncDef = func!(
 
         let frag_off: u16 = args.next().into();
         let len: u16 = args.next().into();
+        let raw: bool = args.next().into();
 
-        Ok(this.fragment(frag_off, len).into())
+        Ok(this.fragment(frag_off, len, raw).into())
     }
 );
 
@@ -124,9 +127,11 @@ const FRAG_TAIL: FuncDef = func!(
     ///
     /// ### Arguments
     /// * `frag_off` Offset in 8-byte blocks
+    /// * 'raw' If true, then omit ethernet header
     resynth fn tail(
         frag_off: U16,
         =>
+        raw: Bool = false,
         =>
         Str
     ) -> Pkt
@@ -136,24 +141,30 @@ const FRAG_TAIL: FuncDef = func!(
         let this: &mut IpFrag = r.as_mut_any().downcast_mut().unwrap();
 
         let frag_off: u16 = args.next().into();
+        let raw: bool = args.next().into();
 
-        Ok(this.tail(frag_off).into())
+        Ok(this.tail(frag_off, raw).into())
     }
 );
 
 const FRAG_DATAGRAM: FuncDef = func!(
     /// Return the entire datagram without fragmenting it
+    ///
+    /// ### Arguments
+    /// * 'raw' If true, then omit ethernet header
     resynth fn datagram(
         =>
+        raw: Bool = false,
         =>
         Str
     ) -> Pkt
     |mut args| {
         let obj = args.take_this();
         let mut r = obj.borrow_mut();
         let this: &mut IpFrag = r.as_mut_any().downcast_mut().unwrap();
+        let raw: bool = args.next().into();
 
-        Ok(this.datagram().into())
+        Ok(this.datagram(raw).into())
     }
 );