Add udp::unicast() and udp::broadcast()

udp::broadcast() is not yet super useful since there's no way to set the
source ethernet address if source IP address isn't set

Author: giannitedesco

examples/dhcp.rsyn

@@ -2,17 +2,14 @@ import ipv4;
 import dhcp;
 import arp;
 
-let client = 192.168.238.112;
-let server = 142.250.207.36;
-
-let dhcp = ipv4::udp::flow(
-  client/dhcp::CLIENT_PORT,
-  server/dhcp::SERVER_PORT,
-);
+let client = 192.168.238.112/dhcp::CLIENT_PORT;
+let server = 142.250.207.36/dhcp::SERVER_PORT;
 
 # There is a low-level DNS API which you can use to construct exact queries,
 # and even malformed queries
-dhcp.client_dgram(
+ipv4::udp::broadcast(
+  src: 0.0.0.0/dhcp::CLIENT_PORT,
+  dst: 255.255.255.255/dhcp::SERVER_PORT,
   dhcp::hdr(
     opcode: dhcp::opcode::REQUEST,
     xid: 0xdeadbeef,
@@ -45,7 +42,9 @@ dhcp.client_dgram(
   dhcp::opt::END,
 );
 
-dhcp.server_dgram(
+ipv4::udp::unicast(
+  src: server,
+  dst: client,
   dhcp::hdr(
     opcode: dhcp::opcode::REPLY,
     xid: 0xdeadbeef,

ezpkt/src/udp4.rs

@@ -18,6 +18,7 @@ const UDP_DGRAM_OVERHEAD: usize =
 /// Helper for creating UDP datagrams
 pub struct UdpDgram {
     pkt: Packet,
+    eth: Hdr<eth_hdr>,
     ip: Hdr<ip_hdr>,
     udp: Hdr<udp_hdr>,
     tot_len: usize,
@@ -26,31 +27,25 @@ pub struct UdpDgram {
 
 impl UdpDgram {
     #[must_use]
-    pub fn with_capacity(src: SocketAddrV4, dst: SocketAddrV4, payload_sz: usize) -> Self {
+    pub fn with_capacity(payload_sz: usize) -> Self {
         let mut pkt = Packet::with_capacity(UDP_DGRAM_OVERHEAD + payload_sz);
 
         let eth: Hdr<eth_hdr> = pkt.push_hdr();
         pkt.get_mut_hdr(&eth)
-            .dst_from_ip(*dst.ip())
-            .src_from_ip(*src.ip())
             .proto(0x0800);
 
         let ip: Hdr<ip_hdr> = pkt.push_hdr();
         pkt.get_mut_hdr(&ip)
             .init()
-            .protocol(17)
-            .saddr(*src.ip())
-            .daddr(*dst.ip());
+            .protocol(17);
 
         let udp: Hdr<udp_hdr> = pkt.push_hdr();
-        pkt.get_mut_hdr(&udp)
-            .sport(src.port())
-            .dport(dst.port());
 
         let tot_len = ip.len() + udp.len();
 
         let ret = Self {
             pkt,
+            eth,
             ip,
             udp,
             tot_len,
@@ -61,15 +56,38 @@ impl UdpDgram {
     }
 
     #[must_use]
-    pub fn new(src: SocketAddrV4, dst: SocketAddrV4) -> Self {
-        Self::with_capacity(src, dst, 0)
+    pub fn new() -> Self {
+        Self::with_capacity(0)
     }
 
     #[must_use]
-    pub fn push(mut self, bytes: &[u8]) -> Self {
-        self.pkt.push_bytes(bytes);
-        self.tot_len += bytes.len();
-        self.dgram_len += bytes.len();
+    pub fn src(mut self, src: SocketAddrV4) -> Self {
+        self.pkt.get_mut_hdr(&self.eth).src_from_ip(*src.ip());
+        self.pkt.get_mut_hdr(&self.ip).saddr(*src.ip());
+        self.pkt.get_mut_hdr(&self.udp).sport(src.port());
+        self
+    }
+
+    #[must_use]
+    pub fn dst(mut self, dst: SocketAddrV4) -> Self {
+        self.pkt.get_mut_hdr(&self.eth).dst_from_ip(*dst.ip());
+        self.pkt.get_mut_hdr(&self.ip).daddr(*dst.ip());
+        self.pkt.get_mut_hdr(&self.udp).dport(dst.port());
+        self
+    }
+
+    #[must_use]
+    pub fn broadcast(mut self) -> Self {
+        self.pkt.get_mut_hdr(&self.eth).broadcast();
+        self
+    }
+
+    #[must_use]
+    pub fn push<T: AsRef<[u8]>>(mut self, bytes: T) -> Self {
+        let buf = bytes.as_ref();
+        self.pkt.push_bytes(buf);
+        self.tot_len += buf.len();
+        self.dgram_len += buf.len();
         self.update_tot_len().update_dgram_len()
     }
 
@@ -88,8 +106,14 @@ impl UdpDgram {
     }
 }
 
+impl Default for UdpDgram {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl From<UdpDgram> for Packet {
-    fn from(seg: UdpDgram) -> Self{
+    fn from(seg: UdpDgram) -> Self {
         seg.pkt
     }
 }
@@ -104,11 +128,11 @@ impl UdpFlow {
     }
 
     fn clnt(&self) -> UdpDgram {
-        UdpDgram::new(self.cl, self.sv)
+        UdpDgram::new().src(self.cl).dst(self.sv)
     }
 
     fn srvr(&self) -> UdpDgram {
-        UdpDgram::new(self.sv, self.cl)
+        UdpDgram::new().src(self.sv).dst(self.cl)
     }
 
     pub fn client_dgram(&mut self, bytes: &[u8]) -> Packet {

ezpkt/src/vxlan.rs

@@ -18,13 +18,10 @@ pub struct VxlanDgram {
 impl VxlanDgram {
     fn new(src: SocketAddrV4, dst: SocketAddrV4, vni: u32) -> Self {
         Self {
-            outer: UdpDgram::with_capacity(
-                src,
-                dst,
-                std::mem::size_of::<vxlan_hdr>(),
-            ).push(
-                vxlan_hdr::with_vni(vni).as_bytes()
-            ),
+            outer: UdpDgram::with_capacity(std::mem::size_of::<vxlan_hdr>())
+                .src(src)
+                .dst(dst)
+                .push(vxlan_hdr::with_vni(vni).as_bytes()),
         }
     }
 

pkt/src/eth.rs

@@ -14,6 +14,8 @@ pub struct eth_hdr {
     pub proto: u16,
 }
 
+pub const BROADCAST: [u8; 6] = [0xff, 0xff, 0xff, 0xff, 0xff, 0xff];
+
 impl eth_hdr {
     pub fn dst_from_ip(&mut self, addr: Ipv4Addr) -> &mut Self {
         let ip = addr.octets();
@@ -31,4 +33,9 @@ impl eth_hdr {
         self.proto = proto.to_be();
         self
     }
+
+    pub fn broadcast(&mut self) -> &mut Self {
+        self.dst.octets = BROADCAST;
+        self
+    }
 }

src/stdlib/ipv4/udp.rs

@@ -1,13 +1,62 @@
 use phf::{phf_map, phf_ordered_map};
 
+use pkt::Packet;
+use ezpkt::{UdpDgram, UdpFlow};
+
 use crate::val::{ValType, Val};
 use crate::str::Buf;
 use crate::libapi::{FuncDef, ArgDecl, Class};
 use crate::sym::Symbol;
-use ezpkt::UdpFlow;
 use crate::func_def;
 
-const UDP_CL_DGRAM: FuncDef = func_def!(
+const BROADCAST: FuncDef = func_def!(
+    "ipv4::udp::broadcast";
+    ValType::Pkt;
+
+    "src" => ValType::Sock4,
+    "dst" => ValType::Sock4,
+    =>
+    =>
+    ValType::Str;
+
+    |mut args| {
+        let src = args.next();
+        let dst = args.next();
+        let buf: Buf = args.join_extra(b"").into();
+        let dgram: Packet = UdpDgram::with_capacity(buf.len())
+            .src(src.into())
+            .dst(dst.into())
+            .broadcast()
+            .push(buf)
+            .into();
+        Ok(dgram.into())
+    }
+);
+
+const UNICAST: FuncDef = func_def!(
+    "ipv4::udp::unicast";
+    ValType::Pkt;
+
+    "src" => ValType::Sock4,
+    "dst" => ValType::Sock4,
+    =>
+    =>
+    ValType::Str;
+
+    |mut args| {
+        let src = args.next();
+        let dst = args.next();
+        let buf: Buf = args.join_extra(b"").into();
+        let dgram: Packet = UdpDgram::with_capacity(buf.len())
+            .src(src.into())
+            .dst(dst.into())
+            .push(buf)
+            .into();
+        Ok(dgram.into())
+    }
+);
+
+const CL_DGRAM: FuncDef = func_def!(
     "ipv4::udp::flow.client_dgram";
     ValType::Pkt;
 
@@ -24,7 +73,7 @@ const UDP_CL_DGRAM: FuncDef = func_def!(
     }
 );
 
-const UDP_SV_DGRAM: FuncDef = func_def!(
+const SV_DGRAM: FuncDef = func_def!(
     "ipv4::udp::flow.server_dgram";
     ValType::Pkt;
 
@@ -44,8 +93,8 @@ const UDP_SV_DGRAM: FuncDef = func_def!(
 impl Class for UdpFlow {
     fn symbols(&self) -> phf::Map<&'static str, Symbol> {
         phf_map! {
-            "client_dgram" => Symbol::Func(&UDP_CL_DGRAM),
-            "server_dgram" => Symbol::Func(&UDP_SV_DGRAM),
+            "client_dgram" => Symbol::Func(&CL_DGRAM),
+            "server_dgram" => Symbol::Func(&SV_DGRAM),
         }
     }
 
@@ -54,7 +103,7 @@ impl Class for UdpFlow {
     }
 }
 
-const UDP_FLOW: FuncDef = func_def!(
+const FLOW: FuncDef = func_def!(
     "flow";
     ValType::Obj;
 
@@ -72,6 +121,8 @@ const UDP_FLOW: FuncDef = func_def!(
 );
 
 pub const UDP4: phf::Map<&'static str, Symbol> = phf_map! {
-    "flow" => Symbol::Func(&UDP_FLOW),
+    "flow" => Symbol::Func(&FLOW),
+    "broadcast" => Symbol::Func(&BROADCAST),
+    "unicast" => Symbol::Func(&UNICAST),
 };