path: root/src/main.rs

#![feature(cursor_split)]
pub mod dhcp;
pub mod tftp;
pub mod wire;

use std::io::{BufRead, Cursor, Read, Result, Write};
use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4, UdpSocket};

const FLAG_BROADCAST: u16 = 1 << 15;

const OPTION_CODE_PAD: u8 = 0;
const OPTION_CODE_END: u8 = 255;
const OPTION_CODE_VENDOR_CLASS_IDENTIFIER: u8 = 60;
const OPTION_CODE_USER_CLASS_INFORMATION: u8 = 77;

const MAGIC_COOKIE: [u8; 4] = [0x63, 0x82, 0x53, 0x63];

//const BOOT_FILE_NAME: &[u8] = b"pxelinux.0";
//const BOOT_FILE_NAME: &[u8] = b"debian-installer/amd64/bootnetx64.efi";
const BOOT_FILE_NAME: &[u8] = b"ipxe.efi";
const BOOT_FILE_NAME_IPXE: &[u8] = b"test.ipxe";

const LOCAL_IPV4: Ipv4Addr = Ipv4Addr::new(192, 168, 1, 100);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
enum BootOp {
    Request,
    Reply,
}

impl BootOp {
    pub const OP_REQUEST: u8 = 1;
    pub const OP_REPLY: u8 = 2;
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
enum HardwareType {
    Ethernet,
}

impl HardwareType {
    pub const TYPE_ETHER: u8 = 1;
    pub const LEN_ETHER: u8 = 6;
}

#[derive(Debug, Clone)]
enum DhcpOption {
    Pad,
    End,
    VendorClassIdentifier(String),
    UserClassInformation(String),
    Unknown { code: u8, data: Vec<u8> },
}

#[derive(Debug)]
struct DhcpPacket {
    op: BootOp,
    htype: HardwareType,
    hlen: u8,
    hops: u8, // should be zero
    xid: u32,
    secs: u16,
    flags: u16,
    ciaddr: Ipv4Addr,
    yiaddr: Ipv4Addr,
    siaddr: Ipv4Addr,
    giaddr: Ipv4Addr,
    chaddr: [u8; 16],
    sname: [u8; 64],
    file: [u8; 128],
    options: Vec<DhcpOption>,
}

fn read_u8(cursor: &mut Cursor<&[u8]>) -> Result<u8> {
    let mut buf = [0u8; 1];
    cursor.read_exact(&mut buf)?;
    Ok(buf[0])
}

fn read_u16(cursor: &mut Cursor<&[u8]>) -> Result<u16> {
    let mut buf = [0u8; 2];
    cursor.read_exact(&mut buf)?;
    Ok(u16::from_be_bytes(buf))
}

fn read_u32(cursor: &mut Cursor<&[u8]>) -> Result<u32> {
    let mut buf = [0u8; 4];
    cursor.read_exact(&mut buf)?;
    Ok(u32::from_be_bytes(buf))
}

fn read_arr<const N: usize>(cursor: &mut Cursor<&[u8]>) -> Result<[u8; N]> {
    let mut buf = [0u8; N];
    cursor.read_exact(&mut buf)?;
    Ok(buf)
}

fn read_null_terminated_vec(cursor: &mut Cursor<&[u8]>) -> Result<Vec<u8>> {
    let mut buf = Vec::default();
    cursor.read_until(0, &mut buf)?;
    buf.pop();
    Ok(buf)
}

fn read_null_terminated_string(cursor: &mut Cursor<&[u8]>) -> Result<String> {
    let buf = read_null_terminated_vec(cursor)?;
    Ok(String::from_utf8(buf).unwrap())
}

fn read_len8_prefixed_vec(cursor: &mut Cursor<&[u8]>) -> Result<Vec<u8>> {
    let len = read_u8(cursor)?;
    let mut buf = vec![0u8; len as usize];
    cursor.read_exact(&mut buf)?;
    Ok(buf)
}

fn read_len8_prefixed_string(cursor: &mut Cursor<&[u8]>) -> Result<String> {
    let buf = read_len8_prefixed_vec(cursor)?;
    Ok(String::from_utf8(buf).unwrap())
}

fn read_ipv4(cursor: &mut Cursor<&[u8]>) -> Result<Ipv4Addr> {
    Ok(Ipv4Addr::from_octets(read_arr(cursor)?))
}

fn read_op(cursor: &mut Cursor<&[u8]>) -> Result<BootOp> {
    let v = read_u8(cursor)?;
    match v {
        BootOp::OP_REQUEST => Ok(BootOp::Request),
        BootOp::OP_REPLY => Ok(BootOp::Reply),
        _ => Err(std::io::Error::new(
            std::io::ErrorKind::InvalidData,
            "invalid boot op",
        )),
    }
}

fn read_htype(cursor: &mut Cursor<&[u8]>) -> Result<HardwareType> {
    match read_u8(cursor)? {
        HardwareType::TYPE_ETHER => Ok(HardwareType::Ethernet),
        _ => Err(std::io::Error::new(
            std::io::ErrorKind::InvalidData,
            "invalid hardware type",
        )),
    }
}

fn read_option(cursor: &mut Cursor<&[u8]>) -> Result<DhcpOption> {
    let code = read_u8(cursor)?;
    Ok(match code {
        OPTION_CODE_PAD => DhcpOption::Pad,
        OPTION_CODE_END => DhcpOption::End,
        OPTION_CODE_VENDOR_CLASS_IDENTIFIER => {
            DhcpOption::VendorClassIdentifier(read_len8_prefixed_string(cursor)?)
        }
        OPTION_CODE_USER_CLASS_INFORMATION => {
            DhcpOption::UserClassInformation(read_len8_prefixed_string(cursor)?)
        }
        _ => {
            let len = read_u8(cursor)?;
            let mut data = vec![0u8; usize::from(len)];
            cursor.read_exact(&mut data)?;
            DhcpOption::Unknown { code, data }
        }
    })
}

fn parse_packet(buf: &[u8]) -> Result<DhcpPacket> {
    let mut cursor = Cursor::new(buf);
    let mut packet = DhcpPacket {
        op: read_op(&mut cursor)?,
        htype: read_htype(&mut cursor)?,
        hlen: read_u8(&mut cursor)?,
        hops: read_u8(&mut cursor)?,
        xid: read_u32(&mut cursor)?,
        secs: read_u16(&mut cursor)?,
        flags: read_u16(&mut cursor)?,
        ciaddr: read_ipv4(&mut cursor)?,
        yiaddr: read_ipv4(&mut cursor)?,
        siaddr: read_ipv4(&mut cursor)?,
        giaddr: read_ipv4(&mut cursor)?,
        chaddr: read_arr(&mut cursor)?,
        sname: read_arr(&mut cursor)?,
        file: read_arr(&mut cursor)?,
        options: Default::default(),
    };

    let magic = read_arr::<4>(&mut cursor)?;
    assert_eq!(magic, MAGIC_COOKIE);

    while cursor.position() < buf.len() as u64 {
        let option = read_option(&mut cursor)?;
        packet.options.push(option);
    }

    Ok(packet)
}

fn write_buf(writer: &mut Vec<u8>, buf: &[u8]) -> Result<()> {
    writer.write_all(buf)
}

fn write_u8(writer: &mut Vec<u8>, v: u8) -> Result<()> {
    write_buf(writer, &[v])
}

fn write_u16(writer: &mut Vec<u8>, v: u16) -> Result<()> {
    let buf = u16::to_be_bytes(v);
    write_buf(writer, &buf)
}

fn write_u32(writer: &mut Vec<u8>, v: u32) -> Result<()> {
    let buf = u32::to_be_bytes(v);
    write_buf(writer, &buf)
}

fn write_ipv4(writer: &mut Vec<u8>, v: Ipv4Addr) -> Result<()> {
    write_buf(writer, &v.octets())
}

fn write_boot_packet(
    xid: u32,
    chaddr: [u8; 16],
    client_uuid: Option<Vec<u8>>,
    ipxe: bool,
) -> Result<Vec<u8>> {
    let mut writer = Vec::default();
    write_u8(&mut writer, BootOp::OP_REPLY)?;
    write_u8(&mut writer, HardwareType::TYPE_ETHER)?;
    write_u8(&mut writer, 6)?;
    write_u8(&mut writer, 0)?;
    write_u32(&mut writer, xid)?;
    write_u16(&mut writer, 0)?;
    write_u16(&mut writer, FLAG_BROADCAST)?;
    write_ipv4(&mut writer, Ipv4Addr::UNSPECIFIED)?; // ciaddr
    write_ipv4(&mut writer, Ipv4Addr::UNSPECIFIED)?; // yiaddr  
    write_ipv4(&mut writer, LOCAL_IPV4)?; // siaddr (TFTP server)
    write_ipv4(&mut writer, Ipv4Addr::UNSPECIFIED)?; // giaddr
    write_buf(&mut writer, &chaddr)?;
    write_buf(&mut writer, &[0u8; 64])?;
    write_buf(&mut writer, &[0u8; 128])?;
    write_buf(&mut writer, &MAGIC_COOKIE)?;

    // Option 53: DHCP Message Type (DHCPOFFER)
    write_u8(&mut writer, 53)?;
    write_u8(&mut writer, 1)?;
    write_u8(&mut writer, 2)?; // DHCPOFFER

    // Option 54: DHCP Server Identifier
    write_u8(&mut writer, 54)?;
    write_u8(&mut writer, 4)?;
    write_ipv4(&mut writer, LOCAL_IPV4)?; // Your server IP

    // Option 60: Vendor Class Identifier
    const PXE_CLIENT: &[u8] = b"PXEClient";
    write_u8(&mut writer, 60)?;
    write_u8(&mut writer, PXE_CLIENT.len() as u8)?;
    write_buf(&mut writer, PXE_CLIENT)?;

    // Option 97: Client Machine Identifier (UUID from client)
    if let Some(uuid) = client_uuid {
        write_u8(&mut writer, 97)?;
        write_u8(&mut writer, uuid.len() as u8)?;
        write_buf(&mut writer, &uuid)?;
    }

    // TFTP server name
    const SERVER_NAME: &[u8] = b"diogos-air";
    write_u8(&mut writer, 66)?;
    write_u8(&mut writer, SERVER_NAME.len() as u8)?;
    write_buf(&mut writer, SERVER_NAME)?;

    write_u8(&mut writer, 67)?;
    if !ipxe {
        write_u8(&mut writer, BOOT_FILE_NAME.len() as u8)?;
        write_buf(&mut writer, BOOT_FILE_NAME)?;
    } else {
        write_u8(&mut writer, BOOT_FILE_NAME_IPXE.len() as u8)?;
        write_buf(&mut writer, BOOT_FILE_NAME_IPXE)?;
    }

    // Option 255: End
    write_u8(&mut writer, 255)?;

    Ok(writer)
}

fn write_boot_ack(xid: u32, chaddr: [u8; 16], client_uuid: Option<Vec<u8>>) -> Result<Vec<u8>> {
    let mut writer = Vec::default();
    write_u8(&mut writer, BootOp::OP_REPLY)?;
    write_u8(&mut writer, HardwareType::TYPE_ETHER)?;
    write_u8(&mut writer, 6)?;
    write_u8(&mut writer, 0)?;
    write_u32(&mut writer, xid)?;
    write_u16(&mut writer, 0)?;
    write_u16(&mut writer, 0)?;
    write_ipv4(&mut writer, Ipv4Addr::UNSPECIFIED)?; // ciaddr
    write_ipv4(&mut writer, Ipv4Addr::UNSPECIFIED)?; // yiaddr  
    write_ipv4(&mut writer, Ipv4Addr::UNSPECIFIED)?; // siaddr (TFTP server)
    write_ipv4(&mut writer, Ipv4Addr::UNSPECIFIED)?; // giaddr
    write_buf(&mut writer, &chaddr)?;
    write_buf(&mut writer, &[0u8; 64])?;
    write_buf(&mut writer, &[0u8; 128])?;
    write_buf(&mut writer, &MAGIC_COOKIE)?;

    // Option 53: DHCP Message Type (DHCPOFFER)
    write_u8(&mut writer, 53)?;
    write_u8(&mut writer, 1)?;
    write_u8(&mut writer, 5)?; // DHCPACK

    // Option 54: DHCP Server Identifier
    write_u8(&mut writer, 54)?;
    write_u8(&mut writer, 4)?;
    write_ipv4(&mut writer, LOCAL_IPV4)?; // Your server IP

    // Option 60: Vendor Class Identifier
    const PXE_CLIENT: &[u8] = b"PXEClient";
    write_u8(&mut writer, 60)?;
    write_u8(&mut writer, PXE_CLIENT.len() as u8)?;
    write_buf(&mut writer, PXE_CLIENT)?;

    // Option 97: Client Machine Identifier (UUID from client)
    if let Some(uuid) = client_uuid {
        write_u8(&mut writer, 97)?;
        write_u8(&mut writer, uuid.len() as u8)?;
        write_buf(&mut writer, &uuid)?;
    }

    // TFTP server name
    const SERVER_NAME: &[u8] = b"diogos-air";
    write_u8(&mut writer, 66)?;
    write_u8(&mut writer, SERVER_NAME.len() as u8)?;
    write_buf(&mut writer, SERVER_NAME)?;

    // TFTP file name
    write_u8(&mut writer, 67)?;
    write_u8(&mut writer, BOOT_FILE_NAME.len() as u8)?;
    write_buf(&mut writer, BOOT_FILE_NAME)?;

    write_u8(&mut writer, 71)?;
    write_u8(&mut writer, 4)?;
    write_buf(&mut writer, &[0, 0, 0, 0])?;

    // Option 255: End
    write_u8(&mut writer, 255)?;

    Ok(writer)
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
struct InvalidTftpOp(u16);

impl std::fmt::Display for InvalidTftpOp {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "invalid tftp opcode '{}'", self.0)
    }
}

