Allow opening two shared TTYPorts

[rockboynton]

trying to open a two shared TTYPorts, but I am running into issues opening the second one, where I get an error with flock::lock_exclusive() -> "Unable to acquire exclusive lock on serial port" (which comes from flock). I don't see why TTYPort::open() unconditionally sets exclusive since given this scheme it seems impossible to open two shared ports using this lib.

open first as exclusive -> immediately set as non-exclusive -> open second as exclusive (fails)

I read the comment for that:

// Try to claim exclusive access to the port. This is performed even
// if the port will later be set as non-exclusive, in order to respect
// other applications that may have an exclusive port lock.

but it doesn't make sense to me, because if we try to open a non-exclusive lock on a serial port that was previous locked as exclusive, the OS syscall should fail anyway.

This should be possible with some refactoring of port locking

This issue was ported from discussion #313

[JimJ92120]

but it doesn't make sense to me, because if we try to open a non-exclusive lock on a serial port that was previous locked as exclusive, the OS syscall should fail anyway.

It seems that issue comes from trying to lock (when opening the second time) a non-exclusive port (which was set first).
A temp workaround would be to build the crate locally and comment out the lock on open: https://github.com/serialport/serialport-rs/blob/main/src/posix/tty.rs#L139

e.g

use std::time::Duration;
use std::thread::sleep;
use std::io::Write;
use std::io::Result;

use serialport;

fn main() -> Result<()> {
    let path = "/dev/ttyACM0";
    let baud_rate = 57600;

    let mut port = serialport::new(path, baud_rate)
        .timeout(Duration::from_millis(1000))
        .open_native()?;
    sleep(Duration::from_secs(2));
    port.set_exclusive(false)?;
    println!("check exclusive: {}", port.exclusive());

    let mut port2 = serialport::new(path, baud_rate)
        .timeout(Duration::from_millis(10))
        .open_native()?;
    port2.set_exclusive(false)?;
    println!("check exclusive: {}", port2.exclusive());

    let output = "Hello, world!\n";

    loop {
        match port.write_all(output.as_bytes()) {
            Ok(()) => println!("Sent: {}", output),
            Err(e) => eprintln!("Error writing to port: {}", e),
        }
        match port2.write_all(output.as_bytes()) {
            Ok(()) => println!("Sent 2: {}", output),
            Err(e) => eprintln!("Error writing to port 2: {}", e),
        }

        sleep(Duration::from_secs(1));
    }
}

For ref: open_native() calls TTYPort::open() which would attempt to lock via flock::lock_exclusive()

[VMshall]

I'm willing to contribute on this issue.

[sirhcel]

I'm willing to contribute on this issue.

Great to hear that! VMshall@830b5cc goes in the right direction. Please feel free to open a PR.