Skip to content

Commit 48db06f

Browse files
KolbyMLKolbyML
committed
Make Windows UDS work with tests and clean implementation
1 parent bddcaae commit 48db06f

File tree

20 files changed

+289
-269
lines changed

20 files changed

+289
-269
lines changed

‎src/lib.rs‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -91,6 +91,10 @@ pub mod windows {
9191
//! Windows only extensions.
9292
9393
pub use crate::sys::named_pipe::NamedPipe;
94+
// blocking windows uds which mimick std implementation used for tests
95+
cfg_net! {
96+
pub use crate::sys::windows::stdnet;
97+
}
9498
}
9599

96100
pub mod features {

‎src/net/tcp/stream.rs‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -269,49 +269,49 @@ impl TcpStream {
269269

270270
impl Read for TcpStream {
271271
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
272-
self.inner.do_io(|inner| (&*inner).read(buf))
272+
self.inner.do_io(|mut inner| inner.read(buf))
273273
}
274274

275275
fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
276-
self.inner.do_io(|inner| (&*inner).read_vectored(bufs))
276+
self.inner.do_io(|mut inner| inner.read_vectored(bufs))
277277
}
278278
}
279279

280280
impl<'a> Read for &'a TcpStream {
281281
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
282-
self.inner.do_io(|inner| (&*inner).read(buf))
282+
self.inner.do_io(|mut inner| inner.read(buf))
283283
}
284284

285285
fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
286-
self.inner.do_io(|inner| (&*inner).read_vectored(bufs))
286+
self.inner.do_io(|mut inner| inner.read_vectored(bufs))
287287
}
288288
}
289289

290290
impl Write for TcpStream {
291291
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
292-
self.inner.do_io(|inner| (&*inner).write(buf))
292+
self.inner.do_io(|mut inner| inner.write(buf))
293293
}
294294

295295
fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
296-
self.inner.do_io(|inner| (&*inner).write_vectored(bufs))
296+
self.inner.do_io(|mut inner| inner.write_vectored(bufs))
297297
}
298298

299299
fn flush(&mut self) -> io::Result<()> {
300-
self.inner.do_io(|inner| (&*inner).flush())
300+
self.inner.do_io(|mut inner| inner.flush())
301301
}
302302
}
303303

304304
impl<'a> Write for &'a TcpStream {
305305
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
306-
self.inner.do_io(|inner| (&*inner).write(buf))
306+
self.inner.do_io(|mut inner| inner.write(buf))
307307
}
308308

309309
fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
310-
self.inner.do_io(|inner| (&*inner).write_vectored(bufs))
310+
self.inner.do_io(|mut inner| inner.write_vectored(bufs))
311311
}
312312

313313
fn flush(&mut self) -> io::Result<()> {
314-
self.inner.do_io(|inner| (&*inner).flush())
314+
self.inner.do_io(|mut inner| inner.flush())
315315
}
316316
}
317317

‎src/net/uds/listener.rs‎