impl std::error::Error for InvalidTftpOp {}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
enum TftpOp {
    ReadRequest,
    WriteRequest,
    Data,
    Ack,
    Error,
    Oack,
}

impl Into<u16> for TftpOp {
    fn into(self) -> u16 {
        match self {
            TftpOp::ReadRequest => 1,
            TftpOp::WriteRequest => 2,
            TftpOp::Data => 3,
            TftpOp::Ack => 4,
            TftpOp::Error => 5,
            TftpOp::Oack => 6,
        }
    }
}

impl TryFrom<u16> for TftpOp {
    type Error = InvalidTftpOp;

    fn try_from(value: u16) -> std::result::Result<Self, InvalidTftpOp> {
        match value {
            1 => Ok(Self::ReadRequest),
            2 => Ok(Self::WriteRequest),
            3 => Ok(Self::Data),
            4 => Ok(Self::Ack),
            5 => Ok(Self::Error),
            6 => Ok(Self::Oack),
            unknown => Err(InvalidTftpOp(unknown)),
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
enum TftpMode {
    NetAscii,
    Octet,
    Mail,
}

#[derive(Debug)]
struct TftpRequestPacket {
    filename: String,
    mode: String,
    tsize: Option<u64>,
    blksize: Option<u64>,
}

#[derive(Debug)]
struct TftpDataPacket {
    block: u16,
    data: Vec<u8>,
}

#[derive(Debug)]
struct TftpAckPacket {
    block: u16,
}

#[derive(Debug)]
struct TftpErrorPacket {
    code: u16,
    message: String,
}

fn tftp_request_packet_parse(cursor: &mut Cursor<&[u8]>) -> Result<TftpRequestPacket> {
    let filename = read_null_terminated_string(cursor)?;
    let mode = read_null_terminated_string(cursor)?;
    let mut tsize = None;
    let mut blksize = None;
    while let Ok(opt_name) = read_null_terminated_string(cursor) {
        if opt_name.is_empty() {
            break;
        }
        let opt_data = read_null_terminated_string(cursor)?;
        match opt_name.as_str() {
            "tsize" => tsize = Some(opt_data.parse::<u64>().unwrap()),
            "blksize" => blksize = Some(opt_data.parse::<u64>().unwrap()),
            _ => eprintln!("unknown tftp request option '{opt_name}'"),
        }
    }

    Ok(TftpRequestPacket {
        filename,
        mode,
        tsize,
        blksize,
    })
}

fn tftp_data_packet_write(writer: &mut Vec<u8>, block: u16, data: Vec<u8>) -> Result<()> {
    write_u16(writer, TftpOp::Data.into())?;
    write_u16(writer, block)?;
    write_buf(writer, &data)?;
    Ok(())
}

fn tftp_oack_packet_write(
    writer: &mut Vec<u8>,
    tsize: Option<u64>,
    blksize: Option<u64>,
) -> Result<()> {
    write_u16(writer, TftpOp::Oack.into())?;

    // Only include options that were requested by the client
    if let Some(blksize_val) = blksize {
        write_buf(writer, b"blksize")?;
        write_u8(writer, 0)?; // null terminator
        let blksize_str = blksize_val.to_string();
        write_buf(writer, blksize_str.as_bytes())?;
        write_u8(writer, 0)?; // null terminator
    }

    if let Some(tsize_val) = tsize {
        write_buf(writer, b"tsize")?;
        write_u8(writer, 0)?; // null terminator
        let tsize_str = tsize_val.to_string();
        write_buf(writer, tsize_str.as_bytes())?;
        write_u8(writer, 0)?; // null terminator
    }

    Ok(())
}

#[derive(Debug)]
enum TftpPacket {
    Request(TftpRequestPacket),
    Data(TftpDataPacket),
    Ack(TftpAckPacket),
    Error(TftpErrorPacket),
}

fn tftp_packet_parse(cursor: &mut Cursor<&[u8]>) -> Result<TftpPacket> {
    let op = TftpOp::try_from(read_u16(cursor)?).unwrap();
    match op {
        TftpOp::ReadRequest | TftpOp::WriteRequest => {
            let filename = read_null_terminated_string(cursor)?;
            let mode = read_null_terminated_string(cursor)?;
            let mut tsize = None;
            let mut blksize = None;

            while let Ok(opt_name) = read_null_terminated_string(cursor) {
                if opt_name.is_empty() {
                    break;
                }
                let opt_data = read_null_terminated_string(cursor)?;
                match opt_name.as_str() {
                    "tsize" => tsize = Some(opt_data.parse::<u64>().unwrap()),
                    "blksize" => blksize = Some(opt_data.parse::<u64>().unwrap()),
                    _ => eprintln!("unknown tftp request option '{opt_name}'"),
                }
            }

            Ok(TftpPacket::Request(TftpRequestPacket {
                filename,
                mode,
                tsize,
                blksize,
            }))
        }
        TftpOp::Data => {
            let block = read_u16(cursor)?;
            let mut data = Vec::new();
            cursor.read_to_end(&mut data)?;
            Ok(TftpPacket::Data(TftpDataPacket { block, data }))
        }
        TftpOp::Ack => {
            let block = read_u16(cursor)?;
            Ok(TftpPacket::Ack(TftpAckPacket { block }))
        }
        TftpOp::Error => {
            let code = read_u16(cursor)?;
            let message = read_null_terminated_string(cursor)?;
            Ok(TftpPacket::Error(TftpErrorPacket { code, message }))
        }
        TftpOp::Oack => {
            // OACK parsing not implemented for now
            Err(std::io::Error::new(
                std::io::ErrorKind::Unsupported,
                "OACK parsing not implemented",
            ))
        }
    }
}

fn main() {
    let socket67 = UdpSocket::bind("0.0.0.0:67").unwrap();
    socket67.set_broadcast(true).unwrap();
    socket67.set_nonblocking(true).unwrap();

    let socket69 = UdpSocket::bind("0.0.0.0:69").unwrap();
    socket69.set_broadcast(false).unwrap();
    socket69.set_nonblocking(true).unwrap();

    let socket4011 = UdpSocket::bind("0.0.0.0:4011").unwrap();
    socket4011.set_broadcast(true).unwrap();
    socket4011.set_nonblocking(true).unwrap();

    let mut last_blksize = 512u64;
    let mut current_file = String::new();

    loop {
        let mut buf = [0u8; 1500];

        // Try port 67 first
        if let Ok((n, addr)) = socket67.recv_from(&mut buf) {
            println!("Received {} bytes from {} on port 67", n, addr);
            handle_packet(&buf[..n], &socket67);
        } else if let Ok((n, addr)) = socket4011.recv_from(&mut buf) {
            println!("Received {} bytes from {} on port 4011", n, addr);
            handle_packet_4011(&buf[..n], &socket4011, addr);
        } else if let Ok((n, addr)) = socket69.recv_from(&mut buf) {
            let mut cursor = Cursor::new(&buf[..n]);

            let packet = tftp_packet_parse(&mut cursor).unwrap();
            println!("Received TFTP request from {addr}: {packet:#?}");

            let mut response = Vec::default();
            match packet {
                TftpPacket::Request(tftp_request_packet) => {
                    println!(
                        "Request options: tsize={:?}, blksize={:?}",
                        tftp_request_packet.tsize, tftp_request_packet.blksize
                    );

                    let filepath = format!("tftp/{}", tftp_request_packet.filename);
                    current_file = filepath.clone();
                    let meta = std::fs::metadata(&filepath).unwrap();
                    let actual_file_size = meta.len();

                    // Only send OACK if client sent options
                    if tftp_request_packet.tsize.is_some() || tftp_request_packet.blksize.is_some()
                    {
                        if let Some(blksize) = tftp_request_packet.blksize {
                            last_blksize = blksize;
                        }

                        let tsize_response = if tftp_request_packet.tsize.is_some() {
                            Some(actual_file_size)
                        } else {
                            None
                        };

                        tftp_oack_packet_write(
                            &mut response,
                            tsize_response,
                            tftp_request_packet.blksize,
                        )
                        .unwrap();
                    } else {
                        // No options, send first data block directly
                        let contents = std::fs::read(&filepath).unwrap();
                        let block_size = 512;
                        let first_block = if contents.len() > block_size {
                            contents[..block_size].to_vec()
                        } else {
                            contents
                        };

                        tftp_data_packet_write(&mut response, 1, first_block).unwrap();
                    }
                }
                TftpPacket::Data(tftp_data_packet) => {
                    println!("Received DATA packet: block {}", tftp_data_packet.block);
                }
                TftpPacket::Ack(tftp_ack_packet) => {
                    println!("Received ACK packet: block {}", tftp_ack_packet.block);

                    let contents = std::fs::read(&current_file).unwrap();
                    let next_block = tftp_ack_packet.block + 1;
                    let start_offset = (next_block - 1) as u64 * last_blksize;
                    let end_offset = next_block as u64 * last_blksize;
                    let prev_start_offset = (next_block.saturating_sub(2)) as u64 * last_blksize;
                    let prev_remain = contents.len() - prev_start_offset as usize;
                    if prev_remain as u64 >= last_blksize || tftp_ack_packet.block == 0 {
                        let end = std::cmp::min(end_offset as usize, contents.len());
                        let block_data = contents[start_offset as usize..end].to_vec();
                        println!("sending tftp data packet with {} bytes", block_data.len());
                        tftp_data_packet_write(&mut response, next_block, block_data).unwrap();
                    }
                }
                TftpPacket::Error(tftp_error_packet) => {
                    println!(
                        "Received ERROR packet: code {}, message: {}",
                        tftp_error_packet.code, tftp_error_packet.message
                    );
                }
            }
            //
            // let filepath = format!("tftp/{}", request.filename);
            // let meta = std::fs::metadata(&filepath).unwrap();
            // let contents = std::fs::read(&filepath).unwrap();
            // let mut response = Vec::default();
            if !response.is_empty() {
                socket69.send_to(&response, addr).unwrap();
            }
        } else {
            std::thread::sleep(std::time::Duration::from_millis(10));
        }
    }
}

fn handle_packet(buf: &[u8], socket: &UdpSocket) {
    match parse_packet(buf) {
        Ok(packet) => {
            println!("Parsed DHCP packet: XID={:08x}", packet.xid);

            // Check if it's a PXE client and extract client UUID
            let mut is_pxe = false;
            let mut client_uuid = None;
            let mut is_ipxe = false;

            for option in &packet.options {
                match option {
                    DhcpOption::VendorClassIdentifier(vendor_class) => {
                        println!("Vendor class: {}", vendor_class);
                        if vendor_class.contains("PXEClient") {
                            is_pxe = true;
                        }
                    }
                    DhcpOption::UserClassInformation(user_class) => {
                        println!("User class: {}", user_class);
                        is_ipxe = true;
                    }
                    DhcpOption::Unknown { code: 97, data } => {
                        println!("Found client machine identifier");
                        client_uuid = Some(data.clone());
                    }
                    _ => {}
                }
            }

            if is_pxe {
                println!("Responding to PXE client with DHCPOFFER");
                let response =
                    write_boot_packet(packet.xid, packet.chaddr, client_uuid, is_ipxe).unwrap();
                socket
                    .send_to(&response, SocketAddrV4::new(Ipv4Addr::BROADCAST, 68))
                    .unwrap();
            } else {
                println!("Not a PXE client, ignoring");
            }
        }
        Err(e) => {
            println!("Failed to parse packet: {}", e);
        }
    }
}

fn handle_packet_4011(buf: &[u8], socket: &UdpSocket, sender_addr: SocketAddr) {
    match parse_packet(buf) {
        Ok(packet) => {
            println!("Parsed DHCP packet on 4011: XID={:08x}", packet.xid);

            // Extract client UUID
            let mut client_uuid = None;
            for option in &packet.options {
                if let DhcpOption::Unknown { code: 97, data } = option {
                    client_uuid = Some(data.clone());
                    break;
                }
            }

            println!("Responding with DHCPACK");
            let response = write_boot_ack(packet.xid, packet.chaddr, client_uuid).unwrap();
            socket.send_to(&response, sender_addr).unwrap();
        }
        Err(e) => {
            println!("Failed to parse packet on 4011: {}", e);
        }
    }
}

const DHCP_PACKET_PAYLOAD: &'static [u8] = &[
    0x1, 0x1, 0x6, 0x0, 0xf1, 0x25, 0x7c, 0x21, 0x0, 0x0, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2b, 0x67, 0x3f, 0xda, 0x70, 0x0, 0x0,
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x63, 0x82, 0x53, 0x63, 0x35, 0x1, 0x1, 0x39,
    0x2, 0x5, 0xc0, 0x37, 0x23, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0xc, 0xd, 0xf, 0x11, 0x12, 0x16,
    0x17, 0x1c, 0x28, 0x29, 0x2a, 0x2b, 0x32, 0x33, 0x36, 0x3a, 0x3b, 0x3c, 0x42, 0x43, 0x61, 0x80,
    0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x61, 0x11, 0x0, 0xcc, 0xfc, 0x32, 0x1b, 0xce, 0x2a,
    0xb2, 0x11, 0xa8, 0x5c, 0xb1, 0xac, 0x38, 0x38, 0x10, 0xf, 0x5e, 0x3, 0x1, 0x3, 0x10, 0x5d,
    0x2, 0x0, 0x7, 0x3c, 0x20, 0x50, 0x58, 0x45, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x3a, 0x41,
    0x72, 0x63, 0x68, 0x3a, 0x30, 0x30, 0x30, 0x30, 0x37, 0x3a, 0x55, 0x4e, 0x44, 0x49, 0x3a, 0x30,
    0x30, 0x33, 0x30, 0x31, 0x36, 0xff,
];