Function open_socket

tcp/src/main.rs:299–505

Open a socket and wait in a loop for messages on given handle

(address: IpAddress, port: u16, comm_handle: CommHandle)

/// Open a socket and wait in a loop for messages on given handle
fn open_socket(address: IpAddress, port: u16, comm_handle: CommHandle) {
    println!("[tcp] Connecting to {} port {}", address, port);

    let tcp_rx_buffer = TcpSocketBuffer::new(vec![0; 4096]);
    let tcp_tx_buffer = TcpSocketBuffer::new(vec![0; 4096]);
    let tcp_socket = TcpSocket::new(tcp_rx_buffer, tcp_tx_buffer);

    let tcp_handle = {
        let mut some_interface = INTERFACE.write();
        let interface = (*some_interface).as_mut().unwrap();
        let tcp_handle = interface.add_socket(tcp_socket);

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

        let (socket, cx) = interface.get_socket_and_context::<TcpSocket>(tcp_handle);

        // Random port number for the local port
        let local_port = ephemeral_port_number();
        if socket.connect(cx, (address, port), local_port).is_err() {
            println!("[tcp {}/{}] socket.connect failed", address, port);
            interface.remove_socket(tcp_handle);
            None
        } else {
            Some(tcp_handle)
        }
    };

    loop {
        match syscalls::receive(&comm_handle) {
            Ok(syscalls::Message::Long(
                message::WRITE,
                MessageData::Value(length),
                MessageData::MemoryHandle(handle))) => {

                // Get a slice
                let mut data = handle.as_slice::<u8>(length as usize);

                // Keep trying to send the data
                loop {
                    match tcp_handle {
                        Some(handle) => {
                            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!("[tcp {}/{}] Network error: {:?}", address, port, e);
                            }

                            let socket = interface.get_socket::<TcpSocket>(handle);

                            if socket.may_send() {
                                match socket.send_slice(data) {
                                    Ok(length) => { // Succeeded in sending some or all the data
                                        println!("[tcp {}/{}] Sent {} bytes", address, port, length);
                                        if length == data.len() {
                                            // All data sent