Lines changed: 0 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -35,21 +35,12 @@ impl UnixListener {
3535
/// standard library in the Mio equivalent. The conversion assumes nothing
3636
/// about the underlying listener; it is left up to the user to set it in
3737
/// non-blocking mode.
38-
#[cfg(unix)]
39-
#[cfg_attr(docsrs, doc(cfg(unix)))]
4038
pub fn from_std(listener: net::UnixListener) -> UnixListener {
4139
UnixListener {
4240
inner: IoSource::new(listener),
4341
}
4442
}
4543

46-
#[cfg(windows)]
47-
pub(crate) fn from_std(listener: net::UnixListener) -> UnixListener {
48-
UnixListener {
49-
inner: IoSource::new(listener),
50-
}
51-
}
52-
5344
/// Accepts a new incoming connection to this listener.
5445
///
5546
/// The call is responsible for ensuring that the listening socket is in

‎src/net/uds/stream.rs‎

Lines changed: 37 additions & 47 deletions
Original file line numberDiff line numberDiff line change
@@ -49,21 +49,12 @@ impl UnixStream {
4949
/// The Unix stream here will not have `connect` called on it, so it
5050
/// should already be connected via some other means (be it manually, or
5151
/// the standard library).
52-
#[cfg(unix)]
53-
#[cfg_attr(docsrs, doc(cfg(unix)))]
5452
pub fn from_std(stream: net::UnixStream) -> UnixStream {
5553
UnixStream {
5654
inner: IoSource::new(stream),
5755
}
5856
}
5957

60-
#[cfg(windows)]
61-
pub(crate) fn from_std(stream: net::UnixStream) -> UnixStream {
62-
UnixStream {
63-
inner: IoSource::new(stream),
64-
}
65-
}
66-
6758
/// Creates an unnamed pair of connected sockets.
6859
///
6960
/// Returns two `UnixStream`s which are connected to each other.
@@ -178,34 +169,6 @@ impl UnixStream {
178169
/// # let _ = std::fs::remove_file(&file_path);
179170
/// let server = UnixListener::bind(&file_path).unwrap();
180171
///
181-
/// let handle = std::thread::spawn(move || {
182-
/// if let Ok((stream2, _)) = server.accept() {
183-
/// // Wait until the stream is readable...
184-
///
185-
/// // Read from the stream using a direct WinSock call, of course the
186-
/// // `io::Read` implementation would be easier to use.
187-
/// let mut buf = [0; 512];
188-
/// let n = stream2.try_io(|| {
189-
/// let res = unsafe {
190-
/// WinSock::recv(
191-
/// stream2.as_raw_socket().try_into().unwrap(),
192-
/// &mut buf as *mut _ as *mut _,
193-
/// buf.len() as c_int,
194-
/// 0
195-
/// )
196-
/// };
197-
/// if res != WinSock::SOCKET_ERROR {
198-
/// Ok(res as usize)
199-
/// } else {
200-
/// // If EAGAIN or EWOULDBLOCK is set by WinSock::recv, the closure
201-
/// // should return `WouldBlock` error.
202-
/// Err(io::Error::last_os_error())
203-
/// }
204-
/// }).unwrap();
205-
/// eprintln!("read {} bytes", n);
206-
/// }
207-
/// });
208-
///
209172
/// let stream1 = UnixStream::connect(&file_path).unwrap();
210173
///
211174
/// // Wait until the stream is writable...
@@ -234,6 +197,33 @@ impl UnixStream {
234197
/// })?;
235198
/// eprintln!("write {} bytes", n);
236199
///
200+
/// let handle = std::thread::spawn(move || {
201+
/// if let Ok((stream2, _)) = server.accept() {
202+
/// // Wait until the stream is readable...
203+
///
204+
/// // Read from the stream using a direct WinSock call, of course the
205+
/// // `io::Read` implementation would be easier to use.
206+
/// let mut buf = [0; 512];
207+
/// let n = stream2.try_io(|| {
208+
/// let res = unsafe {
209+
/// WinSock::recv(
210+
/// stream2.as_raw_socket().try_into().unwrap(),
211+
/// &mut buf as *mut _ as *mut _,
212+
/// buf.len() as c_int,
213+
/// 0
214+
/// )
215+
/// };
216+
/// if res != WinSock::SOCKET_ERROR {
217+
/// Ok(res as usize)
218+
/// } else {
219+
/// // If EAGAIN or EWOULDBLOCK is set by WinSock::recv, the closure
220+
/// // should return `WouldBlock` error.
221+
/// Err(io::Error::last_os_error())
222+
/// }
223+
/// }).unwrap();
224+
/// eprintln!("read {} bytes", n);
225+
/// }
226+
/// });
237227
/// # handle.join().unwrap();
238228
/// # Ok(())
239229
/// # }
@@ -248,49 +238,49 @@ impl UnixStream {
248238

249239
impl Read for UnixStream {
250240
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
251-
self.inner.do_io(|inner| (&*inner).read(buf))
241+
self.inner.do_io(|mut inner| inner.read(buf))
252242
}
253243

254244
fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
255-
self.inner.do_io(|inner| (&*inner).read_vectored(bufs))
245+
self.inner.do_io(|mut inner| inner.read_vectored(bufs))
256246
}
257247
}
258248

259249
impl<'a> Read for &'a UnixStream {
260250
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
261-
self.inner.do_io(|inner| (&*inner).read(buf))
251+
self.inner.do_io(|mut inner| inner.read(buf))
262252
}
263253

264254
fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
265-
self.inner.do_io(|inner| (&*inner).read_vectored(bufs))
255+
self.inner.do_io(|mut inner| inner.read_vectored(bufs))
266256
}
267257
}
268258

269259
impl Write for UnixStream {
270260
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
271-
self.inner.do_io(|inner| (&*inner).write(buf))
261+
self.inner.do_io(|mut inner| inner.write(buf))
272262
}
273263

274264
fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
275-
self.inner.do_io(|inner| (&*inner).write_vectored(bufs))
265+
self.inner.do_io(|mut inner| inner.write_vectored(bufs))
276266
}
277267

278268
fn flush(&mut self) -> io::Result<()> {
279-
self.inner.do_io(|inner| (&*inner).flush())
269+
self.inner.do_io(|mut inner| inner.flush())
280270
}
281271
}
282272

283273
impl<'a> Write for &'a UnixStream {
284274
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
285-
self.inner.do_io(|inner| (&*inner).write(buf))
275+
self.inner.do_io(|mut inner| inner.write(buf))
286276
}
287277

288278
fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
289-
self.inner.do_io(|inner| (&*inner).write_vectored(bufs))
279+
self.inner.do_io(|mut inner| inner.write_vectored(bufs))
290280
}
291281

292282
fn flush(&mut self) -> io::Result<()> {
293-
self.inner.do_io(|inner| (&*inner).flush())
283+
self.inner.do_io(|mut inner| inner.flush())
294284
}
295285
}
296286

