/dev/net/tun not writable

[lparam]

not-writable-demo.tar.gz

steps to reproduce

1. cargo build; sudo ./target/debug/demo
2. wait a few seconds
3. press any key in the same terminal of the demo program

key code

        loop {
            select! {
                r = tun_file.read(&mut tun_buf).fuse() => match r {
                    Ok(n) => {
                        println!("read {} bytes {:?} from tun", n, &tun_buf[..n]);
                    }
                    Err(e) => {
                        println!("read error: {}", e);
                    }
                },
                line = lines_from_stdin.next().fuse() => match line {
                    Some(line) => {
                        let line = line?;
                        println!("line: {}", line);
                        let buf: [u8; 32] = [0x45, 0x00, 0x00, 0x20, 0x91, 0xb3, 0x40, 0x00, 0x40, 0x11, 0x8d, 0x17, 0x0a, 0x00, 0x05, 0x01, 0x0a, 0x00, 0x05, 0x03, 0x83, 0x0d, 0x1f, 0x90, 0x00, 0x0c, 0x7c, 0xc9, 0x61, 0x62, 0x63, 0x0a];
                        match tun_file.write(&buf).await { // block here, not writable
                            Ok(n) => {
                                println!("write {} bytes to tun", n);
                            },
                            Err(e) => {
                                println!("write error: {}", e);
                            }
                        }
                        // the codes below works fine.
                        /*let n = match unsafe { libc::write(tun_file.as_raw_fd(), buf.as_ptr() as _, buf.len() as _) } {
                            -1 => 0,
                            n => n,
                        };
                        println!("write {} bytes to tun", n);*/
                    }
                    None => break,
                }
            }
        }

[yoshuawuyts]

This should've been addressed by #574; @lparam can you verify if this is still happening?

If not, can you perhaps share the code in a repo? Opening a zip file feels a bit scary haha 😅

[lparam]

@yoshuawuyts Yes, it's still happening. I open a repo async-std-simultaneously

@lparam Did you test with a version of async-std that includes the #574? When I did testing on my machine last time the problem seemed to be resolved, so I'm just checking.

[lparam]

@stjepang Yes. I have tested it on v1.3.0.

[oblique]

@yoshuawuyts @stjepang I have the same problem with /dev/ptmx. And I believe all UNIX special files will have the same issue, since they can block indefinitely.

After my investigation I concluded the following:

• tun_file.read() is locks for reading, spawns a thread for read() syscall, but never reads anything.
• User writes something on terminal and press enter.
• tun_file.write() waits for lock.

The workaround:

        let mut tun_file_rx = tun_file;
        let mut tun_file_tx = unsafe {
            let new_fd = libc::dup(tun_file_rx.as_raw_fd());
            File::from_raw_fd(new_fd)
        };

And then use tun_file_rx for reading and tun_file_tx for writing.

However, even if it works with /dev/net/tun, it still misbehaves with /dev/ptmx. I will open another issue for /dev/ptmx case with a proposal.