Function resolve

tcp/src/dns.rs:150–249

Find the IP address of a given host name Uses CACHE to store previous lookups, and uses the DNS server last added to SERVERS.

(name: &str)

/// Uses CACHE to store previous lookups, and uses the DNS server last
/// added to SERVERS.
pub fn resolve(name: &str) -> Result<IpAddress, ResponseCode> {
    // Check the cache
    {
        let cache = CACHE.read();
        if let Some(addr) = cache.get(name) {
            // Here could check expiry time
            return Ok(addr.clone());
        }
    }

    // Get the IP address of a DNS server
    let dns_address = {
        let servers = SERVERS.read();
        match servers.last() {
            Some(addr) => addr.clone(),
            None => {return Err(ResponseCode::NotImplemented);}
        }
    };

    let server = IpEndpoint::new(dns_address, DNS_PORT);

    // Get a local port for the connection
    let local_port = crate::ephemeral_port_number();
    let client = IpEndpoint::new(IpAddress::Unspecified, local_port);

    let query = Message::query(name, QueryType::A, QueryClass::IN);

    // Add the UDP socket to the network interface
    let udp_handle = {
        let udp_rx_buffer = UdpSocketBuffer::new(vec![UdpPacketMetadata::EMPTY], vec![0; 2048]);
        let udp_tx_buffer = UdpSocketBuffer::new(vec![UdpPacketMetadata::EMPTY], vec![0; 2048]);
        let udp_socket = UdpSocket::new(udp_rx_buffer, udp_tx_buffer);

        let mut some_interface = INTERFACE.write();
        let interface = (*some_interface).as_mut().unwrap();
        interface.add_socket(udp_socket)
    };

    #[derive(Debug)]
    enum State { Bind, Query, Response }
    let mut state = State::Bind;

    // Don't keep a reference to INTERFACE because this thread
    // is interleaved with threads servicing other requests.
    loop {
        {
            // Get a lock on the INTERFACE
            let mut some_interface = INTERFACE.write();
            let interface = (*some_interface).as_mut().unwrap();

            if let Err(e) = interface.poll(Instant::from_micros(time::microseconds_monotonic() as i64)) {
                println!("Network Error: {}", e);
                return Err(ResponseCode::UnknownError);
            }

            let socket = interface.get_socket::<UdpSocket>(udp_handle);

            state = match state {