‎src/sys/unix/pipe.rs‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -333,29 +333,29 @@ impl event::Source for Sender {
333333

334334
impl Write for Sender {
335335
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
336-
self.inner.do_io(|sender| (&*sender).write(buf))
336+
self.inner.do_io(|mut sender| sender.write(buf))
337337
}
338338

339339
fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
340-
self.inner.do_io(|sender| (&*sender).write_vectored(bufs))
340+
self.inner.do_io(|mut sender| sender.write_vectored(bufs))
341341
}
342342

343343
fn flush(&mut self) -> io::Result<()> {
344-
self.inner.do_io(|sender| (&*sender).flush())
344+
self.inner.do_io(|mut sender| sender.flush())
345345
}
346346
}
347347

348348
impl Write for &Sender {
349349
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
350-
self.inner.do_io(|sender| (&*sender).write(buf))
350+
self.inner.do_io(|mut sender| sender.write(buf))
351351
}
352352

353353
fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
354-
self.inner.do_io(|sender| (&*sender).write_vectored(bufs))
354+
self.inner.do_io(|mut sender| sender.write_vectored(bufs))
355355
}
356356

357357
fn flush(&mut self) -> io::Result<()> {
358-
self.inner.do_io(|sender| (&*sender).flush())
358+
self.inner.do_io(|mut sender| sender.flush())
359359
}
360360
}
361361

@@ -498,21 +498,21 @@ impl event::Source for Receiver {
498498

499499
impl Read for Receiver {
500500
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
501-
self.inner.do_io(|sender| (&*sender).read(buf))
501+
self.inner.do_io(|mut sender| sender.read(buf))
502502
}
503503

504504
fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
505-
self.inner.do_io(|sender| (&*sender).read_vectored(bufs))
505+
self.inner.do_io(|mut sender| sender.read_vectored(bufs))
506506
}
507507
}
508508

509509
impl Read for &Receiver {
510510
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
511-
self.inner.do_io(|sender| (&*sender).read(buf))
511+
self.inner.do_io(|mut sender| sender.read(buf))
512512
}
513513

514514
fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
515-
self.inner.do_io(|sender| (&*sender).read_vectored(bufs))
515+
self.inner.do_io(|mut sender| sender.read_vectored(bufs))
516516
}
517517
}
518518

‎src/sys/unix/uds/mod.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -61,7 +61,7 @@ cfg_os_poll! {
6161
let offset = path_offset(&sockaddr);
6262
let mut socklen = offset + bytes.len();
6363

64-
match bytes.get(0) {
64+
match bytes.first() {
6565
// The struct has already been zeroes so the null byte for pathname
6666
// addresses is already there.
6767
Some(&0) | None => {}

‎src/sys/windows/iocp.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -206,7 +206,7 @@ impl CompletionStatus {
206206
/// A completion key is a per-handle key that is specified when it is added
207207
/// to an I/O completion port via `add_handle` or `add_socket`.
208208
pub fn token(&self) -> usize {
209-
self.0.lpCompletionKey as usize
209+
self.0.lpCompletionKey
210210
}
211211

212212
/// Returns a pointer to the `Overlapped` structure that was specified when
@@ -268,6 +268,6 @@ mod tests {
268268
}
269269
assert_eq!(s[2].bytes_transferred(), 0);
270270
assert_eq!(s[2].token(), 0);
271-
assert_eq!(s[2].overlapped(), 0 as *mut _);
271+
assert_eq!(s[2].overlapped(), std::ptr::null_mut());
272272
}
273273
}

‎src/sys/windows/mod.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -28,7 +28,7 @@ macro_rules! wsa_syscall {
2828
}
2929

3030
cfg_net! {
31-
pub(crate) mod stdnet;
31+
pub mod stdnet;
3232
pub(crate) mod uds;
3333
pub(crate) use self::uds::SocketAddr;
3434
}

‎src/sys/windows/net.rs‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,7 @@
11
use std::io;
22
use std::mem;
33
use std::net::SocketAddr;
4+
use std::sync::Once;
45

56
use windows_sys::Win32::Networking::WinSock::{
67
closesocket, ioctlsocket, socket, AF_INET, AF_INET6, FIONBIO, IN6_ADDR, IN6_ADDR_0,
@@ -74,7 +75,7 @@ pub(crate) fn socket_addr(addr: &SocketAddr) -> (SocketAddrCRepr, i32) {
7475
};
7576

7677
let sockaddr_in = SOCKADDR_IN {
77-
sin_family: AF_INET as u16, // 1
78+
sin_family: AF_INET, // 1
7879
sin_port: addr.port().to_be(),
7980
sin_addr,
8081
sin_zero: [0; 8],
@@ -96,7 +97,7 @@ pub(crate) fn socket_addr(addr: &SocketAddr) -> (SocketAddrCRepr, i32) {
9697
};
9798

9899
let sockaddr_in6 = SOCKADDR_IN6 {
99-
sin6_family: AF_INET6 as u16, // 23
100+
sin6_family: AF_INET6, // 23
100101
sin6_port: addr.port().to_be(),
101102
sin6_addr,
102103
sin6_flowinfo: addr.flowinfo(),

0 commit comments

Comments
 (0)