1 files changed, 214 insertions, 0 deletions

diff --git a/src/dhcp.rs b/src/dhcp.rs
new file mode 100644
index 0000000..b53ee92
--- /dev/null
+++ b/src/dhcp.rs
@@ -0,0 +1,214 @@
+use std::{
+    io::{Result, Write},
+    net::Ipv4Addr,
+};
+
+use crate::wire;
+
+const MAGIC_COOKIE: [u8; 4] = [0x63, 0x82, 0x53, 0x63];
+
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum BootOp {
+    #[default]
+    Request,
+    Reply,
+}
+
+impl BootOp {
+    pub const OP_REQUEST: u8 = 1;
+    pub const OP_REPLY: u8 = 2;
+}
+
+impl From<BootOp> for u8 {
+    fn from(value: BootOp) -> Self {
+        match value {
+            BootOp::Request => BootOp::OP_REQUEST,
+            BootOp::Reply => BootOp::OP_REPLY,
+        }
+    }
+}
+
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum HardwareType {
+    #[default]
+    Ethernet,
+}
+
+impl HardwareType {
+    pub const TYPE_ETHER: u8 = 1;
+    pub const LEN_ETHER: u8 = 6;
+
+    pub fn hardware_len(&self) -> u8 {
+        match self {
+            HardwareType::Ethernet => Self::LEN_ETHER,
+        }
+    }
+}
+
+impl From<HardwareType> for u8 {
+    fn from(value: HardwareType) -> Self {
+        match value {
+            HardwareType::Ethernet => HardwareType::TYPE_ETHER,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum DhcpMessageType {
+    Ack,
+}
+
+impl DhcpMessageType {
+    pub const CODE_ACK: u8 = 5;
+
+    pub fn code(&self) -> u8 {
+        match self {
+            DhcpMessageType::Ack => Self::CODE_ACK,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum DhcpOption {
+    Pad,
+    End,
+    MessageType(DhcpMessageType),
+    ServerIdentifier(Ipv4Addr),
+    VendorClassIdentifier(String),
+    TftpServerName(String),
+    TftpFileName(String),
+    UserClassInformation(String),
+    ClientMachineIdentifier(String),
+    Unknown { code: u8, data: Vec<u8> },
+}
+
+impl DhcpOption {
+    pub const CODE_PAD: u8 = 0;
+    pub const CODE_END: u8 = 255;
+    pub const CODE_DHCP_MESSAGE_TYPE: u8 = 53;
+    pub const CODE_DHCP_SERVER_IDENTIFIER: u8 = 54;
+    pub const CODE_VENDOR_CLASS_IDENTIFIER: u8 = 60;
+    pub const CODE_TFTP_SERVER_NAME: u8 = 66;
+    pub const CODE_TFTP_FILE_NAME: u8 = 67;
+    pub const CODE_USER_CLASS_INFORMATION: u8 = 77;
+    pub const CODE_CLIENT_MACHINE_IDENTIFIER: u8 = 97;
+
+    pub fn code(&self) -> u8 {
+        match self {
+            DhcpOption::Pad => Self::CODE_PAD,
+            DhcpOption::End => Self::CODE_END,
+            DhcpOption::MessageType(_) => Self::CODE_DHCP_MESSAGE_TYPE,
+            DhcpOption::ServerIdentifier(_) => Self::CODE_DHCP_SERVER_IDENTIFIER,
+            DhcpOption::VendorClassIdentifier(_) => Self::CODE_VENDOR_CLASS_IDENTIFIER,
+            DhcpOption::TftpServerName(_) => Self::CODE_TFTP_SERVER_NAME,
+            DhcpOption::TftpFileName(_) => Self::CODE_TFTP_FILE_NAME,
+            DhcpOption::UserClassInformation(_) => Self::CODE_USER_CLASS_INFORMATION,
+            DhcpOption::ClientMachineIdentifier(_) => Self::CODE_CLIENT_MACHINE_IDENTIFIER,
+            DhcpOption::Unknown { code, .. } => *code,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct DhcpPacket {
+    pub op: BootOp,
+    pub htype: HardwareType,
+    pub xid: u32,
+    pub secs: u16,
+    pub flags: u16,
+    pub ciaddr: Ipv4Addr,
+    pub yiaddr: Ipv4Addr,
+    pub siaddr: Ipv4Addr,
+    pub giaddr: Ipv4Addr,
+    pub chaddr: [u8; 16],
+    // server host name
+    pub sname: Option<String>,
+    // boot file name
+    pub file: Option<String>,
+    pub options: Vec<DhcpOption>,
+}
+
+impl Default for DhcpPacket {
+    fn default() -> Self {
+        Self {
+            op: Default::default(),
+            htype: Default::default(),
+            xid: Default::default(),
+            secs: Default::default(),
+            flags: Default::default(),
+            ciaddr: Ipv4Addr::UNSPECIFIED,
+            yiaddr: Ipv4Addr::UNSPECIFIED,
+            siaddr: Ipv4Addr::UNSPECIFIED,
+            giaddr: Ipv4Addr::UNSPECIFIED,
+            chaddr: Default::default(),
+            sname: Default::default(),
+            file: Default::default(),
+            options: Default::default(),
+        }
+    }
+}
+
+pub fn write_packet<W: Write>(mut writer: W, packet: &DhcpPacket) -> Result<()> {
+    wire::write_u8(&mut writer, u8::from(packet.op))?;
+    wire::write_u8(&mut writer, u8::from(packet.htype))?;
+    wire::write_u8(&mut writer, packet.htype.hardware_len())?;
+    wire::write_u8(&mut writer, 0)?; // hops
+    wire::write_u32(&mut writer, packet.xid)?;
+    wire::write_u16(&mut writer, packet.secs)?;
+    wire::write_u16(&mut writer, packet.flags)?;
+    wire::write_ipv4(&mut writer, packet.ciaddr)?;
+    wire::write_ipv4(&mut writer, packet.yiaddr)?;
+    wire::write_ipv4(&mut writer, packet.siaddr)?;
+    wire::write_ipv4(&mut writer, packet.giaddr)?;
+    wire::write(&mut writer, &packet.chaddr)?;
+    match &packet.sname {
+        Some(name) => wire::write_null_terminated_string(&mut writer, &name)?,
+        None => wire::write_null_terminated_string(&mut writer, "")?,
+    };
+    match &packet.file {
+        Some(name) => wire::write_null_terminated_string(&mut writer, &name)?,
+        None => wire::write_null_terminated_string(&mut writer, "")?,
+    };
+    wire::write(&mut writer, &MAGIC_COOKIE)?;
+    for option in &packet.options {
+        write_option(&mut writer, option)?;
+    }
+    write_option(&mut writer, &DhcpOption::End)?;
+    Ok(())
+}
+
+pub fn write_option<W: Write>(mut writer: W, option: &DhcpOption) -> Result<()> {
+    wire::write_u8(&mut writer, option.code())?;
+    match option {
+        DhcpOption::Pad | DhcpOption::End => {}
+        DhcpOption::MessageType(t) => {
+            wire::write_u8(&mut writer, 1)?;
+            wire::write_u8(&mut writer, t.code())?;
+        }
+        DhcpOption::ServerIdentifier(ip) => {
+            wire::write_u8(&mut writer, 4)?;
+            wire::write_ipv4(&mut writer, *ip)?;
+        }
+        DhcpOption::VendorClassIdentifier(vendor_class) => {
+            write_option_len_prefixed_string(&mut writer, &vendor_class)?
+        }
+        DhcpOption::TftpServerName(name) => write_option_len_prefixed_string(&mut writer, &name)?,
+        DhcpOption::TftpFileName(name) => write_option_len_prefixed_string(&mut writer, &name)?,
+        DhcpOption::UserClassInformation(user_class) => {
+            write_option_len_prefixed_string(&mut writer, &user_class)?
+        }
+        DhcpOption::ClientMachineIdentifier(identifier) => {
+            write_option_len_prefixed_string(&mut writer, &identifier)?
+        }
+        DhcpOption::Unknown { data, .. } => {
+            wire::write_u8(&mut writer, u8::try_from(data.len()).unwrap())?;
+            wire::write(&mut writer, &data)?;
+        }
+    }
+    Ok(())
+}
+
+fn write_option_len_prefixed_string<W: Write>(mut writer: W, s: &str) -> Result<()> {
+    wire::write_u8(&mut writer, u8::try_from(s.len()).unwrap())?;
+    wire::write(&mut writer, s.as_bytes())
+}