1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

use crate::{Listener, NamedPipe, WindowsPipeTransport};
use async_trait::async_trait;
use std::{
    ffi::{OsStr, OsString},
    fmt, io, mem,
};
use tokio::net::windows::named_pipe::{NamedPipeServer, ServerOptions};

/// Represents a [`Listener`] for incoming connections over a named windows pipe
pub struct WindowsPipeListener {
    addr: OsString,
    inner: NamedPipeServer,
}

impl WindowsPipeListener {
    /// Creates a new listener by binding to the specified local address
    /// using the given name, which translates to `\\.\pipe\{name}`
    pub fn bind_local(name: impl AsRef<OsStr>) -> io::Result<Self> {
        let mut addr = OsString::from(r"\\.\pipe\");
        addr.push(name.as_ref());
        Self::bind(addr)
    }

    /// Creates a new listener by binding to the specified address
    pub fn bind(addr: impl Into<OsString>) -> io::Result<Self> {
        let addr = addr.into();
        let pipe = ServerOptions::new()
            .first_pipe_instance(true)
            .create(addr.as_os_str())?;
        Ok(Self { addr, inner: pipe })
    }

    /// Returns the addr that the listener is bound to
    pub fn addr(&self) -> &OsStr {
        &self.addr
    }
}

impl fmt::Debug for WindowsPipeListener {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("WindowsPipeListener")
            .field("addr", &self.addr)
            .finish()
    }
}

#[async_trait]
impl Listener for WindowsPipeListener {
    type Output = WindowsPipeTransport;

    async fn accept(&mut self) -> io::Result<Self::Output> {
        // Wait for a new connection on the current server pipe
        self.inner.connect().await?;

        // Create a new server pipe to use for the next connection
        // as the current pipe is now taken with our existing connection
        let pipe = mem::replace(&mut self.inner, ServerOptions::new().create(&self.addr)?);

        Ok(WindowsPipeTransport {
            addr: self.addr.clone(),
            inner: NamedPipe::from(pipe),
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use tokio::{
        io::{AsyncReadExt, AsyncWriteExt},
        sync::oneshot,
        task::JoinHandle,
    };

    #[tokio::test]
    async fn should_fail_to_bind_if_pipe_already_bound() {
        // Generate a pipe name
        let name = format!("test_pipe_{}", rand::random::<usize>());

        // Listen at the pipe
        let _listener =
            WindowsPipeListener::bind_local(&name).expect("Unexpectedly failed to bind first time");

        // Now this should fail as we're already bound to the name
        WindowsPipeListener::bind_local(&name)
            .expect_err("Unexpectedly succeeded in binding to same pipe");
    }

    #[tokio::test]
    async fn should_be_able_to_receive_connections_and_send_and_receive_data_with_them() {
        let (tx, rx) = oneshot::channel();

        // Spawn a task that will wait for two connections and then
        // return the success or failure
        let task: JoinHandle<io::Result<()>> = tokio::spawn(async move {
            // Generate a pipe name
            let name = format!("test_pipe_{}", rand::random::<usize>());

            // Listen at the pipe
            let mut listener = WindowsPipeListener::bind_local(&name)?;

            // Send the name back to our main test thread
            tx.send(name)
                .map_err(|x| io::Error::new(io::ErrorKind::Other, x))?;

            // Get first connection
            let mut conn_1 = listener.accept().await?;

            // Send some data to the first connection (12 bytes)
            conn_1.write_all(b"hello conn 1").await?;

            // Get some data from the first connection (14 bytes)
            let mut buf: [u8; 14] = [0; 14];
            let _ = conn_1.read_exact(&mut buf).await?;
            assert_eq!(&buf, b"hello server 1");

            // Get second connection
            let mut conn_2 = listener.accept().await?;

            // Send some data on to second connection (12 bytes)
            conn_2.write_all(b"hello conn 2").await?;

            // Get some data from the second connection (14 bytes)
            let mut buf: [u8; 14] = [0; 14];
            let _ = conn_2.read_exact(&mut buf).await?;
            assert_eq!(&buf, b"hello server 2");

            Ok(())
        });

        // Wait for the server to be ready
        let name = rx.await.expect("Failed to get server name");

        // Connect to the listener twice, sending some bytes and receiving some bytes from each
        let mut buf: [u8; 12] = [0; 12];

        let mut conn = WindowsPipeTransport::connect_local(&name)
            .await
            .expect("Conn 1 failed to connect");
        conn.write_all(b"hello server 1")
            .await
            .expect("Conn 1 failed to write");
        conn.read_exact(&mut buf)
            .await
            .expect("Conn 1 failed to read");
        assert_eq!(&buf, b"hello conn 1");

        let mut conn = WindowsPipeTransport::connect_local(&name)
            .await
            .expect("Conn 2 failed to connect");
        conn.write_all(b"hello server 2")
            .await
            .expect("Conn 2 failed to write");
        conn.read_exact(&mut buf)
            .await
            .expect("Conn 2 failed to read");
        assert_eq!(&buf, b"hello conn 2");

        // Verify that the task has completed by waiting on it
        let _ = task.await.expect("Listener task failed unexpectedly");
    }
}