Struct PxeBaseCodeProtocol

#[repr(C)]
pub struct PxeBaseCodeProtocol(/* private fields */);

Implementations

impl PxeBaseCodeProtocol

pub fn get_any<'a>() -> Result<Option<&'a PxeBaseCodeProtocol>>

pub fn get_all<'a>() -> Result<Vec<&'a PxeBaseCodeProtocol>>

pub fn get_all_mut<'a>() -> Result<Vec<&'a mut PxeBaseCodeProtocol>>

Examples found in repository

examples/sample_efi_app.rs (line 38)

fn run(_sys_table: &mut SystemTable) -> Result<(), String> {
    println!("Hello from UEFI");
    println!("");

    let pxe_protocols = net::pxebc::PxeBaseCodeProtocol::get_all_mut()
            .map_err(|_| "error while locating PXE protocols")?;

    if pxe_protocols.len() == 0 {
        return Err(String::from("No PXE protocols found"));
    }

    println!("Found {0} PXE protocols", pxe_protocols.len());

    let pxe_protocol = &pxe_protocols[0];
    
    if pxe_protocol.cached_dhcp_config().unwrap_or(None).is_none() { // If there's cached config then DHCP has already happend. Otherwise we start it.
        println!("Performing DHCP...");
        let dhcp_config = pxe_protocol.run_dhcp().map_err(|e| format!("Dhcp failed - {}", e))?;

        println!("    Your IP: {}, Subnet mask: {}", dhcp_config.ip(), dhcp_config.subnet_mask());
        if let Some(server_ip) =  dhcp_config.dhcp_server_addr() {
            println!("    Server IP: {}", server_ip);
        }
    }

    println!("");
    println!("Testing TCP by sending HTTP request to the given addr");

    print!("Enter addr to connect to (<host>:<port>): ");
    let stdin = efi::stdin();
    let addr = stdin.lines().next().unwrap().unwrap();

    println!("Connecting to {}...", addr);

    net::TcpStream::connect(addr)
        .and_then(|mut stream| {
            println!("Connected!");
            let buf = "GET / HTTP/1.1".as_bytes();
            use io::Write;

            stream.write(&buf).unwrap();
            stream.write("\r\n".as_bytes()).unwrap();
            stream.write("Content-Length: 0\r\n".as_bytes()).unwrap();
            stream.write("\r\n".as_bytes()).unwrap();

            println!("Req sent");

            println!("");
            println!("Received resp: ");
            let mut rbuf = [0_u8; 2048];

            let read = stream.read(&mut rbuf).unwrap();

            if read == 0 {
                return Err(EfiErrorKind::NoResponse.into())
            }

            let resp = String::from_utf8_lossy(&rbuf[..read]).into_owned();

            println!("{}", resp);

            println!("");

            Ok(())
        })
        .or_else(|e| {
            Err(format!("Failed to connect. Status code: {:?}", e))
        })?;

    Ok(())
}

pub fn cached_dhcp_config(&self) -> Result<Option<DhcpConfig>>

Examples found in repository

examples/sample_efi_app.rs (line 49)

fn run(_sys_table: &mut SystemTable) -> Result<(), String> {
    println!("Hello from UEFI");
    println!("");

    let pxe_protocols = net::pxebc::PxeBaseCodeProtocol::get_all_mut()
            .map_err(|_| "error while locating PXE protocols")?;

    if pxe_protocols.len() == 0 {
        return Err(String::from("No PXE protocols found"));
    }

    println!("Found {0} PXE protocols", pxe_protocols.len());

    let pxe_protocol = &pxe_protocols[0];
    
    if pxe_protocol.cached_dhcp_config().unwrap_or(None).is_none() { // If there's cached config then DHCP has already happend. Otherwise we start it.
        println!("Performing DHCP...");
        let dhcp_config = pxe_protocol.run_dhcp().map_err(|e| format!("Dhcp failed - {}", e))?;

        println!("    Your IP: {}, Subnet mask: {}", dhcp_config.ip(), dhcp_config.subnet_mask());
        if let Some(server_ip) =  dhcp_config.dhcp_server_addr() {
            println!("    Server IP: {}", server_ip);
        }
    }

    println!("");
    println!("Testing TCP by sending HTTP request to the given addr");

    print!("Enter addr to connect to (<host>:<port>): ");
    let stdin = efi::stdin();
    let addr = stdin.lines().next().unwrap().unwrap();

    println!("Connecting to {}...", addr);

    net::TcpStream::connect(addr)
        .and_then(|mut stream| {
            println!("Connected!");
            let buf = "GET / HTTP/1.1".as_bytes();
            use io::Write;

            stream.write(&buf).unwrap();
            stream.write("\r\n".as_bytes()).unwrap();
            stream.write("Content-Length: 0\r\n".as_bytes()).unwrap();
            stream.write("\r\n".as_bytes()).unwrap();

            println!("Req sent");

            println!("");
            println!("Received resp: ");
            let mut rbuf = [0_u8; 2048];

            let read = stream.read(&mut rbuf).unwrap();

            if read == 0 {
                return Err(EfiErrorKind::NoResponse.into())
            }

            let resp = String::from_utf8_lossy(&rbuf[..read]).into_owned();

            println!("{}", resp);

            println!("");

            Ok(())
        })
        .or_else(|e| {
            Err(format!("Failed to connect. Status code: {:?}", e))
        })?;

    Ok(())
}

pub fn run_dhcp(&self) -> Result<DhcpConfig>

Examples found in repository

examples/sample_efi_app.rs (line 51)

fn run(_sys_table: &mut SystemTable) -> Result<(), String> {
    println!("Hello from UEFI");
    println!("");

    let pxe_protocols = net::pxebc::PxeBaseCodeProtocol::get_all_mut()
            .map_err(|_| "error while locating PXE protocols")?;

    if pxe_protocols.len() == 0 {
        return Err(String::from("No PXE protocols found"));
    }

    println!("Found {0} PXE protocols", pxe_protocols.len());

    let pxe_protocol = &pxe_protocols[0];
    
    if pxe_protocol.cached_dhcp_config().unwrap_or(None).is_none() { // If there's cached config then DHCP has already happend. Otherwise we start it.
        println!("Performing DHCP...");
        let dhcp_config = pxe_protocol.run_dhcp().map_err(|e| format!("Dhcp failed - {}", e))?;

        println!("    Your IP: {}, Subnet mask: {}", dhcp_config.ip(), dhcp_config.subnet_mask());
        if let Some(server_ip) =  dhcp_config.dhcp_server_addr() {
            println!("    Server IP: {}", server_ip);
        }
    }

    println!("");
    println!("Testing TCP by sending HTTP request to the given addr");

    print!("Enter addr to connect to (<host>:<port>): ");
    let stdin = efi::stdin();
    let addr = stdin.lines().next().unwrap().unwrap();

    println!("Connecting to {}...", addr);

    net::TcpStream::connect(addr)
        .and_then(|mut stream| {
            println!("Connected!");
            let buf = "GET / HTTP/1.1".as_bytes();
            use io::Write;

            stream.write(&buf).unwrap();
            stream.write("\r\n".as_bytes()).unwrap();
            stream.write("Content-Length: 0\r\n".as_bytes()).unwrap();
            stream.write("\r\n".as_bytes()).unwrap();

            println!("Req sent");

            println!("");
            println!("Received resp: ");
            let mut rbuf = [0_u8; 2048];

            let read = stream.read(&mut rbuf).unwrap();

            if read == 0 {
                return Err(EfiErrorKind::NoResponse.into())
            }

            let resp = String::from_utf8_lossy(&rbuf[..read]).into_owned();

            println!("{}", resp);

            println!("");

            Ok(())
        })
        .or_else(|e| {
            Err(format!("Failed to connect. Status code: {:?}", e))
        })?;

    Ok(())
}

pub fn run_boot_server_discovery( &self, _dhcp_config: &DhcpConfig, ) -> Result<BootServerConfig>

pub fn set_proxy_offer(&mut self, pxe_reply_packet: &Dhcpv4Packet) -> Result<()>

pub fn mtftp_get_file_size( &self, server_ip: &IpAddr, filename: &NullTerminatedAsciiStr<'_>, ) -> Result<u64>

pub fn mtftp_get_file( &self, server_ip: &IpAddr, filename: &NullTerminatedAsciiStr<'_>, ) -> Result<Vec<u8>>

Trait Implementations

impl From<EFI_PXE_BASE_CODE_PROTOCOL> for PxeBaseCodeProtocol

fn from(raw_protocol: EFI_PXE_BASE_CODE_PROTOCOL) -> Self

Converts to this type from the input type.