diff options
Diffstat (limited to '')
136 files changed, 31068 insertions, 0 deletions
diff --git a/third_party/rust/mio-0.6.23/.cargo-checksum.json b/third_party/rust/mio-0.6.23/.cargo-checksum.json new file mode 100644 index 0000000000..87772bc2e9 --- /dev/null +++ b/third_party/rust/mio-0.6.23/.cargo-checksum.json @@ -0,0 +1 @@ +{"files":{"CHANGELOG.md":"4ba3d031a78895b4251cc75585215ded07c2d4ca84b79dea5c55a68fd973a29d","Cargo.toml":"1cebd8a3a1509948b24b4de3ed6eedd2441f1a36e4831a2b2b3c38539b7ead70","LICENSE":"07919255c7e04793d8ea760d6c2ce32d19f9ff02bdbdde3ce90b1e1880929a9b","README.md":"eedc84973c97348ea27f93ac7d3232098438d4455c7eaedf6fcc7f105ac9f321","src/channel.rs":"b16493a2b74334156e153b1f4143b0e98d43cd4d7bff0275066dfa575dde2402","src/deprecated/event_loop.rs":"ba931d256e6e57d5635c6cfc6e3a4add4551c87f16457d901b334a129f9cf41d","src/deprecated/handler.rs":"13cbc0c193f43a331e125e05d5eddf3712fe86e41a8721186d3672518ef8a9cc","src/deprecated/io.rs":"4948217ffeeba4f508cc89744da5d6af858b4ad7b4be23f927a00df93bdf2984","src/deprecated/mod.rs":"4310471b5a1313dbf53b492769a3031b15353eb269333b7c1a890bc2709def7c","src/deprecated/notify.rs":"8cb108387ebcfb75764e4dd2868d80eb00d793c4b7c867c08cd86ef10b91b023","src/deprecated/unix.rs":"76c832e7db8263395b576930186fe1a3c472589bed41810d445d89f0eed684eb","src/event_imp.rs":"f8cff47dedc52dab9c7cc2d707f2c2d86d7185f942f02ace4c60353cc6094035","src/io.rs":"9207ffc93ea744b09bc6872fa4d378d7c75640f9ac38b1fa67b940c7cb5d0ade","src/lazycell.rs":"871dbd89f6918a354c2ec2d2a8b89e4aa30754e7e3e8dfcf2f5a6071156e39cf","src/lib.rs":"b875273d1852b6ef11a112fb27147587f5ed699e2c3ce99da3175358a8ff6fdd","src/net/mod.rs":"340c63a8efe9ee774b7bf8ed8c0f72fc7563e5c4b35f6a8b243f92d366e145a2","src/net/tcp.rs":"8b06dc8d2dd9fb7cd52db582fd7fe608b6a50cdf7ce18cf0abb9992956e95f6d","src/net/udp.rs":"8b5728924a07917d2845bbfb060cadb842b36a74d5372ac7707eb7f169a67d4d","src/poll.rs":"e76bb316deedbd9306f91ca8ab394d02b5676fa767746bd9770c5c9dff490426","src/sys/fuchsia/awakener.rs":"71a4a0083242457b0a96326c69c0f98b23dfdb97be96deb26ee02fa9d1dfb212","src/sys/fuchsia/eventedfd.rs":"bd8f43d2b61cdd6a5d0df9c0dc1cb43e1708140d01a05611055277ed55a33b63","src/sys/fuchsia/handles.rs":"161a69e8a8d7f71326a9c53bcb7685d0a81d184aba8e20da27c64aa27dfd56b2","src/sys/fuchsia/mod.rs":"9d80f1214abc93f48b6b6c12ce5b6cfaddbda592c8f3410564d0237228cae2d0","src/sys/fuchsia/net.rs":"50340191dd9cbe317bd6e6ae0170c03daa9141f15c96782b96484e3d8b8301b1","src/sys/fuchsia/ready.rs":"7e6bb7235c52ab4a2134d36cf982f6a4fd6e18050e737b40ee84c89a10a9faac","src/sys/fuchsia/selector.rs":"f3be7f8d683d43e4a8313246e4cacb9444549bf66ecb2234f0d0f53172043bf5","src/sys/mod.rs":"64bea046e4a9feb1f2e2fb8326452c1be8b9d56cf8794df0af4fbdf565204255","src/sys/unix/awakener.rs":"20a61d8f39b2f2abf4f166a3ed46fa0d79907ddf92758eaddb880c67321db56c","src/sys/unix/dlsym.rs":"559337d1f6c10e6c1172bd3908a9dcfa5a0828b53b04f7ca3a0d926afa85cd63","src/sys/unix/epoll.rs":"26b34910c87883f1b8170b95aed1bf3d9ecd9442c7afd23ff1b87d54391e2c88","src/sys/unix/eventedfd.rs":"a0bd2096ab5acf42c48110f024bc8ea052ba62c707345c7db46fea7a494388df","src/sys/unix/io.rs":"a518f09020f821e87bcf9c2ecb4bf501d428619ddfd7b35a26629b614919b14c","src/sys/unix/kqueue.rs":"3bf9f9635a8607569e3176998b61d1801e5bb35a94588c827a0a954656eee3ea","src/sys/unix/mod.rs":"15ddcfab101e7dfb926f82fd2d6eebb30c66f43fc2af00e4bb2f687c7059e0d0","src/sys/unix/ready.rs":"8494e27731d6842a90e01ec783d37001802f472f81358177e047d43b4bc68c43","src/sys/unix/tcp.rs":"19d483762fc8c8a1cb182b2f2ead85534f99394cf605a14d5ed46db7f3354667","src/sys/unix/udp.rs":"bc2e8ad142b17797a7d038e720ff57ac9840eb5b2b26696c854180085ccd1873","src/sys/unix/uds.rs":"5223d4d35048019d175679686cc65a08baf027df0b2127428e2f322bbb533309","src/sys/unix/uio.rs":"3942a49548dd3a37e5fd6044a103d92e2635965ace1ab370be10c82245b41f66","src/sys/windows/awakener.rs":"2d3cdaf8b523675e2f64c5fd81e1197d5255384517b9753b718c5c47acf0cabd","src/sys/windows/buffer_pool.rs":"636f4b7510a507f9985987699ce8ec140b2ed852abb231443ee1486c80759eed","src/sys/windows/from_raw_arc.rs":"659dabdf5037546e3783aacc422992b4248b0ba2ddcce52b149d35bc723550e5","src/sys/windows/mod.rs":"afeec8cd4e3adeaf6ffe68b134ad1b4ba07faa3abae96f6f9a00bbc20ff5f2c5","src/sys/windows/selector.rs":"0137276cff457f84511e007bb9527f5e082ec04e898b8f8e0acd39fe65c00148","src/sys/windows/tcp.rs":"9942db351f91229d01a0b9f52dd6c9680050d3abcee9fbb6b4f2f14896dc2c58","src/sys/windows/udp.rs":"1ef869b660bcf89ea6498552474abf8f540946631e14d5b610ca31014cd9045f","src/timer.rs":"540d521c5b4a79f3b1c01296ef2e14e2e3743192f25180ee6e71e367692ce762","src/token.rs":"4a56f851709470df2eed803c57c68b0a4b12ea86fa1b8d2c999bec7a85d58ec0","src/udp.rs":"442e620f3ea0cf010497d3ad775debd585f28e79a025993d40471c8e6839dc98"},"package":"4afd66f5b91bf2a3bc13fad0e21caedac168ca4c707504e75585648ae80e4cc4"}
\ No newline at end of file diff --git a/third_party/rust/mio-0.6.23/CHANGELOG.md b/third_party/rust/mio-0.6.23/CHANGELOG.md new file mode 100644 index 0000000000..c17ebd0151 --- /dev/null +++ b/third_party/rust/mio-0.6.23/CHANGELOG.md @@ -0,0 +1,227 @@ +# 0.6.23 (Dec 01, 2020) + +### Changed +- **MSRV**: Increased the MSRV from 1.18.0 (Jun 8, 2017) to 1.31.0 (Dec 6, + 2018) + (https://github.com/tokio-rs/mio/commit/4879e0d32ddfd98e762fc87240e594a3ad8fca30). + +### Fixed +- Work around Linux kernel < 2.6.37 bug on 32-bits making timeouts longer then + ~30 minutes effectively infinite + (https://github.com/tokio-rs/mio/commit/e7cba59950e9c9fa6194e29b5b1e72029e3df455). +- Update miow and net2 depedencies to get rid of invalid memory layout assumption + (https://github.com/tokio-rs/mio/commit/13f02ac0a86d7c0c0001e5ff8960a0b4340d075c). + +# 0.6.22 (May 01, 2020) + +### Added +- Add support for illumos target (#1294) + +# 0.6.21 (November 27, 2019) + +### Fixed +- remove `=` dependency on `cfg-if`. + +# 0.6.20 (November 21, 2019) + +### Fixed +- Use default IOCP concurrency value (#1161). +- setting FD_CLOEXEC in pipe (#1095). + +# 0.6.19 (May 28, 2018) + +### Fixed +- Do not trigger HUP events on kqueue platforms (#958). + +# 0.6.18 (May 24, 2018) + +### Fixed +- Fix compilation on kqueue platforms with 32bit C long (#948). + +# 0.6.17 (May 15, 2018) + +### Fixed +- Don't report `RDHUP` as `HUP` (#939) +- Fix lazycell related compilation issues. +- Fix EPOLLPRI conflicting with READABLE +- Abort process on ref count overflows + +### Added +- Define PRI on all targets + +# 0.6.16 (September 5, 2018) + +* Add EPOLLPRI readiness to UnixReady on supported platforms (#867) +* Reduce spurious awaken calls (#875) + +# 0.6.15 (July 3, 2018) + +* Implement `Evented` for containers (#840). +* Fix android-aarch64 build (#850). + +# 0.6.14 (March 8, 2018) + +* Add `Poll::poll_interruptible` (#811) +* Add `Ready::all` and `usize` conversions (#825) + +# 0.6.13 (February 5, 2018) + +* Fix build on DragonFlyBSD. +* Add `TcpListener::from_std` that does not require the socket addr. +* Deprecate `TcpListener::from_listener` in favor of from_std. + +# 0.6.12 (January 5, 2018) + +* Add `TcpStream::peek` function (#773). +* Raise minimum Rust version to 1.18.0. +* `Poll`: retry select() when interrupted by a signal (#742). +* Deprecate `Events` index access (#713). +* Add `Events::clear` (#782). +* Add support for `lio_listio` (#780). + +# 0.6.11 (October 25, 2017) + +* Allow register to take empty interest (#640). +* Fix bug with TCP errors on windows (#725). +* Add TcpListener::accept_std (#733). +* Update IoVec to fix soundness bug -- includes behavior change. (#747). +* Minimum Rust version is now 1.14.0. +* Fix Android x86_64 build. +* Misc API & doc polish. + +# 0.6.10 (July 27, 2017) + +* Experimental support for Fuchsia +* Add `only_v6` option for UDP sockets +* Fix build on NetBSD +* Minimum Rust version is now 1.13.0 +* Assignment operators (e.g. `|=`) are now implemented for `Ready` + +# 0.6.9 (June 7, 2017) + +* More socket options are exposed through the TCP types, brought in through the + `net2` crate. + +# 0.6.8 (May 26, 2017) + +* Support Fuchia +* POSIX AIO support +* Fix memory leak caused by Register::new2 +* Windows: fix handling failed TCP connections +* Fix build on aarch64-linux-android +* Fix usage of `O_CLOEXEC` with `SETFL` + +# 0.6.7 (April 27, 2017) + +* Ignore EPIPE coming out of `kevent` +* Timer thread should exit when timer is dropped. + +# 0.6.6 (March 22, 2017) + +* Add send(), recv() and connect() to UDPSocket. +* Fix bug in custom readiness queue +* Move net types into `net` module + +# 0.6.5 (March 14, 2017) + +* Misc improvements to kqueue bindings +* Add official support for iOS, Android, BSD +* Reimplement custom readiness queue +* `Poll` is now `Sync` +* Officially deprecate non-core functionality (timers, channel, etc...) +* `Registration` now implements `Evented` +* Fix bug around error conditions with `connect` on windows. +* Use iovec crate for scatter / gather operations +* Only support readable and writable readiness on all platforms +* Expose additional readiness in a platform specific capacity + +# 0.6.4 (January 24, 2017) + +* Fix compilation on musl +* Add `TcpStream::from_stream` which converts a std TCP stream to Mio. + +# 0.6.3 (January 22, 2017) + +* Implement readv/writev for `TcpStream`, allowing vectored reads/writes to + work across platforms +* Remove `nix` dependency +* Implement `Display` and `Error` for some channel error types. +* Optimize TCP on Windows through `SetFileCompletionNotificationModes` + +# 0.6.2 (December 18, 2016) + +* Allow registration of custom handles on Windows (like `EventedFd` on Unix) +* Send only one byte for the awakener on Unix instead of four +* Fix a bug in the timer implementation which caused an infinite loop + +# 0.6.1 (October 30, 2016) + +* Update dependency of `libc` to 0.2.16 +* Fix channel `dec` logic +* Fix a timer bug around timeout cancellation +* Don't allocate buffers for TCP reads on Windows +* Touched up documentation in a few places +* Fix an infinite looping timer thread on OSX +* Fix compile on 32-bit OSX +* Fix compile on FreeBSD + +# 0.6.0 (September 2, 2016) + +* Shift primary API towards `Poll` +* `EventLoop` and types to `deprecated` mod. All contents of the + `deprecated` mod will be removed by Mio 1.0. +* Increase minimum supported Rust version to 1.9.0 +* Deprecate unix domain socket implementation in favor of using a + version external to Mio. For example: https://github.com/alexcrichton/mio-uds. +* Remove various types now included in `std` +* Updated TCP & UDP APIs to match the versions in `std` +* Enable implementing `Evented` for any type via `Registration` +* Rename `IoEvent` -> `Event` +* Access `Event` data via functions vs. public fields. +* Expose `Events` as a public type that is passed into `Poll` +* Use `std::time::Duration` for all APIs that require a time duration. +* Polled events are now retrieved via `Events` type. +* Implement `std::error::Error` for `TimerError` +* Relax `Send` bound on notify messages. +* Remove `Clone` impl for `Timeout` (future proof) +* Remove `mio::prelude` +* Remove `mio::util` +* Remove dependency on bytes + +# 0.5.0 (December 3, 2015) + +* Windows support (#239) +* NetBSD support (#306) +* Android support (#295) +* Don't re-export bytes types +* Renamed `EventLoop::register_opt` to `EventLoop::register` (#257) +* `EventLoopConfig` is now a builder instead of having public struct fields. It + is also no longer `Copy`. (#259) +* `TcpSocket` is no longer exported in the public API (#262) +* Integrate with net2. (#262) +* `TcpListener` now returns the remote peer address from `accept` as well (#275) +* The `UdpSocket::{send_to, recv_from}` methods are no longer generic over `Buf` + or `MutBuf` but instead take slices directly. The return types have also been + updated to return the number of bytes transferred. (#260) +* Fix bug with kqueue where an error on registration prevented the + changelist from getting flushed (#276) +* Support sending/receiving FDs over UNIX sockets (#291) +* Mio's socket types are permanently associated with an EventLoop (#308) +* Reduce unnecessary poll wakeups (#314) + + +# 0.4.1 (July 21, 2015) + +* [BUGFIX] Fix notify channel concurrency bug (#216) + +# 0.4.0 (July 16, 2015) + +* [BUGFIX] EventLoop::register requests all events, not just readable. +* [BUGFIX] Attempting to send a message to a shutdown event loop fails correctly. +* [FEATURE] Expose TCP shutdown +* [IMPROVEMENT] Coalesce readable & writable into `ready` event (#184) +* [IMPROVEMENT] Rename TryRead & TryWrite function names to avoid conflict with std. +* [IMPROVEMENT] Provide TCP and UDP types in Mio (path to windows #155) +* [IMPROVEMENT] Use clock_ticks crate instead of time (path to windows #155) +* [IMPROVEMENT] Move unix specific features into mio::unix module +* [IMPROVEMENT] TcpListener sets SO_REUSEADDR by default diff --git a/third_party/rust/mio-0.6.23/Cargo.toml b/third_party/rust/mio-0.6.23/Cargo.toml new file mode 100644 index 0000000000..08c5ac150f --- /dev/null +++ b/third_party/rust/mio-0.6.23/Cargo.toml @@ -0,0 +1,70 @@ +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g. crates.io) dependencies +# +# If you believe there's an error in this file please file an +# issue against the rust-lang/cargo repository. If you're +# editing this file be aware that the upstream Cargo.toml +# will likely look very different (and much more reasonable) + +[package] +name = "mio" +version = "0.6.23" +authors = ["Carl Lerche <me@carllerche.com>"] +include = ["Cargo.toml", "LICENSE", "README.md", "CHANGELOG.md", "src/**/*.rs"] +description = "Lightweight non-blocking IO" +homepage = "https://github.com/tokio-rs/mio" +documentation = "https://docs.rs/mio/0.6.23/mio/" +readme = "README.md" +keywords = ["io", "async", "non-blocking"] +categories = ["asynchronous"] +license = "MIT" +repository = "https://github.com/tokio-rs/mio" + +[[test]] +name = "test" +path = "test/mod.rs" +[dependencies.cfg-if] +version = "0.1.9" + +[dependencies.iovec] +version = "0.1.1" + +[dependencies.log] +version = "0.4" + +[dependencies.net2] +version = "0.2.36" + +[dependencies.slab] +version = "0.4.0" +[dev-dependencies.bytes] +version = "0.3.0" + +[dev-dependencies.env_logger] +version = "0.4.0" +default-features = false + +[dev-dependencies.tempdir] +version = "0.3.4" + +[features] +default = ["with-deprecated"] +with-deprecated = [] +[target."cfg(target_os = \"fuchsia\")".dependencies.fuchsia-zircon] +version = "0.3.2" + +[target."cfg(target_os = \"fuchsia\")".dependencies.fuchsia-zircon-sys] +version = "0.3.2" +[target."cfg(unix)".dependencies.libc] +version = "0.2.54" + +[target."cfg(windows)".dependencies.miow] +version = "0.3" + +[target."cfg(windows)".dependencies.winapi] +version = "0.3" +features = ["ioapiset", "minwinbase", "minwindef", "winbase", "winerror", "winnt"] diff --git a/third_party/rust/mio-0.6.23/LICENSE b/third_party/rust/mio-0.6.23/LICENSE new file mode 100644 index 0000000000..3516413824 --- /dev/null +++ b/third_party/rust/mio-0.6.23/LICENSE @@ -0,0 +1,19 @@ +Copyright (c) 2014 Carl Lerche and other MIO contributors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/third_party/rust/mio-0.6.23/README.md b/third_party/rust/mio-0.6.23/README.md new file mode 100644 index 0000000000..2a472bba46 --- /dev/null +++ b/third_party/rust/mio-0.6.23/README.md @@ -0,0 +1,90 @@ +# Mio – Metal IO + +Mio is a lightweight I/O library for Rust with a focus on adding as little +overhead as possible over the OS abstractions. + +[![Crates.io][crates-badge]][crates-url] +[![MIT licensed][mit-badge]][mit-url] +[![Build Status][azure-badge]][azure-url] +[![Build Status][cirrus-badge]][cirrus-url] + +[crates-badge]: https://img.shields.io/crates/v/mio.svg +[crates-url]: https://crates.io/crates/mio +[mit-badge]: https://img.shields.io/badge/license-MIT-blue.svg +[mit-url]: LICENSE +[azure-badge]: https://dev.azure.com/tokio-rs/Tokio/_apis/build/status/tokio-rs.mio?branchName=master +[azure-url]: https://dev.azure.com/tokio-rs/Tokio/_build/latest?definitionId=2&branchName=master +[cirrus-badge]: https://api.cirrus-ci.com/github/carllerche/mio.svg +[cirrus-url]: https://cirrus-ci.com/github/carllerche/mio + +**API documentation** + +* [master](https://tokio-rs.github.io/mio/doc/mio/) +* [v0.6](https://docs.rs/mio/^0.6) + +This is a low level library, if you are looking for something easier to get +started with, see [Tokio](https://tokio.rs). + +## Usage + +To use `mio`, first add this to your `Cargo.toml`: + +```toml +[dependencies] +mio = "0.6" +``` + +Then, add this to your crate root: + +```rust +extern crate mio; +``` + +## Features + +* Non-blocking TCP, UDP. +* I/O event notification queue backed by epoll, kqueue, and IOCP. +* Zero allocations at runtime +* Platform specific extensions. + +## Non-goals + +The following are specifically omitted from Mio and are left to the user +or higher-level libraries. + +* File operations +* Thread pools / multi-threaded event loop +* Timers + +## Platforms + +Currently supported platforms: + +* Linux +* OS X +* Windows +* FreeBSD +* NetBSD +* Solaris +* Android +* iOS + +There are potentially others. If you find that Mio works on another +platform, submit a PR to update the list! + +## Community + +A group of Mio users hang out in the #mio channel on the Mozilla IRC +server (irc.mozilla.org). This can be a good place to go for questions. + +## Contributing + +Interested in getting involved? We would love to help you! For simple +bug fixes, just submit a PR with the fix and we can discuss the fix +directly in the PR. If the fix is more complex, start with an issue. + +If you want to propose an API change, create an issue to start a +discussion with the community. Also, feel free to talk with us in the +IRC channel. + +Finally, be kind. We support the [Rust Code of Conduct](https://www.rust-lang.org/conduct.html). diff --git a/third_party/rust/mio-0.6.23/src/channel.rs b/third_party/rust/mio-0.6.23/src/channel.rs new file mode 100644 index 0000000000..7077c51f86 --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/channel.rs @@ -0,0 +1,390 @@ +//! Thread safe communication channel implementing `Evented` + +#![allow(unused_imports, deprecated, missing_debug_implementations)] + +use {io, Ready, Poll, PollOpt, Registration, SetReadiness, Token}; +use event::Evented; +use lazycell::{LazyCell, AtomicLazyCell}; +use std::any::Any; +use std::fmt; +use std::error; +use std::sync::{mpsc, Arc}; +use std::sync::atomic::{AtomicUsize, Ordering}; + +/// Creates a new asynchronous channel, where the `Receiver` can be registered +/// with `Poll`. +pub fn channel<T>() -> (Sender<T>, Receiver<T>) { + let (tx_ctl, rx_ctl) = ctl_pair(); + let (tx, rx) = mpsc::channel(); + + let tx = Sender { + tx, + ctl: tx_ctl, + }; + + let rx = Receiver { + rx, + ctl: rx_ctl, + }; + + (tx, rx) +} + +/// Creates a new synchronous, bounded channel where the `Receiver` can be +/// registered with `Poll`. +pub fn sync_channel<T>(bound: usize) -> (SyncSender<T>, Receiver<T>) { + let (tx_ctl, rx_ctl) = ctl_pair(); + let (tx, rx) = mpsc::sync_channel(bound); + + let tx = SyncSender { + tx, + ctl: tx_ctl, + }; + + let rx = Receiver { + rx, + ctl: rx_ctl, + }; + + (tx, rx) +} + +pub fn ctl_pair() -> (SenderCtl, ReceiverCtl) { + let inner = Arc::new(Inner { + pending: AtomicUsize::new(0), + senders: AtomicUsize::new(1), + set_readiness: AtomicLazyCell::new(), + }); + + let tx = SenderCtl { + inner: inner.clone(), + }; + + let rx = ReceiverCtl { + registration: LazyCell::new(), + inner, + }; + + (tx, rx) +} + +/// Tracks messages sent on a channel in order to update readiness. +pub struct SenderCtl { + inner: Arc<Inner>, +} + +/// Tracks messages received on a channel in order to track readiness. +pub struct ReceiverCtl { + registration: LazyCell<Registration>, + inner: Arc<Inner>, +} + +pub struct Sender<T> { + tx: mpsc::Sender<T>, + ctl: SenderCtl, +} + +pub struct SyncSender<T> { + tx: mpsc::SyncSender<T>, + ctl: SenderCtl, +} + +pub struct Receiver<T> { + rx: mpsc::Receiver<T>, + ctl: ReceiverCtl, +} + +pub enum SendError<T> { + Io(io::Error), + Disconnected(T), +} + +pub enum TrySendError<T> { + Io(io::Error), + Full(T), + Disconnected(T), +} + +struct Inner { + // The number of outstanding messages for the receiver to read + pending: AtomicUsize, + // The number of sender handles + senders: AtomicUsize, + // The set readiness handle + set_readiness: AtomicLazyCell<SetReadiness>, +} + +impl<T> Sender<T> { + pub fn send(&self, t: T) -> Result<(), SendError<T>> { + self.tx.send(t) + .map_err(SendError::from) + .and_then(|_| { + self.ctl.inc()?; + Ok(()) + }) + } +} + +impl<T> Clone for Sender<T> { + fn clone(&self) -> Sender<T> { + Sender { + tx: self.tx.clone(), + ctl: self.ctl.clone(), + } + } +} + +impl<T> SyncSender<T> { + pub fn send(&self, t: T) -> Result<(), SendError<T>> { + self.tx.send(t) + .map_err(From::from) + .and_then(|_| { + self.ctl.inc()?; + Ok(()) + }) + } + + pub fn try_send(&self, t: T) -> Result<(), TrySendError<T>> { + self.tx.try_send(t) + .map_err(From::from) + .and_then(|_| { + self.ctl.inc()?; + Ok(()) + }) + } +} + +impl<T> Clone for SyncSender<T> { + fn clone(&self) -> SyncSender<T> { + SyncSender { + tx: self.tx.clone(), + ctl: self.ctl.clone(), + } + } +} + +impl<T> Receiver<T> { + pub fn try_recv(&self) -> Result<T, mpsc::TryRecvError> { + self.rx.try_recv().and_then(|res| { + let _ = self.ctl.dec(); + Ok(res) + }) + } +} + +impl<T> Evented for Receiver<T> { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + self.ctl.register(poll, token, interest, opts) + } + + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + self.ctl.reregister(poll, token, interest, opts) + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + self.ctl.deregister(poll) + } +} + +/* + * + * ===== SenderCtl / ReceiverCtl ===== + * + */ + +impl SenderCtl { + /// Call to track that a message has been sent + pub fn inc(&self) -> io::Result<()> { + let cnt = self.inner.pending.fetch_add(1, Ordering::Acquire); + + if 0 == cnt { + // Toggle readiness to readable + if let Some(set_readiness) = self.inner.set_readiness.borrow() { + set_readiness.set_readiness(Ready::readable())?; + } + } + + Ok(()) + } +} + +impl Clone for SenderCtl { + fn clone(&self) -> SenderCtl { + self.inner.senders.fetch_add(1, Ordering::Relaxed); + SenderCtl { inner: self.inner.clone() } + } +} + +impl Drop for SenderCtl { + fn drop(&mut self) { + if self.inner.senders.fetch_sub(1, Ordering::Release) == 1 { + let _ = self.inc(); + } + } +} + +impl ReceiverCtl { + pub fn dec(&self) -> io::Result<()> { + let first = self.inner.pending.load(Ordering::Acquire); + + if first == 1 { + // Unset readiness + if let Some(set_readiness) = self.inner.set_readiness.borrow() { + set_readiness.set_readiness(Ready::empty())?; + } + } + + // Decrement + let second = self.inner.pending.fetch_sub(1, Ordering::AcqRel); + + if first == 1 && second > 1 { + // There are still pending messages. Since readiness was + // previously unset, it must be reset here + if let Some(set_readiness) = self.inner.set_readiness.borrow() { + set_readiness.set_readiness(Ready::readable())?; + } + } + + Ok(()) + } +} + +impl Evented for ReceiverCtl { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + if self.registration.borrow().is_some() { + return Err(io::Error::new(io::ErrorKind::Other, "receiver already registered")); + } + + let (registration, set_readiness) = Registration::new(poll, token, interest, opts); + + + if self.inner.pending.load(Ordering::Relaxed) > 0 { + // TODO: Don't drop readiness + let _ = set_readiness.set_readiness(Ready::readable()); + } + + self.registration.fill(registration).expect("unexpected state encountered"); + self.inner.set_readiness.fill(set_readiness).expect("unexpected state encountered"); + + Ok(()) + } + + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + match self.registration.borrow() { + Some(registration) => registration.update(poll, token, interest, opts), + None => Err(io::Error::new(io::ErrorKind::Other, "receiver not registered")), + } + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + match self.registration.borrow() { + Some(registration) => registration.deregister(poll), + None => Err(io::Error::new(io::ErrorKind::Other, "receiver not registered")), + } + } +} + +/* + * + * ===== Error conversions ===== + * + */ + +impl<T> From<mpsc::SendError<T>> for SendError<T> { + fn from(src: mpsc::SendError<T>) -> SendError<T> { + SendError::Disconnected(src.0) + } +} + +impl<T> From<io::Error> for SendError<T> { + fn from(src: io::Error) -> SendError<T> { + SendError::Io(src) + } +} + +impl<T> From<mpsc::TrySendError<T>> for TrySendError<T> { + fn from(src: mpsc::TrySendError<T>) -> TrySendError<T> { + match src { + mpsc::TrySendError::Full(v) => TrySendError::Full(v), + mpsc::TrySendError::Disconnected(v) => TrySendError::Disconnected(v), + } + } +} + +impl<T> From<mpsc::SendError<T>> for TrySendError<T> { + fn from(src: mpsc::SendError<T>) -> TrySendError<T> { + TrySendError::Disconnected(src.0) + } +} + +impl<T> From<io::Error> for TrySendError<T> { + fn from(src: io::Error) -> TrySendError<T> { + TrySendError::Io(src) + } +} + +/* + * + * ===== Implement Error, Debug and Display for Errors ===== + * + */ + +impl<T: Any> error::Error for SendError<T> { + fn description(&self) -> &str { + match *self { + SendError::Io(ref io_err) => io_err.description(), + SendError::Disconnected(..) => "Disconnected", + } + } +} + +impl<T: Any> error::Error for TrySendError<T> { + fn description(&self) -> &str { + match *self { + TrySendError::Io(ref io_err) => io_err.description(), + TrySendError::Full(..) => "Full", + TrySendError::Disconnected(..) => "Disconnected", + } + } +} + +impl<T> fmt::Debug for SendError<T> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + format_send_error(self, f) + } +} + +impl<T> fmt::Display for SendError<T> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + format_send_error(self, f) + } +} + +impl<T> fmt::Debug for TrySendError<T> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + format_try_send_error(self, f) + } +} + +impl<T> fmt::Display for TrySendError<T> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + format_try_send_error(self, f) + } +} + +#[inline] +fn format_send_error<T>(e: &SendError<T>, f: &mut fmt::Formatter) -> fmt::Result { + match *e { + SendError::Io(ref io_err) => write!(f, "{}", io_err), + SendError::Disconnected(..) => write!(f, "Disconnected"), + } +} + +#[inline] +fn format_try_send_error<T>(e: &TrySendError<T>, f: &mut fmt::Formatter) -> fmt::Result { + match *e { + TrySendError::Io(ref io_err) => write!(f, "{}", io_err), + TrySendError::Full(..) => write!(f, "Full"), + TrySendError::Disconnected(..) => write!(f, "Disconnected"), + } +} diff --git a/third_party/rust/mio-0.6.23/src/deprecated/event_loop.rs b/third_party/rust/mio-0.6.23/src/deprecated/event_loop.rs new file mode 100644 index 0000000000..a4c4580b3a --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/deprecated/event_loop.rs @@ -0,0 +1,346 @@ +use {channel, Poll, Events, Token}; +use event::Evented; +use deprecated::{Handler, NotifyError}; +use event_imp::{Event, Ready, PollOpt}; +use timer::{self, Timer, Timeout}; +use std::{io, fmt, usize}; +use std::default::Default; +use std::time::Duration; + +#[derive(Debug, Default, Clone)] +pub struct EventLoopBuilder { + config: Config, +} + +/// `EventLoop` configuration details +#[derive(Clone, Debug)] +struct Config { + // == Notifications == + notify_capacity: usize, + messages_per_tick: usize, + + // == Timer == + timer_tick: Duration, + timer_wheel_size: usize, + timer_capacity: usize, +} + +impl Default for Config { + fn default() -> Config { + // Default EventLoop configuration values + Config { + notify_capacity: 4_096, + messages_per_tick: 256, + timer_tick: Duration::from_millis(100), + timer_wheel_size: 1_024, + timer_capacity: 65_536, + } + } +} + +impl EventLoopBuilder { + /// Construct a new `EventLoopBuilder` with the default configuration + /// values. + pub fn new() -> EventLoopBuilder { + EventLoopBuilder::default() + } + + /// Sets the maximum number of messages that can be buffered on the event + /// loop's notification channel before a send will fail. + /// + /// The default value for this is 4096. + pub fn notify_capacity(&mut self, capacity: usize) -> &mut Self { + self.config.notify_capacity = capacity; + self + } + + /// Sets the maximum number of messages that can be processed on any tick of + /// the event loop. + /// + /// The default value for this is 256. + pub fn messages_per_tick(&mut self, messages: usize) -> &mut Self { + self.config.messages_per_tick = messages; + self + } + + pub fn timer_tick(&mut self, val: Duration) -> &mut Self { + self.config.timer_tick = val; + self + } + + pub fn timer_wheel_size(&mut self, size: usize) -> &mut Self { + self.config.timer_wheel_size = size; + self + } + + pub fn timer_capacity(&mut self, cap: usize) -> &mut Self { + self.config.timer_capacity = cap; + self + } + + /// Constructs a new `EventLoop` using the configured values. The + /// `EventLoop` will not be running. + pub fn build<H: Handler>(self) -> io::Result<EventLoop<H>> { + EventLoop::configured(self.config) + } +} + +/// Single threaded IO event loop. +pub struct EventLoop<H: Handler> { + run: bool, + poll: Poll, + events: Events, + timer: Timer<H::Timeout>, + notify_tx: channel::SyncSender<H::Message>, + notify_rx: channel::Receiver<H::Message>, + config: Config, +} + +// Token used to represent notifications +const NOTIFY: Token = Token(usize::MAX - 1); +const TIMER: Token = Token(usize::MAX - 2); + +impl<H: Handler> EventLoop<H> { + + /// Constructs a new `EventLoop` using the default configuration values. + /// The `EventLoop` will not be running. + pub fn new() -> io::Result<EventLoop<H>> { + EventLoop::configured(Config::default()) + } + + fn configured(config: Config) -> io::Result<EventLoop<H>> { + // Create the IO poller + let poll = Poll::new()?; + + let timer = timer::Builder::default() + .tick_duration(config.timer_tick) + .num_slots(config.timer_wheel_size) + .capacity(config.timer_capacity) + .build(); + + // Create cross thread notification queue + let (tx, rx) = channel::sync_channel(config.notify_capacity); + + // Register the notification wakeup FD with the IO poller + poll.register(&rx, NOTIFY, Ready::readable(), PollOpt::edge() | PollOpt::oneshot())?; + poll.register(&timer, TIMER, Ready::readable(), PollOpt::edge())?; + + Ok(EventLoop { + run: true, + poll, + timer, + notify_tx: tx, + notify_rx: rx, + config, + events: Events::with_capacity(1024), + }) + } + + /// Returns a sender that allows sending messages to the event loop in a + /// thread-safe way, waking up the event loop if needed. + /// + /// # Implementation Details + /// + /// Each [EventLoop](#) contains a lock-free queue with a pre-allocated + /// buffer size. The size can be changed by modifying + /// [EventLoopConfig.notify_capacity](struct.EventLoopConfig.html#method.notify_capacity). + /// When a message is sent to the EventLoop, it is first pushed on to the + /// queue. Then, if the EventLoop is currently running, an atomic flag is + /// set to indicate that the next loop iteration should be started without + /// waiting. + /// + /// If the loop is blocked waiting for IO events, then it is woken up. The + /// strategy for waking up the event loop is platform dependent. For + /// example, on a modern Linux OS, eventfd is used. On older OSes, a pipe + /// is used. + /// + /// The strategy of setting an atomic flag if the event loop is not already + /// sleeping allows avoiding an expensive wakeup operation if at all possible. + pub fn channel(&self) -> Sender<H::Message> { + Sender::new(self.notify_tx.clone()) + } + + /// Schedules a timeout after the requested time interval. When the + /// duration has been reached, + /// [Handler::timeout](trait.Handler.html#method.timeout) will be invoked + /// passing in the supplied token. + /// + /// Returns a handle to the timeout that can be used to cancel the timeout + /// using [#clear_timeout](#method.clear_timeout). + pub fn timeout(&mut self, token: H::Timeout, delay: Duration) -> timer::Result<Timeout> { + self.timer.set_timeout(delay, token) + } + + /// If the supplied timeout has not been triggered, cancel it such that it + /// will not be triggered in the future. + pub fn clear_timeout(&mut self, timeout: &Timeout) -> bool { + self.timer.cancel_timeout(&timeout).is_some() + } + + /// Tells the event loop to exit after it is done handling all events in the + /// current iteration. + pub fn shutdown(&mut self) { + self.run = false; + } + + /// Indicates whether the event loop is currently running. If it's not it has either + /// stopped or is scheduled to stop on the next tick. + pub fn is_running(&self) -> bool { + self.run + } + + /// Registers an IO handle with the event loop. + pub fn register<E: ?Sized>(&mut self, io: &E, token: Token, interest: Ready, opt: PollOpt) -> io::Result<()> + where E: Evented + { + self.poll.register(io, token, interest, opt) + } + + /// Re-Registers an IO handle with the event loop. + pub fn reregister<E: ?Sized>(&mut self, io: &E, token: Token, interest: Ready, opt: PollOpt) -> io::Result<()> + where E: Evented + { + self.poll.reregister(io, token, interest, opt) + } + + /// Keep spinning the event loop indefinitely, and notify the handler whenever + /// any of the registered handles are ready. + pub fn run(&mut self, handler: &mut H) -> io::Result<()> { + self.run = true; + + while self.run { + // Execute ticks as long as the event loop is running + self.run_once(handler, None)?; + } + + Ok(()) + } + + /// Deregisters an IO handle with the event loop. + /// + /// Both kqueue and epoll will automatically clear any pending events when closing a + /// file descriptor (socket). In that case, this method does not need to be called + /// prior to dropping a connection from the slab. + /// + /// Warning: kqueue effectively builds in deregister when using edge-triggered mode with + /// oneshot. Calling `deregister()` on the socket will cause a TcpStream error. + pub fn deregister<E: ?Sized>(&mut self, io: &E) -> io::Result<()> where E: Evented { + self.poll.deregister(io) + } + + /// Spin the event loop once, with a given timeout (forever if `None`), + /// and notify the handler if any of the registered handles become ready + /// during that time. + pub fn run_once(&mut self, handler: &mut H, timeout: Option<Duration>) -> io::Result<()> { + trace!("event loop tick"); + + // Check the registered IO handles for any new events. Each poll + // is for one second, so a shutdown request can last as long as + // one second before it takes effect. + let events = match self.io_poll(timeout) { + Ok(e) => e, + Err(err) => { + if err.kind() == io::ErrorKind::Interrupted { + handler.interrupted(self); + 0 + } else { + return Err(err); + } + } + }; + + self.io_process(handler, events); + handler.tick(self); + Ok(()) + } + + #[inline] + fn io_poll(&mut self, timeout: Option<Duration>) -> io::Result<usize> { + self.poll.poll(&mut self.events, timeout) + } + + // Process IO events that have been previously polled + fn io_process(&mut self, handler: &mut H, cnt: usize) { + let mut i = 0; + + trace!("io_process(..); cnt={}; len={}", cnt, self.events.len()); + + // Iterate over the notifications. Each event provides the token + // it was registered with (which usually represents, at least, the + // handle that the event is about) as well as information about + // what kind of event occurred (readable, writable, signal, etc.) + while i < cnt { + let evt = self.events.get(i).unwrap(); + + trace!("event={:?}; idx={:?}", evt, i); + + match evt.token() { + NOTIFY => self.notify(handler), + TIMER => self.timer_process(handler), + _ => self.io_event(handler, evt) + } + + i += 1; + } + } + + fn io_event(&mut self, handler: &mut H, evt: Event) { + handler.ready(self, evt.token(), evt.readiness()); + } + + fn notify(&mut self, handler: &mut H) { + for _ in 0..self.config.messages_per_tick { + match self.notify_rx.try_recv() { + Ok(msg) => handler.notify(self, msg), + _ => break, + } + } + + // Re-register + let _ = self.poll.reregister(&self.notify_rx, NOTIFY, Ready::readable(), PollOpt::edge() | PollOpt::oneshot()); + } + + fn timer_process(&mut self, handler: &mut H) { + while let Some(t) = self.timer.poll() { + handler.timeout(self, t); + } + } +} + +impl<H: Handler> fmt::Debug for EventLoop<H> { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("EventLoop") + .field("run", &self.run) + .field("poll", &self.poll) + .field("config", &self.config) + .finish() + } +} + +/// Sends messages to the EventLoop from other threads. +pub struct Sender<M> { + tx: channel::SyncSender<M> +} + +impl<M> fmt::Debug for Sender<M> { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + write!(fmt, "Sender<?> {{ ... }}") + } +} + +impl<M> Clone for Sender <M> { + fn clone(&self) -> Sender<M> { + Sender { tx: self.tx.clone() } + } +} + +impl<M> Sender<M> { + fn new(tx: channel::SyncSender<M>) -> Sender<M> { + Sender { tx } + } + + pub fn send(&self, msg: M) -> Result<(), NotifyError<M>> { + self.tx.try_send(msg)?; + Ok(()) + } +} diff --git a/third_party/rust/mio-0.6.23/src/deprecated/handler.rs b/third_party/rust/mio-0.6.23/src/deprecated/handler.rs new file mode 100644 index 0000000000..db1bc314a7 --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/deprecated/handler.rs @@ -0,0 +1,37 @@ +use {Ready, Token}; +use deprecated::{EventLoop}; + +#[allow(unused_variables)] +pub trait Handler: Sized { + type Timeout; + type Message; + + /// Invoked when the socket represented by `token` is ready to be operated + /// on. `events` indicates the specific operations that are + /// ready to be performed. + /// + /// For example, when a TCP socket is ready to be read from, `events` will + /// have `readable` set. When the socket is ready to be written to, + /// `events` will have `writable` set. + /// + /// This function will only be invoked a single time per socket per event + /// loop tick. + fn ready(&mut self, event_loop: &mut EventLoop<Self>, token: Token, events: Ready) { + } + + /// Invoked when a message has been received via the event loop's channel. + fn notify(&mut self, event_loop: &mut EventLoop<Self>, msg: Self::Message) { + } + + /// Invoked when a timeout has completed. + fn timeout(&mut self, event_loop: &mut EventLoop<Self>, timeout: Self::Timeout) { + } + + /// Invoked when `EventLoop` has been interrupted by a signal interrupt. + fn interrupted(&mut self, event_loop: &mut EventLoop<Self>) { + } + + /// Invoked at the end of an event loop tick. + fn tick(&mut self, event_loop: &mut EventLoop<Self>) { + } +} diff --git a/third_party/rust/mio-0.6.23/src/deprecated/io.rs b/third_party/rust/mio-0.6.23/src/deprecated/io.rs new file mode 100644 index 0000000000..16ff27993b --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/deprecated/io.rs @@ -0,0 +1,28 @@ +use ::io::MapNonBlock; +use std::io::{self, Read, Write}; + +pub trait TryRead { + fn try_read(&mut self, buf: &mut [u8]) -> io::Result<Option<usize>>; +} + +pub trait TryWrite { + fn try_write(&mut self, buf: &[u8]) -> io::Result<Option<usize>>; +} + +impl<T: Read> TryRead for T { + fn try_read(&mut self, dst: &mut [u8]) -> io::Result<Option<usize>> { + self.read(dst).map_non_block() + } +} + +impl<T: Write> TryWrite for T { + fn try_write(&mut self, src: &[u8]) -> io::Result<Option<usize>> { + self.write(src).map_non_block() + } +} + +pub trait TryAccept { + type Output; + + fn accept(&self) -> io::Result<Option<Self::Output>>; +} diff --git a/third_party/rust/mio-0.6.23/src/deprecated/mod.rs b/third_party/rust/mio-0.6.23/src/deprecated/mod.rs new file mode 100644 index 0000000000..124a2eee3d --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/deprecated/mod.rs @@ -0,0 +1,36 @@ +#![allow(deprecated)] + +mod event_loop; +mod io; +mod handler; +mod notify; + +#[cfg(all(unix, not(target_os = "fuchsia")))] +pub mod unix; + +pub use self::event_loop::{ + EventLoop, + EventLoopBuilder, + Sender, +}; +pub use self::io::{ + TryAccept, + TryRead, + TryWrite, +}; +pub use self::handler::{ + Handler, +}; +pub use self::notify::{ + NotifyError, +}; +#[cfg(all(unix, not(target_os = "fuchsia")))] +pub use self::unix::{ + pipe, + PipeReader, + PipeWriter, + UnixListener, + UnixSocket, + UnixStream, + Shutdown, +}; diff --git a/third_party/rust/mio-0.6.23/src/deprecated/notify.rs b/third_party/rust/mio-0.6.23/src/deprecated/notify.rs new file mode 100644 index 0000000000..c8432d6b0e --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/deprecated/notify.rs @@ -0,0 +1,63 @@ +use {channel}; +use std::{fmt, io, error, any}; + +pub enum NotifyError<T> { + Io(io::Error), + Full(T), + Closed(Option<T>), +} + +impl<M> fmt::Debug for NotifyError<M> { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + match *self { + NotifyError::Io(ref e) => { + write!(fmt, "NotifyError::Io({:?})", e) + } + NotifyError::Full(..) => { + write!(fmt, "NotifyError::Full(..)") + } + NotifyError::Closed(..) => { + write!(fmt, "NotifyError::Closed(..)") + } + } + } +} + +impl<M> fmt::Display for NotifyError<M> { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + match *self { + NotifyError::Io(ref e) => { + write!(fmt, "IO error: {}", e) + } + NotifyError::Full(..) => write!(fmt, "Full"), + NotifyError::Closed(..) => write!(fmt, "Closed") + } + } +} + +impl<M: any::Any> error::Error for NotifyError<M> { + fn description(&self) -> &str { + match *self { + NotifyError::Io(ref err) => err.description(), + NotifyError::Closed(..) => "The receiving end has hung up", + NotifyError::Full(..) => "Queue is full" + } + } + + fn cause(&self) -> Option<&error::Error> { + match *self { + NotifyError::Io(ref err) => Some(err), + _ => None + } + } +} + +impl<M> From<channel::TrySendError<M>> for NotifyError<M> { + fn from(src: channel::TrySendError<M>) -> NotifyError<M> { + match src { + channel::TrySendError::Io(e) => NotifyError::Io(e), + channel::TrySendError::Full(v) => NotifyError::Full(v), + channel::TrySendError::Disconnected(v) => NotifyError::Closed(Some(v)), + } + } +} diff --git a/third_party/rust/mio-0.6.23/src/deprecated/unix.rs b/third_party/rust/mio-0.6.23/src/deprecated/unix.rs new file mode 100644 index 0000000000..97c6a60ba4 --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/deprecated/unix.rs @@ -0,0 +1,420 @@ +use {io, sys, Ready, Poll, PollOpt, Token}; +use event::Evented; +use deprecated::TryAccept; +use io::MapNonBlock; +use std::io::{Read, Write}; +use std::path::Path; +pub use std::net::Shutdown; +use std::process; + +pub use sys::Io; + +#[derive(Debug)] +pub struct UnixSocket { + sys: sys::UnixSocket, +} + +impl UnixSocket { + /// Returns a new, unbound, non-blocking Unix domain socket + pub fn stream() -> io::Result<UnixSocket> { + sys::UnixSocket::stream() + .map(From::from) + } + + /// Connect the socket to the specified address + pub fn connect<P: AsRef<Path> + ?Sized>(self, addr: &P) -> io::Result<(UnixStream, bool)> { + let complete = match self.sys.connect(addr) { + Ok(()) => true, + Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => false, + Err(e) => return Err(e), + }; + Ok((From::from(self.sys), complete)) + } + + /// Bind the socket to the specified address + pub fn bind<P: AsRef<Path> + ?Sized>(&self, addr: &P) -> io::Result<()> { + self.sys.bind(addr) + } + + /// Listen for incoming requests + pub fn listen(self, backlog: usize) -> io::Result<UnixListener> { + self.sys.listen(backlog)?; + Ok(From::from(self.sys)) + } + + pub fn try_clone(&self) -> io::Result<UnixSocket> { + self.sys.try_clone() + .map(From::from) + } +} + +impl Evented for UnixSocket { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + self.sys.register(poll, token, interest, opts) + } + + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + self.sys.reregister(poll, token, interest, opts) + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + self.sys.deregister(poll) + } +} + +impl From<sys::UnixSocket> for UnixSocket { + fn from(sys: sys::UnixSocket) -> UnixSocket { + UnixSocket { sys } + } +} + +/* + * + * ===== UnixStream ===== + * + */ + +#[derive(Debug)] +pub struct UnixStream { + sys: sys::UnixSocket, +} + +impl UnixStream { + pub fn connect<P: AsRef<Path> + ?Sized>(path: &P) -> io::Result<UnixStream> { + UnixSocket::stream() + .and_then(|sock| sock.connect(path)) + .map(|(sock, _)| sock) + } + + pub fn try_clone(&self) -> io::Result<UnixStream> { + self.sys.try_clone() + .map(From::from) + } + + pub fn shutdown(&self, how: Shutdown) -> io::Result<usize> { + self.sys.shutdown(how).map(|_| 0) + } + + pub fn read_recv_fd(&mut self, buf: &mut [u8]) -> io::Result<(usize, Option<RawFd>)> { + self.sys.read_recv_fd(buf) + } + + pub fn try_read_recv_fd(&mut self, buf: &mut [u8]) -> io::Result<Option<(usize, Option<RawFd>)>> { + self.read_recv_fd(buf).map_non_block() + } + + pub fn write_send_fd(&mut self, buf: &[u8], fd: RawFd) -> io::Result<usize> { + self.sys.write_send_fd(buf, fd) + } + + pub fn try_write_send_fd(&mut self, buf: &[u8], fd: RawFd) -> io::Result<Option<usize>> { + self.write_send_fd(buf, fd).map_non_block() + } +} + +impl Read for UnixStream { + fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { + self.sys.read(buf) + } +} + +impl Write for UnixStream { + fn write(&mut self, buf: &[u8]) -> io::Result<usize> { + self.sys.write(buf) + } + + fn flush(&mut self) -> io::Result<()> { + self.sys.flush() + } +} + +impl Evented for UnixStream { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + self.sys.register(poll, token, interest, opts) + } + + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + self.sys.reregister(poll, token, interest, opts) + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + self.sys.deregister(poll) + } +} + +impl From<sys::UnixSocket> for UnixStream { + fn from(sys: sys::UnixSocket) -> UnixStream { + UnixStream { sys } + } +} + +/* + * + * ===== UnixListener ===== + * + */ + +#[derive(Debug)] +pub struct UnixListener { + sys: sys::UnixSocket, +} + +impl UnixListener { + pub fn bind<P: AsRef<Path> + ?Sized>(addr: &P) -> io::Result<UnixListener> { + UnixSocket::stream().and_then(|sock| { + sock.bind(addr)?; + sock.listen(256) + }) + } + + pub fn accept(&self) -> io::Result<UnixStream> { + self.sys.accept().map(From::from) + } + + pub fn try_clone(&self) -> io::Result<UnixListener> { + self.sys.try_clone().map(From::from) + } +} + +impl Evented for UnixListener { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + self.sys.register(poll, token, interest, opts) + } + + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + self.sys.reregister(poll, token, interest, opts) + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + self.sys.deregister(poll) + } +} + +impl TryAccept for UnixListener { + type Output = UnixStream; + + fn accept(&self) -> io::Result<Option<UnixStream>> { + UnixListener::accept(self).map_non_block() + } +} + +impl From<sys::UnixSocket> for UnixListener { + fn from(sys: sys::UnixSocket) -> UnixListener { + UnixListener { sys } + } +} + +/* + * + * ===== Pipe ===== + * + */ + +pub fn pipe() -> io::Result<(PipeReader, PipeWriter)> { + let (rd, wr) = sys::pipe()?; + Ok((From::from(rd), From::from(wr))) +} + +#[derive(Debug)] +pub struct PipeReader { + io: Io, +} + +impl PipeReader { + pub fn from_stdout(stdout: process::ChildStdout) -> io::Result<Self> { + if let Err(e) = sys::set_nonblock(stdout.as_raw_fd()) { + return Err(e); + } + Ok(PipeReader::from(unsafe { Io::from_raw_fd(stdout.into_raw_fd()) })) + } + pub fn from_stderr(stderr: process::ChildStderr) -> io::Result<Self> { + if let Err(e) = sys::set_nonblock(stderr.as_raw_fd()) { + return Err(e); + } + Ok(PipeReader::from(unsafe { Io::from_raw_fd(stderr.into_raw_fd()) })) + } +} + +impl Read for PipeReader { + fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { + self.io.read(buf) + } +} + +impl<'a> Read for &'a PipeReader { + fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { + (&self.io).read(buf) + } +} + +impl Evented for PipeReader { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + self.io.register(poll, token, interest, opts) + } + + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + self.io.reregister(poll, token, interest, opts) + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + self.io.deregister(poll) + } +} + +impl From<Io> for PipeReader { + fn from(io: Io) -> PipeReader { + PipeReader { io } + } +} + +#[derive(Debug)] +pub struct PipeWriter { + io: Io, +} + +impl PipeWriter { + pub fn from_stdin(stdin: process::ChildStdin) -> io::Result<Self> { + if let Err(e) = sys::set_nonblock(stdin.as_raw_fd()) { + return Err(e); + } + Ok(PipeWriter::from(unsafe { Io::from_raw_fd(stdin.into_raw_fd()) })) + } +} + +impl Write for PipeWriter { + fn write(&mut self, buf: &[u8]) -> io::Result<usize> { + self.io.write(buf) + } + + fn flush(&mut self) -> io::Result<()> { + self.io.flush() + } +} + +impl<'a> Write for &'a PipeWriter { + fn write(&mut self, buf: &[u8]) -> io::Result<usize> { + (&self.io).write(buf) + } + + fn flush(&mut self) -> io::Result<()> { + (&self.io).flush() + } +} + +impl Evented for PipeWriter { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + self.io.register(poll, token, interest, opts) + } + + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + self.io.reregister(poll, token, interest, opts) + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + self.io.deregister(poll) + } +} + +impl From<Io> for PipeWriter { + fn from(io: Io) -> PipeWriter { + PipeWriter { io } + } +} + +/* + * + * ===== Conversions ===== + * + */ + +use std::os::unix::io::{RawFd, IntoRawFd, AsRawFd, FromRawFd}; + +impl IntoRawFd for UnixSocket { + fn into_raw_fd(self) -> RawFd { + self.sys.into_raw_fd() + } +} + +impl AsRawFd for UnixSocket { + fn as_raw_fd(&self) -> RawFd { + self.sys.as_raw_fd() + } +} + +impl FromRawFd for UnixSocket { + unsafe fn from_raw_fd(fd: RawFd) -> UnixSocket { + UnixSocket { sys: FromRawFd::from_raw_fd(fd) } + } +} + +impl IntoRawFd for UnixStream { + fn into_raw_fd(self) -> RawFd { + self.sys.into_raw_fd() + } +} + +impl AsRawFd for UnixStream { + fn as_raw_fd(&self) -> RawFd { + self.sys.as_raw_fd() + } +} + +impl FromRawFd for UnixStream { + unsafe fn from_raw_fd(fd: RawFd) -> UnixStream { + UnixStream { sys: FromRawFd::from_raw_fd(fd) } + } +} + +impl IntoRawFd for UnixListener { + fn into_raw_fd(self) -> RawFd { + self.sys.into_raw_fd() + } +} + +impl AsRawFd for UnixListener { + fn as_raw_fd(&self) -> RawFd { + self.sys.as_raw_fd() + } +} + +impl FromRawFd for UnixListener { + unsafe fn from_raw_fd(fd: RawFd) -> UnixListener { + UnixListener { sys: FromRawFd::from_raw_fd(fd) } + } +} + +impl IntoRawFd for PipeReader { + fn into_raw_fd(self) -> RawFd { + self.io.into_raw_fd() + } +} + +impl AsRawFd for PipeReader { + fn as_raw_fd(&self) -> RawFd { + self.io.as_raw_fd() + } +} + +impl FromRawFd for PipeReader { + unsafe fn from_raw_fd(fd: RawFd) -> PipeReader { + PipeReader { io: FromRawFd::from_raw_fd(fd) } + } +} + +impl IntoRawFd for PipeWriter { + fn into_raw_fd(self) -> RawFd { + self.io.into_raw_fd() + } +} + +impl AsRawFd for PipeWriter { + fn as_raw_fd(&self) -> RawFd { + self.io.as_raw_fd() + } +} + +impl FromRawFd for PipeWriter { + unsafe fn from_raw_fd(fd: RawFd) -> PipeWriter { + PipeWriter { io: FromRawFd::from_raw_fd(fd) } + } +} diff --git a/third_party/rust/mio-0.6.23/src/event_imp.rs b/third_party/rust/mio-0.6.23/src/event_imp.rs new file mode 100644 index 0000000000..7573ebca83 --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/event_imp.rs @@ -0,0 +1,1162 @@ +use {Poll, Token}; +use std::{fmt, io, ops}; + +/// A value that may be registered with `Poll` +/// +/// Values that implement `Evented` can be registered with `Poll`. Users of Mio +/// should not use the `Evented` trait functions directly. Instead, the +/// equivalent functions on `Poll` should be used. +/// +/// See [`Poll`] for more details. +/// +/// # Implementing `Evented` +/// +/// There are two types of `Evented` values. +/// +/// * **System** handles, which are backed by sockets or other system handles. +/// These `Evented` handles will be monitored by the system selector. In this +/// case, an implementation of `Evented` delegates to a lower level handle. +/// +/// * **User** handles, which are driven entirely in user space using +/// [`Registration`] and [`SetReadiness`]. In this case, the implementer takes +/// responsibility for driving the readiness state changes. +/// +/// [`Poll`]: ../struct.Poll.html +/// [`Registration`]: ../struct.Registration.html +/// [`SetReadiness`]: ../struct.SetReadiness.html +/// +/// # Examples +/// +/// Implementing `Evented` on a struct containing a socket: +/// +/// ``` +/// use mio::{Ready, Poll, PollOpt, Token}; +/// use mio::event::Evented; +/// use mio::net::TcpStream; +/// +/// use std::io; +/// +/// pub struct MyEvented { +/// socket: TcpStream, +/// } +/// +/// impl Evented for MyEvented { +/// fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) +/// -> io::Result<()> +/// { +/// // Delegate the `register` call to `socket` +/// self.socket.register(poll, token, interest, opts) +/// } +/// +/// fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) +/// -> io::Result<()> +/// { +/// // Delegate the `reregister` call to `socket` +/// self.socket.reregister(poll, token, interest, opts) +/// } +/// +/// fn deregister(&self, poll: &Poll) -> io::Result<()> { +/// // Delegate the `deregister` call to `socket` +/// self.socket.deregister(poll) +/// } +/// } +/// ``` +/// +/// Implement `Evented` using [`Registration`] and [`SetReadiness`]. +/// +/// ``` +/// use mio::{Ready, Registration, Poll, PollOpt, Token}; +/// use mio::event::Evented; +/// +/// use std::io; +/// use std::time::Instant; +/// use std::thread; +/// +/// pub struct Deadline { +/// when: Instant, +/// registration: Registration, +/// } +/// +/// impl Deadline { +/// pub fn new(when: Instant) -> Deadline { +/// let (registration, set_readiness) = Registration::new2(); +/// +/// thread::spawn(move || { +/// let now = Instant::now(); +/// +/// if now < when { +/// thread::sleep(when - now); +/// } +/// +/// set_readiness.set_readiness(Ready::readable()); +/// }); +/// +/// Deadline { +/// when: when, +/// registration: registration, +/// } +/// } +/// +/// pub fn is_elapsed(&self) -> bool { +/// Instant::now() >= self.when +/// } +/// } +/// +/// impl Evented for Deadline { +/// fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) +/// -> io::Result<()> +/// { +/// self.registration.register(poll, token, interest, opts) +/// } +/// +/// fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) +/// -> io::Result<()> +/// { +/// self.registration.reregister(poll, token, interest, opts) +/// } +/// +/// fn deregister(&self, poll: &Poll) -> io::Result<()> { +/// self.registration.deregister(poll) +/// } +/// } +/// ``` +pub trait Evented { + /// Register `self` with the given `Poll` instance. + /// + /// This function should not be called directly. Use [`Poll::register`] + /// instead. Implementors should handle registration by either delegating + /// the call to another `Evented` type or creating a [`Registration`]. + /// + /// [`Poll::register`]: ../struct.Poll.html#method.register + /// [`Registration`]: ../struct.Registration.html + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()>; + + /// Re-register `self` with the given `Poll` instance. + /// + /// This function should not be called directly. Use [`Poll::reregister`] + /// instead. Implementors should handle re-registration by either delegating + /// the call to another `Evented` type or calling + /// [`SetReadiness::set_readiness`]. + /// + /// [`Poll::reregister`]: ../struct.Poll.html#method.reregister + /// [`SetReadiness::set_readiness`]: ../struct.SetReadiness.html#method.set_readiness + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()>; + + /// Deregister `self` from the given `Poll` instance + /// + /// This function should not be called directly. Use [`Poll::deregister`] + /// instead. Implementors should handle deregistration by either delegating + /// the call to another `Evented` type or by dropping the [`Registration`] + /// associated with `self`. + /// + /// [`Poll::deregister`]: ../struct.Poll.html#method.deregister + /// [`Registration`]: ../struct.Registration.html + fn deregister(&self, poll: &Poll) -> io::Result<()>; +} + +impl Evented for Box<Evented> { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + self.as_ref().register(poll, token, interest, opts) + } + + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + self.as_ref().reregister(poll, token, interest, opts) + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + self.as_ref().deregister(poll) + } +} + +impl<T: Evented> Evented for Box<T> { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + self.as_ref().register(poll, token, interest, opts) + } + + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + self.as_ref().reregister(poll, token, interest, opts) + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + self.as_ref().deregister(poll) + } +} + +impl<T: Evented> Evented for ::std::sync::Arc<T> { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + self.as_ref().register(poll, token, interest, opts) + } + + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + self.as_ref().reregister(poll, token, interest, opts) + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + self.as_ref().deregister(poll) + } +} + +/// Options supplied when registering an `Evented` handle with `Poll` +/// +/// `PollOpt` values can be combined together using the various bitwise +/// operators. +/// +/// For high level documentation on polling and poll options, see [`Poll`]. +/// +/// # Examples +/// +/// ``` +/// use mio::PollOpt; +/// +/// let opts = PollOpt::edge() | PollOpt::oneshot(); +/// +/// assert!(opts.is_edge()); +/// assert!(opts.is_oneshot()); +/// assert!(!opts.is_level()); +/// ``` +/// +/// [`Poll`]: struct.Poll.html +#[derive(Copy, PartialEq, Eq, Clone, PartialOrd, Ord)] +pub struct PollOpt(usize); + +impl PollOpt { + /// Return a `PollOpt` representing no set options. + /// + /// See [`Poll`] for more documentation on polling. + /// + /// # Examples + /// + /// ``` + /// use mio::PollOpt; + /// + /// let opt = PollOpt::empty(); + /// + /// assert!(!opt.is_level()); + /// ``` + /// + /// [`Poll`]: struct.Poll.html + #[inline] + pub fn empty() -> PollOpt { + PollOpt(0) + } + + /// Return a `PollOpt` representing edge-triggered notifications. + /// + /// See [`Poll`] for more documentation on polling. + /// + /// # Examples + /// + /// ``` + /// use mio::PollOpt; + /// + /// let opt = PollOpt::edge(); + /// + /// assert!(opt.is_edge()); + /// ``` + /// + /// [`Poll`]: struct.Poll.html + #[inline] + pub fn edge() -> PollOpt { + PollOpt(0b0001) + } + + /// Return a `PollOpt` representing level-triggered notifications. + /// + /// See [`Poll`] for more documentation on polling. + /// + /// # Examples + /// + /// ``` + /// use mio::PollOpt; + /// + /// let opt = PollOpt::level(); + /// + /// assert!(opt.is_level()); + /// ``` + /// + /// [`Poll`]: struct.Poll.html + #[inline] + pub fn level() -> PollOpt { + PollOpt(0b0010) + } + + /// Return a `PollOpt` representing oneshot notifications. + /// + /// See [`Poll`] for more documentation on polling. + /// + /// # Examples + /// + /// ``` + /// use mio::PollOpt; + /// + /// let opt = PollOpt::oneshot(); + /// + /// assert!(opt.is_oneshot()); + /// ``` + /// + /// [`Poll`]: struct.Poll.html + #[inline] + pub fn oneshot() -> PollOpt { + PollOpt(0b0100) + } + + #[deprecated(since = "0.6.5", note = "removed")] + #[cfg(feature = "with-deprecated")] + #[doc(hidden)] + #[inline] + pub fn urgent() -> PollOpt { + PollOpt(0b1000) + } + + #[deprecated(since = "0.6.5", note = "removed")] + #[cfg(feature = "with-deprecated")] + #[doc(hidden)] + #[inline] + pub fn all() -> PollOpt { + PollOpt::edge() | PollOpt::level() | PollOpt::oneshot() + } + + /// Returns true if the options include edge-triggered notifications. + /// + /// See [`Poll`] for more documentation on polling. + /// + /// # Examples + /// + /// ``` + /// use mio::PollOpt; + /// + /// let opt = PollOpt::edge(); + /// + /// assert!(opt.is_edge()); + /// ``` + /// + /// [`Poll`]: struct.Poll.html + #[inline] + pub fn is_edge(&self) -> bool { + self.contains(PollOpt::edge()) + } + + /// Returns true if the options include level-triggered notifications. + /// + /// See [`Poll`] for more documentation on polling. + /// + /// # Examples + /// + /// ``` + /// use mio::PollOpt; + /// + /// let opt = PollOpt::level(); + /// + /// assert!(opt.is_level()); + /// ``` + /// + /// [`Poll`]: struct.Poll.html + #[inline] + pub fn is_level(&self) -> bool { + self.contains(PollOpt::level()) + } + + /// Returns true if the options includes oneshot. + /// + /// See [`Poll`] for more documentation on polling. + /// + /// # Examples + /// + /// ``` + /// use mio::PollOpt; + /// + /// let opt = PollOpt::oneshot(); + /// + /// assert!(opt.is_oneshot()); + /// ``` + /// + /// [`Poll`]: struct.Poll.html + #[inline] + pub fn is_oneshot(&self) -> bool { + self.contains(PollOpt::oneshot()) + } + + #[deprecated(since = "0.6.5", note = "removed")] + #[cfg(feature = "with-deprecated")] + #[doc(hidden)] + #[allow(deprecated)] + #[inline] + pub fn is_urgent(&self) -> bool { + self.contains(PollOpt::urgent()) + } + + #[deprecated(since = "0.6.5", note = "removed")] + #[cfg(feature = "with-deprecated")] + #[doc(hidden)] + #[inline] + pub fn bits(&self) -> usize { + self.0 + } + + /// Returns true if `self` is a superset of `other`. + /// + /// `other` may represent more than one option, in which case the function + /// only returns true if `self` contains all of the options specified in + /// `other`. + /// + /// See [`Poll`] for more documentation on polling. + /// + /// # Examples + /// + /// ``` + /// use mio::PollOpt; + /// + /// let opt = PollOpt::oneshot(); + /// + /// assert!(opt.contains(PollOpt::oneshot())); + /// assert!(!opt.contains(PollOpt::edge())); + /// ``` + /// + /// ``` + /// use mio::PollOpt; + /// + /// let opt = PollOpt::oneshot() | PollOpt::edge(); + /// + /// assert!(opt.contains(PollOpt::oneshot())); + /// assert!(opt.contains(PollOpt::edge())); + /// ``` + /// + /// ``` + /// use mio::PollOpt; + /// + /// let opt = PollOpt::oneshot() | PollOpt::edge(); + /// + /// assert!(!PollOpt::oneshot().contains(opt)); + /// assert!(opt.contains(opt)); + /// assert!((opt | PollOpt::level()).contains(opt)); + /// ``` + /// + /// [`Poll`]: struct.Poll.html + #[inline] + pub fn contains(&self, other: PollOpt) -> bool { + (*self & other) == other + } + + /// Adds all options represented by `other` into `self`. + /// + /// This is equivalent to `*self = *self | other`. + /// + /// # Examples + /// + /// ``` + /// use mio::PollOpt; + /// + /// let mut opt = PollOpt::empty(); + /// opt.insert(PollOpt::oneshot()); + /// + /// assert!(opt.is_oneshot()); + /// ``` + #[inline] + pub fn insert(&mut self, other: PollOpt) { + self.0 |= other.0; + } + + /// Removes all options represented by `other` from `self`. + /// + /// This is equivalent to `*self = *self & !other`. + /// + /// # Examples + /// + /// ``` + /// use mio::PollOpt; + /// + /// let mut opt = PollOpt::oneshot(); + /// opt.remove(PollOpt::oneshot()); + /// + /// assert!(!opt.is_oneshot()); + /// ``` + #[inline] + pub fn remove(&mut self, other: PollOpt) { + self.0 &= !other.0; + } +} + +impl ops::BitOr for PollOpt { + type Output = PollOpt; + + #[inline] + fn bitor(self, other: PollOpt) -> PollOpt { + PollOpt(self.0 | other.0) + } +} + +impl ops::BitXor for PollOpt { + type Output = PollOpt; + + #[inline] + fn bitxor(self, other: PollOpt) -> PollOpt { + PollOpt(self.0 ^ other.0) + } +} + +impl ops::BitAnd for PollOpt { + type Output = PollOpt; + + #[inline] + fn bitand(self, other: PollOpt) -> PollOpt { + PollOpt(self.0 & other.0) + } +} + +impl ops::Sub for PollOpt { + type Output = PollOpt; + + #[inline] + fn sub(self, other: PollOpt) -> PollOpt { + PollOpt(self.0 & !other.0) + } +} + +#[cfg(feature = "with-deprecated")] +#[doc(hidden)] +impl ops::Not for PollOpt { + type Output = PollOpt; + + #[inline] + fn not(self) -> PollOpt { + PollOpt(!self.0) + } +} + +impl fmt::Debug for PollOpt { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + let mut one = false; + let flags = [ + (PollOpt::edge(), "Edge-Triggered"), + (PollOpt::level(), "Level-Triggered"), + (PollOpt::oneshot(), "OneShot")]; + + for &(flag, msg) in &flags { + if self.contains(flag) { + if one { write!(fmt, " | ")? } + write!(fmt, "{}", msg)?; + + one = true + } + } + + if !one { + fmt.write_str("(empty)")?; + } + + Ok(()) + } +} + +#[test] +fn test_debug_pollopt() { + assert_eq!("(empty)", format!("{:?}", PollOpt::empty())); + assert_eq!("Edge-Triggered", format!("{:?}", PollOpt::edge())); + assert_eq!("Level-Triggered", format!("{:?}", PollOpt::level())); + assert_eq!("OneShot", format!("{:?}", PollOpt::oneshot())); +} + +/// A set of readiness event kinds +/// +/// `Ready` is a set of operation descriptors indicating which kind of an +/// operation is ready to be performed. For example, `Ready::readable()` +/// indicates that the associated `Evented` handle is ready to perform a +/// `read` operation. +/// +/// This struct only represents portable event kinds. Since only readable and +/// writable events are guaranteed to be raised on all systems, those are the +/// only ones available via the `Ready` struct. There are also platform specific +/// extensions to `Ready`, i.e. `UnixReady`, which provide additional readiness +/// event kinds only available on unix platforms. +/// +/// `Ready` values can be combined together using the various bitwise operators. +/// +/// For high level documentation on polling and readiness, see [`Poll`]. +/// +/// # Examples +/// +/// ``` +/// use mio::Ready; +/// +/// let ready = Ready::readable() | Ready::writable(); +/// +/// assert!(ready.is_readable()); +/// assert!(ready.is_writable()); +/// ``` +/// +/// [`Poll`]: struct.Poll.html +/// [`readable`]: #method.readable +/// [`writable`]: #method.writable +/// [readiness]: struct.Poll.html#readiness-operations +#[derive(Copy, PartialEq, Eq, Clone, PartialOrd, Ord)] +pub struct Ready(usize); + +const READABLE: usize = 0b00001; +const WRITABLE: usize = 0b00010; + +// These are deprecated and are moved into platform specific implementations. +const ERROR: usize = 0b00100; +const HUP: usize = 0b01000; + +impl Ready { + /// Returns the empty `Ready` set. + /// + /// See [`Poll`] for more documentation on polling. + /// + /// # Examples + /// + /// ``` + /// use mio::Ready; + /// + /// let ready = Ready::empty(); + /// + /// assert!(!ready.is_readable()); + /// ``` + /// + /// [`Poll`]: struct.Poll.html + pub fn empty() -> Ready { + Ready(0) + } + + #[deprecated(since = "0.6.5", note = "use Ready::empty instead")] + #[cfg(feature = "with-deprecated")] + #[doc(hidden)] + pub fn none() -> Ready { + Ready::empty() + } + + /// Returns a `Ready` representing readable readiness. + /// + /// See [`Poll`] for more documentation on polling. + /// + /// # Examples + /// + /// ``` + /// use mio::Ready; + /// + /// let ready = Ready::readable(); + /// + /// assert!(ready.is_readable()); + /// ``` + /// + /// [`Poll`]: struct.Poll.html + #[inline] + pub fn readable() -> Ready { + Ready(READABLE) + } + + /// Returns a `Ready` representing writable readiness. + /// + /// See [`Poll`] for more documentation on polling. + /// + /// # Examples + /// + /// ``` + /// use mio::Ready; + /// + /// let ready = Ready::writable(); + /// + /// assert!(ready.is_writable()); + /// ``` + /// + /// [`Poll`]: struct.Poll.html + #[inline] + pub fn writable() -> Ready { + Ready(WRITABLE) + } + + #[deprecated(since = "0.6.5", note = "use UnixReady instead")] + #[cfg(feature = "with-deprecated")] + #[doc(hidden)] + #[inline] + pub fn error() -> Ready { + Ready(ERROR) + } + + #[deprecated(since = "0.6.5", note = "use UnixReady instead")] + #[cfg(feature = "with-deprecated")] + #[doc(hidden)] + #[inline] + pub fn hup() -> Ready { + Ready(HUP) + } + + /// Returns a `Ready` representing readiness for all operations. + /// + /// This includes platform specific operations as well (`hup`, `aio`, + /// `error`, `lio`, `pri`). + /// + /// See [`Poll`] for more documentation on polling. + /// + /// # Examples + /// + /// ``` + /// use mio::Ready; + /// + /// let ready = Ready::all(); + /// + /// assert!(ready.is_readable()); + /// assert!(ready.is_writable()); + /// ``` + /// + /// [`Poll`]: struct.Poll.html + #[inline] + pub fn all() -> Ready { + Ready(READABLE | WRITABLE | ::sys::READY_ALL) + } + + /// Returns true if `Ready` is the empty set + /// + /// See [`Poll`] for more documentation on polling. + /// + /// # Examples + /// + /// ``` + /// use mio::Ready; + /// + /// let ready = Ready::empty(); + /// assert!(ready.is_empty()); + /// ``` + /// + /// [`Poll`]: struct.Poll.html + #[inline] + pub fn is_empty(&self) -> bool { + *self == Ready::empty() + } + + #[deprecated(since = "0.6.5", note = "use Ready::is_empty instead")] + #[cfg(feature = "with-deprecated")] + #[doc(hidden)] + #[inline] + pub fn is_none(&self) -> bool { + self.is_empty() + } + + /// Returns true if the value includes readable readiness + /// + /// See [`Poll`] for more documentation on polling. + /// + /// # Examples + /// + /// ``` + /// use mio::Ready; + /// + /// let ready = Ready::readable(); + /// + /// assert!(ready.is_readable()); + /// ``` + /// + /// [`Poll`]: struct.Poll.html + #[inline] + pub fn is_readable(&self) -> bool { + self.contains(Ready::readable()) + } + + /// Returns true if the value includes writable readiness + /// + /// See [`Poll`] for more documentation on polling. + /// + /// # Examples + /// + /// ``` + /// use mio::Ready; + /// + /// let ready = Ready::writable(); + /// + /// assert!(ready.is_writable()); + /// ``` + /// + /// [`Poll`]: struct.Poll.html + #[inline] + pub fn is_writable(&self) -> bool { + self.contains(Ready::writable()) + } + + #[deprecated(since = "0.6.5", note = "use UnixReady instead")] + #[cfg(feature = "with-deprecated")] + #[doc(hidden)] + #[inline] + pub fn is_error(&self) -> bool { + self.contains(Ready(ERROR)) + } + + #[deprecated(since = "0.6.5", note = "use UnixReady instead")] + #[cfg(feature = "with-deprecated")] + #[doc(hidden)] + #[inline] + pub fn is_hup(&self) -> bool { + self.contains(Ready(HUP)) + } + + /// Adds all readiness represented by `other` into `self`. + /// + /// This is equivalent to `*self = *self | other`. + /// + /// # Examples + /// + /// ``` + /// use mio::Ready; + /// + /// let mut readiness = Ready::empty(); + /// readiness.insert(Ready::readable()); + /// + /// assert!(readiness.is_readable()); + /// ``` + #[inline] + pub fn insert<T: Into<Self>>(&mut self, other: T) { + let other = other.into(); + self.0 |= other.0; + } + + /// Removes all options represented by `other` from `self`. + /// + /// This is equivalent to `*self = *self & !other`. + /// + /// # Examples + /// + /// ``` + /// use mio::Ready; + /// + /// let mut readiness = Ready::readable(); + /// readiness.remove(Ready::readable()); + /// + /// assert!(!readiness.is_readable()); + /// ``` + #[inline] + pub fn remove<T: Into<Self>>(&mut self, other: T) { + let other = other.into(); + self.0 &= !other.0; + } + + #[deprecated(since = "0.6.5", note = "removed")] + #[cfg(feature = "with-deprecated")] + #[doc(hidden)] + #[inline] + pub fn bits(&self) -> usize { + self.0 + } + + /// Returns true if `self` is a superset of `other`. + /// + /// `other` may represent more than one readiness operations, in which case + /// the function only returns true if `self` contains all readiness + /// specified in `other`. + /// + /// See [`Poll`] for more documentation on polling. + /// + /// # Examples + /// + /// ``` + /// use mio::Ready; + /// + /// let readiness = Ready::readable(); + /// + /// assert!(readiness.contains(Ready::readable())); + /// assert!(!readiness.contains(Ready::writable())); + /// ``` + /// + /// ``` + /// use mio::Ready; + /// + /// let readiness = Ready::readable() | Ready::writable(); + /// + /// assert!(readiness.contains(Ready::readable())); + /// assert!(readiness.contains(Ready::writable())); + /// ``` + /// + /// ``` + /// use mio::Ready; + /// + /// let readiness = Ready::readable() | Ready::writable(); + /// + /// assert!(!Ready::readable().contains(readiness)); + /// assert!(readiness.contains(readiness)); + /// ``` + /// + /// [`Poll`]: struct.Poll.html + #[inline] + pub fn contains<T: Into<Self>>(&self, other: T) -> bool { + let other = other.into(); + (*self & other) == other + } + + /// Create a `Ready` instance using the given `usize` representation. + /// + /// The `usize` representation must have been obtained from a call to + /// `Ready::as_usize`. + /// + /// The `usize` representation must be treated as opaque. There is no + /// guaranteed correlation between the returned value and platform defined + /// constants. Also, there is no guarantee that the `usize` representation + /// will remain constant across patch releases of Mio. + /// + /// This function is mainly provided to allow the caller to loa a + /// readiness value from an `AtomicUsize`. + /// + /// # Examples + /// + /// ``` + /// use mio::Ready; + /// + /// let ready = Ready::readable(); + /// let ready_usize = ready.as_usize(); + /// let ready2 = Ready::from_usize(ready_usize); + /// + /// assert_eq!(ready, ready2); + /// ``` + pub fn from_usize(val: usize) -> Ready { + Ready(val) + } + + /// Returns a `usize` representation of the `Ready` value. + /// + /// This `usize` representation must be treated as opaque. There is no + /// guaranteed correlation between the returned value and platform defined + /// constants. Also, there is no guarantee that the `usize` representation + /// will remain constant across patch releases of Mio. + /// + /// This function is mainly provided to allow the caller to store a + /// readiness value in an `AtomicUsize`. + /// + /// # Examples + /// + /// ``` + /// use mio::Ready; + /// + /// let ready = Ready::readable(); + /// let ready_usize = ready.as_usize(); + /// let ready2 = Ready::from_usize(ready_usize); + /// + /// assert_eq!(ready, ready2); + /// ``` + pub fn as_usize(&self) -> usize { + self.0 + } +} + +impl<T: Into<Ready>> ops::BitOr<T> for Ready { + type Output = Ready; + + #[inline] + fn bitor(self, other: T) -> Ready { + Ready(self.0 | other.into().0) + } +} + +impl<T: Into<Ready>> ops::BitOrAssign<T> for Ready { + #[inline] + fn bitor_assign(&mut self, other: T) { + self.0 |= other.into().0; + } +} + +impl<T: Into<Ready>> ops::BitXor<T> for Ready { + type Output = Ready; + + #[inline] + fn bitxor(self, other: T) -> Ready { + Ready(self.0 ^ other.into().0) + } +} + +impl<T: Into<Ready>> ops::BitXorAssign<T> for Ready { + #[inline] + fn bitxor_assign(&mut self, other: T) { + self.0 ^= other.into().0; + } +} + +impl<T: Into<Ready>> ops::BitAnd<T> for Ready { + type Output = Ready; + + #[inline] + fn bitand(self, other: T) -> Ready { + Ready(self.0 & other.into().0) + } +} + +impl<T: Into<Ready>> ops::BitAndAssign<T> for Ready { + #[inline] + fn bitand_assign(&mut self, other: T) { + self.0 &= other.into().0 + } +} + +impl<T: Into<Ready>> ops::Sub<T> for Ready { + type Output = Ready; + + #[inline] + fn sub(self, other: T) -> Ready { + Ready(self.0 & !other.into().0) + } +} + +impl<T: Into<Ready>> ops::SubAssign<T> for Ready { + #[inline] + fn sub_assign(&mut self, other: T) { + self.0 &= !other.into().0; + } +} + +#[cfg(feature = "with-deprecated")] +#[doc(hidden)] +impl ops::Not for Ready { + type Output = Ready; + + #[inline] + fn not(self) -> Ready { + Ready(!self.0) + } +} + +impl fmt::Debug for Ready { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + let mut one = false; + let flags = [ + (Ready::readable(), "Readable"), + (Ready::writable(), "Writable"), + (Ready(ERROR), "Error"), + (Ready(HUP), "Hup")]; + + for &(flag, msg) in &flags { + if self.contains(flag) { + if one { write!(fmt, " | ")? } + write!(fmt, "{}", msg)?; + + one = true + } + } + + if !one { + fmt.write_str("(empty)")?; + } + + Ok(()) + } +} + +#[test] +fn test_debug_ready() { + assert_eq!("(empty)", format!("{:?}", Ready::empty())); + assert_eq!("Readable", format!("{:?}", Ready::readable())); + assert_eq!("Writable", format!("{:?}", Ready::writable())); +} + +/// An readiness event returned by [`Poll::poll`]. +/// +/// `Event` is a [readiness state] paired with a [`Token`]. It is returned by +/// [`Poll::poll`]. +/// +/// For more documentation on polling and events, see [`Poll`]. +/// +/// # Examples +/// +/// ``` +/// use mio::{Ready, Token}; +/// use mio::event::Event; +/// +/// let event = Event::new(Ready::readable() | Ready::writable(), Token(0)); +/// +/// assert_eq!(event.readiness(), Ready::readable() | Ready::writable()); +/// assert_eq!(event.token(), Token(0)); +/// ``` +/// +/// [`Poll::poll`]: ../struct.Poll.html#method.poll +/// [`Poll`]: ../struct.Poll.html +/// [readiness state]: ../struct.Ready.html +/// [`Token`]: ../struct.Token.html +#[derive(Copy, Clone, Eq, PartialEq, Debug)] +pub struct Event { + kind: Ready, + token: Token +} + +impl Event { + /// Creates a new `Event` containing `readiness` and `token` + /// + /// # Examples + /// + /// ``` + /// use mio::{Ready, Token}; + /// use mio::event::Event; + /// + /// let event = Event::new(Ready::readable() | Ready::writable(), Token(0)); + /// + /// assert_eq!(event.readiness(), Ready::readable() | Ready::writable()); + /// assert_eq!(event.token(), Token(0)); + /// ``` + pub fn new(readiness: Ready, token: Token) -> Event { + Event { + kind: readiness, + token, + } + } + + /// Returns the event's readiness. + /// + /// # Examples + /// + /// ``` + /// use mio::{Ready, Token}; + /// use mio::event::Event; + /// + /// let event = Event::new(Ready::readable() | Ready::writable(), Token(0)); + /// + /// assert_eq!(event.readiness(), Ready::readable() | Ready::writable()); + /// ``` + pub fn readiness(&self) -> Ready { + self.kind + } + + #[deprecated(since = "0.6.5", note = "use Event::readiness()")] + #[cfg(feature = "with-deprecated")] + #[doc(hidden)] + pub fn kind(&self) -> Ready { + self.kind + } + + /// Returns the event's token. + /// + /// # Examples + /// + /// ``` + /// use mio::{Ready, Token}; + /// use mio::event::Event; + /// + /// let event = Event::new(Ready::readable() | Ready::writable(), Token(0)); + /// + /// assert_eq!(event.token(), Token(0)); + /// ``` + pub fn token(&self) -> Token { + self.token + } +} + +/* + * + * ===== Mio internal helpers ===== + * + */ + +pub fn ready_as_usize(events: Ready) -> usize { + events.0 +} + +pub fn opt_as_usize(opt: PollOpt) -> usize { + opt.0 +} + +pub fn ready_from_usize(events: usize) -> Ready { + Ready(events) +} + +pub fn opt_from_usize(opt: usize) -> PollOpt { + PollOpt(opt) +} + +// Used internally to mutate an `Event` in place +// Not used on all platforms +#[allow(dead_code)] +pub fn kind_mut(event: &mut Event) -> &mut Ready { + &mut event.kind +} diff --git a/third_party/rust/mio-0.6.23/src/io.rs b/third_party/rust/mio-0.6.23/src/io.rs new file mode 100644 index 0000000000..275001387d --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/io.rs @@ -0,0 +1,35 @@ +// Re-export the io::Result / Error types for convenience +pub use std::io::{Read, Write, Result, Error, ErrorKind}; + +// TODO: Delete this +/// A helper trait to provide the map_non_block function on Results. +pub trait MapNonBlock<T> { + /// Maps a `Result<T>` to a `Result<Option<T>>` by converting + /// operation-would-block errors into `Ok(None)`. + fn map_non_block(self) -> Result<Option<T>>; +} + +impl<T> MapNonBlock<T> for Result<T> { + fn map_non_block(self) -> Result<Option<T>> { + use std::io::ErrorKind::WouldBlock; + + match self { + Ok(value) => Ok(Some(value)), + Err(err) => { + if let WouldBlock = err.kind() { + Ok(None) + } else { + Err(err) + } + } + } + } +} + +#[cfg(feature = "with-deprecated")] +pub mod deprecated { + /// Returns a std `WouldBlock` error without allocating + pub fn would_block() -> ::std::io::Error { + ::std::io::ErrorKind::WouldBlock.into() + } +} diff --git a/third_party/rust/mio-0.6.23/src/lazycell.rs b/third_party/rust/mio-0.6.23/src/lazycell.rs new file mode 100644 index 0000000000..681fb2f529 --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/lazycell.rs @@ -0,0 +1,554 @@ +// Original work Copyright (c) 2014 The Rust Project Developers +// Modified work Copyright (c) 2016-2018 Nikita Pekin and the lazycell contributors +// See the README.md file at the top-level directory of this distribution. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![deny(missing_docs)] +#![allow(unused)] + +//! This crate provides a `LazyCell` struct which acts as a lazily filled +//! `Cell`. +//! +//! With a `RefCell`, the inner contents cannot be borrowed for the lifetime of +//! the entire object, but only of the borrows returned. A `LazyCell` is a +//! variation on `RefCell` which allows borrows to be tied to the lifetime of +//! the outer object. +//! +//! `AtomicLazyCell` is a variant that uses an atomic variable to manage +//! coordination in a thread-safe fashion. The limitation of an `AtomicLazyCell` +//! is that after it is initialized, it can't be modified. + +use std::cell::UnsafeCell; +use std::mem; +use std::sync::atomic::{AtomicUsize, Ordering}; + +/// A lazily filled `Cell`, with mutable contents. +/// +/// A `LazyCell` is completely frozen once filled, **unless** you have `&mut` +/// access to it, in which case `LazyCell::borrow_mut` may be used to mutate the +/// contents. +#[derive(Debug, Default)] +pub struct LazyCell<T> { + inner: UnsafeCell<Option<T>>, +} + +impl<T> LazyCell<T> { + /// Creates a new, empty, `LazyCell`. + pub fn new() -> LazyCell<T> { + LazyCell { inner: UnsafeCell::new(None) } + } + + /// Put a value into this cell. + /// + /// This function will return `Err(value)` is the cell is already full. + pub fn fill(&self, value: T) -> Result<(), T> { + let slot = unsafe { &mut *self.inner.get() }; + if slot.is_some() { + return Err(value); + } + *slot = Some(value); + + Ok(()) + } + + /// Put a value into this cell. + /// + /// Note that this function is infallible but requires `&mut self`. By + /// requiring `&mut self` we're guaranteed that no active borrows to this + /// cell can exist so we can always fill in the value. This may not always + /// be usable, however, as `&mut self` may not be possible to borrow. + /// + /// # Return value + /// + /// This function returns the previous value, if any. + pub fn replace(&mut self, value: T) -> Option<T> { + mem::replace(unsafe { &mut *self.inner.get() }, Some(value)) + } + + /// Test whether this cell has been previously filled. + pub fn filled(&self) -> bool { + self.borrow().is_some() + } + + /// Borrows the contents of this lazy cell for the duration of the cell + /// itself. + /// + /// This function will return `Some` if the cell has been previously + /// initialized, and `None` if it has not yet been initialized. + pub fn borrow(&self) -> Option<&T> { + unsafe { &*self.inner.get() }.as_ref() + } + + /// Borrows the contents of this lazy cell mutably for the duration of the cell + /// itself. + /// + /// This function will return `Some` if the cell has been previously + /// initialized, and `None` if it has not yet been initialized. + pub fn borrow_mut(&mut self) -> Option<&mut T> { + unsafe { &mut *self.inner.get() }.as_mut() + } + + /// Borrows the contents of this lazy cell for the duration of the cell + /// itself. + /// + /// If the cell has not yet been filled, the cell is first filled using the + /// function provided. + /// + /// # Panics + /// + /// Panics if the cell becomes filled as a side effect of `f`. + pub fn borrow_with<F: FnOnce() -> T>(&self, f: F) -> &T { + if let Some(value) = self.borrow() { + return value; + } + let value = f(); + if self.fill(value).is_err() { + panic!("borrow_with: cell was filled by closure") + } + self.borrow().unwrap() + } + + /// Borrows the contents of this `LazyCell` mutably for the duration of the + /// cell itself. + /// + /// If the cell has not yet been filled, the cell is first filled using the + /// function provided. + /// + /// # Panics + /// + /// Panics if the cell becomes filled as a side effect of `f`. + pub fn borrow_mut_with<F: FnOnce() -> T>(&mut self, f: F) -> &mut T { + if !self.filled() { + let value = f(); + if self.fill(value).is_err() { + panic!("borrow_mut_with: cell was filled by closure") + } + } + + self.borrow_mut().unwrap() + } + + /// Same as `borrow_with`, but allows the initializing function to fail. + /// + /// # Panics + /// + /// Panics if the cell becomes filled as a side effect of `f`. + pub fn try_borrow_with<E, F>(&self, f: F) -> Result<&T, E> + where F: FnOnce() -> Result<T, E> + { + if let Some(value) = self.borrow() { + return Ok(value); + } + let value = f()?; + if self.fill(value).is_err() { + panic!("try_borrow_with: cell was filled by closure") + } + Ok(self.borrow().unwrap()) + } + + /// Same as `borrow_mut_with`, but allows the initializing function to fail. + /// + /// # Panics + /// + /// Panics if the cell becomes filled as a side effect of `f`. + pub fn try_borrow_mut_with<E, F>(&mut self, f: F) -> Result<&mut T, E> + where F: FnOnce() -> Result<T, E> + { + if self.filled() { + return Ok(self.borrow_mut().unwrap()); + } + let value = f()?; + if self.fill(value).is_err() { + panic!("try_borrow_mut_with: cell was filled by closure") + } + Ok(self.borrow_mut().unwrap()) + } + + /// Consumes this `LazyCell`, returning the underlying value. + pub fn into_inner(self) -> Option<T> { + // Rust 1.25 changed UnsafeCell::into_inner() from unsafe to safe + // function. This unsafe can be removed when supporting Rust older than + // 1.25 is not needed. + #[allow(unused_unsafe)] + unsafe { self.inner.into_inner() } + } +} + +impl<T: Copy> LazyCell<T> { + /// Returns a copy of the contents of the lazy cell. + /// + /// This function will return `Some` if the cell has been previously initialized, + /// and `None` if it has not yet been initialized. + pub fn get(&self) -> Option<T> { + unsafe { *self.inner.get() } + } +} + +// Tracks the AtomicLazyCell inner state +const NONE: usize = 0; +const LOCK: usize = 1; +const SOME: usize = 2; + +/// A lazily filled and thread-safe `Cell`, with frozen contents. +#[derive(Debug, Default)] +pub struct AtomicLazyCell<T> { + inner: UnsafeCell<Option<T>>, + state: AtomicUsize, +} + +impl<T> AtomicLazyCell<T> { + /// Creates a new, empty, `AtomicLazyCell`. + pub fn new() -> AtomicLazyCell<T> { + Self { + inner: UnsafeCell::new(None), + state: AtomicUsize::new(NONE), + } + } + + /// Put a value into this cell. + /// + /// This function will return `Err(value)` is the cell is already full. + pub fn fill(&self, t: T) -> Result<(), T> { + if NONE != self.state.compare_and_swap(NONE, LOCK, Ordering::Acquire) { + return Err(t); + } + + unsafe { *self.inner.get() = Some(t) }; + + if LOCK != self.state.compare_and_swap(LOCK, SOME, Ordering::Release) { + panic!("unable to release lock"); + } + + Ok(()) + } + + /// Put a value into this cell. + /// + /// Note that this function is infallible but requires `&mut self`. By + /// requiring `&mut self` we're guaranteed that no active borrows to this + /// cell can exist so we can always fill in the value. This may not always + /// be usable, however, as `&mut self` may not be possible to borrow. + /// + /// # Return value + /// + /// This function returns the previous value, if any. + pub fn replace(&mut self, value: T) -> Option<T> { + match mem::replace(self.state.get_mut(), SOME) { + NONE | SOME => {} + _ => panic!("cell in inconsistent state"), + } + mem::replace(unsafe { &mut *self.inner.get() }, Some(value)) + } + + /// Test whether this cell has been previously filled. + pub fn filled(&self) -> bool { + self.state.load(Ordering::Acquire) == SOME + } + + /// Borrows the contents of this lazy cell for the duration of the cell + /// itself. + /// + /// This function will return `Some` if the cell has been previously + /// initialized, and `None` if it has not yet been initialized. + pub fn borrow(&self) -> Option<&T> { + match self.state.load(Ordering::Acquire) { + SOME => unsafe { &*self.inner.get() }.as_ref(), + _ => None, + } + } + + /// Consumes this `LazyCell`, returning the underlying value. + pub fn into_inner(self) -> Option<T> { + // Rust 1.25 changed UnsafeCell::into_inner() from unsafe to safe + // function. This unsafe can be removed when supporting Rust older than + // 1.25 is not needed. + #[allow(unused_unsafe)] + unsafe { self.inner.into_inner() } + } +} + +impl<T: Copy> AtomicLazyCell<T> { + /// Returns a copy of the contents of the lazy cell. + /// + /// This function will return `Some` if the cell has been previously initialized, + /// and `None` if it has not yet been initialized. + pub fn get(&self) -> Option<T> { + match self.state.load(Ordering::Acquire) { + SOME => unsafe { *self.inner.get() }, + _ => None, + } + } +} + +unsafe impl<T: Sync + Send> Sync for AtomicLazyCell<T> {} + +unsafe impl<T: Send> Send for AtomicLazyCell<T> {} + +#[cfg(test)] +mod tests { + use super::{AtomicLazyCell, LazyCell}; + + #[test] + fn test_borrow_from_empty() { + let lazycell: LazyCell<usize> = LazyCell::new(); + + let value = lazycell.borrow(); + assert_eq!(value, None); + + let value = lazycell.get(); + assert_eq!(value, None); + } + + #[test] + fn test_fill_and_borrow() { + let lazycell = LazyCell::new(); + + assert!(!lazycell.filled()); + lazycell.fill(1).unwrap(); + assert!(lazycell.filled()); + + let value = lazycell.borrow(); + assert_eq!(value, Some(&1)); + + let value = lazycell.get(); + assert_eq!(value, Some(1)); + } + + #[test] + fn test_borrow_mut() { + let mut lazycell = LazyCell::new(); + assert!(lazycell.borrow_mut().is_none()); + + lazycell.fill(1).unwrap(); + assert_eq!(lazycell.borrow_mut(), Some(&mut 1)); + + *lazycell.borrow_mut().unwrap() = 2; + assert_eq!(lazycell.borrow_mut(), Some(&mut 2)); + + // official way to reset the cell + lazycell = LazyCell::new(); + assert!(lazycell.borrow_mut().is_none()); + } + + #[test] + fn test_already_filled_error() { + let lazycell = LazyCell::new(); + + lazycell.fill(1).unwrap(); + assert_eq!(lazycell.fill(1), Err(1)); + } + + #[test] + fn test_borrow_with() { + let lazycell = LazyCell::new(); + + let value = lazycell.borrow_with(|| 1); + assert_eq!(&1, value); + } + + #[test] + fn test_borrow_with_already_filled() { + let lazycell = LazyCell::new(); + lazycell.fill(1).unwrap(); + + let value = lazycell.borrow_with(|| 1); + assert_eq!(&1, value); + } + + #[test] + fn test_borrow_with_not_called_when_filled() { + let lazycell = LazyCell::new(); + + lazycell.fill(1).unwrap(); + + let value = lazycell.borrow_with(|| 2); + assert_eq!(&1, value); + } + + #[test] + #[should_panic] + fn test_borrow_with_sound_with_reentrancy() { + // Kudos to dbaupp for discovering this issue + // https://www.reddit.com/r/rust/comments/5vs9rt/lazycell_a_rust_library_providing_a_lazilyfilled/de527xm/ + let lazycell: LazyCell<Box<i32>> = LazyCell::new(); + + let mut reference: Option<&i32> = None; + + lazycell.borrow_with(|| { + let _ = lazycell.fill(Box::new(1)); + reference = lazycell.borrow().map(|r| &**r); + Box::new(2) + }); + } + + #[test] + fn test_borrow_mut_with() { + let mut lazycell = LazyCell::new(); + + { + let value = lazycell.borrow_mut_with(|| 1); + assert_eq!(&mut 1, value); + *value = 2; + } + assert_eq!(&2, lazycell.borrow().unwrap()); + } + + #[test] + fn test_borrow_mut_with_already_filled() { + let mut lazycell = LazyCell::new(); + lazycell.fill(1).unwrap(); + + let value = lazycell.borrow_mut_with(|| 1); + assert_eq!(&1, value); + } + + #[test] + fn test_borrow_mut_with_not_called_when_filled() { + let mut lazycell = LazyCell::new(); + + lazycell.fill(1).unwrap(); + + let value = lazycell.borrow_mut_with(|| 2); + assert_eq!(&1, value); + } + + #[test] + fn test_try_borrow_with_ok() { + let lazycell = LazyCell::new(); + let result = lazycell.try_borrow_with::<(), _>(|| Ok(1)); + assert_eq!(result, Ok(&1)); + } + + #[test] + fn test_try_borrow_with_err() { + let lazycell = LazyCell::<()>::new(); + let result = lazycell.try_borrow_with(|| Err(1)); + assert_eq!(result, Err(1)); + } + + #[test] + fn test_try_borrow_with_already_filled() { + let lazycell = LazyCell::new(); + lazycell.fill(1).unwrap(); + let result = lazycell.try_borrow_with::<(), _>(|| unreachable!()); + assert_eq!(result, Ok(&1)); + } + + #[test] + #[should_panic] + fn test_try_borrow_with_sound_with_reentrancy() { + let lazycell: LazyCell<Box<i32>> = LazyCell::new(); + + let mut reference: Option<&i32> = None; + + let _ = lazycell.try_borrow_with::<(), _>(|| { + let _ = lazycell.fill(Box::new(1)); + reference = lazycell.borrow().map(|r| &**r); + Ok(Box::new(2)) + }); + } + + #[test] + fn test_try_borrow_mut_with_ok() { + let mut lazycell = LazyCell::new(); + { + let result = lazycell.try_borrow_mut_with::<(), _>(|| Ok(1)); + assert_eq!(result, Ok(&mut 1)); + *result.unwrap() = 2; + } + assert_eq!(&mut 2, lazycell.borrow().unwrap()); + } + + #[test] + fn test_try_borrow_mut_with_err() { + let mut lazycell = LazyCell::<()>::new(); + let result = lazycell.try_borrow_mut_with(|| Err(1)); + assert_eq!(result, Err(1)); + } + + #[test] + fn test_try_borrow_mut_with_already_filled() { + let mut lazycell = LazyCell::new(); + lazycell.fill(1).unwrap(); + let result = lazycell.try_borrow_mut_with::<(), _>(|| unreachable!()); + assert_eq!(result, Ok(&mut 1)); + } + + #[test] + fn test_into_inner() { + let lazycell = LazyCell::new(); + + lazycell.fill(1).unwrap(); + let value = lazycell.into_inner(); + assert_eq!(value, Some(1)); + } + + #[test] + fn test_atomic_borrow_from_empty() { + let lazycell: AtomicLazyCell<usize> = AtomicLazyCell::new(); + + let value = lazycell.borrow(); + assert_eq!(value, None); + + let value = lazycell.get(); + assert_eq!(value, None); + } + + #[test] + fn test_atomic_fill_and_borrow() { + let lazycell = AtomicLazyCell::new(); + + assert!(!lazycell.filled()); + lazycell.fill(1).unwrap(); + assert!(lazycell.filled()); + + let value = lazycell.borrow(); + assert_eq!(value, Some(&1)); + + let value = lazycell.get(); + assert_eq!(value, Some(1)); + } + + #[test] + fn test_atomic_already_filled_panic() { + let lazycell = AtomicLazyCell::new(); + + lazycell.fill(1).unwrap(); + assert_eq!(1, lazycell.fill(1).unwrap_err()); + } + + #[test] + fn test_atomic_into_inner() { + let lazycell = AtomicLazyCell::new(); + + lazycell.fill(1).unwrap(); + let value = lazycell.into_inner(); + assert_eq!(value, Some(1)); + } + + #[test] + fn normal_replace() { + let mut cell = LazyCell::new(); + assert_eq!(cell.fill(1), Ok(())); + assert_eq!(cell.replace(2), Some(1)); + assert_eq!(cell.replace(3), Some(2)); + assert_eq!(cell.borrow(), Some(&3)); + + let mut cell = LazyCell::new(); + assert_eq!(cell.replace(2), None); + } + + #[test] + fn atomic_replace() { + let mut cell = AtomicLazyCell::new(); + assert_eq!(cell.fill(1), Ok(())); + assert_eq!(cell.replace(2), Some(1)); + assert_eq!(cell.replace(3), Some(2)); + assert_eq!(cell.borrow(), Some(&3)); + } +} diff --git a/third_party/rust/mio-0.6.23/src/lib.rs b/third_party/rust/mio-0.6.23/src/lib.rs new file mode 100644 index 0000000000..96f704603e --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/lib.rs @@ -0,0 +1,308 @@ +#![doc(html_root_url = "https://docs.rs/mio/0.6.23")] +// Mio targets old versions of the Rust compiler. In order to do this, uses +// deprecated APIs. +#![allow(bare_trait_objects, deprecated, unknown_lints)] +#![deny(missing_docs, missing_debug_implementations)] +#![cfg_attr(test, deny(warnings))] + +// Many of mio's public methods violate this lint, but they can't be fixed +// without a breaking change. +#![cfg_attr(feature = "cargo-clippy", allow(clippy::trivially_copy_pass_by_ref))] + +//! A fast, low-level IO library for Rust focusing on non-blocking APIs, event +//! notification, and other useful utilities for building high performance IO +//! apps. +//! +//! # Features +//! +//! * Non-blocking TCP, UDP +//! * I/O event notification queue backed by epoll, kqueue, and IOCP +//! * Zero allocations at runtime +//! * Platform specific extensions +//! +//! # Non-goals +//! +//! The following are specifically omitted from Mio and are left to the user or higher-level libraries. +//! +//! * File operations +//! * Thread pools / multi-threaded event loop +//! * Timers +//! +//! # Platforms +//! +//! Currently supported platforms: +//! +//! * Linux +//! * OS X +//! * Windows +//! * FreeBSD +//! * NetBSD +//! * Android +//! * iOS +//! +//! mio can handle interfacing with each of the event notification systems of the aforementioned platforms. The details of +//! their implementation are further discussed in [`Poll`]. +//! +//! # Usage +//! +//! Using mio starts by creating a [`Poll`], which reads events from the OS and +//! put them into [`Events`]. You can handle IO events from the OS with it. +//! +//! For more detail, see [`Poll`]. +//! +//! [`Poll`]: struct.Poll.html +//! [`Events`]: struct.Events.html +//! +//! # Example +//! +//! ``` +//! use mio::*; +//! use mio::net::{TcpListener, TcpStream}; +//! +//! // Setup some tokens to allow us to identify which event is +//! // for which socket. +//! const SERVER: Token = Token(0); +//! const CLIENT: Token = Token(1); +//! +//! let addr = "127.0.0.1:13265".parse().unwrap(); +//! +//! // Setup the server socket +//! let server = TcpListener::bind(&addr).unwrap(); +//! +//! // Create a poll instance +//! let poll = Poll::new().unwrap(); +//! +//! // Start listening for incoming connections +//! poll.register(&server, SERVER, Ready::readable(), +//! PollOpt::edge()).unwrap(); +//! +//! // Setup the client socket +//! let sock = TcpStream::connect(&addr).unwrap(); +//! +//! // Register the socket +//! poll.register(&sock, CLIENT, Ready::readable(), +//! PollOpt::edge()).unwrap(); +//! +//! // Create storage for events +//! let mut events = Events::with_capacity(1024); +//! +//! loop { +//! poll.poll(&mut events, None).unwrap(); +//! +//! for event in events.iter() { +//! match event.token() { +//! SERVER => { +//! // Accept and drop the socket immediately, this will close +//! // the socket and notify the client of the EOF. +//! let _ = server.accept(); +//! } +//! CLIENT => { +//! // The server just shuts down the socket, let's just exit +//! // from our event loop. +//! return; +//! } +//! _ => unreachable!(), +//! } +//! } +//! } +//! +//! ``` + +extern crate net2; +extern crate iovec; +extern crate slab; + +#[cfg(target_os = "fuchsia")] +extern crate fuchsia_zircon as zircon; +#[cfg(target_os = "fuchsia")] +extern crate fuchsia_zircon_sys as zircon_sys; + +#[cfg(unix)] +extern crate libc; + +#[cfg(windows)] +extern crate miow; + +#[cfg(windows)] +extern crate winapi; + +#[macro_use] +extern crate log; + +mod event_imp; +mod io; +mod poll; +mod sys; +mod token; +mod lazycell; + +pub mod net; + +#[deprecated(since = "0.6.5", note = "use mio-extras instead")] +#[cfg(feature = "with-deprecated")] +#[doc(hidden)] +pub mod channel; + +#[deprecated(since = "0.6.5", note = "use mio-extras instead")] +#[cfg(feature = "with-deprecated")] +#[doc(hidden)] +pub mod timer; + +#[deprecated(since = "0.6.5", note = "update to use `Poll`")] +#[cfg(feature = "with-deprecated")] +#[doc(hidden)] +pub mod deprecated; + +#[deprecated(since = "0.6.5", note = "use iovec crate directly")] +#[cfg(feature = "with-deprecated")] +#[doc(hidden)] +pub use iovec::IoVec; + +#[deprecated(since = "0.6.6", note = "use net module instead")] +#[cfg(feature = "with-deprecated")] +#[doc(hidden)] +pub mod tcp { + pub use net::{TcpListener, TcpStream}; + pub use std::net::Shutdown; +} + +#[deprecated(since = "0.6.6", note = "use net module instead")] +#[cfg(feature = "with-deprecated")] +#[doc(hidden)] +pub mod udp; + +pub use poll::{ + Poll, + Registration, + SetReadiness, +}; +pub use event_imp::{ + PollOpt, + Ready, +}; +pub use token::Token; + +pub mod event { + //! Readiness event types and utilities. + + pub use super::poll::{Events, Iter}; + pub use super::event_imp::{Event, Evented}; +} + +pub use event::{ + Events, +}; + +#[deprecated(since = "0.6.5", note = "use events:: instead")] +#[cfg(feature = "with-deprecated")] +#[doc(hidden)] +pub use event::{Event, Evented}; + +#[deprecated(since = "0.6.5", note = "use events::Iter instead")] +#[cfg(feature = "with-deprecated")] +#[doc(hidden)] +pub use poll::Iter as EventsIter; + +#[deprecated(since = "0.6.5", note = "std::io::Error can avoid the allocation now")] +#[cfg(feature = "with-deprecated")] +#[doc(hidden)] +pub use io::deprecated::would_block; + +#[cfg(all(unix, not(target_os = "fuchsia")))] +pub mod unix { + //! Unix only extensions + pub use sys::{ + EventedFd, + }; + pub use sys::unix::UnixReady; +} + +#[cfg(target_os = "fuchsia")] +pub mod fuchsia { + //! Fuchsia-only extensions + //! + //! # Stability + //! + //! This module depends on the [magenta-sys crate](https://crates.io/crates/magenta-sys) + //! and so might introduce breaking changes, even on minor releases, + //! so long as that crate remains unstable. + pub use sys::{ + EventedHandle, + }; + pub use sys::fuchsia::{FuchsiaReady, zx_signals_t}; +} + +/// Windows-only extensions to the mio crate. +/// +/// Mio on windows is currently implemented with IOCP for a high-performance +/// implementation of asynchronous I/O. Mio then provides TCP and UDP as sample +/// bindings for the system to connect networking types to asynchronous I/O. On +/// Unix this scheme is then also extensible to all other file descriptors with +/// the `EventedFd` type, but on Windows no such analog is available. The +/// purpose of this module, however, is to similarly provide a mechanism for +/// foreign I/O types to get hooked up into the IOCP event loop. +/// +/// This module provides two types for interfacing with a custom IOCP handle: +/// +/// * `Binding` - this type is intended to govern binding with mio's `Poll` +/// type. Each I/O object should contain an instance of `Binding` that's +/// interfaced with for the implementation of the `Evented` trait. The +/// `register`, `reregister`, and `deregister` methods for the `Evented` trait +/// all have rough analogs with `Binding`. +/// +/// Note that this type **does not handle readiness**. That is, this type does +/// not handle whether sockets are readable/writable/etc. It's intended that +/// IOCP types will internally manage this state with a `SetReadiness` type +/// from the `poll` module. The `SetReadiness` is typically lazily created on +/// the first time that `Evented::register` is called and then stored in the +/// I/O object. +/// +/// Also note that for types which represent streams of bytes the mio +/// interface of *readiness* doesn't map directly to the Windows model of +/// *completion*. This means that types will have to perform internal +/// buffering to ensure that a readiness interface can be provided. For a +/// sample implementation see the TCP/UDP modules in mio itself. +/// +/// * `Overlapped` - this type is intended to be used as the concrete instances +/// of the `OVERLAPPED` type that most win32 methods expect. It's crucial, for +/// safety, that all asynchronous operations are initiated with an instance of +/// `Overlapped` and not another instantiation of `OVERLAPPED`. +/// +/// Mio's `Overlapped` type is created with a function pointer that receives +/// a `OVERLAPPED_ENTRY` type when called. This `OVERLAPPED_ENTRY` type is +/// defined in the `winapi` crate. Whenever a completion is posted to an IOCP +/// object the `OVERLAPPED` that was signaled will be interpreted as +/// `Overlapped` in the mio crate and this function pointer will be invoked. +/// Through this function pointer, and through the `OVERLAPPED` pointer, +/// implementations can handle management of I/O events. +/// +/// When put together these two types enable custom Windows handles to be +/// registered with mio's event loops. The `Binding` type is used to associate +/// handles and the `Overlapped` type is used to execute I/O operations. When +/// the I/O operations are completed a custom function pointer is called which +/// typically modifies a `SetReadiness` set by `Evented` methods which will get +/// later hooked into the mio event loop. +#[cfg(windows)] +pub mod windows { + + pub use sys::{Overlapped, Binding}; +} + +#[cfg(feature = "with-deprecated")] +mod convert { + use std::time::Duration; + + const NANOS_PER_MILLI: u32 = 1_000_000; + const MILLIS_PER_SEC: u64 = 1_000; + + /// Convert a `Duration` to milliseconds, rounding up and saturating at + /// `u64::MAX`. + /// + /// The saturating is fine because `u64::MAX` milliseconds are still many + /// million years. + pub fn millis(duration: Duration) -> u64 { + // Round up. + let millis = (duration.subsec_nanos() + NANOS_PER_MILLI - 1) / NANOS_PER_MILLI; + duration.as_secs().saturating_mul(MILLIS_PER_SEC).saturating_add(u64::from(millis)) + } +} diff --git a/third_party/rust/mio-0.6.23/src/net/mod.rs b/third_party/rust/mio-0.6.23/src/net/mod.rs new file mode 100644 index 0000000000..53025c6869 --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/net/mod.rs @@ -0,0 +1,14 @@ +//! Networking primitives +//! +//! The types provided in this module are non-blocking by default and are +//! designed to be portable across all supported Mio platforms. As long as the +//! [portability guidelines] are followed, the behavior should be identical no +//! matter the target platform. +//! +//! [portability guidelines]: ../struct.Poll.html#portability + +mod tcp; +mod udp; + +pub use self::tcp::{TcpListener, TcpStream}; +pub use self::udp::UdpSocket; diff --git a/third_party/rust/mio-0.6.23/src/net/tcp.rs b/third_party/rust/mio-0.6.23/src/net/tcp.rs new file mode 100644 index 0000000000..cc74ab9451 --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/net/tcp.rs @@ -0,0 +1,737 @@ +//! Primitives for working with TCP +//! +//! The types provided in this module are non-blocking by default and are +//! designed to be portable across all supported Mio platforms. As long as the +//! [portability guidelines] are followed, the behavior should be identical no +//! matter the target platform. +//! +/// [portability guidelines]: ../struct.Poll.html#portability + +use std::fmt; +use std::io::{Read, Write}; +use std::net::{self, SocketAddr, SocketAddrV4, SocketAddrV6, Ipv4Addr, Ipv6Addr}; +use std::time::Duration; + +use net2::TcpBuilder; +use iovec::IoVec; + +use {io, sys, Ready, Poll, PollOpt, Token}; +use event::Evented; +use poll::SelectorId; + +/* + * + * ===== TcpStream ===== + * + */ + +/// A non-blocking TCP stream between a local socket and a remote socket. +/// +/// The socket will be closed when the value is dropped. +/// +/// # Examples +/// +/// ``` +/// # use std::net::TcpListener; +/// # use std::error::Error; +/// # +/// # fn try_main() -> Result<(), Box<Error>> { +/// # let _listener = TcpListener::bind("127.0.0.1:34254")?; +/// use mio::{Events, Ready, Poll, PollOpt, Token}; +/// use mio::net::TcpStream; +/// use std::time::Duration; +/// +/// let stream = TcpStream::connect(&"127.0.0.1:34254".parse()?)?; +/// +/// let poll = Poll::new()?; +/// let mut events = Events::with_capacity(128); +/// +/// // Register the socket with `Poll` +/// poll.register(&stream, Token(0), Ready::writable(), +/// PollOpt::edge())?; +/// +/// poll.poll(&mut events, Some(Duration::from_millis(100)))?; +/// +/// // The socket might be ready at this point +/// # Ok(()) +/// # } +/// # +/// # fn main() { +/// # try_main().unwrap(); +/// # } +/// ``` +pub struct TcpStream { + sys: sys::TcpStream, + selector_id: SelectorId, +} + +use std::net::Shutdown; + +// TODO: remove when fuchsia's set_nonblocking is fixed in libstd +#[cfg(target_os = "fuchsia")] +fn set_nonblocking(stream: &net::TcpStream) -> io::Result<()> { + sys::set_nonblock( + ::std::os::unix::io::AsRawFd::as_raw_fd(stream)) +} +#[cfg(not(target_os = "fuchsia"))] +fn set_nonblocking(stream: &net::TcpStream) -> io::Result<()> { + stream.set_nonblocking(true) +} + + +impl TcpStream { + /// Create a new TCP stream and issue a non-blocking connect to the + /// specified address. + /// + /// This convenience method is available and uses the system's default + /// options when creating a socket which is then connected. If fine-grained + /// control over the creation of the socket is desired, you can use + /// `net2::TcpBuilder` to configure a socket and then pass its socket to + /// `TcpStream::connect_stream` to transfer ownership into mio and schedule + /// the connect operation. + pub fn connect(addr: &SocketAddr) -> io::Result<TcpStream> { + let sock = match *addr { + SocketAddr::V4(..) => TcpBuilder::new_v4(), + SocketAddr::V6(..) => TcpBuilder::new_v6(), + }?; + // Required on Windows for a future `connect_overlapped` operation to be + // executed successfully. + if cfg!(windows) { + sock.bind(&inaddr_any(addr))?; + } + TcpStream::connect_stream(sock.to_tcp_stream()?, addr) + } + + /// Creates a new `TcpStream` from the pending socket inside the given + /// `std::net::TcpBuilder`, connecting it to the address specified. + /// + /// This constructor allows configuring the socket before it's actually + /// connected, and this function will transfer ownership to the returned + /// `TcpStream` if successful. An unconnected `TcpStream` can be created + /// with the `net2::TcpBuilder` type (and also configured via that route). + /// + /// The platform specific behavior of this function looks like: + /// + /// * On Unix, the socket is placed into nonblocking mode and then a + /// `connect` call is issued. + /// + /// * On Windows, the address is stored internally and the connect operation + /// is issued when the returned `TcpStream` is registered with an event + /// loop. Note that on Windows you must `bind` a socket before it can be + /// connected, so if a custom `TcpBuilder` is used it should be bound + /// (perhaps to `INADDR_ANY`) before this method is called. + pub fn connect_stream(stream: net::TcpStream, + addr: &SocketAddr) -> io::Result<TcpStream> { + Ok(TcpStream { + sys: sys::TcpStream::connect(stream, addr)?, + selector_id: SelectorId::new(), + }) + } + + /// Creates a new `TcpStream` from a standard `net::TcpStream`. + /// + /// This function is intended to be used to wrap a TCP stream from the + /// standard library in the mio equivalent. The conversion here will + /// automatically set `stream` to nonblocking and the returned object should + /// be ready to get associated with an event loop. + /// + /// Note that the TCP stream here will not have `connect` called on it, so + /// it should already be connected via some other means (be it manually, the + /// net2 crate, or the standard library). + pub fn from_stream(stream: net::TcpStream) -> io::Result<TcpStream> { + set_nonblocking(&stream)?; + + Ok(TcpStream { + sys: sys::TcpStream::from_stream(stream), + selector_id: SelectorId::new(), + }) + } + + /// Returns the socket address of the remote peer of this TCP connection. + pub fn peer_addr(&self) -> io::Result<SocketAddr> { + self.sys.peer_addr() + } + + /// Returns the socket address of the local half of this TCP connection. + pub fn local_addr(&self) -> io::Result<SocketAddr> { + self.sys.local_addr() + } + + /// Creates a new independently owned handle to the underlying socket. + /// + /// The returned `TcpStream` is a reference to the same stream that this + /// object references. Both handles will read and write the same stream of + /// data, and options set on one stream will be propagated to the other + /// stream. + pub fn try_clone(&self) -> io::Result<TcpStream> { + self.sys.try_clone().map(|s| { + TcpStream { + sys: s, + selector_id: self.selector_id.clone(), + } + }) + } + + /// Shuts down the read, write, or both halves of this connection. + /// + /// This function will cause all pending and future I/O on the specified + /// portions to return immediately with an appropriate value (see the + /// documentation of `Shutdown`). + pub fn shutdown(&self, how: Shutdown) -> io::Result<()> { + self.sys.shutdown(how) + } + + /// Sets the value of the `TCP_NODELAY` option on this socket. + /// + /// If set, this option disables the Nagle algorithm. This means that + /// segments are always sent as soon as possible, even if there is only a + /// small amount of data. When not set, data is buffered until there is a + /// sufficient amount to send out, thereby avoiding the frequent sending of + /// small packets. + pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> { + self.sys.set_nodelay(nodelay) + } + + /// Gets the value of the `TCP_NODELAY` option on this socket. + /// + /// For more information about this option, see [`set_nodelay`][link]. + /// + /// [link]: #method.set_nodelay + pub fn nodelay(&self) -> io::Result<bool> { + self.sys.nodelay() + } + + /// Sets the value of the `SO_RCVBUF` option on this socket. + /// + /// Changes the size of the operating system's receive buffer associated + /// with the socket. + pub fn set_recv_buffer_size(&self, size: usize) -> io::Result<()> { + self.sys.set_recv_buffer_size(size) + } + + /// Gets the value of the `SO_RCVBUF` option on this socket. + /// + /// For more information about this option, see + /// [`set_recv_buffer_size`][link]. + /// + /// [link]: #method.set_recv_buffer_size + pub fn recv_buffer_size(&self) -> io::Result<usize> { + self.sys.recv_buffer_size() + } + + /// Sets the value of the `SO_SNDBUF` option on this socket. + /// + /// Changes the size of the operating system's send buffer associated with + /// the socket. + pub fn set_send_buffer_size(&self, size: usize) -> io::Result<()> { + self.sys.set_send_buffer_size(size) + } + + /// Gets the value of the `SO_SNDBUF` option on this socket. + /// + /// For more information about this option, see + /// [`set_send_buffer_size`][link]. + /// + /// [link]: #method.set_send_buffer_size + pub fn send_buffer_size(&self) -> io::Result<usize> { + self.sys.send_buffer_size() + } + + /// Sets whether keepalive messages are enabled to be sent on this socket. + /// + /// On Unix, this option will set the `SO_KEEPALIVE` as well as the + /// `TCP_KEEPALIVE` or `TCP_KEEPIDLE` option (depending on your platform). + /// On Windows, this will set the `SIO_KEEPALIVE_VALS` option. + /// + /// If `None` is specified then keepalive messages are disabled, otherwise + /// the duration specified will be the time to remain idle before sending a + /// TCP keepalive probe. + /// + /// Some platforms specify this value in seconds, so sub-second + /// specifications may be omitted. + pub fn set_keepalive(&self, keepalive: Option<Duration>) -> io::Result<()> { + self.sys.set_keepalive(keepalive) + } + + /// Returns whether keepalive messages are enabled on this socket, and if so + /// the duration of time between them. + /// + /// For more information about this option, see [`set_keepalive`][link]. + /// + /// [link]: #method.set_keepalive + pub fn keepalive(&self) -> io::Result<Option<Duration>> { + self.sys.keepalive() + } + + /// Sets the value for the `IP_TTL` option on this socket. + /// + /// This value sets the time-to-live field that is used in every packet sent + /// from this socket. + pub fn set_ttl(&self, ttl: u32) -> io::Result<()> { + self.sys.set_ttl(ttl) + } + + /// Gets the value of the `IP_TTL` option for this socket. + /// + /// For more information about this option, see [`set_ttl`][link]. + /// + /// [link]: #method.set_ttl + pub fn ttl(&self) -> io::Result<u32> { + self.sys.ttl() + } + + /// Sets the value for the `IPV6_V6ONLY` option on this socket. + /// + /// If this is set to `true` then the socket is restricted to sending and + /// receiving IPv6 packets only. In this case two IPv4 and IPv6 applications + /// can bind the same port at the same time. + /// + /// If this is set to `false` then the socket can be used to send and + /// receive packets from an IPv4-mapped IPv6 address. + pub fn set_only_v6(&self, only_v6: bool) -> io::Result<()> { + self.sys.set_only_v6(only_v6) + } + + /// Gets the value of the `IPV6_V6ONLY` option for this socket. + /// + /// For more information about this option, see [`set_only_v6`][link]. + /// + /// [link]: #method.set_only_v6 + pub fn only_v6(&self) -> io::Result<bool> { + self.sys.only_v6() + } + + /// Sets the value for the `SO_LINGER` option on this socket. + pub fn set_linger(&self, dur: Option<Duration>) -> io::Result<()> { + self.sys.set_linger(dur) + } + + /// Gets the value of the `SO_LINGER` option on this socket. + /// + /// For more information about this option, see [`set_linger`][link]. + /// + /// [link]: #method.set_linger + pub fn linger(&self) -> io::Result<Option<Duration>> { + self.sys.linger() + } + + #[deprecated(since = "0.6.9", note = "use set_keepalive")] + #[cfg(feature = "with-deprecated")] + #[doc(hidden)] + pub fn set_keepalive_ms(&self, keepalive: Option<u32>) -> io::Result<()> { + self.set_keepalive(keepalive.map(|v| { + Duration::from_millis(u64::from(v)) + })) + } + + #[deprecated(since = "0.6.9", note = "use keepalive")] + #[cfg(feature = "with-deprecated")] + #[doc(hidden)] + pub fn keepalive_ms(&self) -> io::Result<Option<u32>> { + self.keepalive().map(|v| { + v.map(|v| { + ::convert::millis(v) as u32 + }) + }) + } + + /// Get the value of the `SO_ERROR` option on this socket. + /// + /// This will retrieve the stored error in the underlying socket, clearing + /// the field in the process. This can be useful for checking errors between + /// calls. + pub fn take_error(&self) -> io::Result<Option<io::Error>> { + self.sys.take_error() + } + + /// Receives data on the socket from the remote address to which it is + /// connected, without removing that data from the queue. On success, + /// returns the number of bytes peeked. + /// + /// Successive calls return the same data. This is accomplished by passing + /// `MSG_PEEK` as a flag to the underlying recv system call. + pub fn peek(&self, buf: &mut [u8]) -> io::Result<usize> { + self.sys.peek(buf) + } + + /// Read in a list of buffers all at once. + /// + /// This operation will attempt to read bytes from this socket and place + /// them into the list of buffers provided. Note that each buffer is an + /// `IoVec` which can be created from a byte slice. + /// + /// The buffers provided will be filled in sequentially. A buffer will be + /// entirely filled up before the next is written to. + /// + /// The number of bytes read is returned, if successful, or an error is + /// returned otherwise. If no bytes are available to be read yet then + /// a "would block" error is returned. This operation does not block. + /// + /// On Unix this corresponds to the `readv` syscall. + pub fn read_bufs(&self, bufs: &mut [&mut IoVec]) -> io::Result<usize> { + self.sys.readv(bufs) + } + + /// Write a list of buffers all at once. + /// + /// This operation will attempt to write a list of byte buffers to this + /// socket. Note that each buffer is an `IoVec` which can be created from a + /// byte slice. + /// + /// The buffers provided will be written sequentially. A buffer will be + /// entirely written before the next is written. + /// + /// The number of bytes written is returned, if successful, or an error is + /// returned otherwise. If the socket is not currently writable then a + /// "would block" error is returned. This operation does not block. + /// + /// On Unix this corresponds to the `writev` syscall. + pub fn write_bufs(&self, bufs: &[&IoVec]) -> io::Result<usize> { + self.sys.writev(bufs) + } +} + +fn inaddr_any(other: &SocketAddr) -> SocketAddr { + match *other { + SocketAddr::V4(..) => { + let any = Ipv4Addr::new(0, 0, 0, 0); + let addr = SocketAddrV4::new(any, 0); + SocketAddr::V4(addr) + } + SocketAddr::V6(..) => { + let any = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0); + let addr = SocketAddrV6::new(any, 0, 0, 0); + SocketAddr::V6(addr) + } + } +} + +impl Read for TcpStream { + fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { + (&self.sys).read(buf) + } +} + +impl<'a> Read for &'a TcpStream { + fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { + (&self.sys).read(buf) + } +} + +impl Write for TcpStream { + fn write(&mut self, buf: &[u8]) -> io::Result<usize> { + (&self.sys).write(buf) + } + + fn flush(&mut self) -> io::Result<()> { + (&self.sys).flush() + } +} + +impl<'a> Write for &'a TcpStream { + fn write(&mut self, buf: &[u8]) -> io::Result<usize> { + (&self.sys).write(buf) + } + + fn flush(&mut self) -> io::Result<()> { + (&self.sys).flush() + } +} + +impl Evented for TcpStream { + fn register(&self, poll: &Poll, token: Token, + interest: Ready, opts: PollOpt) -> io::Result<()> { + self.selector_id.associate_selector(poll)?; + self.sys.register(poll, token, interest, opts) + } + + fn reregister(&self, poll: &Poll, token: Token, + interest: Ready, opts: PollOpt) -> io::Result<()> { + self.sys.reregister(poll, token, interest, opts) + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + self.sys.deregister(poll) + } +} + +impl fmt::Debug for TcpStream { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::Debug::fmt(&self.sys, f) + } +} + +/* + * + * ===== TcpListener ===== + * + */ + +/// A structure representing a socket server +/// +/// # Examples +/// +/// ``` +/// # use std::error::Error; +/// # fn try_main() -> Result<(), Box<Error>> { +/// use mio::{Events, Ready, Poll, PollOpt, Token}; +/// use mio::net::TcpListener; +/// use std::time::Duration; +/// +/// let listener = TcpListener::bind(&"127.0.0.1:34255".parse()?)?; +/// +/// let poll = Poll::new()?; +/// let mut events = Events::with_capacity(128); +/// +/// // Register the socket with `Poll` +/// poll.register(&listener, Token(0), Ready::readable(), +/// PollOpt::edge())?; +/// +/// poll.poll(&mut events, Some(Duration::from_millis(100)))?; +/// +/// // There may be a socket ready to be accepted +/// # Ok(()) +/// # } +/// # +/// # fn main() { +/// # try_main().unwrap(); +/// # } +/// ``` +pub struct TcpListener { + sys: sys::TcpListener, + selector_id: SelectorId, +} + +impl TcpListener { + /// Convenience method to bind a new TCP listener to the specified address + /// to receive new connections. + /// + /// This function will take the following steps: + /// + /// 1. Create a new TCP socket. + /// 2. Set the `SO_REUSEADDR` option on the socket. + /// 3. Bind the socket to the specified address. + /// 4. Call `listen` on the socket to prepare it to receive new connections. + /// + /// If fine-grained control over the binding and listening process for a + /// socket is desired then the `net2::TcpBuilder` methods can be used in + /// combination with the `TcpListener::from_listener` method to transfer + /// ownership into mio. + pub fn bind(addr: &SocketAddr) -> io::Result<TcpListener> { + // Create the socket + let sock = match *addr { + SocketAddr::V4(..) => TcpBuilder::new_v4(), + SocketAddr::V6(..) => TcpBuilder::new_v6(), + }?; + + // Set SO_REUSEADDR, but only on Unix (mirrors what libstd does) + if cfg!(unix) { + sock.reuse_address(true)?; + } + + // Bind the socket + sock.bind(addr)?; + + // listen + let listener = sock.listen(1024)?; + Ok(TcpListener { + sys: sys::TcpListener::new(listener)?, + selector_id: SelectorId::new(), + }) + } + + #[deprecated(since = "0.6.13", note = "use from_std instead")] + #[cfg(feature = "with-deprecated")] + #[doc(hidden)] + pub fn from_listener(listener: net::TcpListener, _: &SocketAddr) + -> io::Result<TcpListener> { + TcpListener::from_std(listener) + } + + /// Creates a new `TcpListener` from an instance of a + /// `std::net::TcpListener` type. + /// + /// This function will set the `listener` provided into nonblocking mode on + /// Unix, and otherwise the stream will just be wrapped up in an mio stream + /// ready to accept new connections and become associated with an event + /// loop. + /// + /// The address provided must be the address that the listener is bound to. + pub fn from_std(listener: net::TcpListener) -> io::Result<TcpListener> { + sys::TcpListener::new(listener).map(|s| { + TcpListener { + sys: s, + selector_id: SelectorId::new(), + } + }) + } + + /// Accepts a new `TcpStream`. + /// + /// This may return an `Err(e)` where `e.kind()` is + /// `io::ErrorKind::WouldBlock`. This means a stream may be ready at a later + /// point and one should wait for a notification before calling `accept` + /// again. + /// + /// If an accepted stream is returned, the remote address of the peer is + /// returned along with it. + pub fn accept(&self) -> io::Result<(TcpStream, SocketAddr)> { + let (s, a) = try!(self.accept_std()); + Ok((TcpStream::from_stream(s)?, a)) + } + + /// Accepts a new `std::net::TcpStream`. + /// + /// This method is the same as `accept`, except that it returns a TCP socket + /// *in blocking mode* which isn't bound to `mio`. This can be later then + /// converted to a `mio` type, if necessary. + pub fn accept_std(&self) -> io::Result<(net::TcpStream, SocketAddr)> { + self.sys.accept() + } + + /// Returns the local socket address of this listener. + pub fn local_addr(&self) -> io::Result<SocketAddr> { + self.sys.local_addr() + } + + /// Creates a new independently owned handle to the underlying socket. + /// + /// The returned `TcpListener` is a reference to the same socket that this + /// object references. Both handles can be used to accept incoming + /// connections and options set on one listener will affect the other. + pub fn try_clone(&self) -> io::Result<TcpListener> { + self.sys.try_clone().map(|s| { + TcpListener { + sys: s, + selector_id: self.selector_id.clone(), + } + }) + } + + /// Sets the value for the `IP_TTL` option on this socket. + /// + /// This value sets the time-to-live field that is used in every packet sent + /// from this socket. + pub fn set_ttl(&self, ttl: u32) -> io::Result<()> { + self.sys.set_ttl(ttl) + } + + /// Gets the value of the `IP_TTL` option for this socket. + /// + /// For more information about this option, see [`set_ttl`][link]. + /// + /// [link]: #method.set_ttl + pub fn ttl(&self) -> io::Result<u32> { + self.sys.ttl() + } + + /// Sets the value for the `IPV6_V6ONLY` option on this socket. + /// + /// If this is set to `true` then the socket is restricted to sending and + /// receiving IPv6 packets only. In this case two IPv4 and IPv6 applications + /// can bind the same port at the same time. + /// + /// If this is set to `false` then the socket can be used to send and + /// receive packets from an IPv4-mapped IPv6 address. + pub fn set_only_v6(&self, only_v6: bool) -> io::Result<()> { + self.sys.set_only_v6(only_v6) + } + + /// Gets the value of the `IPV6_V6ONLY` option for this socket. + /// + /// For more information about this option, see [`set_only_v6`][link]. + /// + /// [link]: #method.set_only_v6 + pub fn only_v6(&self) -> io::Result<bool> { + self.sys.only_v6() + } + + /// Get the value of the `SO_ERROR` option on this socket. + /// + /// This will retrieve the stored error in the underlying socket, clearing + /// the field in the process. This can be useful for checking errors between + /// calls. + pub fn take_error(&self) -> io::Result<Option<io::Error>> { + self.sys.take_error() + } +} + +impl Evented for TcpListener { + fn register(&self, poll: &Poll, token: Token, + interest: Ready, opts: PollOpt) -> io::Result<()> { + self.selector_id.associate_selector(poll)?; + self.sys.register(poll, token, interest, opts) + } + + fn reregister(&self, poll: &Poll, token: Token, + interest: Ready, opts: PollOpt) -> io::Result<()> { + self.sys.reregister(poll, token, interest, opts) + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + self.sys.deregister(poll) + } +} + +impl fmt::Debug for TcpListener { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::Debug::fmt(&self.sys, f) + } +} + +/* + * + * ===== UNIX ext ===== + * + */ + +#[cfg(all(unix, not(target_os = "fuchsia")))] +use std::os::unix::io::{IntoRawFd, AsRawFd, FromRawFd, RawFd}; + +#[cfg(all(unix, not(target_os = "fuchsia")))] +impl IntoRawFd for TcpStream { + fn into_raw_fd(self) -> RawFd { + self.sys.into_raw_fd() + } +} + +#[cfg(all(unix, not(target_os = "fuchsia")))] +impl AsRawFd for TcpStream { + fn as_raw_fd(&self) -> RawFd { + self.sys.as_raw_fd() + } +} + +#[cfg(all(unix, not(target_os = "fuchsia")))] +impl FromRawFd for TcpStream { + unsafe fn from_raw_fd(fd: RawFd) -> TcpStream { + TcpStream { + sys: FromRawFd::from_raw_fd(fd), + selector_id: SelectorId::new(), + } + } +} + +#[cfg(all(unix, not(target_os = "fuchsia")))] +impl IntoRawFd for TcpListener { + fn into_raw_fd(self) -> RawFd { + self.sys.into_raw_fd() + } +} + +#[cfg(all(unix, not(target_os = "fuchsia")))] +impl AsRawFd for TcpListener { + fn as_raw_fd(&self) -> RawFd { + self.sys.as_raw_fd() + } +} + +#[cfg(all(unix, not(target_os = "fuchsia")))] +impl FromRawFd for TcpListener { + unsafe fn from_raw_fd(fd: RawFd) -> TcpListener { + TcpListener { + sys: FromRawFd::from_raw_fd(fd), + selector_id: SelectorId::new(), + } + } +} diff --git a/third_party/rust/mio-0.6.23/src/net/udp.rs b/third_party/rust/mio-0.6.23/src/net/udp.rs new file mode 100644 index 0000000000..0d89511ac7 --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/net/udp.rs @@ -0,0 +1,645 @@ +//! Primitives for working with UDP +//! +//! The types provided in this module are non-blocking by default and are +//! designed to be portable across all supported Mio platforms. As long as the +//! [portability guidelines] are followed, the behavior should be identical no +//! matter the target platform. +//! +/// [portability guidelines]: ../struct.Poll.html#portability + +use {io, sys, Ready, Poll, PollOpt, Token}; +use event::Evented; +use poll::SelectorId; +use std::fmt; +use std::net::{self, Ipv4Addr, Ipv6Addr, SocketAddr}; + +#[cfg(all(unix, not(target_os = "fuchsia")))] +use iovec::IoVec; + +/// A User Datagram Protocol socket. +/// +/// This is an implementation of a bound UDP socket. This supports both IPv4 and +/// IPv6 addresses, and there is no corresponding notion of a server because UDP +/// is a datagram protocol. +/// +/// # Examples +/// +/// ``` +/// # use std::error::Error; +/// # +/// # fn try_main() -> Result<(), Box<Error>> { +/// // An Echo program: +/// // SENDER -> sends a message. +/// // ECHOER -> listens and prints the message received. +/// +/// use mio::net::UdpSocket; +/// use mio::{Events, Ready, Poll, PollOpt, Token}; +/// use std::time::Duration; +/// +/// const SENDER: Token = Token(0); +/// const ECHOER: Token = Token(1); +/// +/// // This operation will fail if the address is in use, so we select different ports for each +/// // socket. +/// let sender_socket = UdpSocket::bind(&"127.0.0.1:0".parse()?)?; +/// let echoer_socket = UdpSocket::bind(&"127.0.0.1:0".parse()?)?; +/// +/// // If we do not use connect here, SENDER and ECHOER would need to call send_to and recv_from +/// // respectively. +/// sender_socket.connect(echoer_socket.local_addr().unwrap())?; +/// +/// // We need a Poll to check if SENDER is ready to be written into, and if ECHOER is ready to be +/// // read from. +/// let poll = Poll::new()?; +/// +/// // We register our sockets here so that we can check if they are ready to be written/read. +/// poll.register(&sender_socket, SENDER, Ready::writable(), PollOpt::edge())?; +/// poll.register(&echoer_socket, ECHOER, Ready::readable(), PollOpt::edge())?; +/// +/// let msg_to_send = [9; 9]; +/// let mut buffer = [0; 9]; +/// +/// let mut events = Events::with_capacity(128); +/// loop { +/// poll.poll(&mut events, Some(Duration::from_millis(100)))?; +/// for event in events.iter() { +/// match event.token() { +/// // Our SENDER is ready to be written into. +/// SENDER => { +/// let bytes_sent = sender_socket.send(&msg_to_send)?; +/// assert_eq!(bytes_sent, 9); +/// println!("sent {:?} -> {:?} bytes", msg_to_send, bytes_sent); +/// }, +/// // Our ECHOER is ready to be read from. +/// ECHOER => { +/// let num_recv = echoer_socket.recv(&mut buffer)?; +/// println!("echo {:?} -> {:?}", buffer, num_recv); +/// buffer = [0; 9]; +/// # return Ok(()); +/// } +/// _ => unreachable!() +/// } +/// } +/// } +/// # +/// # Ok(()) +/// # } +/// # +/// # fn main() { +/// # try_main().unwrap(); +/// # } +/// ``` +pub struct UdpSocket { + sys: sys::UdpSocket, + selector_id: SelectorId, +} + +impl UdpSocket { + /// Creates a UDP socket from the given address. + /// + /// # Examples + /// + /// ``` + /// # use std::error::Error; + /// # + /// # fn try_main() -> Result<(), Box<Error>> { + /// use mio::net::UdpSocket; + /// + /// // We must bind it to an open address. + /// let socket = match UdpSocket::bind(&"127.0.0.1:0".parse()?) { + /// Ok(new_socket) => new_socket, + /// Err(fail) => { + /// // We panic! here, but you could try to bind it again on another address. + /// panic!("Failed to bind socket. {:?}", fail); + /// } + /// }; + /// + /// // Our socket was created, but we should not use it before checking it's readiness. + /// # Ok(()) + /// # } + /// # + /// # fn main() { + /// # try_main().unwrap(); + /// # } + /// ``` + pub fn bind(addr: &SocketAddr) -> io::Result<UdpSocket> { + let socket = net::UdpSocket::bind(addr)?; + UdpSocket::from_socket(socket) + } + + /// Creates a new mio-wrapped socket from an underlying and bound std + /// socket. + /// + /// This function requires that `socket` has previously been bound to an + /// address to work correctly, and returns an I/O object which can be used + /// with mio to send/receive UDP messages. + /// + /// This can be used in conjunction with net2's `UdpBuilder` interface to + /// configure a socket before it's handed off to mio, such as setting + /// options like `reuse_address` or binding to multiple addresses. + pub fn from_socket(socket: net::UdpSocket) -> io::Result<UdpSocket> { + Ok(UdpSocket { + sys: sys::UdpSocket::new(socket)?, + selector_id: SelectorId::new(), + }) + } + + /// Returns the socket address that this socket was created from. + /// + /// # Examples + /// + // This assertion is almost, but not quite, universal. It fails on + // shared-IP FreeBSD jails. It's hard for mio to know whether we're jailed, + // so simply disable the test on FreeBSD. + #[cfg_attr(not(target_os = "freebsd"), doc = " ```")] + #[cfg_attr(target_os = "freebsd", doc = " ```no_run")] + /// # use std::error::Error; + /// # + /// # fn try_main() -> Result<(), Box<Error>> { + /// use mio::net::UdpSocket; + /// + /// let addr = "127.0.0.1:0".parse()?; + /// let socket = UdpSocket::bind(&addr)?; + /// # Ok(()) + /// # } + /// # + /// # fn main() { + /// # try_main().unwrap(); + /// # } + /// ``` + pub fn local_addr(&self) -> io::Result<SocketAddr> { + self.sys.local_addr() + } + + /// Creates a new independently owned handle to the underlying socket. + /// + /// The returned `UdpSocket` is a reference to the same socket that this + /// object references. Both handles will read and write the same port, and + /// options set on one socket will be propagated to the other. + /// + /// # Examples + /// + /// ``` + /// # use std::error::Error; + /// # + /// # fn try_main() -> Result<(), Box<Error>> { + /// use mio::net::UdpSocket; + /// + /// // We must bind it to an open address. + /// let socket = UdpSocket::bind(&"127.0.0.1:0".parse()?)?; + /// let cloned_socket = socket.try_clone()?; + /// + /// assert_eq!(socket.local_addr()?, cloned_socket.local_addr()?); + /// + /// # Ok(()) + /// # } + /// # + /// # fn main() { + /// # try_main().unwrap(); + /// # } + /// ``` + pub fn try_clone(&self) -> io::Result<UdpSocket> { + self.sys.try_clone() + .map(|s| { + UdpSocket { + sys: s, + selector_id: self.selector_id.clone(), + } + }) + } + + /// Sends data on the socket to the given address. On success, returns the + /// number of bytes written. + /// + /// Address type can be any implementor of `ToSocketAddrs` trait. See its + /// documentation for concrete examples. + /// + /// # Examples + /// + /// ```no_run + /// # use std::error::Error; + /// # fn try_main() -> Result<(), Box<Error>> { + /// use mio::net::UdpSocket; + /// + /// let socket = UdpSocket::bind(&"127.0.0.1:0".parse()?)?; + /// + /// // We must check if the socket is writable before calling send_to, + /// // or we could run into a WouldBlock error. + /// + /// let bytes_sent = socket.send_to(&[9; 9], &"127.0.0.1:11100".parse()?)?; + /// assert_eq!(bytes_sent, 9); + /// # + /// # Ok(()) + /// # } + /// # + /// # fn main() { + /// # try_main().unwrap(); + /// # } + /// ``` + pub fn send_to(&self, buf: &[u8], target: &SocketAddr) -> io::Result<usize> { + self.sys.send_to(buf, target) + } + + /// Receives data from the socket. On success, returns the number of bytes + /// read and the address from whence the data came. + /// + /// # Examples + /// + /// ```no_run + /// # use std::error::Error; + /// # + /// # fn try_main() -> Result<(), Box<Error>> { + /// use mio::net::UdpSocket; + /// + /// let socket = UdpSocket::bind(&"127.0.0.1:0".parse()?)?; + /// + /// // We must check if the socket is readable before calling recv_from, + /// // or we could run into a WouldBlock error. + /// + /// let mut buf = [0; 9]; + /// let (num_recv, from_addr) = socket.recv_from(&mut buf)?; + /// println!("Received {:?} -> {:?} bytes from {:?}", buf, num_recv, from_addr); + /// # + /// # Ok(()) + /// # } + /// # + /// # fn main() { + /// # try_main().unwrap(); + /// # } + /// ``` + pub fn recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> { + self.sys.recv_from(buf) + } + + /// Sends data on the socket to the address previously bound via connect(). On success, + /// returns the number of bytes written. + pub fn send(&self, buf: &[u8]) -> io::Result<usize> { + self.sys.send(buf) + } + + /// Receives data from the socket previously bound with connect(). On success, returns + /// the number of bytes read. + pub fn recv(&self, buf: &mut [u8]) -> io::Result<usize> { + self.sys.recv(buf) + } + + /// Connects the UDP socket setting the default destination for `send()` + /// and limiting packets that are read via `recv` from the address specified + /// in `addr`. + pub fn connect(&self, addr: SocketAddr) -> io::Result<()> { + self.sys.connect(addr) + } + + /// Sets the value of the `SO_BROADCAST` option for this socket. + /// + /// When enabled, this socket is allowed to send packets to a broadcast + /// address. + /// + /// # Examples + /// + /// ``` + /// # use std::error::Error; + /// # + /// # fn try_main() -> Result<(), Box<Error>> { + /// use mio::net::UdpSocket; + /// + /// let broadcast_socket = UdpSocket::bind(&"127.0.0.1:0".parse()?)?; + /// if broadcast_socket.broadcast()? == false { + /// broadcast_socket.set_broadcast(true)?; + /// } + /// + /// assert_eq!(broadcast_socket.broadcast()?, true); + /// # + /// # Ok(()) + /// # } + /// # + /// # fn main() { + /// # try_main().unwrap(); + /// # } + /// ``` + pub fn set_broadcast(&self, on: bool) -> io::Result<()> { + self.sys.set_broadcast(on) + } + + /// Gets the value of the `SO_BROADCAST` option for this socket. + /// + /// For more information about this option, see + /// [`set_broadcast`][link]. + /// + /// [link]: #method.set_broadcast + /// + /// # Examples + /// + /// ``` + /// # use std::error::Error; + /// # + /// # fn try_main() -> Result<(), Box<Error>> { + /// use mio::net::UdpSocket; + /// + /// let broadcast_socket = UdpSocket::bind(&"127.0.0.1:0".parse()?)?; + /// assert_eq!(broadcast_socket.broadcast()?, false); + /// # + /// # Ok(()) + /// # } + /// # + /// # fn main() { + /// # try_main().unwrap(); + /// # } + /// ``` + pub fn broadcast(&self) -> io::Result<bool> { + self.sys.broadcast() + } + + /// Sets the value of the `IP_MULTICAST_LOOP` option for this socket. + /// + /// If enabled, multicast packets will be looped back to the local socket. + /// Note that this may not have any affect on IPv6 sockets. + pub fn set_multicast_loop_v4(&self, on: bool) -> io::Result<()> { + self.sys.set_multicast_loop_v4(on) + } + + /// Gets the value of the `IP_MULTICAST_LOOP` option for this socket. + /// + /// For more information about this option, see + /// [`set_multicast_loop_v4`][link]. + /// + /// [link]: #method.set_multicast_loop_v4 + pub fn multicast_loop_v4(&self) -> io::Result<bool> { + self.sys.multicast_loop_v4() + } + + /// Sets the value of the `IP_MULTICAST_TTL` option for this socket. + /// + /// Indicates the time-to-live value of outgoing multicast packets for + /// this socket. The default value is 1 which means that multicast packets + /// don't leave the local network unless explicitly requested. + /// + /// Note that this may not have any affect on IPv6 sockets. + pub fn set_multicast_ttl_v4(&self, ttl: u32) -> io::Result<()> { + self.sys.set_multicast_ttl_v4(ttl) + } + + /// Gets the value of the `IP_MULTICAST_TTL` option for this socket. + /// + /// For more information about this option, see + /// [`set_multicast_ttl_v4`][link]. + /// + /// [link]: #method.set_multicast_ttl_v4 + pub fn multicast_ttl_v4(&self) -> io::Result<u32> { + self.sys.multicast_ttl_v4() + } + + /// Sets the value of the `IPV6_MULTICAST_LOOP` option for this socket. + /// + /// Controls whether this socket sees the multicast packets it sends itself. + /// Note that this may not have any affect on IPv4 sockets. + pub fn set_multicast_loop_v6(&self, on: bool) -> io::Result<()> { + self.sys.set_multicast_loop_v6(on) + } + + /// Gets the value of the `IPV6_MULTICAST_LOOP` option for this socket. + /// + /// For more information about this option, see + /// [`set_multicast_loop_v6`][link]. + /// + /// [link]: #method.set_multicast_loop_v6 + pub fn multicast_loop_v6(&self) -> io::Result<bool> { + self.sys.multicast_loop_v6() + } + + /// Sets the value for the `IP_TTL` option on this socket. + /// + /// This value sets the time-to-live field that is used in every packet sent + /// from this socket. + /// + /// # Examples + /// + /// ``` + /// # use std::error::Error; + /// # + /// # fn try_main() -> Result<(), Box<Error>> { + /// use mio::net::UdpSocket; + /// + /// let socket = UdpSocket::bind(&"127.0.0.1:0".parse()?)?; + /// if socket.ttl()? < 255 { + /// socket.set_ttl(255)?; + /// } + /// + /// assert_eq!(socket.ttl()?, 255); + /// # + /// # Ok(()) + /// # } + /// # + /// # fn main() { + /// # try_main().unwrap(); + /// # } + /// ``` + pub fn set_ttl(&self, ttl: u32) -> io::Result<()> { + self.sys.set_ttl(ttl) + } + + /// Gets the value of the `IP_TTL` option for this socket. + /// + /// For more information about this option, see [`set_ttl`][link]. + /// + /// [link]: #method.set_ttl + /// + /// # Examples + /// + /// ``` + /// # use std::error::Error; + /// # + /// # fn try_main() -> Result<(), Box<Error>> { + /// use mio::net::UdpSocket; + /// + /// let socket = UdpSocket::bind(&"127.0.0.1:0".parse()?)?; + /// socket.set_ttl(255)?; + /// + /// assert_eq!(socket.ttl()?, 255); + /// # + /// # Ok(()) + /// # } + /// # + /// # fn main() { + /// # try_main().unwrap(); + /// # } + /// ``` + pub fn ttl(&self) -> io::Result<u32> { + self.sys.ttl() + } + + /// Executes an operation of the `IP_ADD_MEMBERSHIP` type. + /// + /// This function specifies a new multicast group for this socket to join. + /// The address must be a valid multicast address, and `interface` is the + /// address of the local interface with which the system should join the + /// multicast group. If it's equal to `INADDR_ANY` then an appropriate + /// interface is chosen by the system. + pub fn join_multicast_v4(&self, + multiaddr: &Ipv4Addr, + interface: &Ipv4Addr) -> io::Result<()> { + self.sys.join_multicast_v4(multiaddr, interface) + } + + /// Executes an operation of the `IPV6_ADD_MEMBERSHIP` type. + /// + /// This function specifies a new multicast group for this socket to join. + /// The address must be a valid multicast address, and `interface` is the + /// index of the interface to join/leave (or 0 to indicate any interface). + pub fn join_multicast_v6(&self, + multiaddr: &Ipv6Addr, + interface: u32) -> io::Result<()> { + self.sys.join_multicast_v6(multiaddr, interface) + } + + /// Executes an operation of the `IP_DROP_MEMBERSHIP` type. + /// + /// For more information about this option, see + /// [`join_multicast_v4`][link]. + /// + /// [link]: #method.join_multicast_v4 + pub fn leave_multicast_v4(&self, + multiaddr: &Ipv4Addr, + interface: &Ipv4Addr) -> io::Result<()> { + self.sys.leave_multicast_v4(multiaddr, interface) + } + + /// Executes an operation of the `IPV6_DROP_MEMBERSHIP` type. + /// + /// For more information about this option, see + /// [`join_multicast_v6`][link]. + /// + /// [link]: #method.join_multicast_v6 + pub fn leave_multicast_v6(&self, + multiaddr: &Ipv6Addr, + interface: u32) -> io::Result<()> { + self.sys.leave_multicast_v6(multiaddr, interface) + } + + /// Sets the value for the `IPV6_V6ONLY` option on this socket. + /// + /// If this is set to `true` then the socket is restricted to sending and + /// receiving IPv6 packets only. In this case two IPv4 and IPv6 applications + /// can bind the same port at the same time. + /// + /// If this is set to `false` then the socket can be used to send and + /// receive packets from an IPv4-mapped IPv6 address. + pub fn set_only_v6(&self, only_v6: bool) -> io::Result<()> { + self.sys.set_only_v6(only_v6) + } + + /// Gets the value of the `IPV6_V6ONLY` option for this socket. + /// + /// For more information about this option, see [`set_only_v6`][link]. + /// + /// [link]: #method.set_only_v6 + pub fn only_v6(&self) -> io::Result<bool> { + self.sys.only_v6() + } + + /// Get the value of the `SO_ERROR` option on this socket. + /// + /// This will retrieve the stored error in the underlying socket, clearing + /// the field in the process. This can be useful for checking errors between + /// calls. + pub fn take_error(&self) -> io::Result<Option<io::Error>> { + self.sys.take_error() + } + + /// Receives a single datagram message socket previously bound with connect. + /// + /// This operation will attempt to read bytes from this socket and place + /// them into the list of buffers provided. Note that each buffer is an + /// `IoVec` which can be created from a byte slice. + /// + /// The buffers provided will be filled sequentially. A buffer will be + /// entirely filled up before the next is written to. + /// + /// The number of bytes read is returned, if successful, or an error is + /// returned otherwise. If no bytes are available to be read yet then + /// a [`WouldBlock`][link] error is returned. This operation does not block. + /// + /// On Unix this corresponds to the `readv` syscall. + /// + /// [link]: https://doc.rust-lang.org/nightly/std/io/enum.ErrorKind.html#variant.WouldBlock + #[cfg(all(unix, not(target_os = "fuchsia")))] + pub fn recv_bufs(&self, bufs: &mut [&mut IoVec]) -> io::Result<usize> { + self.sys.readv(bufs) + } + + /// Sends data on the socket to the address previously bound via connect. + /// + /// This operation will attempt to send a list of byte buffers to this + /// socket in a single datagram. Note that each buffer is an `IoVec` + /// which can be created from a byte slice. + /// + /// The buffers provided will be written sequentially. A buffer will be + /// entirely written before the next is written. + /// + /// The number of bytes written is returned, if successful, or an error is + /// returned otherwise. If the socket is not currently writable then a + /// [`WouldBlock`][link] error is returned. This operation does not block. + /// + /// On Unix this corresponds to the `writev` syscall. + /// + /// [link]: https://doc.rust-lang.org/nightly/std/io/enum.ErrorKind.html#variant.WouldBlock + #[cfg(all(unix, not(target_os = "fuchsia")))] + pub fn send_bufs(&self, bufs: &[&IoVec]) -> io::Result<usize> { + self.sys.writev(bufs) + } +} + +impl Evented for UdpSocket { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + self.selector_id.associate_selector(poll)?; + self.sys.register(poll, token, interest, opts) + } + + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + self.sys.reregister(poll, token, interest, opts) + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + self.sys.deregister(poll) + } +} + +impl fmt::Debug for UdpSocket { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::Debug::fmt(&self.sys, f) + } +} + +/* + * + * ===== UNIX ext ===== + * + */ + +#[cfg(all(unix, not(target_os = "fuchsia")))] +use std::os::unix::io::{IntoRawFd, AsRawFd, FromRawFd, RawFd}; + +#[cfg(all(unix, not(target_os = "fuchsia")))] +impl IntoRawFd for UdpSocket { + fn into_raw_fd(self) -> RawFd { + self.sys.into_raw_fd() + } +} + +#[cfg(all(unix, not(target_os = "fuchsia")))] +impl AsRawFd for UdpSocket { + fn as_raw_fd(&self) -> RawFd { + self.sys.as_raw_fd() + } +} + +#[cfg(all(unix, not(target_os = "fuchsia")))] +impl FromRawFd for UdpSocket { + unsafe fn from_raw_fd(fd: RawFd) -> UdpSocket { + UdpSocket { + sys: FromRawFd::from_raw_fd(fd), + selector_id: SelectorId::new(), + } + } +} + diff --git a/third_party/rust/mio-0.6.23/src/poll.rs b/third_party/rust/mio-0.6.23/src/poll.rs new file mode 100644 index 0000000000..7985d456cd --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/poll.rs @@ -0,0 +1,2783 @@ +use {sys, Token}; +use event_imp::{self as event, Ready, Event, Evented, PollOpt}; +use std::{fmt, io, ptr, usize}; +use std::cell::UnsafeCell; +use std::{mem, ops, isize}; +#[cfg(all(unix, not(target_os = "fuchsia")))] +use std::os::unix::io::AsRawFd; +#[cfg(all(unix, not(target_os = "fuchsia")))] +use std::os::unix::io::RawFd; +use std::process; +use std::sync::{Arc, Mutex, Condvar}; +use std::sync::atomic::{AtomicUsize, AtomicPtr, AtomicBool}; +use std::sync::atomic::Ordering::{self, Acquire, Release, AcqRel, Relaxed, SeqCst}; +use std::time::{Duration, Instant}; + +// Poll is backed by two readiness queues. The first is a system readiness queue +// represented by `sys::Selector`. The system readiness queue handles events +// provided by the system, such as TCP and UDP. The second readiness queue is +// implemented in user space by `ReadinessQueue`. It provides a way to implement +// purely user space `Evented` types. +// +// `ReadinessQueue` is backed by a MPSC queue that supports reuse of linked +// list nodes. This significantly reduces the number of required allocations. +// Each `Registration` / `SetReadiness` pair allocates a single readiness node +// that is used for the lifetime of the registration. +// +// The readiness node also includes a single atomic variable, `state` that +// tracks most of the state associated with the registration. This includes the +// current readiness, interest, poll options, and internal state. When the node +// state is mutated, it is queued in the MPSC channel. A call to +// `ReadinessQueue::poll` will dequeue and process nodes. The node state can +// still be mutated while it is queued in the channel for processing. +// Intermediate state values do not matter as long as the final state is +// included in the call to `poll`. This is the eventually consistent nature of +// the readiness queue. +// +// The readiness node is ref counted using the `ref_count` field. On creation, +// the ref_count is initialized to 3: one `Registration` handle, one +// `SetReadiness` handle, and one for the readiness queue. Since the readiness queue +// doesn't *always* hold a handle to the node, we don't use the Arc type for +// managing ref counts (this is to avoid constantly incrementing and +// decrementing the ref count when pushing & popping from the queue). When the +// `Registration` handle is dropped, the `dropped` flag is set on the node, then +// the node is pushed into the registration queue. When Poll::poll pops the +// node, it sees the drop flag is set, and decrements it's ref count. +// +// The MPSC queue is a modified version of the intrusive MPSC node based queue +// described by 1024cores [1]. +// +// The first modification is that two markers are used instead of a single +// `stub`. The second marker is a `sleep_marker` which is used to signal to +// producers that the consumer is going to sleep. This sleep_marker is only used +// when the queue is empty, implying that the only node in the queue is +// `end_marker`. +// +// The second modification is an `until` argument passed to the dequeue +// function. When `poll` encounters a level-triggered node, the node will be +// immediately pushed back into the queue. In order to avoid an infinite loop, +// `poll` before pushing the node, the pointer is saved off and then passed +// again as the `until` argument. If the next node to pop is `until`, then +// `Dequeue::Empty` is returned. +// +// [1] http://www.1024cores.net/home/lock-free-algorithms/queues/intrusive-mpsc-node-based-queue + + +/// Polls for readiness events on all registered values. +/// +/// `Poll` allows a program to monitor a large number of `Evented` types, +/// waiting until one or more become "ready" for some class of operations; e.g. +/// reading and writing. An `Evented` type is considered ready if it is possible +/// to immediately perform a corresponding operation; e.g. [`read`] or +/// [`write`]. +/// +/// To use `Poll`, an `Evented` type must first be registered with the `Poll` +/// instance using the [`register`] method, supplying readiness interest. The +/// readiness interest tells `Poll` which specific operations on the handle to +/// monitor for readiness. A `Token` is also passed to the [`register`] +/// function. When `Poll` returns a readiness event, it will include this token. +/// This associates the event with the `Evented` handle that generated the +/// event. +/// +/// [`read`]: tcp/struct.TcpStream.html#method.read +/// [`write`]: tcp/struct.TcpStream.html#method.write +/// [`register`]: #method.register +/// +/// # Examples +/// +/// A basic example -- establishing a `TcpStream` connection. +/// +/// ``` +/// # use std::error::Error; +/// # fn try_main() -> Result<(), Box<Error>> { +/// use mio::{Events, Poll, Ready, PollOpt, Token}; +/// use mio::net::TcpStream; +/// +/// use std::net::{TcpListener, SocketAddr}; +/// +/// // Bind a server socket to connect to. +/// let addr: SocketAddr = "127.0.0.1:0".parse()?; +/// let server = TcpListener::bind(&addr)?; +/// +/// // Construct a new `Poll` handle as well as the `Events` we'll store into +/// let poll = Poll::new()?; +/// let mut events = Events::with_capacity(1024); +/// +/// // Connect the stream +/// let stream = TcpStream::connect(&server.local_addr()?)?; +/// +/// // Register the stream with `Poll` +/// poll.register(&stream, Token(0), Ready::readable() | Ready::writable(), PollOpt::edge())?; +/// +/// // Wait for the socket to become ready. This has to happens in a loop to +/// // handle spurious wakeups. +/// loop { +/// poll.poll(&mut events, None)?; +/// +/// for event in &events { +/// if event.token() == Token(0) && event.readiness().is_writable() { +/// // The socket connected (probably, it could still be a spurious +/// // wakeup) +/// return Ok(()); +/// } +/// } +/// } +/// # Ok(()) +/// # } +/// # +/// # fn main() { +/// # try_main().unwrap(); +/// # } +/// ``` +/// +/// # Edge-triggered and level-triggered +/// +/// An [`Evented`] registration may request edge-triggered events or +/// level-triggered events. This is done by setting `register`'s +/// [`PollOpt`] argument to either [`edge`] or [`level`]. +/// +/// The difference between the two can be described as follows. Supposed that +/// this scenario happens: +/// +/// 1. A [`TcpStream`] is registered with `Poll`. +/// 2. The socket receives 2kb of data. +/// 3. A call to [`Poll::poll`] returns the token associated with the socket +/// indicating readable readiness. +/// 4. 1kb is read from the socket. +/// 5. Another call to [`Poll::poll`] is made. +/// +/// If when the socket was registered with `Poll`, edge triggered events were +/// requested, then the call to [`Poll::poll`] done in step **5** will +/// (probably) hang despite there being another 1kb still present in the socket +/// read buffer. The reason for this is that edge-triggered mode delivers events +/// only when changes occur on the monitored [`Evented`]. So, in step *5* the +/// caller might end up waiting for some data that is already present inside the +/// socket buffer. +/// +/// With edge-triggered events, operations **must** be performed on the +/// `Evented` type until [`WouldBlock`] is returned. In other words, after +/// receiving an event indicating readiness for a certain operation, one should +/// assume that [`Poll::poll`] may never return another event for the same token +/// and readiness until the operation returns [`WouldBlock`]. +/// +/// By contrast, when level-triggered notifications was requested, each call to +/// [`Poll::poll`] will return an event for the socket as long as data remains +/// in the socket buffer. Generally, level-triggered events should be avoided if +/// high performance is a concern. +/// +/// Since even with edge-triggered events, multiple events can be generated upon +/// receipt of multiple chunks of data, the caller has the option to set the +/// [`oneshot`] flag. This tells `Poll` to disable the associated [`Evented`] +/// after the event is returned from [`Poll::poll`]. The subsequent calls to +/// [`Poll::poll`] will no longer include events for [`Evented`] handles that +/// are disabled even if the readiness state changes. The handle can be +/// re-enabled by calling [`reregister`]. When handles are disabled, internal +/// resources used to monitor the handle are maintained until the handle is +/// dropped or deregistered. This makes re-registering the handle a fast +/// operation. +/// +/// For example, in the following scenario: +/// +/// 1. A [`TcpStream`] is registered with `Poll`. +/// 2. The socket receives 2kb of data. +/// 3. A call to [`Poll::poll`] returns the token associated with the socket +/// indicating readable readiness. +/// 4. 2kb is read from the socket. +/// 5. Another call to read is issued and [`WouldBlock`] is returned +/// 6. The socket receives another 2kb of data. +/// 7. Another call to [`Poll::poll`] is made. +/// +/// Assuming the socket was registered with `Poll` with the [`edge`] and +/// [`oneshot`] options, then the call to [`Poll::poll`] in step 7 would block. This +/// is because, [`oneshot`] tells `Poll` to disable events for the socket after +/// returning an event. +/// +/// In order to receive the event for the data received in step 6, the socket +/// would need to be reregistered using [`reregister`]. +/// +/// [`PollOpt`]: struct.PollOpt.html +/// [`edge`]: struct.PollOpt.html#method.edge +/// [`level`]: struct.PollOpt.html#method.level +/// [`Poll::poll`]: struct.Poll.html#method.poll +/// [`WouldBlock`]: https://doc.rust-lang.org/std/io/enum.ErrorKind.html#variant.WouldBlock +/// [`Evented`]: event/trait.Evented.html +/// [`TcpStream`]: tcp/struct.TcpStream.html +/// [`reregister`]: #method.reregister +/// [`oneshot`]: struct.PollOpt.html#method.oneshot +/// +/// # Portability +/// +/// Using `Poll` provides a portable interface across supported platforms as +/// long as the caller takes the following into consideration: +/// +/// ### Spurious events +/// +/// [`Poll::poll`] may return readiness events even if the associated +/// [`Evented`] handle is not actually ready. Given the same code, this may +/// happen more on some platforms than others. It is important to never assume +/// that, just because a readiness notification was received, that the +/// associated operation will succeed as well. +/// +/// If operation fails with [`WouldBlock`], then the caller should not treat +/// this as an error, but instead should wait until another readiness event is +/// received. +/// +/// ### Draining readiness +/// +/// When using edge-triggered mode, once a readiness event is received, the +/// corresponding operation must be performed repeatedly until it returns +/// [`WouldBlock`]. Unless this is done, there is no guarantee that another +/// readiness event will be delivered, even if further data is received for the +/// [`Evented`] handle. +/// +/// For example, in the first scenario described above, after step 5, even if +/// the socket receives more data there is no guarantee that another readiness +/// event will be delivered. +/// +/// ### Readiness operations +/// +/// The only readiness operations that are guaranteed to be present on all +/// supported platforms are [`readable`] and [`writable`]. All other readiness +/// operations may have false negatives and as such should be considered +/// **hints**. This means that if a socket is registered with [`readable`], +/// [`error`], and [`hup`] interest, and either an error or hup is received, a +/// readiness event will be generated for the socket, but it **may** only +/// include `readable` readiness. Also note that, given the potential for +/// spurious events, receiving a readiness event with `hup` or `error` doesn't +/// actually mean that a `read` on the socket will return a result matching the +/// readiness event. +/// +/// In other words, portable programs that explicitly check for [`hup`] or +/// [`error`] readiness should be doing so as an **optimization** and always be +/// able to handle an error or HUP situation when performing the actual read +/// operation. +/// +/// [`readable`]: struct.Ready.html#method.readable +/// [`writable`]: struct.Ready.html#method.writable +/// [`error`]: unix/struct.UnixReady.html#method.error +/// [`hup`]: unix/struct.UnixReady.html#method.hup +/// +/// ### Registering handles +/// +/// Unless otherwise noted, it should be assumed that types implementing +/// [`Evented`] will never become ready unless they are registered with `Poll`. +/// +/// For example: +/// +/// ``` +/// # use std::error::Error; +/// # fn try_main() -> Result<(), Box<Error>> { +/// use mio::{Poll, Ready, PollOpt, Token}; +/// use mio::net::TcpStream; +/// use std::time::Duration; +/// use std::thread; +/// +/// let sock = TcpStream::connect(&"216.58.193.100:80".parse()?)?; +/// +/// thread::sleep(Duration::from_secs(1)); +/// +/// let poll = Poll::new()?; +/// +/// // The connect is not guaranteed to have started until it is registered at +/// // this point +/// poll.register(&sock, Token(0), Ready::readable() | Ready::writable(), PollOpt::edge())?; +/// # Ok(()) +/// # } +/// # +/// # fn main() { +/// # try_main().unwrap(); +/// # } +/// ``` +/// +/// # Implementation notes +/// +/// `Poll` is backed by the selector provided by the operating system. +/// +/// | OS | Selector | +/// |------------|-----------| +/// | Linux | [epoll] | +/// | OS X, iOS | [kqueue] | +/// | Windows | [IOCP] | +/// | FreeBSD | [kqueue] | +/// | Android | [epoll] | +/// +/// On all supported platforms, socket operations are handled by using the +/// system selector. Platform specific extensions (e.g. [`EventedFd`]) allow +/// accessing other features provided by individual system selectors. For +/// example, Linux's [`signalfd`] feature can be used by registering the FD with +/// `Poll` via [`EventedFd`]. +/// +/// On all platforms except windows, a call to [`Poll::poll`] is mostly just a +/// direct call to the system selector. However, [IOCP] uses a completion model +/// instead of a readiness model. In this case, `Poll` must adapt the completion +/// model Mio's API. While non-trivial, the bridge layer is still quite +/// efficient. The most expensive part being calls to `read` and `write` require +/// data to be copied into an intermediate buffer before it is passed to the +/// kernel. +/// +/// Notifications generated by [`SetReadiness`] are handled by an internal +/// readiness queue. A single call to [`Poll::poll`] will collect events from +/// both from the system selector and the internal readiness queue. +/// +/// [epoll]: http://man7.org/linux/man-pages/man7/epoll.7.html +/// [kqueue]: https://www.freebsd.org/cgi/man.cgi?query=kqueue&sektion=2 +/// [IOCP]: https://msdn.microsoft.com/en-us/library/windows/desktop/aa365198(v=vs.85).aspx +/// [`signalfd`]: http://man7.org/linux/man-pages/man2/signalfd.2.html +/// [`EventedFd`]: unix/struct.EventedFd.html +/// [`SetReadiness`]: struct.SetReadiness.html +/// [`Poll::poll`]: struct.Poll.html#method.poll +pub struct Poll { + // Platform specific IO selector + selector: sys::Selector, + + // Custom readiness queue + readiness_queue: ReadinessQueue, + + // Use an atomic to first check if a full lock will be required. This is a + // fast-path check for single threaded cases avoiding the extra syscall + lock_state: AtomicUsize, + + // Sequences concurrent calls to `Poll::poll` + lock: Mutex<()>, + + // Wakeup the next waiter + condvar: Condvar, +} + +/// Handle to a user space `Poll` registration. +/// +/// `Registration` allows implementing [`Evented`] for types that cannot work +/// with the [system selector]. A `Registration` is always paired with a +/// `SetReadiness`, which allows updating the registration's readiness state. +/// When [`set_readiness`] is called and the `Registration` is associated with a +/// [`Poll`] instance, a readiness event will be created and eventually returned +/// by [`poll`]. +/// +/// A `Registration` / `SetReadiness` pair is created by calling +/// [`Registration::new2`]. At this point, the registration is not being +/// monitored by a [`Poll`] instance, so calls to `set_readiness` will not +/// result in any readiness notifications. +/// +/// `Registration` implements [`Evented`], so it can be used with [`Poll`] using +/// the same [`register`], [`reregister`], and [`deregister`] functions used +/// with TCP, UDP, etc... types. Once registered with [`Poll`], readiness state +/// changes result in readiness events being dispatched to the [`Poll`] instance +/// with which `Registration` is registered. +/// +/// **Note**, before using `Registration` be sure to read the +/// [`set_readiness`] documentation and the [portability] notes. The +/// guarantees offered by `Registration` may be weaker than expected. +/// +/// For high level documentation, see [`Poll`]. +/// +/// # Examples +/// +/// ``` +/// use mio::{Ready, Registration, Poll, PollOpt, Token}; +/// use mio::event::Evented; +/// +/// use std::io; +/// use std::time::Instant; +/// use std::thread; +/// +/// pub struct Deadline { +/// when: Instant, +/// registration: Registration, +/// } +/// +/// impl Deadline { +/// pub fn new(when: Instant) -> Deadline { +/// let (registration, set_readiness) = Registration::new2(); +/// +/// thread::spawn(move || { +/// let now = Instant::now(); +/// +/// if now < when { +/// thread::sleep(when - now); +/// } +/// +/// set_readiness.set_readiness(Ready::readable()); +/// }); +/// +/// Deadline { +/// when: when, +/// registration: registration, +/// } +/// } +/// +/// pub fn is_elapsed(&self) -> bool { +/// Instant::now() >= self.when +/// } +/// } +/// +/// impl Evented for Deadline { +/// fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) +/// -> io::Result<()> +/// { +/// self.registration.register(poll, token, interest, opts) +/// } +/// +/// fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) +/// -> io::Result<()> +/// { +/// self.registration.reregister(poll, token, interest, opts) +/// } +/// +/// fn deregister(&self, poll: &Poll) -> io::Result<()> { +/// poll.deregister(&self.registration) +/// } +/// } +/// ``` +/// +/// [system selector]: struct.Poll.html#implementation-notes +/// [`Poll`]: struct.Poll.html +/// [`Registration::new2`]: struct.Registration.html#method.new2 +/// [`Evented`]: event/trait.Evented.html +/// [`set_readiness`]: struct.SetReadiness.html#method.set_readiness +/// [`register`]: struct.Poll.html#method.register +/// [`reregister`]: struct.Poll.html#method.reregister +/// [`deregister`]: struct.Poll.html#method.deregister +/// [portability]: struct.Poll.html#portability +pub struct Registration { + inner: RegistrationInner, +} + +unsafe impl Send for Registration {} +unsafe impl Sync for Registration {} + +/// Updates the readiness state of the associated `Registration`. +/// +/// See [`Registration`] for more documentation on using `SetReadiness` and +/// [`Poll`] for high level polling documentation. +/// +/// [`Poll`]: struct.Poll.html +/// [`Registration`]: struct.Registration.html +#[derive(Clone)] +pub struct SetReadiness { + inner: RegistrationInner, +} + +unsafe impl Send for SetReadiness {} +unsafe impl Sync for SetReadiness {} + +/// Used to associate an IO type with a Selector +#[derive(Debug)] +pub struct SelectorId { + id: AtomicUsize, +} + +struct RegistrationInner { + // Unsafe pointer to the registration's node. The node is ref counted. This + // cannot "simply" be tracked by an Arc because `Poll::poll` has an implicit + // handle though it isn't stored anywhere. In other words, `Poll::poll` + // needs to decrement the ref count before the node is freed. + node: *mut ReadinessNode, +} + +#[derive(Clone)] +struct ReadinessQueue { + inner: Arc<ReadinessQueueInner>, +} + +unsafe impl Send for ReadinessQueue {} +unsafe impl Sync for ReadinessQueue {} + +struct ReadinessQueueInner { + // Used to wake up `Poll` when readiness is set in another thread. + awakener: sys::Awakener, + + // Head of the MPSC queue used to signal readiness to `Poll::poll`. + head_readiness: AtomicPtr<ReadinessNode>, + + // Tail of the readiness queue. + // + // Only accessed by Poll::poll. Coordination will be handled by the poll fn + tail_readiness: UnsafeCell<*mut ReadinessNode>, + + // Fake readiness node used to punctuate the end of the readiness queue. + // Before attempting to read from the queue, this node is inserted in order + // to partition the queue between nodes that are "owned" by the dequeue end + // and nodes that will be pushed on by producers. + end_marker: Box<ReadinessNode>, + + // Similar to `end_marker`, but this node signals to producers that `Poll` + // has gone to sleep and must be woken up. + sleep_marker: Box<ReadinessNode>, + + // Similar to `end_marker`, but the node signals that the queue is closed. + // This happens when `ReadyQueue` is dropped and signals to producers that + // the nodes should no longer be pushed into the queue. + closed_marker: Box<ReadinessNode>, +} + +/// Node shared by a `Registration` / `SetReadiness` pair as well as the node +/// queued into the MPSC channel. +struct ReadinessNode { + // Node state, see struct docs for `ReadinessState` + // + // This variable is the primary point of coordination between all the + // various threads concurrently accessing the node. + state: AtomicState, + + // The registration token cannot fit into the `state` variable, so it is + // broken out here. In order to atomically update both the state and token + // we have to jump through a few hoops. + // + // First, `state` includes `token_read_pos` and `token_write_pos`. These can + // either be 0, 1, or 2 which represent a token slot. `token_write_pos` is + // the token slot that contains the most up to date registration token. + // `token_read_pos` is the token slot that `poll` is currently reading from. + // + // When a call to `update` includes a different token than the one currently + // associated with the registration (token_write_pos), first an unused token + // slot is found. The unused slot is the one not represented by + // `token_read_pos` OR `token_write_pos`. The new token is written to this + // slot, then `state` is updated with the new `token_write_pos` value. This + // requires that there is only a *single* concurrent call to `update`. + // + // When `poll` reads a node state, it checks that `token_read_pos` matches + // `token_write_pos`. If they do not match, then it atomically updates + // `state` such that `token_read_pos` is set to `token_write_pos`. It will + // then read the token at the newly updated `token_read_pos`. + token_0: UnsafeCell<Token>, + token_1: UnsafeCell<Token>, + token_2: UnsafeCell<Token>, + + // Used when the node is queued in the readiness linked list. Accessing + // this field requires winning the "queue" lock + next_readiness: AtomicPtr<ReadinessNode>, + + // Ensures that there is only one concurrent call to `update`. + // + // Each call to `update` will attempt to swap `update_lock` from `false` to + // `true`. If the CAS succeeds, the thread has obtained the update lock. If + // the CAS fails, then the `update` call returns immediately and the update + // is discarded. + update_lock: AtomicBool, + + // Pointer to Arc<ReadinessQueueInner> + readiness_queue: AtomicPtr<()>, + + // Tracks the number of `ReadyRef` pointers + ref_count: AtomicUsize, +} + +/// Stores the ReadinessNode state in an AtomicUsize. This wrapper around the +/// atomic variable handles encoding / decoding `ReadinessState` values. +struct AtomicState { + inner: AtomicUsize, +} + +const MASK_2: usize = 4 - 1; +const MASK_4: usize = 16 - 1; +const QUEUED_MASK: usize = 1 << QUEUED_SHIFT; +const DROPPED_MASK: usize = 1 << DROPPED_SHIFT; + +const READINESS_SHIFT: usize = 0; +const INTEREST_SHIFT: usize = 4; +const POLL_OPT_SHIFT: usize = 8; +const TOKEN_RD_SHIFT: usize = 12; +const TOKEN_WR_SHIFT: usize = 14; +const QUEUED_SHIFT: usize = 16; +const DROPPED_SHIFT: usize = 17; + +/// Tracks all state for a single `ReadinessNode`. The state is packed into a +/// `usize` variable from low to high bit as follows: +/// +/// 4 bits: Registration current readiness +/// 4 bits: Registration interest +/// 4 bits: Poll options +/// 2 bits: Token position currently being read from by `poll` +/// 2 bits: Token position last written to by `update` +/// 1 bit: Queued flag, set when node is being pushed into MPSC queue. +/// 1 bit: Dropped flag, set when all `Registration` handles have been dropped. +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +struct ReadinessState(usize); + +/// Returned by `dequeue_node`. Represents the different states as described by +/// the queue documentation on 1024cores.net. +enum Dequeue { + Data(*mut ReadinessNode), + Empty, + Inconsistent, +} + +const AWAKEN: Token = Token(usize::MAX); +const MAX_REFCOUNT: usize = (isize::MAX) as usize; + +/* + * + * ===== Poll ===== + * + */ + +impl Poll { + /// Return a new `Poll` handle. + /// + /// This function will make a syscall to the operating system to create the + /// system selector. If this syscall fails, `Poll::new` will return with the + /// error. + /// + /// See [struct] level docs for more details. + /// + /// [struct]: struct.Poll.html + /// + /// # Examples + /// + /// ``` + /// # use std::error::Error; + /// # fn try_main() -> Result<(), Box<Error>> { + /// use mio::{Poll, Events}; + /// use std::time::Duration; + /// + /// let poll = match Poll::new() { + /// Ok(poll) => poll, + /// Err(e) => panic!("failed to create Poll instance; err={:?}", e), + /// }; + /// + /// // Create a structure to receive polled events + /// let mut events = Events::with_capacity(1024); + /// + /// // Wait for events, but none will be received because no `Evented` + /// // handles have been registered with this `Poll` instance. + /// let n = poll.poll(&mut events, Some(Duration::from_millis(500)))?; + /// assert_eq!(n, 0); + /// # Ok(()) + /// # } + /// # + /// # fn main() { + /// # try_main().unwrap(); + /// # } + /// ``` + pub fn new() -> io::Result<Poll> { + is_send::<Poll>(); + is_sync::<Poll>(); + + let poll = Poll { + selector: sys::Selector::new()?, + readiness_queue: ReadinessQueue::new()?, + lock_state: AtomicUsize::new(0), + lock: Mutex::new(()), + condvar: Condvar::new(), + }; + + // Register the notification wakeup FD with the IO poller + poll.readiness_queue.inner.awakener.register(&poll, AWAKEN, Ready::readable(), PollOpt::edge())?; + + Ok(poll) + } + + /// Register an `Evented` handle with the `Poll` instance. + /// + /// Once registered, the `Poll` instance will monitor the `Evented` handle + /// for readiness state changes. When it notices a state change, it will + /// return a readiness event for the handle the next time [`poll`] is + /// called. + /// + /// See the [`struct`] docs for a high level overview. + /// + /// # Arguments + /// + /// `handle: &E: Evented`: This is the handle that the `Poll` instance + /// should monitor for readiness state changes. + /// + /// `token: Token`: The caller picks a token to associate with the socket. + /// When [`poll`] returns an event for the handle, this token is included. + /// This allows the caller to map the event to its handle. The token + /// associated with the `Evented` handle can be changed at any time by + /// calling [`reregister`]. + /// + /// `token` cannot be `Token(usize::MAX)` as it is reserved for internal + /// usage. + /// + /// See documentation on [`Token`] for an example showing how to pick + /// [`Token`] values. + /// + /// `interest: Ready`: Specifies which operations `Poll` should monitor for + /// readiness. `Poll` will only return readiness events for operations + /// specified by this argument. + /// + /// If a socket is registered with readable interest and the socket becomes + /// writable, no event will be returned from [`poll`]. + /// + /// The readiness interest for an `Evented` handle can be changed at any + /// time by calling [`reregister`]. + /// + /// `opts: PollOpt`: Specifies the registration options. The most common + /// options being [`level`] for level-triggered events, [`edge`] for + /// edge-triggered events, and [`oneshot`]. + /// + /// The registration options for an `Evented` handle can be changed at any + /// time by calling [`reregister`]. + /// + /// # Notes + /// + /// Unless otherwise specified, the caller should assume that once an + /// `Evented` handle is registered with a `Poll` instance, it is bound to + /// that `Poll` instance for the lifetime of the `Evented` handle. This + /// remains true even if the `Evented` handle is deregistered from the poll + /// instance using [`deregister`]. + /// + /// This function is **thread safe**. It can be called concurrently from + /// multiple threads. + /// + /// [`struct`]: # + /// [`reregister`]: #method.reregister + /// [`deregister`]: #method.deregister + /// [`poll`]: #method.poll + /// [`level`]: struct.PollOpt.html#method.level + /// [`edge`]: struct.PollOpt.html#method.edge + /// [`oneshot`]: struct.PollOpt.html#method.oneshot + /// [`Token`]: struct.Token.html + /// + /// # Examples + /// + /// ``` + /// # use std::error::Error; + /// # fn try_main() -> Result<(), Box<Error>> { + /// use mio::{Events, Poll, Ready, PollOpt, Token}; + /// use mio::net::TcpStream; + /// use std::time::{Duration, Instant}; + /// + /// let poll = Poll::new()?; + /// let socket = TcpStream::connect(&"216.58.193.100:80".parse()?)?; + /// + /// // Register the socket with `poll` + /// poll.register(&socket, Token(0), Ready::readable() | Ready::writable(), PollOpt::edge())?; + /// + /// let mut events = Events::with_capacity(1024); + /// let start = Instant::now(); + /// let timeout = Duration::from_millis(500); + /// + /// loop { + /// let elapsed = start.elapsed(); + /// + /// if elapsed >= timeout { + /// // Connection timed out + /// return Ok(()); + /// } + /// + /// let remaining = timeout - elapsed; + /// poll.poll(&mut events, Some(remaining))?; + /// + /// for event in &events { + /// if event.token() == Token(0) { + /// // Something (probably) happened on the socket. + /// return Ok(()); + /// } + /// } + /// } + /// # Ok(()) + /// # } + /// # + /// # fn main() { + /// # try_main().unwrap(); + /// # } + /// ``` + pub fn register<E: ?Sized>(&self, handle: &E, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> + where E: Evented + { + validate_args(token)?; + + /* + * Undefined behavior: + * - Reusing a token with a different `Evented` without deregistering + * (or closing) the original `Evented`. + */ + trace!("registering with poller"); + + // Register interests for this socket + handle.register(self, token, interest, opts)?; + + Ok(()) + } + + /// Re-register an `Evented` handle with the `Poll` instance. + /// + /// Re-registering an `Evented` handle allows changing the details of the + /// registration. Specifically, it allows updating the associated `token`, + /// `interest`, and `opts` specified in previous `register` and `reregister` + /// calls. + /// + /// The `reregister` arguments fully override the previous values. In other + /// words, if a socket is registered with [`readable`] interest and the call + /// to `reregister` specifies [`writable`], then read interest is no longer + /// requested for the handle. + /// + /// The `Evented` handle must have previously been registered with this + /// instance of `Poll` otherwise the call to `reregister` will return with + /// an error. + /// + /// `token` cannot be `Token(usize::MAX)` as it is reserved for internal + /// usage. + /// + /// See the [`register`] documentation for details about the function + /// arguments and see the [`struct`] docs for a high level overview of + /// polling. + /// + /// # Examples + /// + /// ``` + /// # use std::error::Error; + /// # fn try_main() -> Result<(), Box<Error>> { + /// use mio::{Poll, Ready, PollOpt, Token}; + /// use mio::net::TcpStream; + /// + /// let poll = Poll::new()?; + /// let socket = TcpStream::connect(&"216.58.193.100:80".parse()?)?; + /// + /// // Register the socket with `poll`, requesting readable + /// poll.register(&socket, Token(0), Ready::readable(), PollOpt::edge())?; + /// + /// // Reregister the socket specifying a different token and write interest + /// // instead. `PollOpt::edge()` must be specified even though that value + /// // is not being changed. + /// poll.reregister(&socket, Token(2), Ready::writable(), PollOpt::edge())?; + /// # Ok(()) + /// # } + /// # + /// # fn main() { + /// # try_main().unwrap(); + /// # } + /// ``` + /// + /// [`struct`]: # + /// [`register`]: #method.register + /// [`readable`]: struct.Ready.html#method.readable + /// [`writable`]: struct.Ready.html#method.writable + pub fn reregister<E: ?Sized>(&self, handle: &E, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> + where E: Evented + { + validate_args(token)?; + + trace!("registering with poller"); + + // Register interests for this socket + handle.reregister(self, token, interest, opts)?; + + Ok(()) + } + + /// Deregister an `Evented` handle with the `Poll` instance. + /// + /// When an `Evented` handle is deregistered, the `Poll` instance will + /// no longer monitor it for readiness state changes. Unlike disabling + /// handles with oneshot, deregistering clears up any internal resources + /// needed to track the handle. + /// + /// A handle can be passed back to `register` after it has been + /// deregistered; however, it must be passed back to the **same** `Poll` + /// instance. + /// + /// `Evented` handles are automatically deregistered when they are dropped. + /// It is common to never need to explicitly call `deregister`. + /// + /// # Examples + /// + /// ``` + /// # use std::error::Error; + /// # fn try_main() -> Result<(), Box<Error>> { + /// use mio::{Events, Poll, Ready, PollOpt, Token}; + /// use mio::net::TcpStream; + /// use std::time::Duration; + /// + /// let poll = Poll::new()?; + /// let socket = TcpStream::connect(&"216.58.193.100:80".parse()?)?; + /// + /// // Register the socket with `poll` + /// poll.register(&socket, Token(0), Ready::readable(), PollOpt::edge())?; + /// + /// poll.deregister(&socket)?; + /// + /// let mut events = Events::with_capacity(1024); + /// + /// // Set a timeout because this poll should never receive any events. + /// let n = poll.poll(&mut events, Some(Duration::from_secs(1)))?; + /// assert_eq!(0, n); + /// # Ok(()) + /// # } + /// # + /// # fn main() { + /// # try_main().unwrap(); + /// # } + /// ``` + pub fn deregister<E: ?Sized>(&self, handle: &E) -> io::Result<()> + where E: Evented + { + trace!("deregistering handle with poller"); + + // Deregister interests for this socket + handle.deregister(self)?; + + Ok(()) + } + + /// Wait for readiness events + /// + /// Blocks the current thread and waits for readiness events for any of the + /// `Evented` handles that have been registered with this `Poll` instance. + /// The function will block until either at least one readiness event has + /// been received or `timeout` has elapsed. A `timeout` of `None` means that + /// `poll` will block until a readiness event has been received. + /// + /// The supplied `events` will be cleared and newly received readiness events + /// will be pushed onto the end. At most `events.capacity()` events will be + /// returned. If there are further pending readiness events, they will be + /// returned on the next call to `poll`. + /// + /// A single call to `poll` may result in multiple readiness events being + /// returned for a single `Evented` handle. For example, if a TCP socket + /// becomes both readable and writable, it may be possible for a single + /// readiness event to be returned with both [`readable`] and [`writable`] + /// readiness **OR** two separate events may be returned, one with + /// [`readable`] set and one with [`writable`] set. + /// + /// Note that the `timeout` will be rounded up to the system clock + /// granularity (usually 1ms), and kernel scheduling delays mean that + /// the blocking interval may be overrun by a small amount. + /// + /// `poll` returns the number of readiness events that have been pushed into + /// `events` or `Err` when an error has been encountered with the system + /// selector. The value returned is deprecated and will be removed in 0.7.0. + /// Accessing the events by index is also deprecated. Events can be + /// inserted by other events triggering, thus making sequential access + /// problematic. Use the iterator API instead. See [`iter`]. + /// + /// See the [struct] level documentation for a higher level discussion of + /// polling. + /// + /// [`readable`]: struct.Ready.html#method.readable + /// [`writable`]: struct.Ready.html#method.writable + /// [struct]: # + /// [`iter`]: struct.Events.html#method.iter + /// + /// # Examples + /// + /// A basic example -- establishing a `TcpStream` connection. + /// + /// ``` + /// # use std::error::Error; + /// # fn try_main() -> Result<(), Box<Error>> { + /// use mio::{Events, Poll, Ready, PollOpt, Token}; + /// use mio::net::TcpStream; + /// + /// use std::net::{TcpListener, SocketAddr}; + /// use std::thread; + /// + /// // Bind a server socket to connect to. + /// let addr: SocketAddr = "127.0.0.1:0".parse()?; + /// let server = TcpListener::bind(&addr)?; + /// let addr = server.local_addr()?.clone(); + /// + /// // Spawn a thread to accept the socket + /// thread::spawn(move || { + /// let _ = server.accept(); + /// }); + /// + /// // Construct a new `Poll` handle as well as the `Events` we'll store into + /// let poll = Poll::new()?; + /// let mut events = Events::with_capacity(1024); + /// + /// // Connect the stream + /// let stream = TcpStream::connect(&addr)?; + /// + /// // Register the stream with `Poll` + /// poll.register(&stream, Token(0), Ready::readable() | Ready::writable(), PollOpt::edge())?; + /// + /// // Wait for the socket to become ready. This has to happens in a loop to + /// // handle spurious wakeups. + /// loop { + /// poll.poll(&mut events, None)?; + /// + /// for event in &events { + /// if event.token() == Token(0) && event.readiness().is_writable() { + /// // The socket connected (probably, it could still be a spurious + /// // wakeup) + /// return Ok(()); + /// } + /// } + /// } + /// # Ok(()) + /// # } + /// # + /// # fn main() { + /// # try_main().unwrap(); + /// # } + /// ``` + /// + /// [struct]: # + pub fn poll(&self, events: &mut Events, timeout: Option<Duration>) -> io::Result<usize> { + self.poll1(events, timeout, false) + } + + /// Like `poll`, but may be interrupted by a signal + /// + /// If `poll` is inturrupted while blocking, it will transparently retry the syscall. If you + /// want to handle signals yourself, however, use `poll_interruptible`. + pub fn poll_interruptible(&self, events: &mut Events, timeout: Option<Duration>) -> io::Result<usize> { + self.poll1(events, timeout, true) + } + + fn poll1(&self, events: &mut Events, mut timeout: Option<Duration>, interruptible: bool) -> io::Result<usize> { + let zero = Some(Duration::from_millis(0)); + + // At a high level, the synchronization strategy is to acquire access to + // the critical section by transitioning the atomic from unlocked -> + // locked. If the attempt fails, the thread will wait on the condition + // variable. + // + // # Some more detail + // + // The `lock_state` atomic usize combines: + // + // - locked flag, stored in the least significant bit + // - number of waiting threads, stored in the rest of the bits. + // + // When a thread transitions the locked flag from 0 -> 1, it has + // obtained access to the critical section. + // + // When entering `poll`, a compare-and-swap from 0 -> 1 is attempted. + // This is a fast path for the case when there are no concurrent calls + // to poll, which is very common. + // + // On failure, the mutex is locked, and the thread attempts to increment + // the number of waiting threads component of `lock_state`. If this is + // successfully done while the locked flag is set, then the thread can + // wait on the condition variable. + // + // When a thread exits the critical section, it unsets the locked flag. + // If there are any waiters, which is atomically determined while + // unsetting the locked flag, then the condvar is notified. + + let mut curr = self.lock_state.compare_and_swap(0, 1, SeqCst); + + if 0 != curr { + // Enter slower path + let mut lock = self.lock.lock().unwrap(); + let mut inc = false; + + loop { + if curr & 1 == 0 { + // The lock is currently free, attempt to grab it + let mut next = curr | 1; + + if inc { + // The waiter count has previously been incremented, so + // decrement it here + next -= 2; + } + + let actual = self.lock_state.compare_and_swap(curr, next, SeqCst); + + if actual != curr { + curr = actual; + continue; + } + + // Lock acquired, break from the loop + break; + } + + if timeout == zero { + if inc { + self.lock_state.fetch_sub(2, SeqCst); + } + + return Ok(0); + } + + // The lock is currently held, so wait for it to become + // free. If the waiter count hasn't been incremented yet, do + // so now + if !inc { + let next = curr.checked_add(2).expect("overflow"); + let actual = self.lock_state.compare_and_swap(curr, next, SeqCst); + + if actual != curr { + curr = actual; + continue; + } + + // Track that the waiter count has been incremented for + // this thread and fall through to the condvar waiting + inc = true; + } + + lock = match timeout { + Some(to) => { + let now = Instant::now(); + + // Wait to be notified + let (l, _) = self.condvar.wait_timeout(lock, to).unwrap(); + + // See how much time was elapsed in the wait + let elapsed = now.elapsed(); + + // Update `timeout` to reflect how much time is left to + // wait. + if elapsed >= to { + timeout = zero; + } else { + // Update the timeout + timeout = Some(to - elapsed); + } + + l + } + None => { + self.condvar.wait(lock).unwrap() + } + }; + + // Reload the state + curr = self.lock_state.load(SeqCst); + + // Try to lock again... + } + } + + let ret = self.poll2(events, timeout, interruptible); + + // Release the lock + if 1 != self.lock_state.fetch_and(!1, Release) { + // Acquire the mutex + let _lock = self.lock.lock().unwrap(); + + // There is at least one waiting thread, so notify one + self.condvar.notify_one(); + } + + ret + } + + #[inline] + #[cfg_attr(feature = "cargo-clippy", allow(clippy::if_same_then_else))] + fn poll2(&self, events: &mut Events, mut timeout: Option<Duration>, interruptible: bool) -> io::Result<usize> { + // Compute the timeout value passed to the system selector. If the + // readiness queue has pending nodes, we still want to poll the system + // selector for new events, but we don't want to block the thread to + // wait for new events. + if timeout == Some(Duration::from_millis(0)) { + // If blocking is not requested, then there is no need to prepare + // the queue for sleep + // + // The sleep_marker should be removed by readiness_queue.poll(). + } else if self.readiness_queue.prepare_for_sleep() { + // The readiness queue is empty. The call to `prepare_for_sleep` + // inserts `sleep_marker` into the queue. This signals to any + // threads setting readiness that the `Poll::poll` is going to + // sleep, so the awakener should be used. + } else { + // The readiness queue is not empty, so do not block the thread. + timeout = Some(Duration::from_millis(0)); + } + + loop { + let now = Instant::now(); + // First get selector events + let res = self.selector.select(&mut events.inner, AWAKEN, timeout); + match res { + Ok(true) => { + // Some awakeners require reading from a FD. + self.readiness_queue.inner.awakener.cleanup(); + break; + } + Ok(false) => break, + Err(ref e) if e.kind() == io::ErrorKind::Interrupted && !interruptible => { + // Interrupted by a signal; update timeout if necessary and retry + if let Some(to) = timeout { + let elapsed = now.elapsed(); + if elapsed >= to { + break; + } else { + timeout = Some(to - elapsed); + } + } + } + Err(e) => return Err(e), + } + } + + // Poll custom event queue + self.readiness_queue.poll(&mut events.inner); + + // Return number of polled events + Ok(events.inner.len()) + } +} + +fn validate_args(token: Token) -> io::Result<()> { + if token == AWAKEN { + return Err(io::Error::new(io::ErrorKind::Other, "invalid token")); + } + + Ok(()) +} + +impl fmt::Debug for Poll { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("Poll") + .finish() + } +} + +#[cfg(all(unix, not(target_os = "fuchsia")))] +impl AsRawFd for Poll { + fn as_raw_fd(&self) -> RawFd { + self.selector.as_raw_fd() + } +} + +/// A collection of readiness events. +/// +/// `Events` is passed as an argument to [`Poll::poll`] and will be used to +/// receive any new readiness events received since the last poll. Usually, a +/// single `Events` instance is created at the same time as a [`Poll`] and +/// reused on each call to [`Poll::poll`]. +/// +/// See [`Poll`] for more documentation on polling. +/// +/// # Examples +/// +/// ``` +/// # use std::error::Error; +/// # fn try_main() -> Result<(), Box<Error>> { +/// use mio::{Events, Poll}; +/// use std::time::Duration; +/// +/// let mut events = Events::with_capacity(1024); +/// let poll = Poll::new()?; +/// +/// assert_eq!(0, events.len()); +/// +/// // Register `Evented` handles with `poll` +/// +/// poll.poll(&mut events, Some(Duration::from_millis(100)))?; +/// +/// for event in &events { +/// println!("event={:?}", event); +/// } +/// # Ok(()) +/// # } +/// # +/// # fn main() { +/// # try_main().unwrap(); +/// # } +/// ``` +/// +/// [`Poll::poll`]: struct.Poll.html#method.poll +/// [`Poll`]: struct.Poll.html +pub struct Events { + inner: sys::Events, +} + +/// [`Events`] iterator. +/// +/// This struct is created by the [`iter`] method on [`Events`]. +/// +/// # Examples +/// +/// ``` +/// # use std::error::Error; +/// # fn try_main() -> Result<(), Box<Error>> { +/// use mio::{Events, Poll}; +/// use std::time::Duration; +/// +/// let mut events = Events::with_capacity(1024); +/// let poll = Poll::new()?; +/// +/// // Register handles with `poll` +/// +/// poll.poll(&mut events, Some(Duration::from_millis(100)))?; +/// +/// for event in events.iter() { +/// println!("event={:?}", event); +/// } +/// # Ok(()) +/// # } +/// # +/// # fn main() { +/// # try_main().unwrap(); +/// # } +/// ``` +/// +/// [`Events`]: struct.Events.html +/// [`iter`]: struct.Events.html#method.iter +#[derive(Debug, Clone)] +pub struct Iter<'a> { + inner: &'a Events, + pos: usize, +} + +/// Owned [`Events`] iterator. +/// +/// This struct is created by the `into_iter` method on [`Events`]. +/// +/// # Examples +/// +/// ``` +/// # use std::error::Error; +/// # fn try_main() -> Result<(), Box<Error>> { +/// use mio::{Events, Poll}; +/// use std::time::Duration; +/// +/// let mut events = Events::with_capacity(1024); +/// let poll = Poll::new()?; +/// +/// // Register handles with `poll` +/// +/// poll.poll(&mut events, Some(Duration::from_millis(100)))?; +/// +/// for event in events { +/// println!("event={:?}", event); +/// } +/// # Ok(()) +/// # } +/// # +/// # fn main() { +/// # try_main().unwrap(); +/// # } +/// ``` +/// [`Events`]: struct.Events.html +#[derive(Debug)] +pub struct IntoIter { + inner: Events, + pos: usize, +} + +impl Events { + /// Return a new `Events` capable of holding up to `capacity` events. + /// + /// # Examples + /// + /// ``` + /// use mio::Events; + /// + /// let events = Events::with_capacity(1024); + /// + /// assert_eq!(1024, events.capacity()); + /// ``` + pub fn with_capacity(capacity: usize) -> Events { + Events { + inner: sys::Events::with_capacity(capacity), + } + } + + #[deprecated(since="0.6.10", note="Index access removed in favor of iterator only API.")] + #[doc(hidden)] + pub fn get(&self, idx: usize) -> Option<Event> { + self.inner.get(idx) + } + + #[doc(hidden)] + #[deprecated(since="0.6.10", note="Index access removed in favor of iterator only API.")] + pub fn len(&self) -> usize { + self.inner.len() + } + + /// Returns the number of `Event` values that `self` can hold. + /// + /// ``` + /// use mio::Events; + /// + /// let events = Events::with_capacity(1024); + /// + /// assert_eq!(1024, events.capacity()); + /// ``` + pub fn capacity(&self) -> usize { + self.inner.capacity() + } + + /// Returns `true` if `self` contains no `Event` values. + /// + /// # Examples + /// + /// ``` + /// use mio::Events; + /// + /// let events = Events::with_capacity(1024); + /// + /// assert!(events.is_empty()); + /// ``` + pub fn is_empty(&self) -> bool { + self.inner.is_empty() + } + + /// Returns an iterator over the `Event` values. + /// + /// # Examples + /// + /// ``` + /// # use std::error::Error; + /// # fn try_main() -> Result<(), Box<Error>> { + /// use mio::{Events, Poll}; + /// use std::time::Duration; + /// + /// let mut events = Events::with_capacity(1024); + /// let poll = Poll::new()?; + /// + /// // Register handles with `poll` + /// + /// poll.poll(&mut events, Some(Duration::from_millis(100)))?; + /// + /// for event in events.iter() { + /// println!("event={:?}", event); + /// } + /// # Ok(()) + /// # } + /// # + /// # fn main() { + /// # try_main().unwrap(); + /// # } + /// ``` + pub fn iter(&self) -> Iter { + Iter { + inner: self, + pos: 0 + } + } + + /// Clearing all `Event` values from container explicitly. + /// + /// # Examples + /// + /// ``` + /// # use std::error::Error; + /// # fn try_main() -> Result<(), Box<Error>> { + /// use mio::{Events, Poll}; + /// use std::time::Duration; + /// + /// let mut events = Events::with_capacity(1024); + /// let poll = Poll::new()?; + /// + /// // Register handles with `poll` + /// for _ in 0..2 { + /// events.clear(); + /// poll.poll(&mut events, Some(Duration::from_millis(100)))?; + /// + /// for event in events.iter() { + /// println!("event={:?}", event); + /// } + /// } + /// # Ok(()) + /// # } + /// # + /// # fn main() { + /// # try_main().unwrap(); + /// # } + /// ``` + pub fn clear(&mut self) { + self.inner.clear(); + } +} + +impl<'a> IntoIterator for &'a Events { + type Item = Event; + type IntoIter = Iter<'a>; + + fn into_iter(self) -> Self::IntoIter { + self.iter() + } +} + +impl<'a> Iterator for Iter<'a> { + type Item = Event; + + fn next(&mut self) -> Option<Event> { + let ret = self.inner.inner.get(self.pos); + self.pos += 1; + ret + } +} + +impl IntoIterator for Events { + type Item = Event; + type IntoIter = IntoIter; + + fn into_iter(self) -> Self::IntoIter { + IntoIter { + inner: self, + pos: 0, + } + } +} + +impl Iterator for IntoIter { + type Item = Event; + + fn next(&mut self) -> Option<Event> { + let ret = self.inner.inner.get(self.pos); + self.pos += 1; + ret + } +} + +impl fmt::Debug for Events { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.debug_struct("Events") + .field("capacity", &self.capacity()) + .finish() + } +} + +// ===== Accessors for internal usage ===== + +pub fn selector(poll: &Poll) -> &sys::Selector { + &poll.selector +} + +/* + * + * ===== Registration ===== + * + */ + +// TODO: get rid of this, windows depends on it for now +#[allow(dead_code)] +pub fn new_registration(poll: &Poll, token: Token, ready: Ready, opt: PollOpt) + -> (Registration, SetReadiness) +{ + Registration::new_priv(poll, token, ready, opt) +} + +impl Registration { + /// Create and return a new `Registration` and the associated + /// `SetReadiness`. + /// + /// See [struct] documentation for more detail and [`Poll`] + /// for high level documentation on polling. + /// + /// # Examples + /// + /// ``` + /// # use std::error::Error; + /// # fn try_main() -> Result<(), Box<Error>> { + /// use mio::{Events, Ready, Registration, Poll, PollOpt, Token}; + /// use std::thread; + /// + /// let (registration, set_readiness) = Registration::new2(); + /// + /// thread::spawn(move || { + /// use std::time::Duration; + /// thread::sleep(Duration::from_millis(500)); + /// + /// set_readiness.set_readiness(Ready::readable()); + /// }); + /// + /// let poll = Poll::new()?; + /// poll.register(®istration, Token(0), Ready::readable() | Ready::writable(), PollOpt::edge())?; + /// + /// let mut events = Events::with_capacity(256); + /// + /// loop { + /// poll.poll(&mut events, None); + /// + /// for event in &events { + /// if event.token() == Token(0) && event.readiness().is_readable() { + /// return Ok(()); + /// } + /// } + /// } + /// # Ok(()) + /// # } + /// # + /// # fn main() { + /// # try_main().unwrap(); + /// # } + /// ``` + /// [struct]: # + /// [`Poll`]: struct.Poll.html + pub fn new2() -> (Registration, SetReadiness) { + // Allocate the registration node. The new node will have `ref_count` + // set to 2: one SetReadiness, one Registration. + let node = Box::into_raw(Box::new(ReadinessNode::new( + ptr::null_mut(), Token(0), Ready::empty(), PollOpt::empty(), 2))); + + let registration = Registration { + inner: RegistrationInner { + node, + }, + }; + + let set_readiness = SetReadiness { + inner: RegistrationInner { + node, + }, + }; + + (registration, set_readiness) + } + + #[deprecated(since = "0.6.5", note = "use `new2` instead")] + #[cfg(feature = "with-deprecated")] + #[doc(hidden)] + pub fn new(poll: &Poll, token: Token, interest: Ready, opt: PollOpt) + -> (Registration, SetReadiness) + { + Registration::new_priv(poll, token, interest, opt) + } + + // TODO: Get rid of this (windows depends on it for now) + fn new_priv(poll: &Poll, token: Token, interest: Ready, opt: PollOpt) + -> (Registration, SetReadiness) + { + is_send::<Registration>(); + is_sync::<Registration>(); + is_send::<SetReadiness>(); + is_sync::<SetReadiness>(); + + // Clone handle to the readiness queue, this bumps the ref count + let queue = poll.readiness_queue.inner.clone(); + + // Convert to a *mut () pointer + let queue: *mut () = unsafe { mem::transmute(queue) }; + + // Allocate the registration node. The new node will have `ref_count` + // set to 3: one SetReadiness, one Registration, and one Poll handle. + let node = Box::into_raw(Box::new(ReadinessNode::new( + queue, token, interest, opt, 3))); + + let registration = Registration { + inner: RegistrationInner { + node, + }, + }; + + let set_readiness = SetReadiness { + inner: RegistrationInner { + node, + }, + }; + + (registration, set_readiness) + } + + #[deprecated(since = "0.6.5", note = "use `Evented` impl")] + #[cfg(feature = "with-deprecated")] + #[doc(hidden)] + pub fn update(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + self.inner.update(poll, token, interest, opts) + } + + #[deprecated(since = "0.6.5", note = "use `Poll::deregister` instead")] + #[cfg(feature = "with-deprecated")] + #[doc(hidden)] + pub fn deregister(&self, poll: &Poll) -> io::Result<()> { + self.inner.update(poll, Token(0), Ready::empty(), PollOpt::empty()) + } +} + +impl Evented for Registration { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + self.inner.update(poll, token, interest, opts) + } + + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + self.inner.update(poll, token, interest, opts) + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + self.inner.update(poll, Token(0), Ready::empty(), PollOpt::empty()) + } +} + +impl Drop for Registration { + fn drop(&mut self) { + // `flag_as_dropped` toggles the `dropped` flag and notifies + // `Poll::poll` to release its handle (which is just decrementing + // the ref count). + if self.inner.state.flag_as_dropped() { + // Can't do anything if the queuing fails + let _ = self.inner.enqueue_with_wakeup(); + } + } +} + +impl fmt::Debug for Registration { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("Registration") + .finish() + } +} + +impl SetReadiness { + /// Returns the registration's current readiness. + /// + /// # Note + /// + /// There is no guarantee that `readiness` establishes any sort of memory + /// ordering. Any concurrent data access must be synchronized using another + /// strategy. + /// + /// # Examples + /// + /// ``` + /// # use std::error::Error; + /// # fn try_main() -> Result<(), Box<Error>> { + /// use mio::{Registration, Ready}; + /// + /// let (registration, set_readiness) = Registration::new2(); + /// + /// assert!(set_readiness.readiness().is_empty()); + /// + /// set_readiness.set_readiness(Ready::readable())?; + /// assert!(set_readiness.readiness().is_readable()); + /// # Ok(()) + /// # } + /// # + /// # fn main() { + /// # try_main().unwrap(); + /// # } + /// ``` + pub fn readiness(&self) -> Ready { + self.inner.readiness() + } + + /// Set the registration's readiness + /// + /// If the associated `Registration` is registered with a [`Poll`] instance + /// and has requested readiness events that include `ready`, then a future + /// call to [`Poll::poll`] will receive a readiness event representing the + /// readiness state change. + /// + /// # Note + /// + /// There is no guarantee that `readiness` establishes any sort of memory + /// ordering. Any concurrent data access must be synchronized using another + /// strategy. + /// + /// There is also no guarantee as to when the readiness event will be + /// delivered to poll. A best attempt will be made to make the delivery in a + /// "timely" fashion. For example, the following is **not** guaranteed to + /// work: + /// + /// ``` + /// # use std::error::Error; + /// # fn try_main() -> Result<(), Box<Error>> { + /// use mio::{Events, Registration, Ready, Poll, PollOpt, Token}; + /// + /// let poll = Poll::new()?; + /// let (registration, set_readiness) = Registration::new2(); + /// + /// poll.register(®istration, + /// Token(0), + /// Ready::readable(), + /// PollOpt::edge())?; + /// + /// // Set the readiness, then immediately poll to try to get the readiness + /// // event + /// set_readiness.set_readiness(Ready::readable())?; + /// + /// let mut events = Events::with_capacity(1024); + /// poll.poll(&mut events, None)?; + /// + /// // There is NO guarantee that the following will work. It is possible + /// // that the readiness event will be delivered at a later time. + /// let event = events.get(0).unwrap(); + /// assert_eq!(event.token(), Token(0)); + /// assert!(event.readiness().is_readable()); + /// # Ok(()) + /// # } + /// # + /// # fn main() { + /// # try_main().unwrap(); + /// # } + /// ``` + /// + /// # Examples + /// + /// A simple example, for a more elaborate example, see the [`Evented`] + /// documentation. + /// + /// ``` + /// # use std::error::Error; + /// # fn try_main() -> Result<(), Box<Error>> { + /// use mio::{Registration, Ready}; + /// + /// let (registration, set_readiness) = Registration::new2(); + /// + /// assert!(set_readiness.readiness().is_empty()); + /// + /// set_readiness.set_readiness(Ready::readable())?; + /// assert!(set_readiness.readiness().is_readable()); + /// # Ok(()) + /// # } + /// # + /// # fn main() { + /// # try_main().unwrap(); + /// # } + /// ``` + /// + /// [`Registration`]: struct.Registration.html + /// [`Evented`]: event/trait.Evented.html#examples + /// [`Poll`]: struct.Poll.html + /// [`Poll::poll`]: struct.Poll.html#method.poll + pub fn set_readiness(&self, ready: Ready) -> io::Result<()> { + self.inner.set_readiness(ready) + } +} + +impl fmt::Debug for SetReadiness { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.debug_struct("SetReadiness") + .finish() + } +} + +impl RegistrationInner { + /// Get the registration's readiness. + fn readiness(&self) -> Ready { + self.state.load(Relaxed).readiness() + } + + /// Set the registration's readiness. + /// + /// This function can be called concurrently by an arbitrary number of + /// SetReadiness handles. + fn set_readiness(&self, ready: Ready) -> io::Result<()> { + // Load the current atomic state. + let mut state = self.state.load(Acquire); + let mut next; + + loop { + next = state; + + if state.is_dropped() { + // Node is dropped, no more notifications + return Ok(()); + } + + // Update the readiness + next.set_readiness(ready); + + // If the readiness is not blank, try to obtain permission to + // push the node into the readiness queue. + if !next.effective_readiness().is_empty() { + next.set_queued(); + } + + let actual = self.state.compare_and_swap(state, next, AcqRel); + + if state == actual { + break; + } + + state = actual; + } + + if !state.is_queued() && next.is_queued() { + // We toggled the queued flag, making us responsible for queuing the + // node in the MPSC readiness queue. + self.enqueue_with_wakeup()?; + } + + Ok(()) + } + + /// Update the registration details associated with the node + fn update(&self, poll: &Poll, token: Token, interest: Ready, opt: PollOpt) -> io::Result<()> { + // First, ensure poll instances match + // + // Load the queue pointer, `Relaxed` is sufficient here as only the + // pointer is being operated on. The actual memory is guaranteed to be + // visible the `poll: &Poll` ref passed as an argument to the function. + let mut queue = self.readiness_queue.load(Relaxed); + let other: &*mut () = unsafe { + &*(&poll.readiness_queue.inner as *const _ as *const *mut ()) + }; + let other = *other; + + debug_assert!(mem::size_of::<Arc<ReadinessQueueInner>>() == mem::size_of::<*mut ()>()); + + if queue.is_null() { + // Attempt to set the queue pointer. `Release` ordering synchronizes + // with `Acquire` in `ensure_with_wakeup`. + let actual = self.readiness_queue.compare_and_swap( + queue, other, Release); + + if actual.is_null() { + // The CAS succeeded, this means that the node's ref count + // should be incremented to reflect that the `poll` function + // effectively owns the node as well. + // + // `Relaxed` ordering used for the same reason as in + // RegistrationInner::clone + self.ref_count.fetch_add(1, Relaxed); + + // Note that the `queue` reference stored in our + // `readiness_queue` field is intended to be a strong reference, + // so now that we've successfully claimed the reference we bump + // the refcount here. + // + // Down below in `release_node` when we deallocate this + // `RegistrationInner` is where we'll transmute this back to an + // arc and decrement the reference count. + mem::forget(poll.readiness_queue.clone()); + } else { + // The CAS failed, another thread set the queue pointer, so ensure + // that the pointer and `other` match + if actual != other { + return Err(io::Error::new(io::ErrorKind::Other, "registration handle associated with another `Poll` instance")); + } + } + + queue = other; + } else if queue != other { + return Err(io::Error::new(io::ErrorKind::Other, "registration handle associated with another `Poll` instance")); + } + + unsafe { + let actual = &poll.readiness_queue.inner as *const _ as *const usize; + debug_assert_eq!(queue as usize, *actual); + } + + // The `update_lock` atomic is used as a flag ensuring only a single + // thread concurrently enters the `update` critical section. Any + // concurrent calls to update are discarded. If coordinated updates are + // required, the Mio user is responsible for handling that. + // + // Acquire / Release ordering is used on `update_lock` to ensure that + // data access to the `token_*` variables are scoped to the critical + // section. + + // Acquire the update lock. + if self.update_lock.compare_and_swap(false, true, Acquire) { + // The lock is already held. Discard the update + return Ok(()); + } + + // Relaxed ordering is acceptable here as the only memory that needs to + // be visible as part of the update are the `token_*` variables, and + // ordering has already been handled by the `update_lock` access. + let mut state = self.state.load(Relaxed); + let mut next; + + // Read the current token, again this memory has been ordered by the + // acquire on `update_lock`. + let curr_token_pos = state.token_write_pos(); + let curr_token = unsafe { self::token(self, curr_token_pos) }; + + let mut next_token_pos = curr_token_pos; + + // If the `update` call is changing the token, then compute the next + // available token slot and write the token there. + // + // Note that this computation is happening *outside* of the + // compare-and-swap loop. The update lock ensures that only a single + // thread could be mutating the write_token_position, so the + // `next_token_pos` will never need to be recomputed even if + // `token_read_pos` concurrently changes. This is because + // `token_read_pos` can ONLY concurrently change to the current value of + // `token_write_pos`, so `next_token_pos` will always remain valid. + if token != curr_token { + next_token_pos = state.next_token_pos(); + + // Update the token + match next_token_pos { + 0 => unsafe { *self.token_0.get() = token }, + 1 => unsafe { *self.token_1.get() = token }, + 2 => unsafe { *self.token_2.get() = token }, + _ => unreachable!(), + } + } + + // Now enter the compare-and-swap loop + loop { + next = state; + + // The node is only dropped once all `Registration` handles are + // dropped. Only `Registration` can call `update`. + debug_assert!(!state.is_dropped()); + + // Update the write token position, this will also release the token + // to Poll::poll. + next.set_token_write_pos(next_token_pos); + + // Update readiness and poll opts + next.set_interest(interest); + next.set_poll_opt(opt); + + // If there is effective readiness, the node will need to be queued + // for processing. This exact behavior is still TBD, so we are + // conservative for now and always fire. + // + // See https://github.com/carllerche/mio/issues/535. + if !next.effective_readiness().is_empty() { + next.set_queued(); + } + + // compare-and-swap the state values. Only `Release` is needed here. + // The `Release` ensures that `Poll::poll` will see the token + // update and the update function doesn't care about any other + // memory visibility. + let actual = self.state.compare_and_swap(state, next, Release); + + if actual == state { + break; + } + + // CAS failed, but `curr_token_pos` should not have changed given + // that we still hold the update lock. + debug_assert_eq!(curr_token_pos, actual.token_write_pos()); + + state = actual; + } + + // Release the lock + self.update_lock.store(false, Release); + + if !state.is_queued() && next.is_queued() { + // We are responsible for enqueing the node. + enqueue_with_wakeup(queue, self)?; + } + + Ok(()) + } +} + +impl ops::Deref for RegistrationInner { + type Target = ReadinessNode; + + fn deref(&self) -> &ReadinessNode { + unsafe { &*self.node } + } +} + +impl Clone for RegistrationInner { + fn clone(&self) -> RegistrationInner { + // Using a relaxed ordering is alright here, as knowledge of the + // original reference prevents other threads from erroneously deleting + // the object. + // + // As explained in the [Boost documentation][1], Increasing the + // reference counter can always be done with memory_order_relaxed: New + // references to an object can only be formed from an existing + // reference, and passing an existing reference from one thread to + // another must already provide any required synchronization. + // + // [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html) + let old_size = self.ref_count.fetch_add(1, Relaxed); + + // However we need to guard against massive refcounts in case someone + // is `mem::forget`ing Arcs. If we don't do this the count can overflow + // and users will use-after free. We racily saturate to `isize::MAX` on + // the assumption that there aren't ~2 billion threads incrementing + // the reference count at once. This branch will never be taken in + // any realistic program. + // + // We abort because such a program is incredibly degenerate, and we + // don't care to support it. + if old_size & !MAX_REFCOUNT != 0 { + process::abort(); + } + + RegistrationInner { + node: self.node, + } + } +} + +impl Drop for RegistrationInner { + fn drop(&mut self) { + // Only handles releasing from `Registration` and `SetReadiness` + // handles. Poll has to call this itself. + release_node(self.node); + } +} + +/* + * + * ===== ReadinessQueue ===== + * + */ + +impl ReadinessQueue { + /// Create a new `ReadinessQueue`. + fn new() -> io::Result<ReadinessQueue> { + is_send::<Self>(); + is_sync::<Self>(); + + let end_marker = Box::new(ReadinessNode::marker()); + let sleep_marker = Box::new(ReadinessNode::marker()); + let closed_marker = Box::new(ReadinessNode::marker()); + + let ptr = &*end_marker as *const _ as *mut _; + + Ok(ReadinessQueue { + inner: Arc::new(ReadinessQueueInner { + awakener: sys::Awakener::new()?, + head_readiness: AtomicPtr::new(ptr), + tail_readiness: UnsafeCell::new(ptr), + end_marker, + sleep_marker, + closed_marker, + }) + }) + } + + /// Poll the queue for new events + fn poll(&self, dst: &mut sys::Events) { + // `until` is set with the first node that gets re-enqueued due to being + // set to have level-triggered notifications. This prevents an infinite + // loop where `Poll::poll` will keep dequeuing nodes it enqueues. + let mut until = ptr::null_mut(); + + if dst.len() == dst.capacity() { + // If `dst` is already full, the readiness queue won't be drained. + // This might result in `sleep_marker` staying in the queue and + // unecessary pipe writes occuring. + self.inner.clear_sleep_marker(); + } + + 'outer: + while dst.len() < dst.capacity() { + // Dequeue a node. If the queue is in an inconsistent state, then + // stop polling. `Poll::poll` will be called again shortly and enter + // a syscall, which should be enough to enable the other thread to + // finish the queuing process. + let ptr = match unsafe { self.inner.dequeue_node(until) } { + Dequeue::Empty | Dequeue::Inconsistent => break, + Dequeue::Data(ptr) => ptr, + }; + + let node = unsafe { &*ptr }; + + // Read the node state with Acquire ordering. This allows reading + // the token variables. + let mut state = node.state.load(Acquire); + let mut next; + let mut readiness; + let mut opt; + + loop { + // Build up any changes to the readiness node's state and + // attempt the CAS at the end + next = state; + + // Given that the node was just read from the queue, the + // `queued` flag should still be set. + debug_assert!(state.is_queued()); + + // The dropped flag means we need to release the node and + // perform no further processing on it. + if state.is_dropped() { + // Release the node and continue + release_node(ptr); + continue 'outer; + } + + // Process the node + readiness = state.effective_readiness(); + opt = state.poll_opt(); + + if opt.is_edge() { + // Mark the node as dequeued + next.set_dequeued(); + + if opt.is_oneshot() && !readiness.is_empty() { + next.disarm(); + } + } else if readiness.is_empty() { + next.set_dequeued(); + } + + // Ensure `token_read_pos` is set to `token_write_pos` so that + // we read the most up to date token value. + next.update_token_read_pos(); + + if state == next { + break; + } + + let actual = node.state.compare_and_swap(state, next, AcqRel); + + if actual == state { + break; + } + + state = actual; + } + + // If the queued flag is still set, then the node must be requeued. + // This typically happens when using level-triggered notifications. + if next.is_queued() { + if until.is_null() { + // We never want to see the node again + until = ptr; + } + + // Requeue the node + self.inner.enqueue_node(node); + } + + if !readiness.is_empty() { + // Get the token + let token = unsafe { token(node, next.token_read_pos()) }; + + // Push the event + dst.push_event(Event::new(readiness, token)); + } + } + } + + /// Prepare the queue for the `Poll::poll` thread to block in the system + /// selector. This involves changing `head_readiness` to `sleep_marker`. + /// Returns true if successful and `poll` can block. + fn prepare_for_sleep(&self) -> bool { + let end_marker = self.inner.end_marker(); + let sleep_marker = self.inner.sleep_marker(); + + let tail = unsafe { *self.inner.tail_readiness.get() }; + + // If the tail is currently set to the sleep_marker, then check if the + // head is as well. If it is, then the queue is currently ready to + // sleep. If it is not, then the queue is not empty and there should be + // no sleeping. + if tail == sleep_marker { + return self.inner.head_readiness.load(Acquire) == sleep_marker; + } + + // If the tail is not currently set to `end_marker`, then the queue is + // not empty. + if tail != end_marker { + return false; + } + + // The sleep marker is *not* currently in the readiness queue. + // + // The sleep marker is only inserted in this function. It is also only + // inserted in the tail position. This is guaranteed by first checking + // that the end marker is in the tail position, pushing the sleep marker + // after the end marker, then removing the end marker. + // + // Before inserting a node into the queue, the next pointer has to be + // set to null. Again, this is only safe to do when the node is not + // currently in the queue, but we already have ensured this. + self.inner.sleep_marker.next_readiness.store(ptr::null_mut(), Relaxed); + + let actual = self.inner.head_readiness.compare_and_swap( + end_marker, sleep_marker, AcqRel); + + debug_assert!(actual != sleep_marker); + + if actual != end_marker { + // The readiness queue is not empty + return false; + } + + // The current tail should be pointing to `end_marker` + debug_assert!(unsafe { *self.inner.tail_readiness.get() == end_marker }); + // The `end_marker` next pointer should be null + debug_assert!(self.inner.end_marker.next_readiness.load(Relaxed).is_null()); + + // Update tail pointer. + unsafe { *self.inner.tail_readiness.get() = sleep_marker; } + true + } +} + +impl Drop for ReadinessQueue { + fn drop(&mut self) { + // Close the queue by enqueuing the closed node + self.inner.enqueue_node(&*self.inner.closed_marker); + + loop { + // Free any nodes that happen to be left in the readiness queue + let ptr = match unsafe { self.inner.dequeue_node(ptr::null_mut()) } { + Dequeue::Empty => break, + Dequeue::Inconsistent => { + // This really shouldn't be possible as all other handles to + // `ReadinessQueueInner` are dropped, but handle this by + // spinning I guess? + continue; + } + Dequeue::Data(ptr) => ptr, + }; + + let node = unsafe { &*ptr }; + + let state = node.state.load(Acquire); + + debug_assert!(state.is_queued()); + + release_node(ptr); + } + } +} + +impl ReadinessQueueInner { + fn wakeup(&self) -> io::Result<()> { + self.awakener.wakeup() + } + + /// Prepend the given node to the head of the readiness queue. This is done + /// with relaxed ordering. Returns true if `Poll` needs to be woken up. + fn enqueue_node_with_wakeup(&self, node: &ReadinessNode) -> io::Result<()> { + if self.enqueue_node(node) { + self.wakeup()?; + } + + Ok(()) + } + + /// Push the node into the readiness queue + fn enqueue_node(&self, node: &ReadinessNode) -> bool { + // This is the 1024cores.net intrusive MPSC queue [1] "push" function. + let node_ptr = node as *const _ as *mut _; + + // Relaxed used as the ordering is "released" when swapping + // `head_readiness` + node.next_readiness.store(ptr::null_mut(), Relaxed); + + unsafe { + let mut prev = self.head_readiness.load(Acquire); + + loop { + if prev == self.closed_marker() { + debug_assert!(node_ptr != self.closed_marker()); + // debug_assert!(node_ptr != self.end_marker()); + debug_assert!(node_ptr != self.sleep_marker()); + + if node_ptr != self.end_marker() { + // The readiness queue is shutdown, but the enqueue flag was + // set. This means that we are responsible for decrementing + // the ready queue's ref count + debug_assert!(node.ref_count.load(Relaxed) >= 2); + release_node(node_ptr); + } + + return false; + } + + let act = self.head_readiness.compare_and_swap(prev, node_ptr, AcqRel); + + if prev == act { + break; + } + + prev = act; + } + + debug_assert!((*prev).next_readiness.load(Relaxed).is_null()); + + (*prev).next_readiness.store(node_ptr, Release); + + prev == self.sleep_marker() + } + } + + fn clear_sleep_marker(&self) { + let end_marker = self.end_marker(); + let sleep_marker = self.sleep_marker(); + + unsafe { + let tail = *self.tail_readiness.get(); + + if tail != self.sleep_marker() { + return; + } + + // The empty markeer is *not* currently in the readiness queue + // (since the sleep markeris). + self.end_marker.next_readiness.store(ptr::null_mut(), Relaxed); + + let actual = self.head_readiness.compare_and_swap( + sleep_marker, end_marker, AcqRel); + + debug_assert!(actual != end_marker); + + if actual != sleep_marker { + // The readiness queue is not empty, we cannot remove the sleep + // markeer + return; + } + + // Update the tail pointer. + *self.tail_readiness.get() = end_marker; + } + } + + /// Must only be called in `poll` or `drop` + unsafe fn dequeue_node(&self, until: *mut ReadinessNode) -> Dequeue { + // This is the 1024cores.net intrusive MPSC queue [1] "pop" function + // with the modifications mentioned at the top of the file. + let mut tail = *self.tail_readiness.get(); + let mut next = (*tail).next_readiness.load(Acquire); + + if tail == self.end_marker() || tail == self.sleep_marker() || tail == self.closed_marker() { + if next.is_null() { + // Make sure the sleep marker is removed (as we are no longer + // sleeping + self.clear_sleep_marker(); + + return Dequeue::Empty; + } + + *self.tail_readiness.get() = next; + tail = next; + next = (*next).next_readiness.load(Acquire); + } + + // Only need to check `until` at this point. `until` is either null, + // which will never match tail OR it is a node that was pushed by + // the current thread. This means that either: + // + // 1) The queue is inconsistent, which is handled explicitly + // 2) We encounter `until` at this point in dequeue + // 3) we will pop a different node + if tail == until { + return Dequeue::Empty; + } + + if !next.is_null() { + *self.tail_readiness.get() = next; + return Dequeue::Data(tail); + } + + if self.head_readiness.load(Acquire) != tail { + return Dequeue::Inconsistent; + } + + // Push the stub node + self.enqueue_node(&*self.end_marker); + + next = (*tail).next_readiness.load(Acquire); + + if !next.is_null() { + *self.tail_readiness.get() = next; + return Dequeue::Data(tail); + } + + Dequeue::Inconsistent + } + + fn end_marker(&self) -> *mut ReadinessNode { + &*self.end_marker as *const ReadinessNode as *mut ReadinessNode + } + + fn sleep_marker(&self) -> *mut ReadinessNode { + &*self.sleep_marker as *const ReadinessNode as *mut ReadinessNode + } + + fn closed_marker(&self) -> *mut ReadinessNode { + &*self.closed_marker as *const ReadinessNode as *mut ReadinessNode + } +} + +impl ReadinessNode { + /// Return a new `ReadinessNode`, initialized with a ref_count of 3. + fn new(queue: *mut (), + token: Token, + interest: Ready, + opt: PollOpt, + ref_count: usize) -> ReadinessNode + { + ReadinessNode { + state: AtomicState::new(interest, opt), + // Only the first token is set, the others are initialized to 0 + token_0: UnsafeCell::new(token), + token_1: UnsafeCell::new(Token(0)), + token_2: UnsafeCell::new(Token(0)), + next_readiness: AtomicPtr::new(ptr::null_mut()), + update_lock: AtomicBool::new(false), + readiness_queue: AtomicPtr::new(queue), + ref_count: AtomicUsize::new(ref_count), + } + } + + fn marker() -> ReadinessNode { + ReadinessNode { + state: AtomicState::new(Ready::empty(), PollOpt::empty()), + token_0: UnsafeCell::new(Token(0)), + token_1: UnsafeCell::new(Token(0)), + token_2: UnsafeCell::new(Token(0)), + next_readiness: AtomicPtr::new(ptr::null_mut()), + update_lock: AtomicBool::new(false), + readiness_queue: AtomicPtr::new(ptr::null_mut()), + ref_count: AtomicUsize::new(0), + } + } + + fn enqueue_with_wakeup(&self) -> io::Result<()> { + let queue = self.readiness_queue.load(Acquire); + + if queue.is_null() { + // Not associated with a queue, nothing to do + return Ok(()); + } + + enqueue_with_wakeup(queue, self) + } +} + +fn enqueue_with_wakeup(queue: *mut (), node: &ReadinessNode) -> io::Result<()> { + debug_assert!(!queue.is_null()); + // This is ugly... but we don't want to bump the ref count. + let queue: &Arc<ReadinessQueueInner> = unsafe { + &*(&queue as *const *mut () as *const Arc<ReadinessQueueInner>) + }; + queue.enqueue_node_with_wakeup(node) +} + +unsafe fn token(node: &ReadinessNode, pos: usize) -> Token { + match pos { + 0 => *node.token_0.get(), + 1 => *node.token_1.get(), + 2 => *node.token_2.get(), + _ => unreachable!(), + } +} + +fn release_node(ptr: *mut ReadinessNode) { + unsafe { + // `AcqRel` synchronizes with other `release_node` functions and ensures + // that the drop happens after any reads / writes on other threads. + if (*ptr).ref_count.fetch_sub(1, AcqRel) != 1 { + return; + } + + let node = Box::from_raw(ptr); + + // Decrement the readiness_queue Arc + let queue = node.readiness_queue.load(Acquire); + + if queue.is_null() { + return; + } + + let _: Arc<ReadinessQueueInner> = mem::transmute(queue); + } +} + +impl AtomicState { + fn new(interest: Ready, opt: PollOpt) -> AtomicState { + let state = ReadinessState::new(interest, opt); + + AtomicState { + inner: AtomicUsize::new(state.into()), + } + } + + /// Loads the current `ReadinessState` + fn load(&self, order: Ordering) -> ReadinessState { + self.inner.load(order).into() + } + + /// Stores a state if the current state is the same as `current`. + fn compare_and_swap(&self, current: ReadinessState, new: ReadinessState, order: Ordering) -> ReadinessState { + self.inner.compare_and_swap(current.into(), new.into(), order).into() + } + + // Returns `true` if the node should be queued + fn flag_as_dropped(&self) -> bool { + let prev: ReadinessState = self.inner.fetch_or(DROPPED_MASK | QUEUED_MASK, Release).into(); + // The flag should not have been previously set + debug_assert!(!prev.is_dropped()); + + !prev.is_queued() + } +} + +impl ReadinessState { + // Create a `ReadinessState` initialized with the provided arguments + #[inline] + fn new(interest: Ready, opt: PollOpt) -> ReadinessState { + let interest = event::ready_as_usize(interest); + let opt = event::opt_as_usize(opt); + + debug_assert!(interest <= MASK_4); + debug_assert!(opt <= MASK_4); + + let mut val = interest << INTEREST_SHIFT; + val |= opt << POLL_OPT_SHIFT; + + ReadinessState(val) + } + + #[inline] + fn get(self, mask: usize, shift: usize) -> usize{ + (self.0 >> shift) & mask + } + + #[inline] + fn set(&mut self, val: usize, mask: usize, shift: usize) { + self.0 = (self.0 & !(mask << shift)) | (val << shift) + } + + /// Get the readiness + #[inline] + fn readiness(self) -> Ready { + let v = self.get(MASK_4, READINESS_SHIFT); + event::ready_from_usize(v) + } + + #[inline] + fn effective_readiness(self) -> Ready { + self.readiness() & self.interest() + } + + /// Set the readiness + #[inline] + fn set_readiness(&mut self, v: Ready) { + self.set(event::ready_as_usize(v), MASK_4, READINESS_SHIFT); + } + + /// Get the interest + #[inline] + fn interest(self) -> Ready { + let v = self.get(MASK_4, INTEREST_SHIFT); + event::ready_from_usize(v) + } + + /// Set the interest + #[inline] + fn set_interest(&mut self, v: Ready) { + self.set(event::ready_as_usize(v), MASK_4, INTEREST_SHIFT); + } + + #[inline] + fn disarm(&mut self) { + self.set_interest(Ready::empty()); + } + + /// Get the poll options + #[inline] + fn poll_opt(self) -> PollOpt { + let v = self.get(MASK_4, POLL_OPT_SHIFT); + event::opt_from_usize(v) + } + + /// Set the poll options + #[inline] + fn set_poll_opt(&mut self, v: PollOpt) { + self.set(event::opt_as_usize(v), MASK_4, POLL_OPT_SHIFT); + } + + #[inline] + fn is_queued(self) -> bool { + self.0 & QUEUED_MASK == QUEUED_MASK + } + + /// Set the queued flag + #[inline] + fn set_queued(&mut self) { + // Dropped nodes should never be queued + debug_assert!(!self.is_dropped()); + self.0 |= QUEUED_MASK; + } + + #[inline] + fn set_dequeued(&mut self) { + debug_assert!(self.is_queued()); + self.0 &= !QUEUED_MASK + } + + #[inline] + fn is_dropped(self) -> bool { + self.0 & DROPPED_MASK == DROPPED_MASK + } + + #[inline] + fn token_read_pos(self) -> usize { + self.get(MASK_2, TOKEN_RD_SHIFT) + } + + #[inline] + fn token_write_pos(self) -> usize { + self.get(MASK_2, TOKEN_WR_SHIFT) + } + + #[inline] + fn next_token_pos(self) -> usize { + let rd = self.token_read_pos(); + let wr = self.token_write_pos(); + + match wr { + 0 => { + match rd { + 1 => 2, + 2 => 1, + 0 => 1, + _ => unreachable!(), + } + } + 1 => { + match rd { + 0 => 2, + 2 => 0, + 1 => 2, + _ => unreachable!(), + } + } + 2 => { + match rd { + 0 => 1, + 1 => 0, + 2 => 0, + _ => unreachable!(), + } + } + _ => unreachable!(), + } + } + + #[inline] + fn set_token_write_pos(&mut self, val: usize) { + self.set(val, MASK_2, TOKEN_WR_SHIFT); + } + + #[inline] + fn update_token_read_pos(&mut self) { + let val = self.token_write_pos(); + self.set(val, MASK_2, TOKEN_RD_SHIFT); + } +} + +impl From<ReadinessState> for usize { + fn from(src: ReadinessState) -> usize { + src.0 + } +} + +impl From<usize> for ReadinessState { + fn from(src: usize) -> ReadinessState { + ReadinessState(src) + } +} + +fn is_send<T: Send>() {} +fn is_sync<T: Sync>() {} + +impl SelectorId { + pub fn new() -> SelectorId { + SelectorId { + id: AtomicUsize::new(0), + } + } + + pub fn associate_selector(&self, poll: &Poll) -> io::Result<()> { + let selector_id = self.id.load(Ordering::SeqCst); + + if selector_id != 0 && selector_id != poll.selector.id() { + Err(io::Error::new(io::ErrorKind::Other, "socket already registered")) + } else { + self.id.store(poll.selector.id(), Ordering::SeqCst); + Ok(()) + } + } +} + +impl Clone for SelectorId { + fn clone(&self) -> SelectorId { + SelectorId { + id: AtomicUsize::new(self.id.load(Ordering::SeqCst)), + } + } +} + +#[test] +#[cfg(all(unix, not(target_os = "fuchsia")))] +pub fn as_raw_fd() { + let poll = Poll::new().unwrap(); + assert!(poll.as_raw_fd() > 0); +} diff --git a/third_party/rust/mio-0.6.23/src/sys/fuchsia/awakener.rs b/third_party/rust/mio-0.6.23/src/sys/fuchsia/awakener.rs new file mode 100644 index 0000000000..19bc762429 --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/sys/fuchsia/awakener.rs @@ -0,0 +1,73 @@ +use {io, poll, Evented, Ready, Poll, PollOpt, Token}; +use zircon; +use std::sync::{Arc, Mutex, Weak}; + +pub struct Awakener { + /// Token and weak reference to the port on which Awakener was registered. + /// + /// When `Awakener::wakeup` is called, these are used to send a wakeup message to the port. + inner: Mutex<Option<(Token, Weak<zircon::Port>)>>, +} + +impl Awakener { + /// Create a new `Awakener`. + pub fn new() -> io::Result<Awakener> { + Ok(Awakener { + inner: Mutex::new(None) + }) + } + + /// Send a wakeup signal to the `Selector` on which the `Awakener` was registered. + pub fn wakeup(&self) -> io::Result<()> { + let inner_locked = self.inner.lock().unwrap(); + let &(token, ref weak_port) = + inner_locked.as_ref().expect("Called wakeup on unregistered awakener."); + + let port = weak_port.upgrade().expect("Tried to wakeup a closed port."); + + let status = 0; // arbitrary + let packet = zircon::Packet::from_user_packet( + token.0 as u64, status, zircon::UserPacket::from_u8_array([0; 32])); + + Ok(port.queue(&packet)?) + } + + pub fn cleanup(&self) {} +} + +impl Evented for Awakener { + fn register(&self, + poll: &Poll, + token: Token, + _events: Ready, + _opts: PollOpt) -> io::Result<()> + { + let mut inner_locked = self.inner.lock().unwrap(); + if inner_locked.is_some() { + panic!("Called register on already-registered Awakener."); + } + *inner_locked = Some((token, Arc::downgrade(poll::selector(poll).port()))); + + Ok(()) + } + + fn reregister(&self, + poll: &Poll, + token: Token, + _events: Ready, + _opts: PollOpt) -> io::Result<()> + { + let mut inner_locked = self.inner.lock().unwrap(); + *inner_locked = Some((token, Arc::downgrade(poll::selector(poll).port()))); + + Ok(()) + } + + fn deregister(&self, _poll: &Poll) -> io::Result<()> + { + let mut inner_locked = self.inner.lock().unwrap(); + *inner_locked = None; + + Ok(()) + } +}
\ No newline at end of file diff --git a/third_party/rust/mio-0.6.23/src/sys/fuchsia/eventedfd.rs b/third_party/rust/mio-0.6.23/src/sys/fuchsia/eventedfd.rs new file mode 100644 index 0000000000..e23d0c4a1e --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/sys/fuchsia/eventedfd.rs @@ -0,0 +1,263 @@ +use {io, poll, Evented, Ready, Poll, PollOpt, Token}; +use libc; +use zircon; +use zircon::AsHandleRef; +use sys::fuchsia::{DontDrop, poll_opts_to_wait_async, sys}; +use std::mem; +use std::os::unix::io::RawFd; +use std::sync::{Arc, Mutex}; + +/// Properties of an `EventedFd`'s current registration +#[derive(Debug)] +pub struct EventedFdRegistration { + token: Token, + handle: DontDrop<zircon::Handle>, + rereg_signals: Option<(zircon::Signals, zircon::WaitAsyncOpts)>, +} + +impl EventedFdRegistration { + unsafe fn new(token: Token, + raw_handle: sys::zx_handle_t, + rereg_signals: Option<(zircon::Signals, zircon::WaitAsyncOpts)>, + ) -> Self + { + EventedFdRegistration { + token: token, + handle: DontDrop::new(zircon::Handle::from_raw(raw_handle)), + rereg_signals: rereg_signals + } + } + + pub fn rereg_signals(&self) -> Option<(zircon::Signals, zircon::WaitAsyncOpts)> { + self.rereg_signals + } +} + +/// An event-ed file descriptor. The file descriptor is owned by this structure. +#[derive(Debug)] +pub struct EventedFdInner { + /// Properties of the current registration. + registration: Mutex<Option<EventedFdRegistration>>, + + /// Owned file descriptor. + /// + /// `fd` is closed on `Drop`, so modifying `fd` is a memory-unsafe operation. + fd: RawFd, + + /// Owned `fdio_t` pointer. + fdio: *const sys::fdio_t, +} + +impl EventedFdInner { + pub fn rereg_for_level(&self, port: &zircon::Port) { + let registration_opt = self.registration.lock().unwrap(); + if let Some(ref registration) = *registration_opt { + if let Some((rereg_signals, rereg_opts)) = registration.rereg_signals { + let _res = + registration + .handle.inner_ref() + .wait_async_handle( + port, + registration.token.0 as u64, + rereg_signals, + rereg_opts); + } + } + } + + pub fn registration(&self) -> &Mutex<Option<EventedFdRegistration>> { + &self.registration + } + + pub fn fdio(&self) -> &sys::fdio_t { + unsafe { &*self.fdio } + } +} + +impl Drop for EventedFdInner { + fn drop(&mut self) { + unsafe { + sys::__fdio_release(self.fdio); + let _ = libc::close(self.fd); + } + } +} + +// `EventedInner` must be manually declared `Send + Sync` because it contains a `RawFd` and a +// `*const sys::fdio_t`. These are only used to make thread-safe system calls, so accessing +// them is entirely thread-safe. +// +// Note: one minor exception to this are the calls to `libc::close` and `__fdio_release`, which +// happen on `Drop`. These accesses are safe because `drop` can only be called at most once from +// a single thread, and after it is called no other functions can be called on the `EventedFdInner`. +unsafe impl Sync for EventedFdInner {} +unsafe impl Send for EventedFdInner {} + +#[derive(Clone, Debug)] +pub struct EventedFd { + pub inner: Arc<EventedFdInner> +} + +impl EventedFd { + pub unsafe fn new(fd: RawFd) -> Self { + let fdio = sys::__fdio_fd_to_io(fd); + assert!(fdio != ::std::ptr::null(), "FileDescriptor given to EventedFd must be valid."); + + EventedFd { + inner: Arc::new(EventedFdInner { + registration: Mutex::new(None), + fd: fd, + fdio: fdio, + }) + } + } + + fn handle_and_signals_for_events(&self, interest: Ready, opts: PollOpt) + -> (sys::zx_handle_t, zircon::Signals) + { + let epoll_events = ioevent_to_epoll(interest, opts); + + unsafe { + let mut raw_handle: sys::zx_handle_t = mem::uninitialized(); + let mut signals: sys::zx_signals_t = mem::uninitialized(); + sys::__fdio_wait_begin(self.inner.fdio, epoll_events, &mut raw_handle, &mut signals); + + (raw_handle, signals) + } + } + + fn register_with_lock( + &self, + registration: &mut Option<EventedFdRegistration>, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt) -> io::Result<()> + { + if registration.is_some() { + return Err(io::Error::new( + io::ErrorKind::AlreadyExists, + "Called register on an already registered file descriptor.")); + } + + let (raw_handle, signals) = self.handle_and_signals_for_events(interest, opts); + + let needs_rereg = opts.is_level() && !opts.is_oneshot(); + + // If we need to reregister, then each registration should be `oneshot` + let opts = opts | if needs_rereg { PollOpt::oneshot() } else { PollOpt::empty() }; + + let rereg_signals = if needs_rereg { + Some((signals, poll_opts_to_wait_async(opts))) + } else { + None + }; + + *registration = Some( + unsafe { EventedFdRegistration::new(token, raw_handle, rereg_signals) } + ); + + // We don't have ownership of the handle, so we can't drop it + let handle = DontDrop::new(unsafe { zircon::Handle::from_raw(raw_handle) }); + + let registered = poll::selector(poll) + .register_fd(handle.inner_ref(), self, token, signals, opts); + + if registered.is_err() { + *registration = None; + } + + registered + } + + fn deregister_with_lock( + &self, + registration: &mut Option<EventedFdRegistration>, + poll: &Poll) -> io::Result<()> + { + let old_registration = if let Some(old_reg) = registration.take() { + old_reg + } else { + return Err(io::Error::new( + io::ErrorKind::NotFound, + "Called rereregister on an unregistered file descriptor.")) + }; + + poll::selector(poll) + .deregister_fd(old_registration.handle.inner_ref(), old_registration.token) + } +} + +impl Evented for EventedFd { + fn register(&self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt) -> io::Result<()> + { + self.register_with_lock( + &mut *self.inner.registration.lock().unwrap(), + poll, + token, + interest, + opts) + } + + fn reregister(&self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt) -> io::Result<()> + { + // Take out the registration lock + let mut registration_lock = self.inner.registration.lock().unwrap(); + + // Deregister + self.deregister_with_lock(&mut *registration_lock, poll)?; + + self.register_with_lock( + &mut *registration_lock, + poll, + token, + interest, + opts) + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + let mut registration_lock = self.inner.registration.lock().unwrap(); + self.deregister_with_lock(&mut *registration_lock, poll) + } +} + +fn ioevent_to_epoll(interest: Ready, opts: PollOpt) -> u32 { + use event_imp::ready_from_usize; + const HUP: usize = 0b01000; + + let mut kind = 0; + + if interest.is_readable() { + kind |= libc::EPOLLIN; + } + + if interest.is_writable() { + kind |= libc::EPOLLOUT; + } + + if interest.contains(ready_from_usize(HUP)) { + kind |= libc::EPOLLRDHUP; + } + + if opts.is_edge() { + kind |= libc::EPOLLET; + } + + if opts.is_oneshot() { + kind |= libc::EPOLLONESHOT; + } + + if opts.is_level() { + kind &= !libc::EPOLLET; + } + + kind as u32 +} diff --git a/third_party/rust/mio-0.6.23/src/sys/fuchsia/handles.rs b/third_party/rust/mio-0.6.23/src/sys/fuchsia/handles.rs new file mode 100644 index 0000000000..ae6f07f6d9 --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/sys/fuchsia/handles.rs @@ -0,0 +1,78 @@ +use {io, poll, Evented, Ready, Poll, PollOpt, Token}; +use zircon_sys::zx_handle_t; +use std::sync::Mutex; + +/// Wrapper for registering a `HandleBase` type with mio. +#[derive(Debug)] +pub struct EventedHandle { + /// The handle to be registered. + handle: zx_handle_t, + + /// The current `Token` with which the handle is registered with mio. + token: Mutex<Option<Token>>, +} + +impl EventedHandle { + /// Create a new `EventedHandle` which can be registered with mio + /// in order to receive event notifications. + /// + /// The underlying handle must not be dropped while the + /// `EventedHandle` still exists. + pub unsafe fn new(handle: zx_handle_t) -> Self { + EventedHandle { + handle: handle, + token: Mutex::new(None), + } + } + + /// Get the underlying handle being registered. + pub fn get_handle(&self) -> zx_handle_t { + self.handle + } +} + +impl Evented for EventedHandle { + fn register(&self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt) -> io::Result<()> + { + let mut this_token = self.token.lock().unwrap(); + { + poll::selector(poll).register_handle(self.handle, token, interest, opts)?; + *this_token = Some(token); + } + Ok(()) + } + + fn reregister(&self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt) -> io::Result<()> + { + let mut this_token = self.token.lock().unwrap(); + { + poll::selector(poll).deregister_handle(self.handle, token)?; + *this_token = None; + poll::selector(poll).register_handle(self.handle, token, interest, opts)?; + *this_token = Some(token); + } + Ok(()) + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + let mut this_token = self.token.lock().unwrap(); + let token = if let Some(token) = *this_token { token } else { + return Err(io::Error::new( + io::ErrorKind::NotFound, + "Attempted to deregister an unregistered handle.")) + }; + { + poll::selector(poll).deregister_handle(self.handle, token)?; + *this_token = None; + } + Ok(()) + } +} diff --git a/third_party/rust/mio-0.6.23/src/sys/fuchsia/mod.rs b/third_party/rust/mio-0.6.23/src/sys/fuchsia/mod.rs new file mode 100644 index 0000000000..10728fc8dc --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/sys/fuchsia/mod.rs @@ -0,0 +1,177 @@ +use {io, Ready, PollOpt}; +use libc; +use zircon; +use std::mem; +use std::net::{IpAddr, Ipv4Addr, SocketAddr}; +use std::ops::{Deref, DerefMut}; +use std::os::unix::io::RawFd; + +mod awakener; +mod handles; +mod eventedfd; +mod net; +mod ready; +mod selector; + +use self::eventedfd::{EventedFd, EventedFdInner}; +use self::ready::assert_fuchsia_ready_repr; + +pub use self::awakener::Awakener; +pub use self::handles::EventedHandle; +pub use self::net::{TcpListener, TcpStream, UdpSocket}; +pub use self::selector::{Events, Selector}; +pub use self::ready::{FuchsiaReady, zx_signals_t}; + +// Set non-blocking (workaround since the std version doesn't work in fuchsia) +// TODO: fix the std version and replace this +pub fn set_nonblock(fd: RawFd) -> io::Result<()> { + cvt(unsafe { libc::fcntl(fd, libc::F_SETFL, libc::O_NONBLOCK) }).map(|_| ()) +} + +/// Workaround until fuchsia's recv_from is fixed +unsafe fn recv_from(fd: RawFd, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> { + let flags = 0; + + let n = cvt( + libc::recv(fd, + buf.as_mut_ptr() as *mut libc::c_void, + buf.len(), + flags) + )?; + + // random address-- we don't use it + let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080); + Ok((n as usize, addr)) +} + +mod sys { + #![allow(non_camel_case_types)] + use std::os::unix::io::RawFd; + pub use zircon_sys::{zx_handle_t, zx_signals_t}; + + // 17 fn pointers we don't need for mio :) + pub type fdio_ops_t = [usize; 17]; + + pub type atomic_int_fast32_t = usize; // TODO: https://github.com/rust-lang/libc/issues/631 + + #[repr(C)] + pub struct fdio_t { + pub ops: *const fdio_ops_t, + pub magic: u32, + pub refcount: atomic_int_fast32_t, + pub dupcount: u32, + pub flags: u32, + } + + #[link(name="fdio")] + extern { + pub fn __fdio_fd_to_io(fd: RawFd) -> *const fdio_t; + pub fn __fdio_release(io: *const fdio_t); + + pub fn __fdio_wait_begin( + io: *const fdio_t, + events: u32, + handle_out: &mut zx_handle_t, + signals_out: &mut zx_signals_t, + ); + pub fn __fdio_wait_end( + io: *const fdio_t, + signals: zx_signals_t, + events_out: &mut u32, + ); + } +} + +fn epoll_event_to_ready(epoll: u32) -> Ready { + let epoll = epoll as i32; // casts the bits directly + let mut kind = Ready::empty(); + + if (epoll & libc::EPOLLIN) != 0 || (epoll & libc::EPOLLPRI) != 0 { + kind = kind | Ready::readable(); + } + + if (epoll & libc::EPOLLOUT) != 0 { + kind = kind | Ready::writable(); + } + + kind + + /* TODO: support? + // EPOLLHUP - Usually means a socket error happened + if (epoll & libc::EPOLLERR) != 0 { + kind = kind | UnixReady::error(); + } + + if (epoll & libc::EPOLLRDHUP) != 0 || (epoll & libc::EPOLLHUP) != 0 { + kind = kind | UnixReady::hup(); + } + */ +} + +fn poll_opts_to_wait_async(poll_opts: PollOpt) -> zircon::WaitAsyncOpts { + if poll_opts.is_oneshot() { + zircon::WaitAsyncOpts::Once + } else { + zircon::WaitAsyncOpts::Repeating + } +} + +trait IsMinusOne { + fn is_minus_one(&self) -> bool; +} + +impl IsMinusOne for i32 { + fn is_minus_one(&self) -> bool { *self == -1 } +} + +impl IsMinusOne for isize { + fn is_minus_one(&self) -> bool { *self == -1 } +} + +fn cvt<T: IsMinusOne>(t: T) -> ::io::Result<T> { + use std::io; + + if t.is_minus_one() { + Err(io::Error::last_os_error()) + } else { + Ok(t) + } +} + +/// Utility type to prevent the type inside of it from being dropped. +#[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] +struct DontDrop<T>(Option<T>); + +impl<T> DontDrop<T> { + fn new(t: T) -> DontDrop<T> { + DontDrop(Some(t)) + } + + fn inner_ref(&self) -> &T { + self.0.as_ref().unwrap() + } + + fn inner_mut(&mut self) -> &mut T { + self.0.as_mut().unwrap() + } +} + +impl<T> Deref for DontDrop<T> { + type Target = T; + fn deref(&self) -> &Self::Target { + self.inner_ref() + } +} + +impl<T> DerefMut for DontDrop<T> { + fn deref_mut(&mut self) -> &mut Self::Target { + self.inner_mut() + } +} + +impl<T> Drop for DontDrop<T> { + fn drop(&mut self) { + let inner = self.0.take(); + mem::forget(inner); + } +} diff --git a/third_party/rust/mio-0.6.23/src/sys/fuchsia/net.rs b/third_party/rust/mio-0.6.23/src/sys/fuchsia/net.rs new file mode 100644 index 0000000000..d43ad27bb5 --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/sys/fuchsia/net.rs @@ -0,0 +1,444 @@ +use {io, Evented, Ready, Poll, PollOpt, Token}; +use iovec::IoVec; +use iovec::unix as iovec; +use libc; +use net2::TcpStreamExt; +#[allow(unused_imports)] // only here for Rust 1.8 +use net2::UdpSocketExt; +use sys::fuchsia::{recv_from, set_nonblock, EventedFd, DontDrop}; +use std::cmp; +use std::io::{Read, Write}; +use std::net::{self, Ipv4Addr, Ipv6Addr, SocketAddr}; +use std::os::unix::io::AsRawFd; +use std::time::Duration; + +#[derive(Debug)] +pub struct TcpStream { + io: DontDrop<net::TcpStream>, + evented_fd: EventedFd, +} + +impl TcpStream { + pub fn connect(stream: net::TcpStream, addr: &SocketAddr) -> io::Result<TcpStream> { + try!(set_nonblock(stream.as_raw_fd())); + + let connected = stream.connect(addr); + match connected { + Ok(..) => {} + Err(ref e) if e.raw_os_error() == Some(libc::EINPROGRESS) => {} + Err(e) => return Err(e), + } + + let evented_fd = unsafe { EventedFd::new(stream.as_raw_fd()) }; + + return Ok(TcpStream { + io: DontDrop::new(stream), + evented_fd: evented_fd, + }) + } + + pub fn from_stream(stream: net::TcpStream) -> TcpStream { + let evented_fd = unsafe { EventedFd::new(stream.as_raw_fd()) }; + + TcpStream { + io: DontDrop::new(stream), + evented_fd: evented_fd, + } + } + + pub fn peer_addr(&self) -> io::Result<SocketAddr> { + self.io.peer_addr() + } + + pub fn local_addr(&self) -> io::Result<SocketAddr> { + self.io.local_addr() + } + + pub fn try_clone(&self) -> io::Result<TcpStream> { + self.io.try_clone().map(|s| { + let evented_fd = unsafe { EventedFd::new(s.as_raw_fd()) }; + TcpStream { + io: DontDrop::new(s), + evented_fd: evented_fd, + } + }) + } + + pub fn shutdown(&self, how: net::Shutdown) -> io::Result<()> { + self.io.shutdown(how) + } + + pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> { + self.io.set_nodelay(nodelay) + } + + pub fn nodelay(&self) -> io::Result<bool> { + self.io.nodelay() + } + + pub fn set_recv_buffer_size(&self, size: usize) -> io::Result<()> { + self.io.set_recv_buffer_size(size) + } + + pub fn recv_buffer_size(&self) -> io::Result<usize> { + self.io.recv_buffer_size() + } + + pub fn set_send_buffer_size(&self, size: usize) -> io::Result<()> { + self.io.set_send_buffer_size(size) + } + + pub fn send_buffer_size(&self) -> io::Result<usize> { + self.io.send_buffer_size() + } + + pub fn set_keepalive(&self, keepalive: Option<Duration>) -> io::Result<()> { + self.io.set_keepalive(keepalive) + } + + pub fn keepalive(&self) -> io::Result<Option<Duration>> { + self.io.keepalive() + } + + pub fn set_ttl(&self, ttl: u32) -> io::Result<()> { + self.io.set_ttl(ttl) + } + + pub fn ttl(&self) -> io::Result<u32> { + self.io.ttl() + } + + pub fn set_only_v6(&self, only_v6: bool) -> io::Result<()> { + self.io.set_only_v6(only_v6) + } + + pub fn only_v6(&self) -> io::Result<bool> { + self.io.only_v6() + } + + pub fn set_linger(&self, dur: Option<Duration>) -> io::Result<()> { + self.io.set_linger(dur) + } + + pub fn linger(&self) -> io::Result<Option<Duration>> { + self.io.linger() + } + + pub fn take_error(&self) -> io::Result<Option<io::Error>> { + self.io.take_error() + } + + pub fn peek(&self, buf: &mut [u8]) -> io::Result<usize> { + self.io.peek(buf) + } + + pub fn readv(&self, bufs: &mut [&mut IoVec]) -> io::Result<usize> { + unsafe { + let slice = iovec::as_os_slice_mut(bufs); + let len = cmp::min(<libc::c_int>::max_value() as usize, slice.len()); + let rc = libc::readv(self.io.as_raw_fd(), + slice.as_ptr(), + len as libc::c_int); + if rc < 0 { + Err(io::Error::last_os_error()) + } else { + Ok(rc as usize) + } + } + } + + pub fn writev(&self, bufs: &[&IoVec]) -> io::Result<usize> { + unsafe { + let slice = iovec::as_os_slice(bufs); + let len = cmp::min(<libc::c_int>::max_value() as usize, slice.len()); + let rc = libc::writev(self.io.as_raw_fd(), + slice.as_ptr(), + len as libc::c_int); + if rc < 0 { + Err(io::Error::last_os_error()) + } else { + Ok(rc as usize) + } + } + } +} + +impl<'a> Read for &'a TcpStream { + fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { + self.io.inner_ref().read(buf) + } +} + +impl<'a> Write for &'a TcpStream { + fn write(&mut self, buf: &[u8]) -> io::Result<usize> { + self.io.inner_ref().write(buf) + } + fn flush(&mut self) -> io::Result<()> { + self.io.inner_ref().flush() + } +} + +impl Evented for TcpStream { + fn register(&self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt) -> io::Result<()> + { + self.evented_fd.register(poll, token, interest, opts) + } + + fn reregister(&self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt) -> io::Result<()> + { + self.evented_fd.reregister(poll, token, interest, opts) + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + self.evented_fd.deregister(poll) + } +} + +#[derive(Debug)] +pub struct TcpListener { + io: DontDrop<net::TcpListener>, + evented_fd: EventedFd, +} + +impl TcpListener { + pub fn new(inner: net::TcpListener) -> io::Result<TcpListener> { + set_nonblock(inner.as_raw_fd())?; + + let evented_fd = unsafe { EventedFd::new(inner.as_raw_fd()) }; + + Ok(TcpListener { + io: DontDrop::new(inner), + evented_fd: evented_fd, + }) + } + + pub fn local_addr(&self) -> io::Result<SocketAddr> { + self.io.local_addr() + } + + pub fn try_clone(&self) -> io::Result<TcpListener> { + self.io.try_clone().map(|io| { + let evented_fd = unsafe { EventedFd::new(io.as_raw_fd()) }; + TcpListener { + io: DontDrop::new(io), + evented_fd: evented_fd, + } + }) + } + + pub fn accept(&self) -> io::Result<(TcpStream, SocketAddr)> { + self.io.accept().and_then(|(s, a)| { + set_nonblock(s.as_raw_fd())?; + let evented_fd = unsafe { EventedFd::new(s.as_raw_fd()) }; + return Ok((TcpStream { + io: DontDrop::new(s), + evented_fd: evented_fd, + }, a)) + }) + } + + #[allow(deprecated)] + pub fn set_only_v6(&self, only_v6: bool) -> io::Result<()> { + self.io.set_only_v6(only_v6) + } + + #[allow(deprecated)] + pub fn only_v6(&self) -> io::Result<bool> { + self.io.only_v6() + } + + pub fn set_ttl(&self, ttl: u32) -> io::Result<()> { + self.io.set_ttl(ttl) + } + + pub fn ttl(&self) -> io::Result<u32> { + self.io.ttl() + } + + pub fn take_error(&self) -> io::Result<Option<io::Error>> { + self.io.take_error() + } +} + +impl Evented for TcpListener { + fn register(&self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt) -> io::Result<()> + { + self.evented_fd.register(poll, token, interest, opts) + } + + fn reregister(&self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt) -> io::Result<()> + { + self.evented_fd.reregister(poll, token, interest, opts) + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + self.evented_fd.deregister(poll) + } +} + +#[derive(Debug)] +pub struct UdpSocket { + io: DontDrop<net::UdpSocket>, + evented_fd: EventedFd, +} + +impl UdpSocket { + pub fn new(socket: net::UdpSocket) -> io::Result<UdpSocket> { + set_nonblock(socket.as_raw_fd())?; + + let evented_fd = unsafe { EventedFd::new(socket.as_raw_fd()) }; + + Ok(UdpSocket { + io: DontDrop::new(socket), + evented_fd: evented_fd, + }) + } + + pub fn local_addr(&self) -> io::Result<SocketAddr> { + self.io.local_addr() + } + + pub fn try_clone(&self) -> io::Result<UdpSocket> { + self.io.try_clone().and_then(|io| { + UdpSocket::new(io) + }) + } + + pub fn send_to(&self, buf: &[u8], target: &SocketAddr) -> io::Result<usize> { + self.io.send_to(buf, target) + } + + pub fn recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> { + unsafe { recv_from(self.io.as_raw_fd(), buf) } + } + + pub fn send(&self, buf: &[u8]) -> io::Result<usize> { + self.io.send(buf) + } + + pub fn recv(&self, buf: &mut [u8]) -> io::Result<usize> { + self.io.recv(buf) + } + + pub fn connect(&self, addr: SocketAddr) + -> io::Result<()> { + self.io.connect(addr) + } + + pub fn broadcast(&self) -> io::Result<bool> { + self.io.broadcast() + } + + pub fn set_broadcast(&self, on: bool) -> io::Result<()> { + self.io.set_broadcast(on) + } + + pub fn multicast_loop_v4(&self) -> io::Result<bool> { + self.io.multicast_loop_v4() + } + + pub fn set_multicast_loop_v4(&self, on: bool) -> io::Result<()> { + self.io.set_multicast_loop_v4(on) + } + + pub fn multicast_ttl_v4(&self) -> io::Result<u32> { + self.io.multicast_ttl_v4() + } + + pub fn set_multicast_ttl_v4(&self, ttl: u32) -> io::Result<()> { + self.io.set_multicast_ttl_v4(ttl) + } + + pub fn multicast_loop_v6(&self) -> io::Result<bool> { + self.io.multicast_loop_v6() + } + + pub fn set_multicast_loop_v6(&self, on: bool) -> io::Result<()> { + self.io.set_multicast_loop_v6(on) + } + + pub fn ttl(&self) -> io::Result<u32> { + self.io.ttl() + } + + pub fn set_ttl(&self, ttl: u32) -> io::Result<()> { + self.io.set_ttl(ttl) + } + + pub fn join_multicast_v4(&self, + multiaddr: &Ipv4Addr, + interface: &Ipv4Addr) -> io::Result<()> { + self.io.join_multicast_v4(multiaddr, interface) + } + + pub fn join_multicast_v6(&self, + multiaddr: &Ipv6Addr, + interface: u32) -> io::Result<()> { + self.io.join_multicast_v6(multiaddr, interface) + } + + pub fn leave_multicast_v4(&self, + multiaddr: &Ipv4Addr, + interface: &Ipv4Addr) -> io::Result<()> { + self.io.leave_multicast_v4(multiaddr, interface) + } + + pub fn leave_multicast_v6(&self, + multiaddr: &Ipv6Addr, + interface: u32) -> io::Result<()> { + self.io.leave_multicast_v6(multiaddr, interface) + } + + pub fn set_only_v6(&self, only_v6: bool) -> io::Result<()> { + self.io.set_only_v6(only_v6) + } + + pub fn only_v6(&self) -> io::Result<bool> { + self.io.only_v6() + } + + + pub fn take_error(&self) -> io::Result<Option<io::Error>> { + self.io.take_error() + } +} + +impl Evented for UdpSocket { + fn register(&self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt) -> io::Result<()> + { + self.evented_fd.register(poll, token, interest, opts) + } + + fn reregister(&self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt) -> io::Result<()> + { + self.evented_fd.reregister(poll, token, interest, opts) + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + self.evented_fd.deregister(poll) + } +} diff --git a/third_party/rust/mio-0.6.23/src/sys/fuchsia/ready.rs b/third_party/rust/mio-0.6.23/src/sys/fuchsia/ready.rs new file mode 100644 index 0000000000..97854f8c07 --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/sys/fuchsia/ready.rs @@ -0,0 +1,181 @@ +use event_imp::{Ready, ready_as_usize, ready_from_usize}; +pub use zircon_sys::{ + zx_signals_t, + ZX_OBJECT_READABLE, + ZX_OBJECT_WRITABLE, +}; +use std::ops; + +// The following impls are valid because Fuchsia and mio both represent +// "readable" as `1 << 0` and "writable" as `1 << 2`. +// We define this assertion here and call it from `Selector::new`, +// since `Selector:;new` is guaranteed to be called during a standard mio runtime, +// unlike the functions in this file. +#[inline] +pub fn assert_fuchsia_ready_repr() { + debug_assert!( + ZX_OBJECT_READABLE.bits() as usize == ready_as_usize(Ready::readable()), + "Zircon ZX_OBJECT_READABLE should have the same repr as Ready::readable()" + ); + debug_assert!( + ZX_OBJECT_WRITABLE.bits() as usize == ready_as_usize(Ready::writable()), + "Zircon ZX_OBJECT_WRITABLE should have the same repr as Ready::writable()" + ); +} + +/// Fuchsia specific extensions to `Ready` +/// +/// Provides additional readiness event kinds that are available on Fuchsia. +/// +/// Conversion traits are implemented between `Ready` and `FuchsiaReady`. +/// +/// For high level documentation on polling and readiness, see [`Poll`]. +/// +/// [`Poll`]: struct.Poll.html +#[derive(Debug, Copy, PartialEq, Eq, Clone, PartialOrd, Ord)] +pub struct FuchsiaReady(Ready); + +impl FuchsiaReady { + /// Returns the `FuchsiaReady` as raw zircon signals. + /// This function is just a more explicit, non-generic version of + /// `FuchsiaReady::into`. + #[inline] + pub fn into_zx_signals(self) -> zx_signals_t { + zx_signals_t::from_bits_truncate(ready_as_usize(self.0) as u32) + } +} + +impl Into<zx_signals_t> for FuchsiaReady { + #[inline] + fn into(self) -> zx_signals_t { + self.into_zx_signals() + } +} + +impl From<zx_signals_t> for FuchsiaReady { + #[inline] + fn from(src: zx_signals_t) -> Self { + FuchsiaReady(src.into()) + } +} + +impl From<zx_signals_t> for Ready { + #[inline] + fn from(src: zx_signals_t) -> Self { + ready_from_usize(src.bits() as usize) + } +} + +impl From<Ready> for FuchsiaReady { + #[inline] + fn from(src: Ready) -> FuchsiaReady { + FuchsiaReady(src) + } +} + +impl From<FuchsiaReady> for Ready { + #[inline] + fn from(src: FuchsiaReady) -> Ready { + src.0 + } +} + +impl ops::Deref for FuchsiaReady { + type Target = Ready; + + #[inline] + fn deref(&self) -> &Ready { + &self.0 + } +} + +impl ops::DerefMut for FuchsiaReady { + #[inline] + fn deref_mut(&mut self) -> &mut Ready { + &mut self.0 + } +} + +impl ops::BitOr for FuchsiaReady { + type Output = FuchsiaReady; + + #[inline] + fn bitor(self, other: FuchsiaReady) -> FuchsiaReady { + (self.0 | other.0).into() + } +} + +impl ops::BitXor for FuchsiaReady { + type Output = FuchsiaReady; + + #[inline] + fn bitxor(self, other: FuchsiaReady) -> FuchsiaReady { + (self.0 ^ other.0).into() + } +} + +impl ops::BitAnd for FuchsiaReady { + type Output = FuchsiaReady; + + #[inline] + fn bitand(self, other: FuchsiaReady) -> FuchsiaReady { + (self.0 & other.0).into() + } +} + +impl ops::Sub for FuchsiaReady { + type Output = FuchsiaReady; + + #[inline] + fn sub(self, other: FuchsiaReady) -> FuchsiaReady { + (self.0 & !other.0).into() + } +} + +#[deprecated(since = "0.6.10", note = "removed")] +#[cfg(feature = "with-deprecated")] +#[doc(hidden)] +impl ops::Not for FuchsiaReady { + type Output = FuchsiaReady; + + #[inline] + fn not(self) -> FuchsiaReady { + (!self.0).into() + } +} + +impl ops::BitOr<zx_signals_t> for FuchsiaReady { + type Output = FuchsiaReady; + + #[inline] + fn bitor(self, other: zx_signals_t) -> FuchsiaReady { + self | FuchsiaReady::from(other) + } +} + +impl ops::BitXor<zx_signals_t> for FuchsiaReady { + type Output = FuchsiaReady; + + #[inline] + fn bitxor(self, other: zx_signals_t) -> FuchsiaReady { + self ^ FuchsiaReady::from(other) + } +} + +impl ops::BitAnd<zx_signals_t> for FuchsiaReady { + type Output = FuchsiaReady; + + #[inline] + fn bitand(self, other: zx_signals_t) -> FuchsiaReady { + self & FuchsiaReady::from(other) + } +} + +impl ops::Sub<zx_signals_t> for FuchsiaReady { + type Output = FuchsiaReady; + + #[inline] + fn sub(self, other: zx_signals_t) -> FuchsiaReady { + self - FuchsiaReady::from(other) + } +} diff --git a/third_party/rust/mio-0.6.23/src/sys/fuchsia/selector.rs b/third_party/rust/mio-0.6.23/src/sys/fuchsia/selector.rs new file mode 100644 index 0000000000..27226ac5ff --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/sys/fuchsia/selector.rs @@ -0,0 +1,353 @@ +use {io, Event, PollOpt, Ready, Token}; +use sys::fuchsia::{ + assert_fuchsia_ready_repr, + epoll_event_to_ready, + poll_opts_to_wait_async, + EventedFd, + EventedFdInner, + FuchsiaReady, +}; +use zircon; +use zircon::AsHandleRef; +use zircon_sys::zx_handle_t; +use std::collections::hash_map; +use std::fmt; +use std::mem; +use std::sync::atomic::{AtomicBool, AtomicUsize, ATOMIC_USIZE_INIT, Ordering}; +use std::sync::{Arc, Mutex, Weak}; +use std::time::Duration; +use sys; + +/// The kind of registration-- file descriptor or handle. +/// +/// The last bit of a token is set to indicate the type of the registration. +#[derive(Copy, Clone, Eq, PartialEq)] +enum RegType { + Fd, + Handle, +} + +fn key_from_token_and_type(token: Token, reg_type: RegType) -> io::Result<u64> { + let key = token.0 as u64; + let msb = 1u64 << 63; + if (key & msb) != 0 { + return Err(io::Error::new( + io::ErrorKind::InvalidInput, + "Most-significant bit of token must remain unset.")); + } + + Ok(match reg_type { + RegType::Fd => key, + RegType::Handle => key | msb, + }) +} + +fn token_and_type_from_key(key: u64) -> (Token, RegType) { + let msb = 1u64 << 63; + ( + Token((key & !msb) as usize), + if (key & msb) == 0 { + RegType::Fd + } else { + RegType::Handle + } + ) +} + +/// Each Selector has a globally unique(ish) ID associated with it. This ID +/// gets tracked by `TcpStream`, `TcpListener`, etc... when they are first +/// registered with the `Selector`. If a type that is previously associated with +/// a `Selector` attempts to register itself with a different `Selector`, the +/// operation will return with an error. This matches windows behavior. +static NEXT_ID: AtomicUsize = ATOMIC_USIZE_INIT; + +pub struct Selector { + id: usize, + + /// Zircon object on which the handles have been registered, and on which events occur + port: Arc<zircon::Port>, + + /// Whether or not `tokens_to_rereg` contains any elements. This is a best-effort attempt + /// used to prevent having to lock `tokens_to_rereg` when it is empty. + has_tokens_to_rereg: AtomicBool, + + /// List of `Token`s corresponding to registrations that need to be reregistered before the + /// next `port::wait`. This is necessary to provide level-triggered behavior for + /// `Async::repeating` registrations. + /// + /// When a level-triggered `Async::repeating` event is seen, its token is added to this list so + /// that it will be reregistered before the next `port::wait` call, making `port::wait` return + /// immediately if the signal was high during the reregistration. + /// + /// Note: when used at the same time, the `tokens_to_rereg` lock should be taken out _before_ + /// `token_to_fd`. + tokens_to_rereg: Mutex<Vec<Token>>, + + /// Map from tokens to weak references to `EventedFdInner`-- a structure describing a + /// file handle, its associated `fdio` object, and its current registration. + token_to_fd: Mutex<hash_map::HashMap<Token, Weak<EventedFdInner>>>, +} + +impl Selector { + pub fn new() -> io::Result<Selector> { + // Assertion from fuchsia/ready.rs to make sure that FuchsiaReady's representation is + // compatible with Ready. + assert_fuchsia_ready_repr(); + + let port = Arc::new( + zircon::Port::create(zircon::PortOpts::Default)? + ); + + // offset by 1 to avoid choosing 0 as the id of a selector + let id = NEXT_ID.fetch_add(1, Ordering::Relaxed) + 1; + + let has_tokens_to_rereg = AtomicBool::new(false); + let tokens_to_rereg = Mutex::new(Vec::new()); + let token_to_fd = Mutex::new(hash_map::HashMap::new()); + + Ok(Selector { + id: id, + port: port, + has_tokens_to_rereg: has_tokens_to_rereg, + tokens_to_rereg: tokens_to_rereg, + token_to_fd: token_to_fd, + }) + } + + pub fn id(&self) -> usize { + self.id + } + + /// Returns a reference to the underlying port `Arc`. + pub fn port(&self) -> &Arc<zircon::Port> { &self.port } + + /// Reregisters all registrations pointed to by the `tokens_to_rereg` list + /// if `has_tokens_to_rereg`. + fn reregister_handles(&self) -> io::Result<()> { + // We use `Ordering::Acquire` to make sure that we see all `tokens_to_rereg` + // written before the store using `Ordering::Release`. + if self.has_tokens_to_rereg.load(Ordering::Acquire) { + let mut tokens = self.tokens_to_rereg.lock().unwrap(); + let token_to_fd = self.token_to_fd.lock().unwrap(); + for token in tokens.drain(0..) { + if let Some(eventedfd) = token_to_fd.get(&token) + .and_then(|h| h.upgrade()) { + eventedfd.rereg_for_level(&self.port); + } + } + self.has_tokens_to_rereg.store(false, Ordering::Release); + } + Ok(()) + } + + pub fn select(&self, + evts: &mut Events, + _awakener: Token, + timeout: Option<Duration>) -> io::Result<bool> + { + evts.clear(); + + self.reregister_handles()?; + + let deadline = match timeout { + Some(duration) => { + let nanos = duration.as_secs().saturating_mul(1_000_000_000) + .saturating_add(duration.subsec_nanos() as u64); + + zircon::deadline_after(nanos) + } + None => zircon::ZX_TIME_INFINITE, + }; + + let packet = match self.port.wait(deadline) { + Ok(packet) => packet, + Err(zircon::Status::ErrTimedOut) => return Ok(false), + Err(e) => Err(e)?, + }; + + let observed_signals = match packet.contents() { + zircon::PacketContents::SignalOne(signal_packet) => { + signal_packet.observed() + } + zircon::PacketContents::SignalRep(signal_packet) => { + signal_packet.observed() + } + zircon::PacketContents::User(_user_packet) => { + // User packets are only ever sent by an Awakener + return Ok(true); + } + }; + + let key = packet.key(); + let (token, reg_type) = token_and_type_from_key(key); + + match reg_type { + RegType::Handle => { + // We can return immediately-- no lookup or registration necessary. + evts.events.push(Event::new(Ready::from(observed_signals), token)); + Ok(false) + }, + RegType::Fd => { + // Convert the signals to epoll events using __fdio_wait_end, + // and add to reregistration list if necessary. + let events: u32; + { + let handle = if let Some(handle) = + self.token_to_fd.lock().unwrap() + .get(&token) + .and_then(|h| h.upgrade()) { + handle + } else { + // This handle is apparently in the process of removal. + // It has been removed from the list, but port_cancel has not been called. + return Ok(false); + }; + + events = unsafe { + let mut events: u32 = mem::uninitialized(); + sys::fuchsia::sys::__fdio_wait_end(handle.fdio(), observed_signals, &mut events); + events + }; + + // If necessary, queue to be reregistered before next port_await + let needs_to_rereg = { + let registration_lock = handle.registration().lock().unwrap(); + + registration_lock + .as_ref() + .and_then(|r| r.rereg_signals()) + .is_some() + }; + + if needs_to_rereg { + let mut tokens_to_rereg_lock = self.tokens_to_rereg.lock().unwrap(); + tokens_to_rereg_lock.push(token); + // We use `Ordering::Release` to make sure that we see all `tokens_to_rereg` + // written before the store. + self.has_tokens_to_rereg.store(true, Ordering::Release); + } + } + + evts.events.push(Event::new(epoll_event_to_ready(events), token)); + Ok(false) + }, + } + } + + /// Register event interests for the given IO handle with the OS + pub fn register_fd(&self, + handle: &zircon::Handle, + fd: &EventedFd, + token: Token, + signals: zircon::Signals, + poll_opts: PollOpt) -> io::Result<()> + { + { + let mut token_to_fd = self.token_to_fd.lock().unwrap(); + match token_to_fd.entry(token) { + hash_map::Entry::Occupied(_) => + return Err(io::Error::new(io::ErrorKind::AlreadyExists, + "Attempted to register a filedescriptor on an existing token.")), + hash_map::Entry::Vacant(slot) => slot.insert(Arc::downgrade(&fd.inner)), + }; + } + + let wait_async_opts = poll_opts_to_wait_async(poll_opts); + + let wait_res = handle.wait_async_handle(&self.port, token.0 as u64, signals, wait_async_opts); + + if wait_res.is_err() { + self.token_to_fd.lock().unwrap().remove(&token); + } + + Ok(wait_res?) + } + + /// Deregister event interests for the given IO handle with the OS + pub fn deregister_fd(&self, handle: &zircon::Handle, token: Token) -> io::Result<()> { + self.token_to_fd.lock().unwrap().remove(&token); + + // We ignore NotFound errors since oneshots are automatically deregistered, + // but mio will attempt to deregister them manually. + self.port.cancel(&*handle, token.0 as u64) + .map_err(io::Error::from) + .or_else(|e| if e.kind() == io::ErrorKind::NotFound { + Ok(()) + } else { + Err(e) + }) + } + + pub fn register_handle(&self, + handle: zx_handle_t, + token: Token, + interests: Ready, + poll_opts: PollOpt) -> io::Result<()> + { + if poll_opts.is_level() && !poll_opts.is_oneshot() { + return Err(io::Error::new(io::ErrorKind::InvalidInput, + "Repeated level-triggered events are not supported on Fuchsia handles.")); + } + + let temp_handle = unsafe { zircon::Handle::from_raw(handle) }; + + let res = temp_handle.wait_async_handle( + &self.port, + key_from_token_and_type(token, RegType::Handle)?, + FuchsiaReady::from(interests).into_zx_signals(), + poll_opts_to_wait_async(poll_opts)); + + mem::forget(temp_handle); + + Ok(res?) + } + + + pub fn deregister_handle(&self, handle: zx_handle_t, token: Token) -> io::Result<()> + { + let temp_handle = unsafe { zircon::Handle::from_raw(handle) }; + let res = self.port.cancel(&temp_handle, key_from_token_and_type(token, RegType::Handle)?); + + mem::forget(temp_handle); + + Ok(res?) + } +} + +pub struct Events { + events: Vec<Event> +} + +impl Events { + pub fn with_capacity(_u: usize) -> Events { + // The Fuchsia selector only handles one event at a time, + // so we ignore the default capacity and set it to one. + Events { events: Vec::with_capacity(1) } + } + pub fn len(&self) -> usize { + self.events.len() + } + pub fn capacity(&self) -> usize { + self.events.capacity() + } + pub fn is_empty(&self) -> bool { + self.events.is_empty() + } + pub fn get(&self, idx: usize) -> Option<Event> { + self.events.get(idx).map(|e| *e) + } + pub fn push_event(&mut self, event: Event) { + self.events.push(event) + } + pub fn clear(&mut self) { + self.events.events.drain(0..); + } +} + +impl fmt::Debug for Events { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("Events") + .field("len", &self.len()) + .finish() + } +} diff --git a/third_party/rust/mio-0.6.23/src/sys/mod.rs b/third_party/rust/mio-0.6.23/src/sys/mod.rs new file mode 100644 index 0000000000..8a1705db6c --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/sys/mod.rs @@ -0,0 +1,56 @@ +#[cfg(all(unix, not(target_os = "fuchsia")))] +pub use self::unix::{ + Awakener, + EventedFd, + Events, + Io, + Selector, + TcpStream, + TcpListener, + UdpSocket, + pipe, + set_nonblock, +}; + +#[cfg(all(unix, not(target_os = "fuchsia")))] +pub use self::unix::READY_ALL; + +#[cfg(all(unix, not(target_os = "fuchsia")))] +#[cfg(feature = "with-deprecated")] +pub use self::unix::UnixSocket; + +#[cfg(all(unix, not(target_os = "fuchsia")))] +pub mod unix; + +#[cfg(windows)] +pub use self::windows::{ + Awakener, + Events, + Selector, + TcpStream, + TcpListener, + UdpSocket, + Overlapped, + Binding, +}; + +#[cfg(windows)] +mod windows; + +#[cfg(target_os = "fuchsia")] +pub use self::fuchsia::{ + Awakener, + Events, + EventedHandle, + Selector, + TcpStream, + TcpListener, + UdpSocket, + set_nonblock, +}; + +#[cfg(target_os = "fuchsia")] +pub mod fuchsia; + +#[cfg(not(all(unix, not(target_os = "fuchsia"))))] +pub const READY_ALL: usize = 0; diff --git a/third_party/rust/mio-0.6.23/src/sys/unix/awakener.rs b/third_party/rust/mio-0.6.23/src/sys/unix/awakener.rs new file mode 100644 index 0000000000..9cc367a78c --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/sys/unix/awakener.rs @@ -0,0 +1,74 @@ +pub use self::pipe::Awakener; + +/// Default awakener backed by a pipe +mod pipe { + use sys::unix; + use {io, Ready, Poll, PollOpt, Token}; + use event::Evented; + use std::io::{Read, Write}; + + /* + * + * ===== Awakener ===== + * + */ + + pub struct Awakener { + reader: unix::Io, + writer: unix::Io, + } + + impl Awakener { + pub fn new() -> io::Result<Awakener> { + let (rd, wr) = unix::pipe()?; + + Ok(Awakener { + reader: rd, + writer: wr, + }) + } + + pub fn wakeup(&self) -> io::Result<()> { + match (&self.writer).write(&[1]) { + Ok(_) => Ok(()), + Err(e) => { + if e.kind() == io::ErrorKind::WouldBlock { + Ok(()) + } else { + Err(e) + } + } + } + } + + pub fn cleanup(&self) { + let mut buf = [0; 128]; + + loop { + // Consume data until all bytes are purged + match (&self.reader).read(&mut buf) { + Ok(i) if i > 0 => {}, + _ => return, + } + } + } + + fn reader(&self) -> &unix::Io { + &self.reader + } + } + + impl Evented for Awakener { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + self.reader().register(poll, token, interest, opts) + } + + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + self.reader().reregister(poll, token, interest, opts) + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + self.reader().deregister(poll) + } + } +} diff --git a/third_party/rust/mio-0.6.23/src/sys/unix/dlsym.rs b/third_party/rust/mio-0.6.23/src/sys/unix/dlsym.rs new file mode 100644 index 0000000000..e88c595fc9 --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/sys/unix/dlsym.rs @@ -0,0 +1,47 @@ +use std::marker; +use std::mem; +use std::sync::atomic::{AtomicUsize, Ordering}; + +use libc; + +macro_rules! dlsym { + (fn $name:ident($($t:ty),*) -> $ret:ty) => ( + #[allow(bad_style)] + static $name: ::sys::unix::dlsym::DlSym<unsafe extern fn($($t),*) -> $ret> = + ::sys::unix::dlsym::DlSym { + name: concat!(stringify!($name), "\0"), + addr: ::std::sync::atomic::ATOMIC_USIZE_INIT, + _marker: ::std::marker::PhantomData, + }; + ) +} + +pub struct DlSym<F> { + pub name: &'static str, + pub addr: AtomicUsize, + pub _marker: marker::PhantomData<F>, +} + +impl<F> DlSym<F> { + pub fn get(&self) -> Option<&F> { + assert_eq!(mem::size_of::<F>(), mem::size_of::<usize>()); + unsafe { + if self.addr.load(Ordering::SeqCst) == 0 { + self.addr.store(fetch(self.name), Ordering::SeqCst); + } + if self.addr.load(Ordering::SeqCst) == 1 { + None + } else { + mem::transmute::<&AtomicUsize, Option<&F>>(&self.addr) + } + } + } +} + +unsafe fn fetch(name: &str) -> usize { + assert_eq!(name.as_bytes()[name.len() - 1], 0); + match libc::dlsym(libc::RTLD_DEFAULT, name.as_ptr() as *const _) as usize { + 0 => 1, + n => n, + } +} diff --git a/third_party/rust/mio-0.6.23/src/sys/unix/epoll.rs b/third_party/rust/mio-0.6.23/src/sys/unix/epoll.rs new file mode 100644 index 0000000000..0da787bc95 --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/sys/unix/epoll.rs @@ -0,0 +1,268 @@ +#![allow(deprecated)] +use std::os::unix::io::AsRawFd; +use std::os::unix::io::RawFd; +use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT}; +use std::time::Duration; +use std::{cmp, i32}; + +use libc::{self, c_int}; +use libc::{EPOLLERR, EPOLLHUP, EPOLLONESHOT}; +use libc::{EPOLLET, EPOLLOUT, EPOLLIN, EPOLLPRI}; + +use {io, Ready, PollOpt, Token}; +use event_imp::Event; +use sys::unix::{cvt, UnixReady}; +use sys::unix::io::set_cloexec; + +/// Each Selector has a globally unique(ish) ID associated with it. This ID +/// gets tracked by `TcpStream`, `TcpListener`, etc... when they are first +/// registered with the `Selector`. If a type that is previously associated with +/// a `Selector` attempts to register itself with a different `Selector`, the +/// operation will return with an error. This matches windows behavior. +static NEXT_ID: AtomicUsize = ATOMIC_USIZE_INIT; + +#[derive(Debug)] +pub struct Selector { + id: usize, + epfd: RawFd, +} + +impl Selector { + pub fn new() -> io::Result<Selector> { + let epfd = unsafe { + // Emulate `epoll_create` by using `epoll_create1` if it's available + // and otherwise falling back to `epoll_create` followed by a call to + // set the CLOEXEC flag. + dlsym!(fn epoll_create1(c_int) -> c_int); + + match epoll_create1.get() { + Some(epoll_create1_fn) => { + cvt(epoll_create1_fn(libc::EPOLL_CLOEXEC))? + } + None => { + let fd = cvt(libc::epoll_create(1024))?; + drop(set_cloexec(fd)); + fd + } + } + }; + + // offset by 1 to avoid choosing 0 as the id of a selector + let id = NEXT_ID.fetch_add(1, Ordering::Relaxed) + 1; + + Ok(Selector { + id: id, + epfd: epfd, + }) + } + + pub fn id(&self) -> usize { + self.id + } + + /// Wait for events from the OS + pub fn select(&self, evts: &mut Events, awakener: Token, timeout: Option<Duration>) -> io::Result<bool> { + // A bug in kernels < 2.6.37 makes timeouts larger than LONG_MAX / CONFIG_HZ + // (approx. 30 minutes with CONFIG_HZ=1200) effectively infinite on 32 bits + // architectures. The magic number is the same constant used by libuv. + #[cfg(target_pointer_width = "32")] + const MAX_SAFE_TIMEOUT: u64 = 1789569; + #[cfg(not(target_pointer_width = "32"))] + const MAX_SAFE_TIMEOUT: u64 = c_int::max_value() as u64; + + let timeout_ms = timeout + .map(|to| cmp::min(millis(to), MAX_SAFE_TIMEOUT) as c_int) + .unwrap_or(-1); + + // Wait for epoll events for at most timeout_ms milliseconds + evts.clear(); + unsafe { + let cnt = cvt(libc::epoll_wait(self.epfd, + evts.events.as_mut_ptr(), + evts.events.capacity() as i32, + timeout_ms))?; + let cnt = cnt as usize; + evts.events.set_len(cnt); + + for i in 0..cnt { + if evts.events[i].u64 as usize == awakener.into() { + evts.events.remove(i); + return Ok(true); + } + } + } + + Ok(false) + } + + /// Register event interests for the given IO handle with the OS + pub fn register(&self, fd: RawFd, token: Token, interests: Ready, opts: PollOpt) -> io::Result<()> { + let mut info = libc::epoll_event { + events: ioevent_to_epoll(interests, opts), + u64: usize::from(token) as u64 + }; + + unsafe { + cvt(libc::epoll_ctl(self.epfd, libc::EPOLL_CTL_ADD, fd, &mut info))?; + Ok(()) + } + } + + /// Register event interests for the given IO handle with the OS + pub fn reregister(&self, fd: RawFd, token: Token, interests: Ready, opts: PollOpt) -> io::Result<()> { + let mut info = libc::epoll_event { + events: ioevent_to_epoll(interests, opts), + u64: usize::from(token) as u64 + }; + + unsafe { + cvt(libc::epoll_ctl(self.epfd, libc::EPOLL_CTL_MOD, fd, &mut info))?; + Ok(()) + } + } + + /// Deregister event interests for the given IO handle with the OS + pub fn deregister(&self, fd: RawFd) -> io::Result<()> { + // The &info argument should be ignored by the system, + // but linux < 2.6.9 required it to be not null. + // For compatibility, we provide a dummy EpollEvent. + let mut info = libc::epoll_event { + events: 0, + u64: 0, + }; + + unsafe { + cvt(libc::epoll_ctl(self.epfd, libc::EPOLL_CTL_DEL, fd, &mut info))?; + Ok(()) + } + } +} + +fn ioevent_to_epoll(interest: Ready, opts: PollOpt) -> u32 { + let mut kind = 0; + + if interest.is_readable() { + kind |= EPOLLIN; + } + + if interest.is_writable() { + kind |= EPOLLOUT; + } + + if UnixReady::from(interest).is_priority() { + kind |= EPOLLPRI; + } + + if opts.is_edge() { + kind |= EPOLLET; + } + + if opts.is_oneshot() { + kind |= EPOLLONESHOT; + } + + if opts.is_level() { + kind &= !EPOLLET; + } + + kind as u32 +} + +impl AsRawFd for Selector { + fn as_raw_fd(&self) -> RawFd { + self.epfd + } +} + +impl Drop for Selector { + fn drop(&mut self) { + unsafe { + let _ = libc::close(self.epfd); + } + } +} + +pub struct Events { + events: Vec<libc::epoll_event>, +} + +impl Events { + pub fn with_capacity(u: usize) -> Events { + Events { + events: Vec::with_capacity(u) + } + } + + #[inline] + pub fn len(&self) -> usize { + self.events.len() + } + + #[inline] + pub fn capacity(&self) -> usize { + self.events.capacity() + } + + #[inline] + pub fn is_empty(&self) -> bool { + self.events.is_empty() + } + + #[inline] + pub fn get(&self, idx: usize) -> Option<Event> { + self.events.get(idx).map(|event| { + let epoll = event.events as c_int; + let mut kind = Ready::empty(); + + if (epoll & EPOLLIN) != 0 { + kind = kind | Ready::readable(); + } + + if (epoll & EPOLLPRI) != 0 { + kind = kind | Ready::readable() | UnixReady::priority(); + } + + if (epoll & EPOLLOUT) != 0 { + kind = kind | Ready::writable(); + } + + // EPOLLHUP - Usually means a socket error happened + if (epoll & EPOLLERR) != 0 { + kind = kind | UnixReady::error(); + } + + if (epoll & EPOLLHUP) != 0 { + kind = kind | UnixReady::hup(); + } + + let token = self.events[idx].u64; + + Event::new(kind, Token(token as usize)) + }) + } + + pub fn push_event(&mut self, event: Event) { + self.events.push(libc::epoll_event { + events: ioevent_to_epoll(event.readiness(), PollOpt::empty()), + u64: usize::from(event.token()) as u64 + }); + } + + pub fn clear(&mut self) { + unsafe { self.events.set_len(0); } + } +} + +const NANOS_PER_MILLI: u32 = 1_000_000; +const MILLIS_PER_SEC: u64 = 1_000; + +/// Convert a `Duration` to milliseconds, rounding up and saturating at +/// `u64::MAX`. +/// +/// The saturating is fine because `u64::MAX` milliseconds are still many +/// million years. +pub fn millis(duration: Duration) -> u64 { + // Round up. + let millis = (duration.subsec_nanos() + NANOS_PER_MILLI - 1) / NANOS_PER_MILLI; + duration.as_secs().saturating_mul(MILLIS_PER_SEC).saturating_add(millis as u64) +} diff --git a/third_party/rust/mio-0.6.23/src/sys/unix/eventedfd.rs b/third_party/rust/mio-0.6.23/src/sys/unix/eventedfd.rs new file mode 100644 index 0000000000..72586f6652 --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/sys/unix/eventedfd.rs @@ -0,0 +1,107 @@ +use {io, poll, Ready, Poll, PollOpt, Token}; +use event::Evented; +use std::os::unix::io::RawFd; + +/* + * + * ===== EventedFd ===== + * + */ + +#[derive(Debug)] + +/// Adapter for [`RawFd`] providing an [`Evented`] implementation. +/// +/// `EventedFd` enables registering any type with an FD with [`Poll`]. +/// +/// While only implementations for TCP and UDP are provided, Mio supports +/// registering any FD that can be registered with the underlying OS selector. +/// `EventedFd` provides the necessary bridge. +/// +/// Note that `EventedFd` takes a `&RawFd`. This is because `EventedFd` **does +/// not** take ownership of the FD. Specifically, it will not manage any +/// lifecycle related operations, such as closing the FD on drop. It is expected +/// that the `EventedFd` is constructed right before a call to +/// [`Poll::register`]. See the examples for more detail. +/// +/// # Examples +/// +/// Basic usage +/// +/// ``` +/// # use std::error::Error; +/// # fn try_main() -> Result<(), Box<Error>> { +/// use mio::{Ready, Poll, PollOpt, Token}; +/// use mio::unix::EventedFd; +/// +/// use std::os::unix::io::AsRawFd; +/// use std::net::TcpListener; +/// +/// // Bind a std listener +/// let listener = TcpListener::bind("127.0.0.1:0")?; +/// +/// let poll = Poll::new()?; +/// +/// // Register the listener +/// poll.register(&EventedFd(&listener.as_raw_fd()), +/// Token(0), Ready::readable(), PollOpt::edge())?; +/// # Ok(()) +/// # } +/// # +/// # fn main() { +/// # try_main().unwrap(); +/// # } +/// ``` +/// +/// Implementing [`Evented`] for a custom type backed by a [`RawFd`]. +/// +/// ``` +/// use mio::{Ready, Poll, PollOpt, Token}; +/// use mio::event::Evented; +/// use mio::unix::EventedFd; +/// +/// use std::os::unix::io::RawFd; +/// use std::io; +/// +/// pub struct MyIo { +/// fd: RawFd, +/// } +/// +/// impl Evented for MyIo { +/// fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) +/// -> io::Result<()> +/// { +/// EventedFd(&self.fd).register(poll, token, interest, opts) +/// } +/// +/// fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) +/// -> io::Result<()> +/// { +/// EventedFd(&self.fd).reregister(poll, token, interest, opts) +/// } +/// +/// fn deregister(&self, poll: &Poll) -> io::Result<()> { +/// EventedFd(&self.fd).deregister(poll) +/// } +/// } +/// ``` +/// +/// [`RawFd`]: https://doc.rust-lang.org/std/os/unix/io/type.RawFd.html +/// [`Evented`]: ../event/trait.Evented.html +/// [`Poll`]: ../struct.Poll.html +/// [`Poll::register`]: ../struct.Poll.html#method.register +pub struct EventedFd<'a>(pub &'a RawFd); + +impl<'a> Evented for EventedFd<'a> { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + poll::selector(poll).register(*self.0, token, interest, opts) + } + + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + poll::selector(poll).reregister(*self.0, token, interest, opts) + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + poll::selector(poll).deregister(*self.0) + } +} diff --git a/third_party/rust/mio-0.6.23/src/sys/unix/io.rs b/third_party/rust/mio-0.6.23/src/sys/unix/io.rs new file mode 100644 index 0000000000..47a3a70d1f --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/sys/unix/io.rs @@ -0,0 +1,107 @@ +use std::fs::File; +use std::io::{Read, Write}; +use std::os::unix::io::{IntoRawFd, AsRawFd, FromRawFd, RawFd}; + +use libc; + +use {io, Ready, Poll, PollOpt, Token}; +use event::Evented; +use unix::EventedFd; +use sys::unix::cvt; + +pub fn set_nonblock(fd: libc::c_int) -> io::Result<()> { + unsafe { + let flags = libc::fcntl(fd, libc::F_GETFL); + cvt(libc::fcntl(fd, libc::F_SETFL, flags | libc::O_NONBLOCK)).map(|_|()) + } +} + +pub fn set_cloexec(fd: libc::c_int) -> io::Result<()> { + unsafe { + let flags = libc::fcntl(fd, libc::F_GETFD); + cvt(libc::fcntl(fd, libc::F_SETFD, flags | libc::FD_CLOEXEC)).map(|_| ()) + } +} + +/* + * + * ===== Basic IO type ===== + * + */ + +/// Manages a FD +#[derive(Debug)] +pub struct Io { + fd: File, +} + +impl Io { + /// Try to clone the FD + pub fn try_clone(&self) -> io::Result<Io> { + Ok(Io { fd: self.fd.try_clone()? }) + } +} + +impl FromRawFd for Io { + unsafe fn from_raw_fd(fd: RawFd) -> Io { + Io { fd: File::from_raw_fd(fd) } + } +} + +impl IntoRawFd for Io { + fn into_raw_fd(self) -> RawFd { + self.fd.into_raw_fd() + } +} + +impl AsRawFd for Io { + fn as_raw_fd(&self) -> RawFd { + self.fd.as_raw_fd() + } +} + +impl Evented for Io { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + EventedFd(&self.as_raw_fd()).register(poll, token, interest, opts) + } + + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + EventedFd(&self.as_raw_fd()).reregister(poll, token, interest, opts) + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + EventedFd(&self.as_raw_fd()).deregister(poll) + } +} + +impl Read for Io { + fn read(&mut self, dst: &mut [u8]) -> io::Result<usize> { + (&self.fd).read(dst) + } +} + +impl<'a> Read for &'a Io { + fn read(&mut self, dst: &mut [u8]) -> io::Result<usize> { + (&self.fd).read(dst) + } +} + +impl Write for Io { + fn write(&mut self, src: &[u8]) -> io::Result<usize> { + (&self.fd).write(src) + } + + fn flush(&mut self) -> io::Result<()> { + (&self.fd).flush() + } +} + +impl<'a> Write for &'a Io { + fn write(&mut self, src: &[u8]) -> io::Result<usize> { + (&self.fd).write(src) + } + + fn flush(&mut self) -> io::Result<()> { + (&self.fd).flush() + } +} diff --git a/third_party/rust/mio-0.6.23/src/sys/unix/kqueue.rs b/third_party/rust/mio-0.6.23/src/sys/unix/kqueue.rs new file mode 100644 index 0000000000..59c70e1e18 --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/sys/unix/kqueue.rs @@ -0,0 +1,360 @@ +use std::{cmp, fmt, ptr}; +#[cfg(not(target_os = "netbsd"))] +use std::os::raw::{c_int, c_short}; +use std::os::unix::io::AsRawFd; +use std::os::unix::io::RawFd; +use std::collections::HashMap; +use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT}; +use std::time::Duration; + +use libc::{self, time_t}; + +use {io, Ready, PollOpt, Token}; +use event_imp::{self as event, Event}; +use sys::unix::{cvt, UnixReady}; +use sys::unix::io::set_cloexec; + +/// Each Selector has a globally unique(ish) ID associated with it. This ID +/// gets tracked by `TcpStream`, `TcpListener`, etc... when they are first +/// registered with the `Selector`. If a type that is previously associated with +/// a `Selector` attempts to register itself with a different `Selector`, the +/// operation will return with an error. This matches windows behavior. +static NEXT_ID: AtomicUsize = ATOMIC_USIZE_INIT; + +#[cfg(not(target_os = "netbsd"))] +type Filter = c_short; +#[cfg(not(target_os = "netbsd"))] +type UData = *mut ::libc::c_void; +#[cfg(not(target_os = "netbsd"))] +type Count = c_int; + +#[cfg(target_os = "netbsd")] +type Filter = u32; +#[cfg(target_os = "netbsd")] +type UData = ::libc::intptr_t; +#[cfg(target_os = "netbsd")] +type Count = usize; + +macro_rules! kevent { + ($id: expr, $filter: expr, $flags: expr, $data: expr) => { + libc::kevent { + ident: $id as ::libc::uintptr_t, + filter: $filter as Filter, + flags: $flags, + fflags: 0, + data: 0, + udata: $data as UData, + } + } +} + +pub struct Selector { + id: usize, + kq: RawFd, +} + +impl Selector { + pub fn new() -> io::Result<Selector> { + // offset by 1 to avoid choosing 0 as the id of a selector + let id = NEXT_ID.fetch_add(1, Ordering::Relaxed) + 1; + let kq = unsafe { cvt(libc::kqueue())? }; + drop(set_cloexec(kq)); + + Ok(Selector { + id, + kq, + }) + } + + pub fn id(&self) -> usize { + self.id + } + + pub fn select(&self, evts: &mut Events, awakener: Token, timeout: Option<Duration>) -> io::Result<bool> { + let timeout = timeout.map(|to| { + libc::timespec { + tv_sec: cmp::min(to.as_secs(), time_t::max_value() as u64) as time_t, + // `Duration::subsec_nanos` is guaranteed to be less than one + // billion (the number of nanoseconds in a second), making the + // cast to i32 safe. The cast itself is needed for platforms + // where C's long is only 32 bits. + tv_nsec: libc::c_long::from(to.subsec_nanos() as i32), + } + }); + let timeout = timeout.as_ref().map(|s| s as *const _).unwrap_or(ptr::null_mut()); + + evts.clear(); + unsafe { + let cnt = cvt(libc::kevent(self.kq, + ptr::null(), + 0, + evts.sys_events.0.as_mut_ptr(), + evts.sys_events.0.capacity() as Count, + timeout))?; + evts.sys_events.0.set_len(cnt as usize); + Ok(evts.coalesce(awakener)) + } + } + + pub fn register(&self, fd: RawFd, token: Token, interests: Ready, opts: PollOpt) -> io::Result<()> { + trace!("registering; token={:?}; interests={:?}", token, interests); + + let flags = if opts.contains(PollOpt::edge()) { libc::EV_CLEAR } else { 0 } | + if opts.contains(PollOpt::oneshot()) { libc::EV_ONESHOT } else { 0 } | + libc::EV_RECEIPT; + + unsafe { + let r = if interests.contains(Ready::readable()) { libc::EV_ADD } else { libc::EV_DELETE }; + let w = if interests.contains(Ready::writable()) { libc::EV_ADD } else { libc::EV_DELETE }; + let mut changes = [ + kevent!(fd, libc::EVFILT_READ, flags | r, usize::from(token)), + kevent!(fd, libc::EVFILT_WRITE, flags | w, usize::from(token)), + ]; + + cvt(libc::kevent(self.kq, + changes.as_ptr(), + changes.len() as Count, + changes.as_mut_ptr(), + changes.len() as Count, + ::std::ptr::null()))?; + + for change in changes.iter() { + debug_assert_eq!(change.flags & libc::EV_ERROR, libc::EV_ERROR); + + // Test to see if an error happened + if change.data == 0 { + continue + } + + // Older versions of OSX (10.11 and 10.10 have been witnessed) + // can return EPIPE when registering a pipe file descriptor + // where the other end has already disappeared. For example code + // that creates a pipe, closes a file descriptor, and then + // registers the other end will see an EPIPE returned from + // `register`. + // + // It also turns out that kevent will still report events on the + // file descriptor, telling us that it's readable/hup at least + // after we've done this registration. As a result we just + // ignore `EPIPE` here instead of propagating it. + // + // More info can be found at carllerche/mio#582 + if change.data as i32 == libc::EPIPE && + change.filter == libc::EVFILT_WRITE as Filter { + continue + } + + // ignore ENOENT error for EV_DELETE + let orig_flags = if change.filter == libc::EVFILT_READ as Filter { r } else { w }; + if change.data as i32 == libc::ENOENT && orig_flags & libc::EV_DELETE != 0 { + continue + } + + return Err(::std::io::Error::from_raw_os_error(change.data as i32)); + } + Ok(()) + } + } + + pub fn reregister(&self, fd: RawFd, token: Token, interests: Ready, opts: PollOpt) -> io::Result<()> { + // Just need to call register here since EV_ADD is a mod if already + // registered + self.register(fd, token, interests, opts) + } + + pub fn deregister(&self, fd: RawFd) -> io::Result<()> { + unsafe { + // EV_RECEIPT is a nice way to apply changes and get back per-event results while not + // draining the actual changes. + let filter = libc::EV_DELETE | libc::EV_RECEIPT; +#[cfg(not(target_os = "netbsd"))] + let mut changes = [ + kevent!(fd, libc::EVFILT_READ, filter, ptr::null_mut()), + kevent!(fd, libc::EVFILT_WRITE, filter, ptr::null_mut()), + ]; + +#[cfg(target_os = "netbsd")] + let mut changes = [ + kevent!(fd, libc::EVFILT_READ, filter, 0), + kevent!(fd, libc::EVFILT_WRITE, filter, 0), + ]; + + cvt(libc::kevent(self.kq, + changes.as_ptr(), + changes.len() as Count, + changes.as_mut_ptr(), + changes.len() as Count, + ::std::ptr::null())).map(|_| ())?; + + if changes[0].data as i32 == libc::ENOENT && changes[1].data as i32 == libc::ENOENT { + return Err(::std::io::Error::from_raw_os_error(changes[0].data as i32)); + } + for change in changes.iter() { + debug_assert_eq!(libc::EV_ERROR & change.flags, libc::EV_ERROR); + if change.data != 0 && change.data as i32 != libc::ENOENT { + return Err(::std::io::Error::from_raw_os_error(changes[0].data as i32)); + } + } + Ok(()) + } + } +} + +impl fmt::Debug for Selector { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("Selector") + .field("id", &self.id) + .field("kq", &self.kq) + .finish() + } +} + +impl AsRawFd for Selector { + fn as_raw_fd(&self) -> RawFd { + self.kq + } +} + +impl Drop for Selector { + fn drop(&mut self) { + unsafe { + let _ = libc::close(self.kq); + } + } +} + +pub struct Events { + sys_events: KeventList, + events: Vec<Event>, + event_map: HashMap<Token, usize>, +} + +struct KeventList(Vec<libc::kevent>); + +unsafe impl Send for KeventList {} +unsafe impl Sync for KeventList {} + +impl Events { + pub fn with_capacity(cap: usize) -> Events { + Events { + sys_events: KeventList(Vec::with_capacity(cap)), + events: Vec::with_capacity(cap), + event_map: HashMap::with_capacity(cap) + } + } + + #[inline] + pub fn len(&self) -> usize { + self.events.len() + } + + #[inline] + pub fn capacity(&self) -> usize { + self.events.capacity() + } + + #[inline] + pub fn is_empty(&self) -> bool { + self.events.is_empty() + } + + pub fn get(&self, idx: usize) -> Option<Event> { + self.events.get(idx).cloned() + } + + fn coalesce(&mut self, awakener: Token) -> bool { + let mut ret = false; + self.events.clear(); + self.event_map.clear(); + + for e in self.sys_events.0.iter() { + let token = Token(e.udata as usize); + let len = self.events.len(); + + if token == awakener { + // TODO: Should this return an error if event is an error. It + // is not critical as spurious wakeups are permitted. + ret = true; + continue; + } + + let idx = *self.event_map.entry(token) + .or_insert(len); + + if idx == len { + // New entry, insert the default + self.events.push(Event::new(Ready::empty(), token)); + + } + + if e.flags & libc::EV_ERROR != 0 { + event::kind_mut(&mut self.events[idx]).insert(*UnixReady::error()); + } + + if e.filter == libc::EVFILT_READ as Filter { + event::kind_mut(&mut self.events[idx]).insert(Ready::readable()); + } else if e.filter == libc::EVFILT_WRITE as Filter { + event::kind_mut(&mut self.events[idx]).insert(Ready::writable()); + } +#[cfg(any(target_os = "dragonfly", + target_os = "freebsd", target_os = "ios", target_os = "macos"))] + { + if e.filter == libc::EVFILT_AIO { + event::kind_mut(&mut self.events[idx]).insert(UnixReady::aio()); + } + } +#[cfg(any(target_os = "freebsd"))] + { + if e.filter == libc::EVFILT_LIO { + event::kind_mut(&mut self.events[idx]).insert(UnixReady::lio()); + } + } + } + + ret + } + + pub fn push_event(&mut self, event: Event) { + self.events.push(event); + } + + pub fn clear(&mut self) { + self.sys_events.0.truncate(0); + self.events.truncate(0); + self.event_map.clear(); + } +} + +impl fmt::Debug for Events { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("Events") + .field("len", &self.sys_events.0.len()) + .finish() + } +} + +#[test] +fn does_not_register_rw() { + use {Poll, Ready, PollOpt, Token}; + use unix::EventedFd; + + let kq = unsafe { libc::kqueue() }; + let kqf = EventedFd(&kq); + let poll = Poll::new().unwrap(); + + // registering kqueue fd will fail if write is requested (On anything but some versions of OS + // X) + poll.register(&kqf, Token(1234), Ready::readable(), + PollOpt::edge() | PollOpt::oneshot()).unwrap(); +} + +#[cfg(any(target_os = "dragonfly", + target_os = "freebsd", target_os = "ios", target_os = "macos"))] +#[test] +fn test_coalesce_aio() { + let mut events = Events::with_capacity(1); + events.sys_events.0.push(kevent!(0x1234, libc::EVFILT_AIO, 0, 42)); + events.coalesce(Token(0)); + assert!(events.events[0].readiness() == UnixReady::aio().into()); + assert!(events.events[0].token() == Token(42)); +} diff --git a/third_party/rust/mio-0.6.23/src/sys/unix/mod.rs b/third_party/rust/mio-0.6.23/src/sys/unix/mod.rs new file mode 100644 index 0000000000..c5726c07ce --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/sys/unix/mod.rs @@ -0,0 +1,105 @@ +use libc::{self, c_int}; + +#[macro_use] +pub mod dlsym; + +#[cfg(any( + target_os = "android", + target_os = "illumos", + target_os = "linux", + target_os = "solaris" +))] +mod epoll; + +#[cfg(any( + target_os = "android", + target_os = "illumos", + target_os = "linux", + target_os = "solaris" +))] +pub use self::epoll::{Events, Selector}; + +#[cfg(any(target_os = "bitrig", target_os = "dragonfly", + target_os = "freebsd", target_os = "ios", target_os = "macos", + target_os = "netbsd", target_os = "openbsd"))] +mod kqueue; + +#[cfg(any(target_os = "bitrig", target_os = "dragonfly", + target_os = "freebsd", target_os = "ios", target_os = "macos", + target_os = "netbsd", target_os = "openbsd"))] +pub use self::kqueue::{Events, Selector}; + +mod awakener; +mod eventedfd; +mod io; +mod ready; +mod tcp; +mod udp; +mod uio; + +#[cfg(feature = "with-deprecated")] +mod uds; + +pub use self::awakener::Awakener; +pub use self::eventedfd::EventedFd; +pub use self::io::{Io, set_nonblock}; +pub use self::ready::{UnixReady, READY_ALL}; +pub use self::tcp::{TcpStream, TcpListener}; +pub use self::udp::UdpSocket; + +#[cfg(feature = "with-deprecated")] +pub use self::uds::UnixSocket; + +pub use iovec::IoVec; + +use std::os::unix::io::FromRawFd; + +pub fn pipe() -> ::io::Result<(Io, Io)> { + // Use pipe2 for atomically setting O_CLOEXEC if we can, but otherwise + // just fall back to using `pipe`. + dlsym!(fn pipe2(*mut c_int, c_int) -> c_int); + + let mut pipes = [0; 2]; + unsafe { + match pipe2.get() { + Some(pipe2_fn) => { + let flags = libc::O_NONBLOCK | libc::O_CLOEXEC; + cvt(pipe2_fn(pipes.as_mut_ptr(), flags))?; + Ok((Io::from_raw_fd(pipes[0]), Io::from_raw_fd(pipes[1]))) + } + None => { + cvt(libc::pipe(pipes.as_mut_ptr()))?; + // Ensure the pipe are closed if any of the system calls below + // fail. + let r = Io::from_raw_fd(pipes[0]); + let w = Io::from_raw_fd(pipes[1]); + cvt(libc::fcntl(pipes[0], libc::F_SETFD, libc::FD_CLOEXEC))?; + cvt(libc::fcntl(pipes[1], libc::F_SETFD, libc::FD_CLOEXEC))?; + cvt(libc::fcntl(pipes[0], libc::F_SETFL, libc::O_NONBLOCK))?; + cvt(libc::fcntl(pipes[1], libc::F_SETFL, libc::O_NONBLOCK))?; + Ok((r, w)) + } + } + } +} + +trait IsMinusOne { + fn is_minus_one(&self) -> bool; +} + +impl IsMinusOne for i32 { + fn is_minus_one(&self) -> bool { *self == -1 } +} +impl IsMinusOne for isize { + fn is_minus_one(&self) -> bool { *self == -1 } +} + +fn cvt<T: IsMinusOne>(t: T) -> ::io::Result<T> { + use std::io; + + if t.is_minus_one() { + Err(io::Error::last_os_error()) + } else { + Ok(t) + } +} diff --git a/third_party/rust/mio-0.6.23/src/sys/unix/ready.rs b/third_party/rust/mio-0.6.23/src/sys/unix/ready.rs new file mode 100644 index 0000000000..88f56252dd --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/sys/unix/ready.rs @@ -0,0 +1,525 @@ +use event_imp::{Ready, ready_as_usize, ready_from_usize}; + +use std::ops; +use std::fmt; + +/// Unix specific extensions to `Ready` +/// +/// Provides additional readiness event kinds that are available on unix +/// platforms. Unix platforms are able to provide readiness events for +/// additional socket events, such as HUP and error. +/// +/// HUP events occur when the remote end of a socket hangs up. In the TCP case, +/// this occurs when the remote end of a TCP socket shuts down writes. +/// +/// Error events occur when the socket enters an error state. In this case, the +/// socket will also receive a readable or writable event. Reading or writing to +/// the socket will result in an error. +/// +/// Conversion traits are implemented between `Ready` and `UnixReady`. See the +/// examples. +/// +/// For high level documentation on polling and readiness, see [`Poll`]. +/// +/// # Examples +/// +/// Most of the time, all that is needed is using bit operations +/// +/// ``` +/// use mio::Ready; +/// use mio::unix::UnixReady; +/// +/// let ready = Ready::readable() | UnixReady::hup(); +/// +/// assert!(ready.is_readable()); +/// assert!(UnixReady::from(ready).is_hup()); +/// ``` +/// +/// Basic conversion between ready types. +/// +/// ``` +/// use mio::Ready; +/// use mio::unix::UnixReady; +/// +/// // Start with a portable ready +/// let ready = Ready::readable(); +/// +/// // Convert to a unix ready, adding HUP +/// let mut unix_ready = UnixReady::from(ready) | UnixReady::hup(); +/// +/// unix_ready.insert(UnixReady::error()); +/// +/// // `unix_ready` maintains readable interest +/// assert!(unix_ready.is_readable()); +/// assert!(unix_ready.is_hup()); +/// assert!(unix_ready.is_error()); +/// +/// // Convert back to `Ready` +/// let ready = Ready::from(unix_ready); +/// +/// // Readable is maintained +/// assert!(ready.is_readable()); +/// ``` +/// +/// Registering readable and error interest on a socket +/// +/// ``` +/// # use std::error::Error; +/// # fn try_main() -> Result<(), Box<Error>> { +/// use mio::{Ready, Poll, PollOpt, Token}; +/// use mio::net::TcpStream; +/// use mio::unix::UnixReady; +/// +/// let addr = "216.58.193.68:80".parse()?; +/// let socket = TcpStream::connect(&addr)?; +/// +/// let poll = Poll::new()?; +/// +/// poll.register(&socket, +/// Token(0), +/// Ready::readable() | UnixReady::error(), +/// PollOpt::edge())?; +/// # Ok(()) +/// # } +/// # +/// # fn main() { +/// # try_main().unwrap(); +/// # } +/// ``` +/// +/// [`Poll`]: ../struct.Poll.html +/// [readiness]: struct.Poll.html#readiness-operations +#[derive(Copy, PartialEq, Eq, Clone, PartialOrd, Ord)] +pub struct UnixReady(Ready); + +const ERROR: usize = 0b00_0100; +const HUP: usize = 0b00_1000; + +#[cfg(any(target_os = "dragonfly", + target_os = "freebsd", target_os = "ios", target_os = "macos"))] +const AIO: usize = 0b01_0000; + +#[cfg(not(any(target_os = "dragonfly", + target_os = "freebsd", target_os = "ios", target_os = "macos")))] +const AIO: usize = 0b00_0000; + +#[cfg(any(target_os = "freebsd"))] +const LIO: usize = 0b10_0000; + +#[cfg(not(any(target_os = "freebsd")))] +const LIO: usize = 0b00_0000; + +#[cfg(any( + target_os = "android", + target_os = "illumos", + target_os = "linux", + target_os = "solaris" +))] +const PRI: usize = 0b100_0000; + +#[cfg(not(any( + target_os = "android", + target_os = "illumos", + target_os = "linux", + target_os = "solaris" +)))] +const PRI: usize = 0; + +// Export to support `Ready::all` +pub const READY_ALL: usize = ERROR | HUP | AIO | LIO | PRI; + +#[test] +fn test_ready_all() { + let readable = Ready::readable().as_usize(); + let writable = Ready::writable().as_usize(); + + assert_eq!( + READY_ALL | readable | writable, + ERROR + HUP + AIO + LIO + PRI + readable + writable + ); + + // Issue #896. + #[cfg(any( + target_os = "android", + target_os = "illumos", + target_os = "linux", + target_os = "solaris" + ))] + assert!(!Ready::from(UnixReady::priority()).is_writable()); +} + +impl UnixReady { + /// Returns a `Ready` representing AIO completion readiness + /// + /// See [`Poll`] for more documentation on polling. + /// + /// # Examples + /// + /// ``` + /// use mio::unix::UnixReady; + /// + /// let ready = UnixReady::aio(); + /// + /// assert!(ready.is_aio()); + /// ``` + /// + /// [`Poll`]: ../struct.Poll.html + #[inline] + #[cfg(any(target_os = "dragonfly", + target_os = "freebsd", target_os = "ios", target_os = "macos"))] + pub fn aio() -> UnixReady { + UnixReady(ready_from_usize(AIO)) + } + + #[cfg(not(any(target_os = "dragonfly", + target_os = "freebsd", target_os = "ios", target_os = "macos")))] + #[deprecated(since = "0.6.12", note = "this function is now platform specific")] + #[doc(hidden)] + pub fn aio() -> UnixReady { + UnixReady(Ready::empty()) + } + + /// Returns a `Ready` representing error readiness. + /// + /// **Note that only readable and writable readiness is guaranteed to be + /// supported on all platforms**. This means that `error` readiness + /// should be treated as a hint. For more details, see [readiness] in the + /// poll documentation. + /// + /// See [`Poll`] for more documentation on polling. + /// + /// # Examples + /// + /// ``` + /// use mio::unix::UnixReady; + /// + /// let ready = UnixReady::error(); + /// + /// assert!(ready.is_error()); + /// ``` + /// + /// [`Poll`]: ../struct.Poll.html + /// [readiness]: ../struct.Poll.html#readiness-operations + #[inline] + pub fn error() -> UnixReady { + UnixReady(ready_from_usize(ERROR)) + } + + /// Returns a `Ready` representing HUP readiness. + /// + /// A HUP (or hang-up) signifies that a stream socket **peer** closed the + /// connection, or shut down the writing half of the connection. + /// + /// **Note that only readable and writable readiness is guaranteed to be + /// supported on all platforms**. This means that `hup` readiness + /// should be treated as a hint. For more details, see [readiness] in the + /// poll documentation. It is also unclear if HUP readiness will remain in 0.7. See + /// [here][issue-941]. + /// + /// See [`Poll`] for more documentation on polling. + /// + /// # Examples + /// + /// ``` + /// use mio::unix::UnixReady; + /// + /// let ready = UnixReady::hup(); + /// + /// assert!(ready.is_hup()); + /// ``` + /// + /// [`Poll`]: ../struct.Poll.html + /// [readiness]: ../struct.Poll.html#readiness-operations + /// [issue-941]: https://github.com/tokio-rs/mio/issues/941 + #[inline] + pub fn hup() -> UnixReady { + UnixReady(ready_from_usize(HUP)) + } + + /// Returns a `Ready` representing LIO completion readiness + /// + /// See [`Poll`] for more documentation on polling. + /// + /// # Examples + /// + /// ``` + /// use mio::unix::UnixReady; + /// + /// let ready = UnixReady::lio(); + /// + /// assert!(ready.is_lio()); + /// ``` + /// + /// [`Poll`]: struct.Poll.html + #[inline] + #[cfg(any(target_os = "freebsd"))] + pub fn lio() -> UnixReady { + UnixReady(ready_from_usize(LIO)) + } + + /// Returns a `Ready` representing priority (`EPOLLPRI`) readiness + /// + /// See [`Poll`] for more documentation on polling. + /// + /// # Examples + /// + /// ``` + /// use mio::unix::UnixReady; + /// + /// let ready = UnixReady::priority(); + /// + /// assert!(ready.is_priority()); + /// ``` + /// + /// [`Poll`]: struct.Poll.html + #[inline] + #[cfg(any( + target_os = "android", + target_os = "illumos", + target_os = "linux", + target_os = "solaris" + ))] + pub fn priority() -> UnixReady { + UnixReady(ready_from_usize(PRI)) + } + + /// Returns true if `Ready` contains AIO readiness + /// + /// See [`Poll`] for more documentation on polling. + /// + /// # Examples + /// + /// ``` + /// use mio::unix::UnixReady; + /// + /// let ready = UnixReady::aio(); + /// + /// assert!(ready.is_aio()); + /// ``` + /// + /// [`Poll`]: ../struct.Poll.html + #[inline] + #[cfg(any(target_os = "dragonfly", + target_os = "freebsd", target_os = "ios", target_os = "macos"))] + pub fn is_aio(&self) -> bool { + self.contains(ready_from_usize(AIO)) + } + + #[deprecated(since = "0.6.12", note = "this function is now platform specific")] + #[cfg(feature = "with-deprecated")] + #[cfg(not(any(target_os = "dragonfly", + target_os = "freebsd", target_os = "ios", target_os = "macos")))] + #[doc(hidden)] + pub fn is_aio(&self) -> bool { + false + } + + /// Returns true if the value includes error readiness + /// + /// **Note that only readable and writable readiness is guaranteed to be + /// supported on all platforms**. This means that `error` readiness should + /// be treated as a hint. For more details, see [readiness] in the poll + /// documentation. + /// + /// See [`Poll`] for more documentation on polling. + /// + /// # Examples + /// + /// ``` + /// use mio::unix::UnixReady; + /// + /// let ready = UnixReady::error(); + /// + /// assert!(ready.is_error()); + /// ``` + /// + /// [`Poll`]: ../struct.Poll.html + /// [readiness]: ../struct.Poll.html#readiness-operations + #[inline] + pub fn is_error(&self) -> bool { + self.contains(ready_from_usize(ERROR)) + } + + /// Returns true if the value includes HUP readiness + /// + /// A HUP (or hang-up) signifies that a stream socket **peer** closed the + /// connection, or shut down the writing half of the connection. + /// + /// **Note that only readable and writable readiness is guaranteed to be + /// supported on all platforms**. This means that `hup` readiness + /// should be treated as a hint. For more details, see [readiness] in the + /// poll documentation. + /// + /// See [`Poll`] for more documentation on polling. + /// + /// # Examples + /// + /// ``` + /// use mio::unix::UnixReady; + /// + /// let ready = UnixReady::hup(); + /// + /// assert!(ready.is_hup()); + /// ``` + /// + /// [`Poll`]: ../struct.Poll.html + /// [readiness]: ../struct.Poll.html#readiness-operations + #[inline] + pub fn is_hup(&self) -> bool { + self.contains(ready_from_usize(HUP)) + } + + /// Returns true if `Ready` contains LIO readiness + /// + /// See [`Poll`] for more documentation on polling. + /// + /// # Examples + /// + /// ``` + /// use mio::unix::UnixReady; + /// + /// let ready = UnixReady::lio(); + /// + /// assert!(ready.is_lio()); + /// ``` + #[inline] + #[cfg(any(target_os = "freebsd"))] + pub fn is_lio(&self) -> bool { + self.contains(ready_from_usize(LIO)) + } + + /// Returns true if `Ready` contains priority (`EPOLLPRI`) readiness + /// + /// See [`Poll`] for more documentation on polling. + /// + /// # Examples + /// + /// ``` + /// use mio::unix::UnixReady; + /// + /// let ready = UnixReady::priority(); + /// + /// assert!(ready.is_priority()); + /// ``` + /// + /// [`Poll`]: struct.Poll.html + #[inline] + #[cfg(any( + target_os = "android", + target_os = "illumos", + target_os = "linux", + target_os = "solaris" + ))] + pub fn is_priority(&self) -> bool { + self.contains(ready_from_usize(PRI)) + } +} + +impl From<Ready> for UnixReady { + fn from(src: Ready) -> UnixReady { + UnixReady(src) + } +} + +impl From<UnixReady> for Ready { + fn from(src: UnixReady) -> Ready { + src.0 + } +} + +impl ops::Deref for UnixReady { + type Target = Ready; + + fn deref(&self) -> &Ready { + &self.0 + } +} + +impl ops::DerefMut for UnixReady { + fn deref_mut(&mut self) -> &mut Ready { + &mut self.0 + } +} + +impl ops::BitOr for UnixReady { + type Output = UnixReady; + + #[inline] + fn bitor(self, other: UnixReady) -> UnixReady { + (self.0 | other.0).into() + } +} + +impl ops::BitXor for UnixReady { + type Output = UnixReady; + + #[inline] + fn bitxor(self, other: UnixReady) -> UnixReady { + (self.0 ^ other.0).into() + } +} + +impl ops::BitAnd for UnixReady { + type Output = UnixReady; + + #[inline] + fn bitand(self, other: UnixReady) -> UnixReady { + (self.0 & other.0).into() + } +} + +impl ops::Sub for UnixReady { + type Output = UnixReady; + + #[inline] + fn sub(self, other: UnixReady) -> UnixReady { + ready_from_usize(ready_as_usize(self.0) & !ready_as_usize(other.0)).into() + } +} + +#[cfg(feature = "with-deprecated")] +#[doc(hidden)] +impl ops::Not for UnixReady { + type Output = UnixReady; + + #[inline] + fn not(self) -> UnixReady { + (!self.0).into() + } +} + +impl fmt::Debug for UnixReady { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + let mut one = false; + let flags = [ + (UnixReady(Ready::readable()), "Readable"), + (UnixReady(Ready::writable()), "Writable"), + (UnixReady::error(), "Error"), + (UnixReady::hup(), "Hup"), + #[allow(deprecated)] + (UnixReady::aio(), "Aio"), + #[cfg(any( + target_os = "android", + target_os = "illumos", + target_os = "linux", + target_os = "solaris" + ))] + (UnixReady::priority(), "Priority"), + ]; + + for &(flag, msg) in &flags { + if self.contains(flag) { + if one { write!(fmt, " | ")? } + write!(fmt, "{}", msg)?; + + one = true + } + } + + if !one { + fmt.write_str("(empty)")?; + } + + Ok(()) + } +} diff --git a/third_party/rust/mio-0.6.23/src/sys/unix/tcp.rs b/third_party/rust/mio-0.6.23/src/sys/unix/tcp.rs new file mode 100644 index 0000000000..7962fcecb3 --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/sys/unix/tcp.rs @@ -0,0 +1,286 @@ +use std::fmt; +use std::io::{Read, Write}; +use std::net::{self, SocketAddr}; +use std::os::unix::io::{RawFd, FromRawFd, IntoRawFd, AsRawFd}; +use std::time::Duration; + +use libc; +use net2::TcpStreamExt; +use iovec::IoVec; + +use {io, Ready, Poll, PollOpt, Token}; +use event::Evented; + +use sys::unix::eventedfd::EventedFd; +use sys::unix::io::set_nonblock; +use sys::unix::uio::VecIo; + +pub struct TcpStream { + inner: net::TcpStream, +} + +pub struct TcpListener { + inner: net::TcpListener, +} + +impl TcpStream { + pub fn connect(stream: net::TcpStream, addr: &SocketAddr) -> io::Result<TcpStream> { + set_nonblock(stream.as_raw_fd())?; + + match stream.connect(addr) { + Ok(..) => {} + Err(ref e) if e.raw_os_error() == Some(libc::EINPROGRESS) => {} + Err(e) => return Err(e), + } + + Ok(TcpStream { + inner: stream, + }) + } + + pub fn from_stream(stream: net::TcpStream) -> TcpStream { + TcpStream { + inner: stream, + } + } + + pub fn peer_addr(&self) -> io::Result<SocketAddr> { + self.inner.peer_addr() + } + + pub fn local_addr(&self) -> io::Result<SocketAddr> { + self.inner.local_addr() + } + + pub fn try_clone(&self) -> io::Result<TcpStream> { + self.inner.try_clone().map(|s| { + TcpStream { + inner: s, + } + }) + } + + pub fn shutdown(&self, how: net::Shutdown) -> io::Result<()> { + self.inner.shutdown(how) + } + + pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> { + self.inner.set_nodelay(nodelay) + } + + pub fn nodelay(&self) -> io::Result<bool> { + self.inner.nodelay() + } + + pub fn set_recv_buffer_size(&self, size: usize) -> io::Result<()> { + self.inner.set_recv_buffer_size(size) + } + + pub fn recv_buffer_size(&self) -> io::Result<usize> { + self.inner.recv_buffer_size() + } + + pub fn set_send_buffer_size(&self, size: usize) -> io::Result<()> { + self.inner.set_send_buffer_size(size) + } + + pub fn send_buffer_size(&self) -> io::Result<usize> { + self.inner.send_buffer_size() + } + + pub fn set_keepalive(&self, keepalive: Option<Duration>) -> io::Result<()> { + self.inner.set_keepalive(keepalive) + } + + pub fn keepalive(&self) -> io::Result<Option<Duration>> { + self.inner.keepalive() + } + + pub fn set_ttl(&self, ttl: u32) -> io::Result<()> { + self.inner.set_ttl(ttl) + } + + pub fn ttl(&self) -> io::Result<u32> { + self.inner.ttl() + } + + pub fn set_only_v6(&self, only_v6: bool) -> io::Result<()> { + self.inner.set_only_v6(only_v6) + } + + pub fn only_v6(&self) -> io::Result<bool> { + self.inner.only_v6() + } + + pub fn set_linger(&self, dur: Option<Duration>) -> io::Result<()> { + TcpStreamExt::set_linger(&self.inner, dur) + } + + pub fn linger(&self) -> io::Result<Option<Duration>> { + TcpStreamExt::linger(&self.inner) + } + + pub fn take_error(&self) -> io::Result<Option<io::Error>> { + self.inner.take_error() + } + + pub fn peek(&self, buf: &mut [u8]) -> io::Result<usize> { + self.inner.peek(buf) + } + + pub fn readv(&self, bufs: &mut [&mut IoVec]) -> io::Result<usize> { + self.inner.readv(bufs) + } + + pub fn writev(&self, bufs: &[&IoVec]) -> io::Result<usize> { + self.inner.writev(bufs) + } +} + +impl<'a> Read for &'a TcpStream { + fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { + (&self.inner).read(buf) + } +} + +impl<'a> Write for &'a TcpStream { + fn write(&mut self, buf: &[u8]) -> io::Result<usize> { + (&self.inner).write(buf) + } + + fn flush(&mut self) -> io::Result<()> { + (&self.inner).flush() + } +} + +impl Evented for TcpStream { + fn register(&self, poll: &Poll, token: Token, + interest: Ready, opts: PollOpt) -> io::Result<()> { + EventedFd(&self.as_raw_fd()).register(poll, token, interest, opts) + } + + fn reregister(&self, poll: &Poll, token: Token, + interest: Ready, opts: PollOpt) -> io::Result<()> { + EventedFd(&self.as_raw_fd()).reregister(poll, token, interest, opts) + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + EventedFd(&self.as_raw_fd()).deregister(poll) + } +} + +impl fmt::Debug for TcpStream { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::Debug::fmt(&self.inner, f) + } +} + +impl FromRawFd for TcpStream { + unsafe fn from_raw_fd(fd: RawFd) -> TcpStream { + TcpStream { + inner: net::TcpStream::from_raw_fd(fd), + } + } +} + +impl IntoRawFd for TcpStream { + fn into_raw_fd(self) -> RawFd { + self.inner.into_raw_fd() + } +} + +impl AsRawFd for TcpStream { + fn as_raw_fd(&self) -> RawFd { + self.inner.as_raw_fd() + } +} + +impl TcpListener { + pub fn new(inner: net::TcpListener) -> io::Result<TcpListener> { + set_nonblock(inner.as_raw_fd())?; + Ok(TcpListener { + inner, + }) + } + + pub fn local_addr(&self) -> io::Result<SocketAddr> { + self.inner.local_addr() + } + + pub fn try_clone(&self) -> io::Result<TcpListener> { + self.inner.try_clone().map(|s| { + TcpListener { + inner: s, + } + }) + } + + pub fn accept(&self) -> io::Result<(net::TcpStream, SocketAddr)> { + self.inner.accept() + } + + #[allow(deprecated)] + pub fn set_only_v6(&self, only_v6: bool) -> io::Result<()> { + self.inner.set_only_v6(only_v6) + } + + #[allow(deprecated)] + pub fn only_v6(&self) -> io::Result<bool> { + self.inner.only_v6() + } + + pub fn set_ttl(&self, ttl: u32) -> io::Result<()> { + self.inner.set_ttl(ttl) + } + + pub fn ttl(&self) -> io::Result<u32> { + self.inner.ttl() + } + + pub fn take_error(&self) -> io::Result<Option<io::Error>> { + self.inner.take_error() + } +} + +impl Evented for TcpListener { + fn register(&self, poll: &Poll, token: Token, + interest: Ready, opts: PollOpt) -> io::Result<()> { + EventedFd(&self.as_raw_fd()).register(poll, token, interest, opts) + } + + fn reregister(&self, poll: &Poll, token: Token, + interest: Ready, opts: PollOpt) -> io::Result<()> { + EventedFd(&self.as_raw_fd()).reregister(poll, token, interest, opts) + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + EventedFd(&self.as_raw_fd()).deregister(poll) + } +} + +impl fmt::Debug for TcpListener { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::Debug::fmt(&self.inner, f) + } +} + +impl FromRawFd for TcpListener { + unsafe fn from_raw_fd(fd: RawFd) -> TcpListener { + TcpListener { + inner: net::TcpListener::from_raw_fd(fd), + } + } +} + +impl IntoRawFd for TcpListener { + fn into_raw_fd(self) -> RawFd { + self.inner.into_raw_fd() + } +} + +impl AsRawFd for TcpListener { + fn as_raw_fd(&self) -> RawFd { + self.inner.as_raw_fd() + } +} + diff --git a/third_party/rust/mio-0.6.23/src/sys/unix/udp.rs b/third_party/rust/mio-0.6.23/src/sys/unix/udp.rs new file mode 100644 index 0000000000..c77a9d6380 --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/sys/unix/udp.rs @@ -0,0 +1,181 @@ +use {io, Ready, Poll, PollOpt, Token}; +use event::Evented; +use unix::EventedFd; +use sys::unix::uio::VecIo; +use std::fmt; +use std::net::{self, Ipv4Addr, Ipv6Addr, SocketAddr}; +use std::os::unix::io::{RawFd, IntoRawFd, AsRawFd, FromRawFd}; + +#[allow(unused_imports)] // only here for Rust 1.8 +use net2::UdpSocketExt; +use iovec::IoVec; + +pub struct UdpSocket { + io: net::UdpSocket, +} + +impl UdpSocket { + pub fn new(socket: net::UdpSocket) -> io::Result<UdpSocket> { + socket.set_nonblocking(true)?; + Ok(UdpSocket { + io: socket, + }) + } + + pub fn local_addr(&self) -> io::Result<SocketAddr> { + self.io.local_addr() + } + + pub fn try_clone(&self) -> io::Result<UdpSocket> { + self.io.try_clone().map(|io| { + UdpSocket { + io, + } + }) + } + + pub fn send_to(&self, buf: &[u8], target: &SocketAddr) -> io::Result<usize> { + self.io.send_to(buf, target) + } + + pub fn recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> { + self.io.recv_from(buf) + } + + pub fn send(&self, buf: &[u8]) -> io::Result<usize> { + self.io.send(buf) + } + + pub fn recv(&self, buf: &mut [u8]) -> io::Result<usize> { + self.io.recv(buf) + } + + pub fn connect(&self, addr: SocketAddr) + -> io::Result<()> { + self.io.connect(addr) + } + + pub fn broadcast(&self) -> io::Result<bool> { + self.io.broadcast() + } + + pub fn set_broadcast(&self, on: bool) -> io::Result<()> { + self.io.set_broadcast(on) + } + + pub fn multicast_loop_v4(&self) -> io::Result<bool> { + self.io.multicast_loop_v4() + } + + pub fn set_multicast_loop_v4(&self, on: bool) -> io::Result<()> { + self.io.set_multicast_loop_v4(on) + } + + pub fn multicast_ttl_v4(&self) -> io::Result<u32> { + self.io.multicast_ttl_v4() + } + + pub fn set_multicast_ttl_v4(&self, ttl: u32) -> io::Result<()> { + self.io.set_multicast_ttl_v4(ttl) + } + + pub fn multicast_loop_v6(&self) -> io::Result<bool> { + self.io.multicast_loop_v6() + } + + pub fn set_multicast_loop_v6(&self, on: bool) -> io::Result<()> { + self.io.set_multicast_loop_v6(on) + } + + pub fn ttl(&self) -> io::Result<u32> { + self.io.ttl() + } + + pub fn set_ttl(&self, ttl: u32) -> io::Result<()> { + self.io.set_ttl(ttl) + } + + pub fn join_multicast_v4(&self, + multiaddr: &Ipv4Addr, + interface: &Ipv4Addr) -> io::Result<()> { + self.io.join_multicast_v4(multiaddr, interface) + } + + pub fn join_multicast_v6(&self, + multiaddr: &Ipv6Addr, + interface: u32) -> io::Result<()> { + self.io.join_multicast_v6(multiaddr, interface) + } + + pub fn leave_multicast_v4(&self, + multiaddr: &Ipv4Addr, + interface: &Ipv4Addr) -> io::Result<()> { + self.io.leave_multicast_v4(multiaddr, interface) + } + + pub fn leave_multicast_v6(&self, + multiaddr: &Ipv6Addr, + interface: u32) -> io::Result<()> { + self.io.leave_multicast_v6(multiaddr, interface) + } + + pub fn set_only_v6(&self, only_v6: bool) -> io::Result<()> { + self.io.set_only_v6(only_v6) + } + + pub fn only_v6(&self) -> io::Result<bool> { + self.io.only_v6() + } + + pub fn take_error(&self) -> io::Result<Option<io::Error>> { + self.io.take_error() + } + + pub fn readv(&self, bufs: &mut [&mut IoVec]) -> io::Result<usize> { + self.io.readv(bufs) + } + + pub fn writev(&self, bufs: &[&IoVec]) -> io::Result<usize> { + self.io.writev(bufs) + } +} + +impl Evented for UdpSocket { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + EventedFd(&self.as_raw_fd()).register(poll, token, interest, opts) + } + + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + EventedFd(&self.as_raw_fd()).reregister(poll, token, interest, opts) + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + EventedFd(&self.as_raw_fd()).deregister(poll) + } +} + +impl fmt::Debug for UdpSocket { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::Debug::fmt(&self.io, f) + } +} + +impl FromRawFd for UdpSocket { + unsafe fn from_raw_fd(fd: RawFd) -> UdpSocket { + UdpSocket { + io: net::UdpSocket::from_raw_fd(fd), + } + } +} + +impl IntoRawFd for UdpSocket { + fn into_raw_fd(self) -> RawFd { + self.io.into_raw_fd() + } +} + +impl AsRawFd for UdpSocket { + fn as_raw_fd(&self) -> RawFd { + self.io.as_raw_fd() + } +} diff --git a/third_party/rust/mio-0.6.23/src/sys/unix/uds.rs b/third_party/rust/mio-0.6.23/src/sys/unix/uds.rs new file mode 100644 index 0000000000..f6706784f8 --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/sys/unix/uds.rs @@ -0,0 +1,265 @@ +use std::io::{Read, Write}; +use std::mem; +use std::net::Shutdown; +use std::os::unix::prelude::*; +use std::path::Path; +use std::ptr; + +use libc; + +use {io, Ready, Poll, PollOpt, Token}; +use event::Evented; +use sys::unix::{cvt, Io}; +use sys::unix::io::{set_nonblock, set_cloexec}; + +trait MyInto<T> { + fn my_into(self) -> T; +} + +impl MyInto<u32> for usize { + fn my_into(self) -> u32 { self as u32 } +} + +impl MyInto<usize> for usize { + fn my_into(self) -> usize { self } +} + +unsafe fn sockaddr_un(path: &Path) + -> io::Result<(libc::sockaddr_un, libc::socklen_t)> { + let mut addr: libc::sockaddr_un = mem::zeroed(); + addr.sun_family = libc::AF_UNIX as libc::sa_family_t; + + let bytes = path.as_os_str().as_bytes(); + + if bytes.len() >= addr.sun_path.len() { + return Err(io::Error::new(io::ErrorKind::InvalidInput, + "path must be shorter than SUN_LEN")) + } + for (dst, src) in addr.sun_path.iter_mut().zip(bytes.iter()) { + *dst = *src as libc::c_char; + } + // null byte for pathname addresses is already there because we zeroed the + // struct + + let mut len = sun_path_offset() + bytes.len(); + match bytes.get(0) { + Some(&0) | None => {} + Some(_) => len += 1, + } + Ok((addr, len as libc::socklen_t)) +} + +fn sun_path_offset() -> usize { + // Silence rustc 1.65 warning about mem::uninitialized. + #[allow(invalid_value)] + unsafe { + // Work with an actual instance of the type since using a null pointer is UB + let addr: libc::sockaddr_un = mem::uninitialized(); + let base = &addr as *const _ as usize; + let path = &addr.sun_path as *const _ as usize; + path - base + } +} + +#[derive(Debug)] +pub struct UnixSocket { + io: Io, +} + +impl UnixSocket { + /// Returns a new, unbound, non-blocking Unix domain socket + pub fn stream() -> io::Result<UnixSocket> { + #[cfg(target_os = "linux")] + use libc::{SOCK_CLOEXEC, SOCK_NONBLOCK}; + #[cfg(not(target_os = "linux"))] + const SOCK_CLOEXEC: libc::c_int = 0; + #[cfg(not(target_os = "linux"))] + const SOCK_NONBLOCK: libc::c_int = 0; + + unsafe { + if cfg!(target_os = "linux") { + let flags = libc::SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK; + match cvt(libc::socket(libc::AF_UNIX, flags, 0)) { + Ok(fd) => return Ok(UnixSocket::from_raw_fd(fd)), + Err(ref e) if e.raw_os_error() == Some(libc::EINVAL) => {} + Err(e) => return Err(e), + } + } + + let fd = cvt(libc::socket(libc::AF_UNIX, libc::SOCK_STREAM, 0))?; + let fd = UnixSocket::from_raw_fd(fd); + set_cloexec(fd.as_raw_fd())?; + set_nonblock(fd.as_raw_fd())?; + Ok(fd) + } + } + + /// Connect the socket to the specified address + pub fn connect<P: AsRef<Path> + ?Sized>(&self, addr: &P) -> io::Result<()> { + unsafe { + let (addr, len) = sockaddr_un(addr.as_ref())?; + cvt(libc::connect(self.as_raw_fd(), + &addr as *const _ as *const _, + len))?; + Ok(()) + } + } + + /// Listen for incoming requests + pub fn listen(&self, backlog: usize) -> io::Result<()> { + unsafe { + cvt(libc::listen(self.as_raw_fd(), backlog as i32))?; + Ok(()) + } + } + + pub fn accept(&self) -> io::Result<UnixSocket> { + unsafe { + let fd = cvt(libc::accept(self.as_raw_fd(), + ptr::null_mut(), + ptr::null_mut()))?; + let fd = Io::from_raw_fd(fd); + set_cloexec(fd.as_raw_fd())?; + set_nonblock(fd.as_raw_fd())?; + Ok(UnixSocket { io: fd }) + } + } + + /// Bind the socket to the specified address + pub fn bind<P: AsRef<Path> + ?Sized>(&self, addr: &P) -> io::Result<()> { + unsafe { + let (addr, len) = sockaddr_un(addr.as_ref())?; + cvt(libc::bind(self.as_raw_fd(), + &addr as *const _ as *const _, + len))?; + Ok(()) + } + } + + pub fn try_clone(&self) -> io::Result<UnixSocket> { + Ok(UnixSocket { io: self.io.try_clone()? }) + } + + pub fn shutdown(&self, how: Shutdown) -> io::Result<()> { + let how = match how { + Shutdown::Read => libc::SHUT_RD, + Shutdown::Write => libc::SHUT_WR, + Shutdown::Both => libc::SHUT_RDWR, + }; + unsafe { + cvt(libc::shutdown(self.as_raw_fd(), how))?; + Ok(()) + } + } + + pub fn read_recv_fd(&mut self, buf: &mut [u8]) -> io::Result<(usize, Option<RawFd>)> { + unsafe { + let mut iov = libc::iovec { + iov_base: buf.as_mut_ptr() as *mut _, + iov_len: buf.len(), + }; + struct Cmsg { + hdr: libc::cmsghdr, + data: [libc::c_int; 1], + } + let mut cmsg: Cmsg = mem::zeroed(); + let mut msg: libc::msghdr = mem::zeroed(); + msg.msg_iov = &mut iov; + msg.msg_iovlen = 1; + msg.msg_control = &mut cmsg as *mut _ as *mut _; + msg.msg_controllen = mem::size_of_val(&cmsg).my_into(); + let bytes = cvt(libc::recvmsg(self.as_raw_fd(), &mut msg, 0))?; + + const SCM_RIGHTS: libc::c_int = 1; + + let fd = if cmsg.hdr.cmsg_level == libc::SOL_SOCKET && + cmsg.hdr.cmsg_type == SCM_RIGHTS { + Some(cmsg.data[0]) + } else { + None + }; + Ok((bytes as usize, fd)) + } + } + + pub fn write_send_fd(&mut self, buf: &[u8], fd: RawFd) -> io::Result<usize> { + unsafe { + let mut iov = libc::iovec { + iov_base: buf.as_ptr() as *mut _, + iov_len: buf.len(), + }; + struct Cmsg { + #[allow(dead_code)] + hdr: libc::cmsghdr, + data: [libc::c_int; 1], + } + let mut cmsg: Cmsg = mem::zeroed(); + cmsg.hdr.cmsg_len = mem::size_of_val(&cmsg).my_into(); + cmsg.hdr.cmsg_level = libc::SOL_SOCKET; + cmsg.hdr.cmsg_type = 1; // SCM_RIGHTS + cmsg.data[0] = fd; + let mut msg: libc::msghdr = mem::zeroed(); + msg.msg_iov = &mut iov; + msg.msg_iovlen = 1; + msg.msg_control = &mut cmsg as *mut _ as *mut _; + msg.msg_controllen = mem::size_of_val(&cmsg).my_into(); + let bytes = cvt(libc::sendmsg(self.as_raw_fd(), &msg, 0))?; + Ok(bytes as usize) + } + } +} + +impl Read for UnixSocket { + fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { + self.io.read(buf) + } +} + +impl Write for UnixSocket { + fn write(&mut self, buf: &[u8]) -> io::Result<usize> { + self.io.write(buf) + } + + fn flush(&mut self) -> io::Result<()> { + self.io.flush() + } +} + +impl Evented for UnixSocket { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + self.io.register(poll, token, interest, opts) + } + + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + self.io.reregister(poll, token, interest, opts) + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + self.io.deregister(poll) + } +} + + +impl From<Io> for UnixSocket { + fn from(io: Io) -> UnixSocket { + UnixSocket { io } + } +} + +impl FromRawFd for UnixSocket { + unsafe fn from_raw_fd(fd: RawFd) -> UnixSocket { + UnixSocket { io: Io::from_raw_fd(fd) } + } +} + +impl IntoRawFd for UnixSocket { + fn into_raw_fd(self) -> RawFd { + self.io.into_raw_fd() + } +} + +impl AsRawFd for UnixSocket { + fn as_raw_fd(&self) -> RawFd { + self.io.as_raw_fd() + } +} diff --git a/third_party/rust/mio-0.6.23/src/sys/unix/uio.rs b/third_party/rust/mio-0.6.23/src/sys/unix/uio.rs new file mode 100644 index 0000000000..e38cd4983b --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/sys/unix/uio.rs @@ -0,0 +1,44 @@ +use std::cmp; +use std::io; +use std::os::unix::io::AsRawFd; +use libc; +use iovec::IoVec; +use iovec::unix as iovec; + +pub trait VecIo { + fn readv(&self, bufs: &mut [&mut IoVec]) -> io::Result<usize>; + + fn writev(&self, bufs: &[&IoVec]) -> io::Result<usize>; +} + +impl<T: AsRawFd> VecIo for T { + fn readv(&self, bufs: &mut [&mut IoVec]) -> io::Result<usize> { + unsafe { + let slice = iovec::as_os_slice_mut(bufs); + let len = cmp::min(<libc::c_int>::max_value() as usize, slice.len()); + let rc = libc::readv(self.as_raw_fd(), + slice.as_ptr(), + len as libc::c_int); + if rc < 0 { + Err(io::Error::last_os_error()) + } else { + Ok(rc as usize) + } + } + } + + fn writev(&self, bufs: &[&IoVec]) -> io::Result<usize> { + unsafe { + let slice = iovec::as_os_slice(bufs); + let len = cmp::min(<libc::c_int>::max_value() as usize, slice.len()); + let rc = libc::writev(self.as_raw_fd(), + slice.as_ptr(), + len as libc::c_int); + if rc < 0 { + Err(io::Error::last_os_error()) + } else { + Ok(rc as usize) + } + } + } +}
\ No newline at end of file diff --git a/third_party/rust/mio-0.6.23/src/sys/windows/awakener.rs b/third_party/rust/mio-0.6.23/src/sys/windows/awakener.rs new file mode 100644 index 0000000000..c913bc93f8 --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/sys/windows/awakener.rs @@ -0,0 +1,66 @@ +use std::sync::Mutex; + +use miow::iocp::CompletionStatus; +use {io, poll, Ready, Poll, PollOpt, Token}; +use event::Evented; +use sys::windows::Selector; + +pub struct Awakener { + inner: Mutex<Option<AwakenerInner>>, +} + +struct AwakenerInner { + token: Token, + selector: Selector, +} + +impl Awakener { + pub fn new() -> io::Result<Awakener> { + Ok(Awakener { + inner: Mutex::new(None), + }) + } + + pub fn wakeup(&self) -> io::Result<()> { + // Each wakeup notification has NULL as its `OVERLAPPED` pointer to + // indicate that it's from this awakener and not part of an I/O + // operation. This is specially recognized by the selector. + // + // If we haven't been registered with an event loop yet just silently + // succeed. + if let Some(inner) = self.inner.lock().unwrap().as_ref() { + let status = CompletionStatus::new(0, + usize::from(inner.token), + 0 as *mut _); + inner.selector.port().post(status)?; + } + Ok(()) + } + + pub fn cleanup(&self) { + // noop + } +} + +impl Evented for Awakener { + fn register(&self, poll: &Poll, token: Token, events: Ready, + opts: PollOpt) -> io::Result<()> { + assert_eq!(opts, PollOpt::edge()); + assert_eq!(events, Ready::readable()); + *self.inner.lock().unwrap() = Some(AwakenerInner { + selector: poll::selector(poll).clone_ref(), + token: token, + }); + Ok(()) + } + + fn reregister(&self, poll: &Poll, token: Token, events: Ready, + opts: PollOpt) -> io::Result<()> { + self.register(poll, token, events, opts) + } + + fn deregister(&self, _poll: &Poll) -> io::Result<()> { + *self.inner.lock().unwrap() = None; + Ok(()) + } +} diff --git a/third_party/rust/mio-0.6.23/src/sys/windows/buffer_pool.rs b/third_party/rust/mio-0.6.23/src/sys/windows/buffer_pool.rs new file mode 100644 index 0000000000..86754593fd --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/sys/windows/buffer_pool.rs @@ -0,0 +1,20 @@ +pub struct BufferPool { + pool: Vec<Vec<u8>>, +} + +impl BufferPool { + pub fn new(cap: usize) -> BufferPool { + BufferPool { pool: Vec::with_capacity(cap) } + } + + pub fn get(&mut self, default_cap: usize) -> Vec<u8> { + self.pool.pop().unwrap_or_else(|| Vec::with_capacity(default_cap)) + } + + pub fn put(&mut self, mut buf: Vec<u8>) { + if self.pool.len() < self.pool.capacity(){ + unsafe { buf.set_len(0); } + self.pool.push(buf); + } + } +} diff --git a/third_party/rust/mio-0.6.23/src/sys/windows/from_raw_arc.rs b/third_party/rust/mio-0.6.23/src/sys/windows/from_raw_arc.rs new file mode 100644 index 0000000000..b6d38b2408 --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/sys/windows/from_raw_arc.rs @@ -0,0 +1,116 @@ +//! A "Manual Arc" which allows manually frobbing the reference count +//! +//! This module contains a copy of the `Arc` found in the standard library, +//! stripped down to the bare bones of what we actually need. The reason this is +//! done is for the ability to concretely know the memory layout of the `Inner` +//! structure of the arc pointer itself (e.g. `ArcInner` in the standard +//! library). +//! +//! We do some unsafe casting from `*mut OVERLAPPED` to a `FromRawArc<T>` to +//! ensure that data lives for the length of an I/O operation, but this means +//! that we have to know the layouts of the structures involved. This +//! representation primarily guarantees that the data, `T` is at the front of +//! the inner pointer always. +//! +//! Note that we're missing out on some various optimizations implemented in the +//! standard library: +//! +//! * The size of `FromRawArc` is actually two words because of the drop flag +//! * The compiler doesn't understand that the pointer in `FromRawArc` is never +//! null, so Option<FromRawArc<T>> is not a nullable pointer. + +use std::ops::Deref; +use std::mem; +use std::sync::atomic::{self, AtomicUsize, Ordering}; + +pub struct FromRawArc<T> { + _inner: *mut Inner<T>, +} + +unsafe impl<T: Sync + Send> Send for FromRawArc<T> { } +unsafe impl<T: Sync + Send> Sync for FromRawArc<T> { } + +#[repr(C)] +struct Inner<T> { + data: T, + cnt: AtomicUsize, +} + +impl<T> FromRawArc<T> { + pub fn new(data: T) -> FromRawArc<T> { + let x = Box::new(Inner { + data: data, + cnt: AtomicUsize::new(1), + }); + FromRawArc { _inner: unsafe { mem::transmute(x) } } + } + + pub unsafe fn from_raw(ptr: *mut T) -> FromRawArc<T> { + // Note that if we could use `mem::transmute` here to get a libstd Arc + // (guaranteed) then we could just use std::sync::Arc, but this is the + // crucial reason this currently exists. + FromRawArc { _inner: ptr as *mut Inner<T> } + } +} + +impl<T> Clone for FromRawArc<T> { + fn clone(&self) -> FromRawArc<T> { + // Atomic ordering of Relaxed lifted from libstd, but the general idea + // is that you need synchronization to communicate this increment to + // another thread, so this itself doesn't need to be synchronized. + unsafe { + (*self._inner).cnt.fetch_add(1, Ordering::Relaxed); + } + FromRawArc { _inner: self._inner } + } +} + +impl<T> Deref for FromRawArc<T> { + type Target = T; + + fn deref(&self) -> &T { + unsafe { &(*self._inner).data } + } +} + +impl<T> Drop for FromRawArc<T> { + fn drop(&mut self) { + unsafe { + // Atomic orderings lifted from the standard library + if (*self._inner).cnt.fetch_sub(1, Ordering::Release) != 1 { + return + } + atomic::fence(Ordering::Acquire); + drop(mem::transmute::<_, Box<T>>(self._inner)); + } + } +} + +#[cfg(test)] +mod tests { + use super::FromRawArc; + + #[test] + fn smoke() { + let a = FromRawArc::new(1); + assert_eq!(*a, 1); + assert_eq!(*a.clone(), 1); + } + + #[test] + fn drops() { + struct A<'a>(&'a mut bool); + impl<'a> Drop for A<'a> { + fn drop(&mut self) { + *self.0 = true; + } + } + let mut a = false; + { + let a = FromRawArc::new(A(&mut a)); + let _ = a.clone(); + assert!(!*a.0); + } + assert!(a); + } +} diff --git a/third_party/rust/mio-0.6.23/src/sys/windows/mod.rs b/third_party/rust/mio-0.6.23/src/sys/windows/mod.rs new file mode 100644 index 0000000000..9b9f054495 --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/sys/windows/mod.rs @@ -0,0 +1,193 @@ +//! Implementation of mio for Windows using IOCP +//! +//! This module uses I/O Completion Ports (IOCP) on Windows to implement mio's +//! Unix epoll-like interface. Unfortunately these two I/O models are +//! fundamentally incompatible: +//! +//! * IOCP is a completion-based model where work is submitted to the kernel and +//! a program is notified later when the work finished. +//! * epoll is a readiness-based model where the kernel is queried as to what +//! work can be done, and afterwards the work is done. +//! +//! As a result, this implementation for Windows is much less "low level" than +//! the Unix implementation of mio. This design decision was intentional, +//! however. +//! +//! ## What is IOCP? +//! +//! The [official docs][docs] have a comprehensive explanation of what IOCP is, +//! but at a high level it requires the following operations to be executed to +//! perform some I/O: +//! +//! 1. A completion port is created +//! 2. An I/O handle and a token is registered with this completion port +//! 3. Some I/O is issued on the handle. This generally means that an API was +//! invoked with a zeroed `OVERLAPPED` structure. The API will immediately +//! return. +//! 4. After some time, the application queries the I/O port for completed +//! events. The port will returned a pointer to the `OVERLAPPED` along with +//! the token presented at registration time. +//! +//! Many I/O operations can be fired off before waiting on a port, and the port +//! will block execution of the calling thread until an I/O event has completed +//! (or a timeout has elapsed). +//! +//! Currently all of these low-level operations are housed in a separate `miow` +//! crate to provide a 0-cost abstraction over IOCP. This crate uses that to +//! implement all fiddly bits so there's very few actual Windows API calls or +//! `unsafe` blocks as a result. +//! +//! [docs]: https://msdn.microsoft.com/en-us/library/windows/desktop/aa365198%28v=vs.85%29.aspx +//! +//! ## Safety of IOCP +//! +//! Unfortunately for us, IOCP is pretty unsafe in terms of Rust lifetimes and +//! such. When an I/O operation is submitted to the kernel, it involves handing +//! the kernel a few pointers like a buffer to read/write, an `OVERLAPPED` +//! structure pointer, and perhaps some other buffers such as for socket +//! addresses. These pointers all have to remain valid **for the entire I/O +//! operation's duration**. +//! +//! There's no way to define a safe lifetime for these pointers/buffers over +//! the span of an I/O operation, so we're forced to add a layer of abstraction +//! (not 0-cost) to make these APIs safe. Currently this implementation +//! basically just boxes everything up on the heap to give it a stable address +//! and then keys off that most of the time. +//! +//! ## From completion to readiness +//! +//! Translating a completion-based model to a readiness-based model is also no +//! easy task, and a significant portion of this implementation is managing this +//! translation. The basic idea behind this implementation is to issue I/O +//! operations preemptively and then translate their completions to a "I'm +//! ready" event. +//! +//! For example, in the case of reading a `TcpSocket`, as soon as a socket is +//! connected (or registered after an accept) a read operation is executed. +//! While the read is in progress calls to `read` will return `WouldBlock`, and +//! once the read is completed we translate the completion notification into a +//! `readable` event. Once the internal buffer is drained (e.g. all data from it +//! has been read) a read operation is re-issued. +//! +//! Write operations are a little different from reads, and the current +//! implementation is to just schedule a write as soon as `write` is first +//! called. While that write operation is in progress all future calls to +//! `write` will return `WouldBlock`. Completion of the write then translates to +//! a `writable` event. Note that this will probably want to add some layer of +//! internal buffering in the future. +//! +//! ## Buffer Management +//! +//! As there's lots of I/O operations in flight at any one point in time, +//! there's lots of live buffers that need to be juggled around (e.g. this +//! implementation's own internal buffers). +//! +//! Currently all buffers are created for the I/O operation at hand and are then +//! discarded when it completes (this is listed as future work below). +//! +//! ## Callback Management +//! +//! When the main event loop receives a notification that an I/O operation has +//! completed, some work needs to be done to translate that to a set of events +//! or perhaps some more I/O needs to be scheduled. For example after a +//! `TcpStream` is connected it generates a writable event and also schedules a +//! read. +//! +//! To manage all this the `Selector` uses the `OVERLAPPED` pointer from the +//! completion status. The selector assumes that all `OVERLAPPED` pointers are +//! actually pointers to the interior of a `selector::Overlapped` which means +//! that right after the `OVERLAPPED` itself there's a function pointer. This +//! function pointer is given the completion status as well as another callback +//! to push events onto the selector. +//! +//! The callback for each I/O operation doesn't have any environment, so it +//! relies on memory layout and unsafe casting to translate an `OVERLAPPED` +//! pointer (or in this case a `selector::Overlapped` pointer) to a type of +//! `FromRawArc<T>` (see module docs for why this type exists). +//! +//! ## Thread Safety +//! +//! Currently all of the I/O primitives make liberal use of `Arc` and `Mutex` +//! as an implementation detail. The main reason for this is to ensure that the +//! types are `Send` and `Sync`, but the implementations have not been stressed +//! in multithreaded situations yet. As a result, there are bound to be +//! functional surprises in using these concurrently. +//! +//! ## Future Work +//! +//! First up, let's take a look at unimplemented portions of this module: +//! +//! * The `PollOpt::level()` option is currently entirely unimplemented. +//! * Each `EventLoop` currently owns its completion port, but this prevents an +//! I/O handle from being added to multiple event loops (something that can be +//! done on Unix). Additionally, it hinders event loops moving across threads. +//! This should be solved by likely having a global `Selector` which all +//! others then communicate with. +//! * Although Unix sockets don't exist on Windows, there are named pipes and +//! those should likely be bound here in a similar fashion to `TcpStream`. +//! +//! Next up, there are a few performance improvements and optimizations that can +//! still be implemented +//! +//! * Buffer management right now is pretty bad, they're all just allocated +//! right before an I/O operation and discarded right after. There should at +//! least be some form of buffering buffers. +//! * No calls to `write` are internally buffered before being scheduled, which +//! means that writing performance is abysmal compared to Unix. There should +//! be some level of buffering of writes probably. + +use std::io; +use std::os::windows::prelude::*; + +mod kernel32 { + pub use ::winapi::um::ioapiset::CancelIoEx; + pub use ::winapi::um::winbase::SetFileCompletionNotificationModes; +} +mod winapi { + pub use ::winapi::shared::minwindef::{TRUE, UCHAR}; + pub use ::winapi::um::winnt::HANDLE; +} + +mod awakener; +#[macro_use] +mod selector; +mod tcp; +mod udp; +mod from_raw_arc; +mod buffer_pool; + +pub use self::awakener::Awakener; +pub use self::selector::{Events, Selector, Overlapped, Binding}; +pub use self::tcp::{TcpStream, TcpListener}; +pub use self::udp::UdpSocket; + +#[derive(Copy, Clone)] +enum Family { + V4, V6, +} + +unsafe fn cancel(socket: &AsRawSocket, + overlapped: &Overlapped) -> io::Result<()> { + let handle = socket.as_raw_socket() as winapi::HANDLE; + let ret = kernel32::CancelIoEx(handle, overlapped.as_mut_ptr()); + if ret == 0 { + Err(io::Error::last_os_error()) + } else { + Ok(()) + } +} + +unsafe fn no_notify_on_instant_completion(handle: winapi::HANDLE) -> io::Result<()> { + // TODO: move those to winapi + const FILE_SKIP_COMPLETION_PORT_ON_SUCCESS: winapi::UCHAR = 1; + const FILE_SKIP_SET_EVENT_ON_HANDLE: winapi::UCHAR = 2; + + let flags = FILE_SKIP_COMPLETION_PORT_ON_SUCCESS | FILE_SKIP_SET_EVENT_ON_HANDLE; + + let r = kernel32::SetFileCompletionNotificationModes(handle, flags); + if r == winapi::TRUE { + Ok(()) + } else { + Err(io::Error::last_os_error()) + } +} diff --git a/third_party/rust/mio-0.6.23/src/sys/windows/selector.rs b/third_party/rust/mio-0.6.23/src/sys/windows/selector.rs new file mode 100644 index 0000000000..23b145acdd --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/sys/windows/selector.rs @@ -0,0 +1,538 @@ +#![allow(deprecated)] + +use std::{fmt, io}; +use std::cell::UnsafeCell; +use std::os::windows::prelude::*; +use std::sync::{Arc, Mutex}; +use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT}; +use std::time::Duration; + +use lazycell::AtomicLazyCell; + +use winapi::shared::winerror::WAIT_TIMEOUT; +use winapi::um::minwinbase::{OVERLAPPED, OVERLAPPED_ENTRY}; +use miow; +use miow::iocp::{CompletionPort, CompletionStatus}; + +use event_imp::{Event, Evented, Ready}; +use poll::{self, Poll}; +use sys::windows::buffer_pool::BufferPool; +use {Token, PollOpt}; + +/// Each Selector has a globally unique(ish) ID associated with it. This ID +/// gets tracked by `TcpStream`, `TcpListener`, etc... when they are first +/// registered with the `Selector`. If a type that is previously associated with +/// a `Selector` attempts to register itself with a different `Selector`, the +/// operation will return with an error. This matches windows behavior. +static NEXT_ID: AtomicUsize = ATOMIC_USIZE_INIT; + +/// The guts of the Windows event loop, this is the struct which actually owns +/// a completion port. +/// +/// Internally this is just an `Arc`, and this allows handing out references to +/// the internals to I/O handles registered on this selector. This is +/// required to schedule I/O operations independently of being inside the event +/// loop (e.g. when a call to `write` is seen we're not "in the event loop"). +pub struct Selector { + inner: Arc<SelectorInner>, +} + +struct SelectorInner { + /// Unique identifier of the `Selector` + id: usize, + + /// The actual completion port that's used to manage all I/O + port: CompletionPort, + + /// A pool of buffers usable by this selector. + /// + /// Primitives will take buffers from this pool to perform I/O operations, + /// and once complete they'll be put back in. + buffers: Mutex<BufferPool>, +} + +impl Selector { + pub fn new() -> io::Result<Selector> { + // offset by 1 to avoid choosing 0 as the id of a selector + let id = NEXT_ID.fetch_add(1, Ordering::Relaxed) + 1; + + CompletionPort::new(0).map(|cp| { + Selector { + inner: Arc::new(SelectorInner { + id: id, + port: cp, + buffers: Mutex::new(BufferPool::new(256)), + }), + } + }) + } + + pub fn select(&self, + events: &mut Events, + awakener: Token, + timeout: Option<Duration>) -> io::Result<bool> { + trace!("select; timeout={:?}", timeout); + + // Clear out the previous list of I/O events and get some more! + events.clear(); + + trace!("polling IOCP"); + let n = match self.inner.port.get_many(&mut events.statuses, timeout) { + Ok(statuses) => statuses.len(), + Err(ref e) if e.raw_os_error() == Some(WAIT_TIMEOUT as i32) => 0, + Err(e) => return Err(e), + }; + + let mut ret = false; + for status in events.statuses[..n].iter() { + // This should only ever happen from the awakener, and we should + // only ever have one awakener right now, so assert as such. + if status.overlapped() as usize == 0 { + assert_eq!(status.token(), usize::from(awakener)); + ret = true; + continue; + } + + let callback = unsafe { + (*(status.overlapped() as *mut Overlapped)).callback + }; + + trace!("select; -> got overlapped"); + callback(status.entry()); + } + + trace!("returning"); + Ok(ret) + } + + /// Gets a reference to the underlying `CompletionPort` structure. + pub fn port(&self) -> &CompletionPort { + &self.inner.port + } + + /// Gets a new reference to this selector, although all underlying data + /// structures will refer to the same completion port. + pub fn clone_ref(&self) -> Selector { + Selector { inner: self.inner.clone() } + } + + /// Return the `Selector`'s identifier + pub fn id(&self) -> usize { + self.inner.id + } +} + +impl SelectorInner { + fn identical(&self, other: &SelectorInner) -> bool { + (self as *const SelectorInner) == (other as *const SelectorInner) + } +} + +// A registration is stored in each I/O object which keeps track of how it is +// associated with a `Selector` above. +// +// Once associated with a `Selector`, a registration can never be un-associated +// (due to IOCP requirements). This is actually implemented through the +// `poll::Registration` and `poll::SetReadiness` APIs to keep track of all the +// level/edge/filtering business. +/// A `Binding` is embedded in all I/O objects associated with a `Poll` +/// object. +/// +/// Each registration keeps track of which selector the I/O object is +/// associated with, ensuring that implementations of `Evented` can be +/// conformant for the various methods on Windows. +/// +/// If you're working with custom IOCP-enabled objects then you'll want to +/// ensure that one of these instances is stored in your object and used in the +/// implementation of `Evented`. +/// +/// For more information about how to use this see the `windows` module +/// documentation in this crate. +pub struct Binding { + selector: AtomicLazyCell<Arc<SelectorInner>>, +} + +impl Binding { + /// Creates a new blank binding ready to be inserted into an I/O + /// object. + /// + /// Won't actually do anything until associated with a `Poll` loop. + pub fn new() -> Binding { + Binding { selector: AtomicLazyCell::new() } + } + + /// Registers a new handle with the `Poll` specified, also assigning the + /// `token` specified. + /// + /// This function is intended to be used as part of `Evented::register` for + /// custom IOCP objects. It will add the specified handle to the internal + /// IOCP object with the provided `token`. All future events generated by + /// the handled provided will be received by the `Poll`'s internal IOCP + /// object. + /// + /// # Unsafety + /// + /// This function is unsafe as the `Poll` instance has assumptions about + /// what the `OVERLAPPED` pointer used for each I/O operation looks like. + /// Specifically they must all be instances of the `Overlapped` type in + /// this crate. More information about this can be found on the + /// `windows` module in this crate. + pub unsafe fn register_handle(&self, + handle: &AsRawHandle, + token: Token, + poll: &Poll) -> io::Result<()> { + let selector = poll::selector(poll); + + // Ignore errors, we'll see them on the next line. + drop(self.selector.fill(selector.inner.clone())); + self.check_same_selector(poll)?; + + selector.inner.port.add_handle(usize::from(token), handle) + } + + /// Same as `register_handle` but for sockets. + pub unsafe fn register_socket(&self, + handle: &AsRawSocket, + token: Token, + poll: &Poll) -> io::Result<()> { + let selector = poll::selector(poll); + drop(self.selector.fill(selector.inner.clone())); + self.check_same_selector(poll)?; + selector.inner.port.add_socket(usize::from(token), handle) + } + + /// Reregisters the handle provided from the `Poll` provided. + /// + /// This is intended to be used as part of `Evented::reregister` but note + /// that this function does not currently reregister the provided handle + /// with the `poll` specified. IOCP has a special binding for changing the + /// token which has not yet been implemented. Instead this function should + /// be used to assert that the call to `reregister` happened on the same + /// `Poll` that was passed into to `register`. + /// + /// Eventually, though, the provided `handle` will be re-assigned to have + /// the token `token` on the given `poll` assuming that it's been + /// previously registered with it. + /// + /// # Unsafety + /// + /// This function is unsafe for similar reasons to `register`. That is, + /// there may be pending I/O events and such which aren't handled correctly. + pub unsafe fn reregister_handle(&self, + _handle: &AsRawHandle, + _token: Token, + poll: &Poll) -> io::Result<()> { + self.check_same_selector(poll) + } + + /// Same as `reregister_handle`, but for sockets. + pub unsafe fn reregister_socket(&self, + _socket: &AsRawSocket, + _token: Token, + poll: &Poll) -> io::Result<()> { + self.check_same_selector(poll) + } + + /// Deregisters the handle provided from the `Poll` provided. + /// + /// This is intended to be used as part of `Evented::deregister` but note + /// that this function does not currently deregister the provided handle + /// from the `poll` specified. IOCP has a special binding for that which has + /// not yet been implemented. Instead this function should be used to assert + /// that the call to `deregister` happened on the same `Poll` that was + /// passed into to `register`. + /// + /// # Unsafety + /// + /// This function is unsafe for similar reasons to `register`. That is, + /// there may be pending I/O events and such which aren't handled correctly. + pub unsafe fn deregister_handle(&self, + _handle: &AsRawHandle, + poll: &Poll) -> io::Result<()> { + self.check_same_selector(poll) + } + + /// Same as `deregister_handle`, but for sockets. + pub unsafe fn deregister_socket(&self, + _socket: &AsRawSocket, + poll: &Poll) -> io::Result<()> { + self.check_same_selector(poll) + } + + fn check_same_selector(&self, poll: &Poll) -> io::Result<()> { + let selector = poll::selector(poll); + match self.selector.borrow() { + Some(prev) if prev.identical(&selector.inner) => Ok(()), + Some(_) | + None => Err(other("socket already registered")), + } + } +} + +impl fmt::Debug for Binding { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.debug_struct("Binding") + .finish() + } +} + +/// Helper struct used for TCP and UDP which bundles a `binding` with a +/// `SetReadiness` handle. +pub struct ReadyBinding { + binding: Binding, + readiness: Option<poll::SetReadiness>, +} + +impl ReadyBinding { + /// Creates a new blank binding ready to be inserted into an I/O object. + /// + /// Won't actually do anything until associated with an `Selector` loop. + pub fn new() -> ReadyBinding { + ReadyBinding { + binding: Binding::new(), + readiness: None, + } + } + + /// Returns whether this binding has been associated with a selector + /// yet. + pub fn registered(&self) -> bool { + self.readiness.is_some() + } + + /// Acquires a buffer with at least `size` capacity. + /// + /// If associated with a selector, this will attempt to pull a buffer from + /// that buffer pool. If not associated with a selector, this will allocate + /// a fresh buffer. + pub fn get_buffer(&self, size: usize) -> Vec<u8> { + match self.binding.selector.borrow() { + Some(i) => i.buffers.lock().unwrap().get(size), + None => Vec::with_capacity(size), + } + } + + /// Returns a buffer to this binding. + /// + /// If associated with a selector, this will push the buffer back into the + /// selector's pool of buffers. Otherwise this will just drop the buffer. + pub fn put_buffer(&self, buf: Vec<u8>) { + if let Some(i) = self.binding.selector.borrow() { + i.buffers.lock().unwrap().put(buf); + } + } + + /// Sets the readiness of this I/O object to a particular `set`. + /// + /// This is later used to fill out and respond to requests to `poll`. Note + /// that this is all implemented through the `SetReadiness` structure in the + /// `poll` module. + pub fn set_readiness(&self, set: Ready) { + if let Some(ref i) = self.readiness { + trace!("set readiness to {:?}", set); + i.set_readiness(set).expect("event loop disappeared?"); + } + } + + /// Queries what the current readiness of this I/O object is. + /// + /// This is what's being used to generate events returned by `poll`. + pub fn readiness(&self) -> Ready { + match self.readiness { + Some(ref i) => i.readiness(), + None => Ready::empty(), + } + } + + /// Implementation of the `Evented::register` function essentially. + /// + /// Returns an error if we're already registered with another event loop, + /// and otherwise just reassociates ourselves with the event loop to + /// possible change tokens. + pub fn register_socket(&mut self, + socket: &AsRawSocket, + poll: &Poll, + token: Token, + events: Ready, + opts: PollOpt, + registration: &Mutex<Option<poll::Registration>>) + -> io::Result<()> { + trace!("register {:?} {:?}", token, events); + unsafe { + self.binding.register_socket(socket, token, poll)?; + } + + let (r, s) = poll::new_registration(poll, token, events, opts); + self.readiness = Some(s); + *registration.lock().unwrap() = Some(r); + Ok(()) + } + + /// Implementation of `Evented::reregister` function. + pub fn reregister_socket(&mut self, + socket: &AsRawSocket, + poll: &Poll, + token: Token, + events: Ready, + opts: PollOpt, + registration: &Mutex<Option<poll::Registration>>) + -> io::Result<()> { + trace!("reregister {:?} {:?}", token, events); + unsafe { + self.binding.reregister_socket(socket, token, poll)?; + } + + registration.lock().unwrap() + .as_mut().unwrap() + .reregister(poll, token, events, opts) + } + + /// Implementation of the `Evented::deregister` function. + /// + /// Doesn't allow registration with another event loop, just shuts down + /// readiness notifications and such. + pub fn deregister(&mut self, + socket: &AsRawSocket, + poll: &Poll, + registration: &Mutex<Option<poll::Registration>>) + -> io::Result<()> { + trace!("deregistering"); + unsafe { + self.binding.deregister_socket(socket, poll)?; + } + + registration.lock().unwrap() + .as_ref().unwrap() + .deregister(poll) + } +} + +fn other(s: &str) -> io::Error { + io::Error::new(io::ErrorKind::Other, s) +} + +#[derive(Debug)] +pub struct Events { + /// Raw I/O event completions are filled in here by the call to `get_many` + /// on the completion port above. These are then processed to run callbacks + /// which figure out what to do after the event is done. + statuses: Box<[CompletionStatus]>, + + /// Literal events returned by `get` to the upwards `EventLoop`. This file + /// doesn't really modify this (except for the awakener), instead almost all + /// events are filled in by the `ReadinessQueue` from the `poll` module. + events: Vec<Event>, +} + +impl Events { + pub fn with_capacity(cap: usize) -> Events { + // Note that it's possible for the output `events` to grow beyond the + // capacity as it can also include deferred events, but that's certainly + // not the end of the world! + Events { + statuses: vec![CompletionStatus::zero(); cap].into_boxed_slice(), + events: Vec::with_capacity(cap), + } + } + + pub fn is_empty(&self) -> bool { + self.events.is_empty() + } + + pub fn len(&self) -> usize { + self.events.len() + } + + pub fn capacity(&self) -> usize { + self.events.capacity() + } + + pub fn get(&self, idx: usize) -> Option<Event> { + self.events.get(idx).map(|e| *e) + } + + pub fn push_event(&mut self, event: Event) { + self.events.push(event); + } + + pub fn clear(&mut self) { + self.events.truncate(0); + } +} + +macro_rules! overlapped2arc { + ($e:expr, $t:ty, $($field:ident).+) => ( + #[allow(deref_nullptr)] + { + let offset = offset_of!($t, $($field).+); + debug_assert!(offset < mem::size_of::<$t>()); + FromRawArc::from_raw(($e as usize - offset) as *mut $t) + } + ) +} + +macro_rules! offset_of { + ($t:ty, $($field:ident).+) => ( + &(*(0 as *const $t)).$($field).+ as *const _ as usize + ) +} + +// See sys::windows module docs for why this exists. +// +// The gist of it is that `Selector` assumes that all `OVERLAPPED` pointers are +// actually inside one of these structures so it can use the `Callback` stored +// right after it. +// +// We use repr(C) here to ensure that we can assume the overlapped pointer is +// at the start of the structure so we can just do a cast. +/// A wrapper around an internal instance over `miow::Overlapped` which is in +/// turn a wrapper around the Windows type `OVERLAPPED`. +/// +/// This type is required to be used for all IOCP operations on handles that are +/// registered with an event loop. The event loop will receive notifications +/// over `OVERLAPPED` pointers that have completed, and it will cast that +/// pointer to a pointer to this structure and invoke the associated callback. +#[repr(C)] +pub struct Overlapped { + inner: UnsafeCell<miow::Overlapped>, + callback: fn(&OVERLAPPED_ENTRY), +} + +impl Overlapped { + /// Creates a new `Overlapped` which will invoke the provided `cb` callback + /// whenever it's triggered. + /// + /// The returned `Overlapped` must be used as the `OVERLAPPED` passed to all + /// I/O operations that are registered with mio's event loop. When the I/O + /// operation associated with an `OVERLAPPED` pointer completes the event + /// loop will invoke the function pointer provided by `cb`. + pub fn new(cb: fn(&OVERLAPPED_ENTRY)) -> Overlapped { + Overlapped { + inner: UnsafeCell::new(miow::Overlapped::zero()), + callback: cb, + } + } + + /// Get the underlying `Overlapped` instance as a raw pointer. + /// + /// This can be useful when only a shared borrow is held and the overlapped + /// pointer needs to be passed down to winapi. + pub fn as_mut_ptr(&self) -> *mut OVERLAPPED { + unsafe { + (*self.inner.get()).raw() + } + } +} + +impl fmt::Debug for Overlapped { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.debug_struct("Overlapped") + .finish() + } +} + +// Overlapped's APIs are marked as unsafe Overlapped's APIs are marked as +// unsafe as they must be used with caution to ensure thread safety. The +// structure itself is safe to send across threads. +unsafe impl Send for Overlapped {} +unsafe impl Sync for Overlapped {} diff --git a/third_party/rust/mio-0.6.23/src/sys/windows/tcp.rs b/third_party/rust/mio-0.6.23/src/sys/windows/tcp.rs new file mode 100644 index 0000000000..236e7866a6 --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/sys/windows/tcp.rs @@ -0,0 +1,853 @@ +use std::fmt; +use std::io::{self, Read, ErrorKind}; +use std::mem; +use std::net::{self, SocketAddr, Shutdown}; +use std::os::windows::prelude::*; +use std::sync::{Mutex, MutexGuard}; +use std::time::Duration; + +use miow::iocp::CompletionStatus; +use miow::net::*; +use net2::{TcpBuilder, TcpStreamExt as Net2TcpExt}; +use winapi::um::minwinbase::OVERLAPPED_ENTRY; +use winapi::um::winnt::HANDLE; +use iovec::IoVec; + +use {poll, Ready, Poll, PollOpt, Token}; +use event::Evented; +use sys::windows::from_raw_arc::FromRawArc; +use sys::windows::selector::{Overlapped, ReadyBinding}; +use sys::windows::Family; + +pub struct TcpStream { + /// Separately stored implementation to ensure that the `Drop` + /// implementation on this type is only executed when it's actually dropped + /// (many clones of this `imp` are made). + imp: StreamImp, + registration: Mutex<Option<poll::Registration>>, +} + +pub struct TcpListener { + imp: ListenerImp, + registration: Mutex<Option<poll::Registration>>, +} + +#[derive(Clone)] +struct StreamImp { + /// A stable address and synchronized access for all internals. This serves + /// to ensure that all `Overlapped` pointers are valid for a long period of + /// time as well as allowing completion callbacks to have access to the + /// internals without having ownership. + /// + /// Note that the reference count also allows us "loan out" copies to + /// completion ports while I/O is running to guarantee that this stays alive + /// until the I/O completes. You'll notice a number of calls to + /// `mem::forget` below, and these only happen on successful scheduling of + /// I/O and are paired with `overlapped2arc!` macro invocations in the + /// completion callbacks (to have a decrement match the increment). + inner: FromRawArc<StreamIo>, +} + +#[derive(Clone)] +struct ListenerImp { + inner: FromRawArc<ListenerIo>, +} + +struct StreamIo { + inner: Mutex<StreamInner>, + read: Overlapped, // also used for connect + write: Overlapped, + socket: net::TcpStream, +} + +struct ListenerIo { + inner: Mutex<ListenerInner>, + accept: Overlapped, + family: Family, + socket: net::TcpListener, +} + +struct StreamInner { + iocp: ReadyBinding, + deferred_connect: Option<SocketAddr>, + read: State<(), ()>, + write: State<(Vec<u8>, usize), (Vec<u8>, usize)>, + /// whether we are instantly notified of success + /// (FILE_SKIP_COMPLETION_PORT_ON_SUCCESS, + /// without a roundtrip through the event loop) + instant_notify: bool, +} + +struct ListenerInner { + iocp: ReadyBinding, + accept: State<net::TcpStream, (net::TcpStream, SocketAddr)>, + accept_buf: AcceptAddrsBuf, +} + +enum State<T, U> { + Empty, // no I/O operation in progress + Pending(T), // an I/O operation is in progress + Ready(U), // I/O has finished with this value + Error(io::Error), // there was an I/O error +} + +impl TcpStream { + fn new(socket: net::TcpStream, + deferred_connect: Option<SocketAddr>) -> TcpStream { + TcpStream { + registration: Mutex::new(None), + imp: StreamImp { + inner: FromRawArc::new(StreamIo { + read: Overlapped::new(read_done), + write: Overlapped::new(write_done), + socket: socket, + inner: Mutex::new(StreamInner { + iocp: ReadyBinding::new(), + deferred_connect: deferred_connect, + read: State::Empty, + write: State::Empty, + instant_notify: false, + }), + }), + }, + } + } + + pub fn connect(socket: net::TcpStream, addr: &SocketAddr) + -> io::Result<TcpStream> { + socket.set_nonblocking(true)?; + Ok(TcpStream::new(socket, Some(*addr))) + } + + pub fn from_stream(stream: net::TcpStream) -> TcpStream { + TcpStream::new(stream, None) + } + + pub fn peer_addr(&self) -> io::Result<SocketAddr> { + self.imp.inner.socket.peer_addr() + } + + pub fn local_addr(&self) -> io::Result<SocketAddr> { + self.imp.inner.socket.local_addr() + } + + pub fn try_clone(&self) -> io::Result<TcpStream> { + self.imp.inner.socket.try_clone().map(|s| TcpStream::new(s, None)) + } + + pub fn shutdown(&self, how: Shutdown) -> io::Result<()> { + self.imp.inner.socket.shutdown(how) + } + + pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> { + self.imp.inner.socket.set_nodelay(nodelay) + } + + pub fn nodelay(&self) -> io::Result<bool> { + self.imp.inner.socket.nodelay() + } + + pub fn set_recv_buffer_size(&self, size: usize) -> io::Result<()> { + self.imp.inner.socket.set_recv_buffer_size(size) + } + + pub fn recv_buffer_size(&self) -> io::Result<usize> { + self.imp.inner.socket.recv_buffer_size() + } + + pub fn set_send_buffer_size(&self, size: usize) -> io::Result<()> { + self.imp.inner.socket.set_send_buffer_size(size) + } + + pub fn send_buffer_size(&self) -> io::Result<usize> { + self.imp.inner.socket.send_buffer_size() + } + + pub fn set_keepalive(&self, keepalive: Option<Duration>) -> io::Result<()> { + self.imp.inner.socket.set_keepalive(keepalive) + } + + pub fn keepalive(&self) -> io::Result<Option<Duration>> { + self.imp.inner.socket.keepalive() + } + + pub fn set_ttl(&self, ttl: u32) -> io::Result<()> { + self.imp.inner.socket.set_ttl(ttl) + } + + pub fn ttl(&self) -> io::Result<u32> { + self.imp.inner.socket.ttl() + } + + pub fn set_only_v6(&self, only_v6: bool) -> io::Result<()> { + self.imp.inner.socket.set_only_v6(only_v6) + } + + pub fn only_v6(&self) -> io::Result<bool> { + self.imp.inner.socket.only_v6() + } + + pub fn set_linger(&self, dur: Option<Duration>) -> io::Result<()> { + Net2TcpExt::set_linger(&self.imp.inner.socket, dur) + } + + pub fn linger(&self) -> io::Result<Option<Duration>> { + Net2TcpExt::linger(&self.imp.inner.socket) + } + + pub fn take_error(&self) -> io::Result<Option<io::Error>> { + if let Some(e) = self.imp.inner.socket.take_error()? { + return Ok(Some(e)) + } + + // If the syscall didn't return anything then also check to see if we've + // squirreled away an error elsewhere for example as part of a connect + // operation. + // + // Typically this is used like so: + // + // 1. A `connect` is issued + // 2. Wait for the socket to be writable + // 3. Call `take_error` to see if the connect succeeded. + // + // Right now the `connect` operation finishes in `read_done` below and + // fill will in `State::Error` in the `read` slot if it fails, so we + // extract that here. + let mut me = self.inner(); + match mem::replace(&mut me.read, State::Empty) { + State::Error(e) => { + self.imp.schedule_read(&mut me); + Ok(Some(e)) + } + other => { + me.read = other; + Ok(None) + } + } + } + + fn inner(&self) -> MutexGuard<StreamInner> { + self.imp.inner() + } + + fn before_read(&self) -> io::Result<MutexGuard<StreamInner>> { + let mut me = self.inner(); + + match me.read { + // Empty == we're not associated yet, and if we're pending then + // these are both cases where we return "would block" + State::Empty | + State::Pending(()) => return Err(io::ErrorKind::WouldBlock.into()), + + // If we got a delayed error as part of a `read_overlapped` below, + // return that here. Also schedule another read in case it was + // transient. + State::Error(_) => { + let e = match mem::replace(&mut me.read, State::Empty) { + State::Error(e) => e, + _ => panic!(), + }; + self.imp.schedule_read(&mut me); + return Err(e) + } + + // If we're ready for a read then some previous 0-byte read has + // completed. In that case the OS's socket buffer has something for + // us, so we just keep pulling out bytes while we can in the loop + // below. + State::Ready(()) => {} + } + + Ok(me) + } + + fn post_register(&self, interest: Ready, me: &mut StreamInner) { + if interest.is_readable() { + self.imp.schedule_read(me); + } + + // At least with epoll, if a socket is registered with an interest in + // writing and it's immediately writable then a writable event is + // generated immediately, so do so here. + if interest.is_writable() { + if let State::Empty = me.write { + self.imp.add_readiness(me, Ready::writable()); + } + } + } + + pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> { + match IoVec::from_bytes_mut(buf) { + Some(vec) => self.readv(&mut [vec]), + None => Ok(0), + } + } + + pub fn peek(&self, buf: &mut [u8]) -> io::Result<usize> { + let mut me = self.before_read()?; + + match (&self.imp.inner.socket).peek(buf) { + Ok(n) => Ok(n), + Err(e) => { + me.read = State::Empty; + self.imp.schedule_read(&mut me); + Err(e) + } + } + } + + pub fn readv(&self, bufs: &mut [&mut IoVec]) -> io::Result<usize> { + let mut me = self.before_read()?; + + // TODO: Does WSARecv work on a nonblocking sockets? We ideally want to + // call that instead of looping over all the buffers and calling + // `recv` on each buffer. I'm not sure though if an overlapped + // socket in nonblocking mode would work with that use case, + // however, so for now we just call `recv`. + + let mut amt = 0; + for buf in bufs { + match (&self.imp.inner.socket).read(buf) { + // If we did a partial read, then return what we've read so far + Ok(n) if n < buf.len() => return Ok(amt + n), + + // Otherwise filled this buffer entirely, so try to fill the + // next one as well. + Ok(n) => amt += n, + + // If we hit an error then things get tricky if we've already + // read some data. If the error is "would block" then we just + // return the data we've read so far while scheduling another + // 0-byte read. + // + // If we've read data and the error kind is not "would block", + // then we stash away the error to get returned later and return + // the data that we've read. + // + // Finally if we haven't actually read any data we just + // reschedule a 0-byte read to happen again and then return the + // error upwards. + Err(e) => { + if amt > 0 && e.kind() == io::ErrorKind::WouldBlock { + me.read = State::Empty; + self.imp.schedule_read(&mut me); + return Ok(amt) + } else if amt > 0 { + me.read = State::Error(e); + return Ok(amt) + } else { + me.read = State::Empty; + self.imp.schedule_read(&mut me); + return Err(e) + } + } + } + } + + Ok(amt) + } + + pub fn write(&self, buf: &[u8]) -> io::Result<usize> { + match IoVec::from_bytes(buf) { + Some(vec) => self.writev(&[vec]), + None => Ok(0), + } + } + + pub fn writev(&self, bufs: &[&IoVec]) -> io::Result<usize> { + let mut me = self.inner(); + let me = &mut *me; + + match mem::replace(&mut me.write, State::Empty) { + State::Empty => {} + State::Error(e) => return Err(e), + other => { + me.write = other; + return Err(io::ErrorKind::WouldBlock.into()) + } + } + + if !me.iocp.registered() { + return Err(io::ErrorKind::WouldBlock.into()) + } + + if bufs.is_empty() { + return Ok(0) + } + + let len = bufs.iter().map(|b| b.len()).fold(0, |a, b| a + b); + let mut intermediate = me.iocp.get_buffer(len); + for buf in bufs { + intermediate.extend_from_slice(buf); + } + self.imp.schedule_write(intermediate, 0, me); + Ok(len) + } + + pub fn flush(&self) -> io::Result<()> { + Ok(()) + } +} + +impl StreamImp { + fn inner(&self) -> MutexGuard<StreamInner> { + self.inner.inner.lock().unwrap() + } + + fn schedule_connect(&self, addr: &SocketAddr) -> io::Result<()> { + unsafe { + trace!("scheduling a connect"); + self.inner.socket.connect_overlapped(addr, &[], self.inner.read.as_mut_ptr())?; + } + // see docs above on StreamImp.inner for rationale on forget + mem::forget(self.clone()); + Ok(()) + } + + /// Schedule a read to happen on this socket, enqueuing us to receive a + /// notification when a read is ready. + /// + /// Note that this does *not* work with a buffer. When reading a TCP stream + /// we actually read into a 0-byte buffer so Windows will send us a + /// notification when the socket is otherwise ready for reading. This allows + /// us to avoid buffer allocations for in-flight reads. + fn schedule_read(&self, me: &mut StreamInner) { + match me.read { + State::Empty => {} + State::Ready(_) | State::Error(_) => { + self.add_readiness(me, Ready::readable()); + return; + } + _ => return, + } + + me.iocp.set_readiness(me.iocp.readiness() - Ready::readable()); + + trace!("scheduling a read"); + let res = unsafe { + self.inner.socket.read_overlapped(&mut [], self.inner.read.as_mut_ptr()) + }; + match res { + // Note that `Ok(true)` means that this completed immediately and + // our socket is readable. This typically means that the caller of + // this function (likely `read` above) can try again as an + // optimization and return bytes quickly. + // + // Normally, though, although the read completed immediately + // there's still an IOCP completion packet enqueued that we're going + // to receive. + // + // You can configure this behavior (miow) with + // SetFileCompletionNotificationModes to indicate that `Ok(true)` + // does **not** enqueue a completion packet. (This is the case + // for me.instant_notify) + // + // Note that apparently libuv has scary code to work around bugs in + // `WSARecv` for UDP sockets apparently for handles which have had + // the `SetFileCompletionNotificationModes` function called on them, + // worth looking into! + Ok(Some(_)) if me.instant_notify => { + me.read = State::Ready(()); + self.add_readiness(me, Ready::readable()); + } + Ok(_) => { + // see docs above on StreamImp.inner for rationale on forget + me.read = State::Pending(()); + mem::forget(self.clone()); + } + Err(e) => { + me.read = State::Error(e); + self.add_readiness(me, Ready::readable()); + } + } + } + + /// Similar to `schedule_read`, except that this issues, well, writes. + /// + /// This function will continually attempt to write the entire contents of + /// the buffer `buf` until they have all been written. The `pos` argument is + /// the current offset within the buffer up to which the contents have + /// already been written. + /// + /// A new writable event (e.g. allowing another write) will only happen once + /// the buffer has been written completely (or hit an error). + fn schedule_write(&self, + buf: Vec<u8>, + mut pos: usize, + me: &mut StreamInner) { + + // About to write, clear any pending level triggered events + me.iocp.set_readiness(me.iocp.readiness() - Ready::writable()); + + loop { + trace!("scheduling a write of {} bytes", buf[pos..].len()); + let ret = unsafe { + self.inner.socket.write_overlapped(&buf[pos..], self.inner.write.as_mut_ptr()) + }; + match ret { + Ok(Some(transferred_bytes)) if me.instant_notify => { + trace!("done immediately with {} bytes", transferred_bytes); + if transferred_bytes == buf.len() - pos { + self.add_readiness(me, Ready::writable()); + me.write = State::Empty; + break; + } + pos += transferred_bytes; + } + Ok(_) => { + trace!("scheduled for later"); + // see docs above on StreamImp.inner for rationale on forget + me.write = State::Pending((buf, pos)); + mem::forget(self.clone()); + break; + } + Err(e) => { + trace!("write error: {}", e); + me.write = State::Error(e); + self.add_readiness(me, Ready::writable()); + me.iocp.put_buffer(buf); + break; + } + } + } + } + + /// Pushes an event for this socket onto the selector its registered for. + /// + /// When an event is generated on this socket, if it happened after the + /// socket was closed then we don't want to actually push the event onto our + /// selector as otherwise it's just a spurious notification. + fn add_readiness(&self, me: &mut StreamInner, set: Ready) { + me.iocp.set_readiness(set | me.iocp.readiness()); + } +} + +fn read_done(status: &OVERLAPPED_ENTRY) { + let status = CompletionStatus::from_entry(status); + let me2 = StreamImp { + inner: unsafe { overlapped2arc!(status.overlapped(), StreamIo, read) }, + }; + + let mut me = me2.inner(); + match mem::replace(&mut me.read, State::Empty) { + State::Pending(()) => { + trace!("finished a read: {}", status.bytes_transferred()); + assert_eq!(status.bytes_transferred(), 0); + me.read = State::Ready(()); + return me2.add_readiness(&mut me, Ready::readable()) + } + s => me.read = s, + } + + // If a read didn't complete, then the connect must have just finished. + trace!("finished a connect"); + + // By guarding with socket.result(), we ensure that a connection + // was successfully made before performing operations requiring a + // connected socket. + match unsafe { me2.inner.socket.result(status.overlapped()) } + .and_then(|_| me2.inner.socket.connect_complete()) + { + Ok(()) => { + me2.add_readiness(&mut me, Ready::writable()); + me2.schedule_read(&mut me); + } + Err(e) => { + me2.add_readiness(&mut me, Ready::readable() | Ready::writable()); + me.read = State::Error(e); + } + } +} + +fn write_done(status: &OVERLAPPED_ENTRY) { + let status = CompletionStatus::from_entry(status); + trace!("finished a write {}", status.bytes_transferred()); + let me2 = StreamImp { + inner: unsafe { overlapped2arc!(status.overlapped(), StreamIo, write) }, + }; + let mut me = me2.inner(); + let (buf, pos) = match mem::replace(&mut me.write, State::Empty) { + State::Pending(pair) => pair, + _ => unreachable!(), + }; + let new_pos = pos + (status.bytes_transferred() as usize); + if new_pos == buf.len() { + me2.add_readiness(&mut me, Ready::writable()); + } else { + me2.schedule_write(buf, new_pos, &mut me); + } +} + +impl Evented for TcpStream { + fn register(&self, poll: &Poll, token: Token, + interest: Ready, opts: PollOpt) -> io::Result<()> { + let mut me = self.inner(); + me.iocp.register_socket(&self.imp.inner.socket, poll, token, + interest, opts, &self.registration)?; + + unsafe { + super::no_notify_on_instant_completion(self.imp.inner.socket.as_raw_socket() as HANDLE)?; + me.instant_notify = true; + } + + // If we were connected before being registered process that request + // here and go along our merry ways. Note that the callback for a + // successful connect will worry about generating writable/readable + // events and scheduling a new read. + if let Some(addr) = me.deferred_connect.take() { + return self.imp.schedule_connect(&addr).map(|_| ()) + } + self.post_register(interest, &mut me); + Ok(()) + } + + fn reregister(&self, poll: &Poll, token: Token, + interest: Ready, opts: PollOpt) -> io::Result<()> { + let mut me = self.inner(); + me.iocp.reregister_socket(&self.imp.inner.socket, poll, token, + interest, opts, &self.registration)?; + self.post_register(interest, &mut me); + Ok(()) + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + self.inner().iocp.deregister(&self.imp.inner.socket, + poll, &self.registration) + } +} + +impl fmt::Debug for TcpStream { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.debug_struct("TcpStream") + .finish() + } +} + +impl Drop for TcpStream { + fn drop(&mut self) { + // If we're still internally reading, we're no longer interested. Note + // though that we don't cancel any writes which may have been issued to + // preserve the same semantics as Unix. + // + // Note that "Empty" here may mean that a connect is pending, so we + // cancel even if that happens as well. + unsafe { + match self.inner().read { + State::Pending(_) | State::Empty => { + trace!("cancelling active TCP read"); + drop(super::cancel(&self.imp.inner.socket, + &self.imp.inner.read)); + } + State::Ready(_) | State::Error(_) => {} + } + } + } +} + +impl TcpListener { + pub fn new(socket: net::TcpListener) + -> io::Result<TcpListener> { + let addr = socket.local_addr()?; + Ok(TcpListener::new_family(socket, match addr { + SocketAddr::V4(..) => Family::V4, + SocketAddr::V6(..) => Family::V6, + })) + } + + fn new_family(socket: net::TcpListener, family: Family) -> TcpListener { + TcpListener { + registration: Mutex::new(None), + imp: ListenerImp { + inner: FromRawArc::new(ListenerIo { + accept: Overlapped::new(accept_done), + family: family, + socket: socket, + inner: Mutex::new(ListenerInner { + iocp: ReadyBinding::new(), + accept: State::Empty, + accept_buf: AcceptAddrsBuf::new(), + }), + }), + }, + } + } + + pub fn accept(&self) -> io::Result<(net::TcpStream, SocketAddr)> { + let mut me = self.inner(); + + let ret = match mem::replace(&mut me.accept, State::Empty) { + State::Empty => return Err(io::ErrorKind::WouldBlock.into()), + State::Pending(t) => { + me.accept = State::Pending(t); + return Err(io::ErrorKind::WouldBlock.into()); + } + State::Ready((s, a)) => Ok((s, a)), + State::Error(e) => Err(e), + }; + + self.imp.schedule_accept(&mut me); + + return ret + } + + pub fn local_addr(&self) -> io::Result<SocketAddr> { + self.imp.inner.socket.local_addr() + } + + pub fn try_clone(&self) -> io::Result<TcpListener> { + self.imp.inner.socket.try_clone().map(|s| { + TcpListener::new_family(s, self.imp.inner.family) + }) + } + + #[allow(deprecated)] + pub fn set_only_v6(&self, only_v6: bool) -> io::Result<()> { + self.imp.inner.socket.set_only_v6(only_v6) + } + + #[allow(deprecated)] + pub fn only_v6(&self) -> io::Result<bool> { + self.imp.inner.socket.only_v6() + } + + pub fn set_ttl(&self, ttl: u32) -> io::Result<()> { + self.imp.inner.socket.set_ttl(ttl) + } + + pub fn ttl(&self) -> io::Result<u32> { + self.imp.inner.socket.ttl() + } + + pub fn take_error(&self) -> io::Result<Option<io::Error>> { + self.imp.inner.socket.take_error() + } + + fn inner(&self) -> MutexGuard<ListenerInner> { + self.imp.inner() + } +} + +impl ListenerImp { + fn inner(&self) -> MutexGuard<ListenerInner> { + self.inner.inner.lock().unwrap() + } + + fn schedule_accept(&self, me: &mut ListenerInner) { + match me.accept { + State::Empty => {} + _ => return + } + + me.iocp.set_readiness(me.iocp.readiness() - Ready::readable()); + + let res = match self.inner.family { + Family::V4 => TcpBuilder::new_v4(), + Family::V6 => TcpBuilder::new_v6(), + } + .and_then(|builder| builder.to_tcp_stream()) + .and_then(|stream| unsafe { + trace!("scheduling an accept"); + self.inner + .socket + .accept_overlapped(&stream, &mut me.accept_buf, self.inner.accept.as_mut_ptr()) + .map(|x| (stream, x)) + }); + match res { + Ok((socket, _)) => { + // see docs above on StreamImp.inner for rationale on forget + me.accept = State::Pending(socket); + mem::forget(self.clone()); + } + Err(e) => { + me.accept = State::Error(e); + self.add_readiness(me, Ready::readable()); + } + } + } + + // See comments in StreamImp::push + fn add_readiness(&self, me: &mut ListenerInner, set: Ready) { + me.iocp.set_readiness(set | me.iocp.readiness()); + } +} + +fn accept_done(status: &OVERLAPPED_ENTRY) { + let status = CompletionStatus::from_entry(status); + let me2 = ListenerImp { + inner: unsafe { overlapped2arc!(status.overlapped(), ListenerIo, accept) }, + }; + + let mut me = me2.inner(); + let socket = match mem::replace(&mut me.accept, State::Empty) { + State::Pending(s) => s, + _ => unreachable!(), + }; + trace!("finished an accept"); + let result = me2.inner.socket.accept_complete(&socket).and_then(|()| { + me.accept_buf.parse(&me2.inner.socket) + }).and_then(|buf| { + buf.remote().ok_or_else(|| { + io::Error::new(ErrorKind::Other, "could not obtain remote address") + }) + }); + me.accept = match result { + Ok(remote_addr) => State::Ready((socket, remote_addr)), + Err(e) => State::Error(e), + }; + me2.add_readiness(&mut me, Ready::readable()); +} + +impl Evented for TcpListener { + fn register(&self, poll: &Poll, token: Token, + interest: Ready, opts: PollOpt) -> io::Result<()> { + let mut me = self.inner(); + me.iocp.register_socket(&self.imp.inner.socket, poll, token, + interest, opts, &self.registration)?; + + unsafe { + super::no_notify_on_instant_completion(self.imp.inner.socket.as_raw_socket() as HANDLE)?; + } + + self.imp.schedule_accept(&mut me); + Ok(()) + } + + fn reregister(&self, poll: &Poll, token: Token, + interest: Ready, opts: PollOpt) -> io::Result<()> { + let mut me = self.inner(); + me.iocp.reregister_socket(&self.imp.inner.socket, poll, token, + interest, opts, &self.registration)?; + self.imp.schedule_accept(&mut me); + Ok(()) + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + self.inner().iocp.deregister(&self.imp.inner.socket, + poll, &self.registration) + } +} + +impl fmt::Debug for TcpListener { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.debug_struct("TcpListener") + .finish() + } +} + +impl Drop for TcpListener { + fn drop(&mut self) { + // If we're still internally reading, we're no longer interested. + unsafe { + match self.inner().accept { + State::Pending(_) => { + trace!("cancelling active TCP accept"); + drop(super::cancel(&self.imp.inner.socket, + &self.imp.inner.accept)); + } + State::Empty | + State::Ready(_) | + State::Error(_) => {} + } + } + } +} diff --git a/third_party/rust/mio-0.6.23/src/sys/windows/udp.rs b/third_party/rust/mio-0.6.23/src/sys/windows/udp.rs new file mode 100644 index 0000000000..f5ea96c324 --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/sys/windows/udp.rs @@ -0,0 +1,414 @@ +//! UDP for IOCP +//! +//! Note that most of this module is quite similar to the TCP module, so if +//! something seems odd you may also want to try the docs over there. + +use std::fmt; +use std::io::prelude::*; +use std::io; +use std::mem; +use std::net::{self, Ipv4Addr, Ipv6Addr, SocketAddr}; +use std::sync::{Mutex, MutexGuard}; + +#[allow(unused_imports)] +use net2::{UdpBuilder, UdpSocketExt}; +use winapi::shared::winerror::WSAEMSGSIZE; +use winapi::um::minwinbase::OVERLAPPED_ENTRY; +use miow::iocp::CompletionStatus; +use miow::net::SocketAddrBuf; +use miow::net::UdpSocketExt as MiowUdpSocketExt; + +use {poll, Ready, Poll, PollOpt, Token}; +use event::Evented; +use sys::windows::from_raw_arc::FromRawArc; +use sys::windows::selector::{Overlapped, ReadyBinding}; + +pub struct UdpSocket { + imp: Imp, + registration: Mutex<Option<poll::Registration>>, +} + +#[derive(Clone)] +struct Imp { + inner: FromRawArc<Io>, +} + +struct Io { + read: Overlapped, + write: Overlapped, + socket: net::UdpSocket, + inner: Mutex<Inner>, +} + +struct Inner { + iocp: ReadyBinding, + read: State<Vec<u8>, Vec<u8>>, + write: State<Vec<u8>, (Vec<u8>, usize)>, + read_buf: SocketAddrBuf, +} + +enum State<T, U> { + Empty, + Pending(T), + Ready(U), + Error(io::Error), +} + +impl UdpSocket { + pub fn new(socket: net::UdpSocket) -> io::Result<UdpSocket> { + Ok(UdpSocket { + registration: Mutex::new(None), + imp: Imp { + inner: FromRawArc::new(Io { + read: Overlapped::new(recv_done), + write: Overlapped::new(send_done), + socket: socket, + inner: Mutex::new(Inner { + iocp: ReadyBinding::new(), + read: State::Empty, + write: State::Empty, + read_buf: SocketAddrBuf::new(), + }), + }), + }, + }) + } + + pub fn local_addr(&self) -> io::Result<SocketAddr> { + self.imp.inner.socket.local_addr() + } + + pub fn try_clone(&self) -> io::Result<UdpSocket> { + self.imp.inner.socket.try_clone().and_then(UdpSocket::new) + } + + /// Note that unlike `TcpStream::write` this function will not attempt to + /// continue writing `buf` until its entirely written. + /// + /// TODO: This... may be wrong in the long run. We're reporting that we + /// successfully wrote all of the bytes in `buf` but it's possible + /// that we don't actually end up writing all of them! + pub fn send_to(&self, buf: &[u8], target: &SocketAddr) + -> io::Result<usize> { + let mut me = self.inner(); + let me = &mut *me; + + match me.write { + State::Empty => {} + _ => return Err(io::ErrorKind::WouldBlock.into()), + } + + if !me.iocp.registered() { + return Err(io::ErrorKind::WouldBlock.into()) + } + + let interest = me.iocp.readiness(); + me.iocp.set_readiness(interest - Ready::writable()); + + let mut owned_buf = me.iocp.get_buffer(64 * 1024); + let amt = owned_buf.write(buf)?; + unsafe { + trace!("scheduling a send"); + self.imp.inner.socket.send_to_overlapped(&owned_buf, target, + self.imp.inner.write.as_mut_ptr()) + }?; + me.write = State::Pending(owned_buf); + mem::forget(self.imp.clone()); + Ok(amt) + } + + /// Note that unlike `TcpStream::write` this function will not attempt to + /// continue writing `buf` until its entirely written. + /// + /// TODO: This... may be wrong in the long run. We're reporting that we + /// successfully wrote all of the bytes in `buf` but it's possible + /// that we don't actually end up writing all of them! + pub fn send(&self, buf: &[u8]) -> io::Result<usize> { + let mut me = self.inner(); + let me = &mut *me; + + match me.write { + State::Empty => {} + _ => return Err(io::ErrorKind::WouldBlock.into()), + } + + if !me.iocp.registered() { + return Err(io::ErrorKind::WouldBlock.into()) + } + + let interest = me.iocp.readiness(); + me.iocp.set_readiness(interest - Ready::writable()); + + let mut owned_buf = me.iocp.get_buffer(64 * 1024); + let amt = owned_buf.write(buf)?; + unsafe { + trace!("scheduling a send"); + self.imp.inner.socket.send_overlapped(&owned_buf, self.imp.inner.write.as_mut_ptr()) + + }?; + me.write = State::Pending(owned_buf); + mem::forget(self.imp.clone()); + Ok(amt) + } + + pub fn recv_from(&self, mut buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> { + let mut me = self.inner(); + match mem::replace(&mut me.read, State::Empty) { + State::Empty => Err(io::ErrorKind::WouldBlock.into()), + State::Pending(b) => { me.read = State::Pending(b); Err(io::ErrorKind::WouldBlock.into()) } + State::Ready(data) => { + // If we weren't provided enough space to receive the message + // then don't actually read any data, just return an error. + if buf.len() < data.len() { + me.read = State::Ready(data); + Err(io::Error::from_raw_os_error(WSAEMSGSIZE as i32)) + } else { + let r = if let Some(addr) = me.read_buf.to_socket_addr() { + buf.write(&data).unwrap(); + Ok((data.len(), addr)) + } else { + Err(io::Error::new(io::ErrorKind::Other, + "failed to parse socket address")) + }; + me.iocp.put_buffer(data); + self.imp.schedule_read_from(&mut me); + r + } + } + State::Error(e) => { + self.imp.schedule_read_from(&mut me); + Err(e) + } + } + } + + pub fn recv(&self, buf: &mut [u8]) + -> io::Result<usize> { + //Since recv_from can be used on connected sockets just call it and drop the address. + self.recv_from(buf).map(|(size,_)| size) + } + + pub fn connect(&self, addr: SocketAddr) -> io::Result<()> { + self.imp.inner.socket.connect(addr) + } + + pub fn broadcast(&self) -> io::Result<bool> { + self.imp.inner.socket.broadcast() + } + + pub fn set_broadcast(&self, on: bool) -> io::Result<()> { + self.imp.inner.socket.set_broadcast(on) + } + + pub fn multicast_loop_v4(&self) -> io::Result<bool> { + self.imp.inner.socket.multicast_loop_v4() + } + + pub fn set_multicast_loop_v4(&self, on: bool) -> io::Result<()> { + self.imp.inner.socket.set_multicast_loop_v4(on) + } + + pub fn multicast_ttl_v4(&self) -> io::Result<u32> { + self.imp.inner.socket.multicast_ttl_v4() + } + + pub fn set_multicast_ttl_v4(&self, ttl: u32) -> io::Result<()> { + self.imp.inner.socket.set_multicast_ttl_v4(ttl) + } + + pub fn multicast_loop_v6(&self) -> io::Result<bool> { + self.imp.inner.socket.multicast_loop_v6() + } + + pub fn set_multicast_loop_v6(&self, on: bool) -> io::Result<()> { + self.imp.inner.socket.set_multicast_loop_v6(on) + } + + pub fn ttl(&self) -> io::Result<u32> { + self.imp.inner.socket.ttl() + } + + pub fn set_ttl(&self, ttl: u32) -> io::Result<()> { + self.imp.inner.socket.set_ttl(ttl) + } + + pub fn join_multicast_v4(&self, + multiaddr: &Ipv4Addr, + interface: &Ipv4Addr) -> io::Result<()> { + self.imp.inner.socket.join_multicast_v4(multiaddr, interface) + } + + pub fn join_multicast_v6(&self, + multiaddr: &Ipv6Addr, + interface: u32) -> io::Result<()> { + self.imp.inner.socket.join_multicast_v6(multiaddr, interface) + } + + pub fn leave_multicast_v4(&self, + multiaddr: &Ipv4Addr, + interface: &Ipv4Addr) -> io::Result<()> { + self.imp.inner.socket.leave_multicast_v4(multiaddr, interface) + } + + pub fn leave_multicast_v6(&self, + multiaddr: &Ipv6Addr, + interface: u32) -> io::Result<()> { + self.imp.inner.socket.leave_multicast_v6(multiaddr, interface) + } + + pub fn set_only_v6(&self, only_v6: bool) -> io::Result<()> { + self.imp.inner.socket.set_only_v6(only_v6) + } + + pub fn only_v6(&self) -> io::Result<bool> { + self.imp.inner.socket.only_v6() + } + + pub fn take_error(&self) -> io::Result<Option<io::Error>> { + self.imp.inner.socket.take_error() + } + + fn inner(&self) -> MutexGuard<Inner> { + self.imp.inner() + } + + fn post_register(&self, interest: Ready, me: &mut Inner) { + if interest.is_readable() { + //We use recv_from here since it is well specified for both + //connected and non-connected sockets and we can discard the address + //when calling recv(). + self.imp.schedule_read_from(me); + } + // See comments in TcpSocket::post_register for what's going on here + if interest.is_writable() { + if let State::Empty = me.write { + self.imp.add_readiness(me, Ready::writable()); + } + } + } +} + +impl Imp { + fn inner(&self) -> MutexGuard<Inner> { + self.inner.inner.lock().unwrap() + } + + fn schedule_read_from(&self, me: &mut Inner) { + match me.read { + State::Empty => {} + _ => return, + } + + let interest = me.iocp.readiness(); + me.iocp.set_readiness(interest - Ready::readable()); + + let mut buf = me.iocp.get_buffer(64 * 1024); + let res = unsafe { + trace!("scheduling a read"); + let cap = buf.capacity(); + buf.set_len(cap); + self.inner.socket.recv_from_overlapped(&mut buf, &mut me.read_buf, + self.inner.read.as_mut_ptr()) + }; + match res { + Ok(_) => { + me.read = State::Pending(buf); + mem::forget(self.clone()); + } + Err(e) => { + me.read = State::Error(e); + self.add_readiness(me, Ready::readable()); + me.iocp.put_buffer(buf); + } + } + } + + // See comments in tcp::StreamImp::push + fn add_readiness(&self, me: &Inner, set: Ready) { + me.iocp.set_readiness(set | me.iocp.readiness()); + } +} + +impl Evented for UdpSocket { + fn register(&self, poll: &Poll, token: Token, + interest: Ready, opts: PollOpt) -> io::Result<()> { + let mut me = self.inner(); + me.iocp.register_socket(&self.imp.inner.socket, + poll, token, interest, opts, + &self.registration)?; + self.post_register(interest, &mut me); + Ok(()) + } + + fn reregister(&self, poll: &Poll, token: Token, + interest: Ready, opts: PollOpt) -> io::Result<()> { + let mut me = self.inner(); + me.iocp.reregister_socket(&self.imp.inner.socket, + poll, token, interest, + opts, &self.registration)?; + self.post_register(interest, &mut me); + Ok(()) + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + self.inner().iocp.deregister(&self.imp.inner.socket, + poll, &self.registration) + } +} + +impl fmt::Debug for UdpSocket { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.debug_struct("UdpSocket") + .finish() + } +} + +impl Drop for UdpSocket { + fn drop(&mut self) { + let inner = self.inner(); + + // If we're still internally reading, we're no longer interested. Note + // though that we don't cancel any writes which may have been issued to + // preserve the same semantics as Unix. + unsafe { + match inner.read { + State::Pending(_) => { + drop(super::cancel(&self.imp.inner.socket, + &self.imp.inner.read)); + } + State::Empty | + State::Ready(_) | + State::Error(_) => {} + } + } + } +} + +fn send_done(status: &OVERLAPPED_ENTRY) { + let status = CompletionStatus::from_entry(status); + trace!("finished a send {}", status.bytes_transferred()); + let me2 = Imp { + inner: unsafe { overlapped2arc!(status.overlapped(), Io, write) }, + }; + let mut me = me2.inner(); + me.write = State::Empty; + me2.add_readiness(&mut me, Ready::writable()); +} + +fn recv_done(status: &OVERLAPPED_ENTRY) { + let status = CompletionStatus::from_entry(status); + trace!("finished a recv {}", status.bytes_transferred()); + let me2 = Imp { + inner: unsafe { overlapped2arc!(status.overlapped(), Io, read) }, + }; + let mut me = me2.inner(); + let mut buf = match mem::replace(&mut me.read, State::Empty) { + State::Pending(buf) => buf, + _ => unreachable!(), + }; + unsafe { + buf.set_len(status.bytes_transferred() as usize); + } + me.read = State::Ready(buf); + me2.add_readiness(&mut me, Ready::readable()); +} diff --git a/third_party/rust/mio-0.6.23/src/timer.rs b/third_party/rust/mio-0.6.23/src/timer.rs new file mode 100644 index 0000000000..c591be5e27 --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/timer.rs @@ -0,0 +1,516 @@ +//! Timer optimized for I/O related operations + +#![allow(deprecated, missing_debug_implementations)] + +use {convert, io, Ready, Poll, PollOpt, Registration, SetReadiness, Token}; +use event::Evented; +use lazycell::LazyCell; +use slab::Slab; +use std::{cmp, error, fmt, u64, usize, iter, thread}; +use std::sync::Arc; +use std::sync::atomic::{AtomicUsize, Ordering}; +use std::time::{Duration, Instant}; + +use self::TimerErrorKind::TimerOverflow; + +pub struct Timer<T> { + // Size of each tick in milliseconds + tick_ms: u64, + // Slab of timeout entries + entries: Slab<Entry<T>>, + // Timeout wheel. Each tick, the timer will look at the next slot for + // timeouts that match the current tick. + wheel: Vec<WheelEntry>, + // Tick 0's time instant + start: Instant, + // The current tick + tick: Tick, + // The next entry to possibly timeout + next: Token, + // Masks the target tick to get the slot + mask: u64, + // Set on registration with Poll + inner: LazyCell<Inner>, +} + +pub struct Builder { + // Approximate duration of each tick + tick: Duration, + // Number of slots in the timer wheel + num_slots: usize, + // Max number of timeouts that can be in flight at a given time. + capacity: usize, +} + +#[derive(Clone, Debug)] +pub struct Timeout { + // Reference into the timer entry slab + token: Token, + // Tick that it should match up with + tick: u64, +} + +struct Inner { + registration: Registration, + set_readiness: SetReadiness, + wakeup_state: WakeupState, + wakeup_thread: thread::JoinHandle<()>, +} + +impl Drop for Inner { + fn drop(&mut self) { + // 1. Set wakeup state to TERMINATE_THREAD (https://github.com/carllerche/mio/blob/master/src/timer.rs#L451) + self.wakeup_state.store(TERMINATE_THREAD, Ordering::Release); + // 2. Wake him up + self.wakeup_thread.thread().unpark(); + } +} + +#[derive(Copy, Clone, Debug)] +struct WheelEntry { + next_tick: Tick, + head: Token, +} + +// Doubly linked list of timer entries. Allows for efficient insertion / +// removal of timeouts. +struct Entry<T> { + state: T, + links: EntryLinks, +} + +#[derive(Copy, Clone)] +struct EntryLinks { + tick: Tick, + prev: Token, + next: Token +} + +type Tick = u64; + +const TICK_MAX: Tick = u64::MAX; + +// Manages communication with wakeup thread +type WakeupState = Arc<AtomicUsize>; + +pub type Result<T> = ::std::result::Result<T, TimerError>; +// TODO: remove +pub type TimerResult<T> = Result<T>; + + +/// Deprecated and unused. +#[derive(Debug)] +pub struct TimerError; + +/// Deprecated and unused. +#[derive(Debug)] +pub enum TimerErrorKind { + TimerOverflow, +} + +// TODO: Remove +pub type OldTimerResult<T> = Result<T>; + +const TERMINATE_THREAD: usize = 0; +const EMPTY: Token = Token(usize::MAX); + +impl Builder { + pub fn tick_duration(mut self, duration: Duration) -> Builder { + self.tick = duration; + self + } + + pub fn num_slots(mut self, num_slots: usize) -> Builder { + self.num_slots = num_slots; + self + } + + pub fn capacity(mut self, capacity: usize) -> Builder { + self.capacity = capacity; + self + } + + pub fn build<T>(self) -> Timer<T> { + Timer::new(convert::millis(self.tick), self.num_slots, self.capacity, Instant::now()) + } +} + +impl Default for Builder { + fn default() -> Builder { + Builder { + tick: Duration::from_millis(100), + num_slots: 256, + capacity: 65_536, + } + } +} + +impl<T> Timer<T> { + fn new(tick_ms: u64, num_slots: usize, capacity: usize, start: Instant) -> Timer<T> { + let num_slots = num_slots.next_power_of_two(); + let capacity = capacity.next_power_of_two(); + let mask = (num_slots as u64) - 1; + let wheel = iter::repeat(WheelEntry { next_tick: TICK_MAX, head: EMPTY }) + .take(num_slots).collect(); + + Timer { + tick_ms, + entries: Slab::with_capacity(capacity), + wheel, + start, + tick: 0, + next: EMPTY, + mask, + inner: LazyCell::new(), + } + } + + pub fn set_timeout(&mut self, delay_from_now: Duration, state: T) -> Result<Timeout> { + let delay_from_start = self.start.elapsed() + delay_from_now; + self.set_timeout_at(delay_from_start, state) + } + + fn set_timeout_at(&mut self, delay_from_start: Duration, state: T) -> Result<Timeout> { + let mut tick = duration_to_tick(delay_from_start, self.tick_ms); + trace!("setting timeout; delay={:?}; tick={:?}; current-tick={:?}", delay_from_start, tick, self.tick); + + // Always target at least 1 tick in the future + if tick <= self.tick { + tick = self.tick + 1; + } + + self.insert(tick, state) + } + + fn insert(&mut self, tick: Tick, state: T) -> Result<Timeout> { + // Get the slot for the requested tick + let slot = (tick & self.mask) as usize; + let curr = self.wheel[slot]; + + // Insert the new entry + let entry = Entry::new(state, tick, curr.head); + let token = Token(self.entries.insert(entry)); + + if curr.head != EMPTY { + // If there was a previous entry, set its prev pointer to the new + // entry + self.entries[curr.head.into()].links.prev = token; + } + + // Update the head slot + self.wheel[slot] = WheelEntry { + next_tick: cmp::min(tick, curr.next_tick), + head: token, + }; + + self.schedule_readiness(tick); + + trace!("inserted timeout; slot={}; token={:?}", slot, token); + + // Return the new timeout + Ok(Timeout { + token, + tick + }) + } + + pub fn cancel_timeout(&mut self, timeout: &Timeout) -> Option<T> { + let links = match self.entries.get(timeout.token.into()) { + Some(e) => e.links, + None => return None + }; + + // Sanity check + if links.tick != timeout.tick { + return None; + } + + self.unlink(&links, timeout.token); + Some(self.entries.remove(timeout.token.into()).state) + } + + pub fn poll(&mut self) -> Option<T> { + let target_tick = current_tick(self.start, self.tick_ms); + self.poll_to(target_tick) + } + + fn poll_to(&mut self, mut target_tick: Tick) -> Option<T> { + trace!("tick_to; target_tick={}; current_tick={}", target_tick, self.tick); + + if target_tick < self.tick { + target_tick = self.tick; + } + + while self.tick <= target_tick { + let curr = self.next; + + trace!("ticking; curr={:?}", curr); + + if curr == EMPTY { + self.tick += 1; + + let slot = self.slot_for(self.tick); + self.next = self.wheel[slot].head; + + // Handle the case when a slot has a single timeout which gets + // canceled before the timeout expires. In this case, the + // slot's head is EMPTY but there is a value for next_tick. Not + // resetting next_tick here causes the timer to get stuck in a + // loop. + if self.next == EMPTY { + self.wheel[slot].next_tick = TICK_MAX; + } + } else { + let slot = self.slot_for(self.tick); + + if curr == self.wheel[slot].head { + self.wheel[slot].next_tick = TICK_MAX; + } + + let links = self.entries[curr.into()].links; + + if links.tick <= self.tick { + trace!("triggering; token={:?}", curr); + + // Unlink will also advance self.next + self.unlink(&links, curr); + + // Remove and return the token + return Some(self.entries.remove(curr.into()).state); + } else { + let next_tick = self.wheel[slot].next_tick; + self.wheel[slot].next_tick = cmp::min(next_tick, links.tick); + self.next = links.next; + } + } + } + + // No more timeouts to poll + if let Some(inner) = self.inner.borrow() { + trace!("unsetting readiness"); + let _ = inner.set_readiness.set_readiness(Ready::empty()); + + if let Some(tick) = self.next_tick() { + self.schedule_readiness(tick); + } + } + + None + } + + fn unlink(&mut self, links: &EntryLinks, token: Token) { + trace!("unlinking timeout; slot={}; token={:?}", + self.slot_for(links.tick), token); + + if links.prev == EMPTY { + let slot = self.slot_for(links.tick); + self.wheel[slot].head = links.next; + } else { + self.entries[links.prev.into()].links.next = links.next; + } + + if links.next != EMPTY { + self.entries[links.next.into()].links.prev = links.prev; + + if token == self.next { + self.next = links.next; + } + } else if token == self.next { + self.next = EMPTY; + } + } + + fn schedule_readiness(&self, tick: Tick) { + if let Some(inner) = self.inner.borrow() { + // Coordinate setting readiness w/ the wakeup thread + let mut curr = inner.wakeup_state.load(Ordering::Acquire); + + loop { + if curr as Tick <= tick { + // Nothing to do, wakeup is already scheduled + return; + } + + // Attempt to move the wakeup time forward + trace!("advancing the wakeup time; target={}; curr={}", tick, curr); + let actual = inner.wakeup_state.compare_and_swap(curr, tick as usize, Ordering::Release); + + if actual == curr { + // Signal to the wakeup thread that the wakeup time has + // been changed. + trace!("unparking wakeup thread"); + inner.wakeup_thread.thread().unpark(); + return; + } + + curr = actual; + } + } + } + + // Next tick containing a timeout + fn next_tick(&self) -> Option<Tick> { + if self.next != EMPTY { + let slot = self.slot_for(self.entries[self.next.into()].links.tick); + + if self.wheel[slot].next_tick == self.tick { + // There is data ready right now + return Some(self.tick); + } + } + + self.wheel.iter().map(|e| e.next_tick).min() + } + + fn slot_for(&self, tick: Tick) -> usize { + (self.mask & tick) as usize + } +} + +impl<T> Default for Timer<T> { + fn default() -> Timer<T> { + Builder::default().build() + } +} + +impl<T> Evented for Timer<T> { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + if self.inner.borrow().is_some() { + return Err(io::Error::new(io::ErrorKind::Other, "timer already registered")); + } + + let (registration, set_readiness) = Registration::new(poll, token, interest, opts); + let wakeup_state = Arc::new(AtomicUsize::new(usize::MAX)); + let thread_handle = spawn_wakeup_thread( + wakeup_state.clone(), + set_readiness.clone(), + self.start, self.tick_ms); + + self.inner.fill(Inner { + registration, + set_readiness, + wakeup_state, + wakeup_thread: thread_handle, + }).expect("timer already registered"); + + if let Some(next_tick) = self.next_tick() { + self.schedule_readiness(next_tick); + } + + Ok(()) + } + + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + match self.inner.borrow() { + Some(inner) => inner.registration.update(poll, token, interest, opts), + None => Err(io::Error::new(io::ErrorKind::Other, "receiver not registered")), + } + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + match self.inner.borrow() { + Some(inner) => inner.registration.deregister(poll), + None => Err(io::Error::new(io::ErrorKind::Other, "receiver not registered")), + } + } +} + +impl fmt::Debug for Inner { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("Inner") + .field("registration", &self.registration) + .field("wakeup_state", &self.wakeup_state.load(Ordering::Relaxed)) + .finish() + } +} + +fn spawn_wakeup_thread(state: WakeupState, set_readiness: SetReadiness, start: Instant, tick_ms: u64) -> thread::JoinHandle<()> { + thread::spawn(move || { + let mut sleep_until_tick = state.load(Ordering::Acquire) as Tick; + + loop { + if sleep_until_tick == TERMINATE_THREAD as Tick { + return; + } + + let now_tick = current_tick(start, tick_ms); + + trace!("wakeup thread: sleep_until_tick={:?}; now_tick={:?}", sleep_until_tick, now_tick); + + if now_tick < sleep_until_tick { + // Calling park_timeout with u64::MAX leads to undefined + // behavior in pthread, causing the park to return immediately + // and causing the thread to tightly spin. Instead of u64::MAX + // on large values, simply use a blocking park. + match tick_ms.checked_mul(sleep_until_tick - now_tick) { + Some(sleep_duration) => { + trace!("sleeping; tick_ms={}; now_tick={}; sleep_until_tick={}; duration={:?}", + tick_ms, now_tick, sleep_until_tick, sleep_duration); + thread::park_timeout(Duration::from_millis(sleep_duration)); + } + None => { + trace!("sleeping; tick_ms={}; now_tick={}; blocking sleep", + tick_ms, now_tick); + thread::park(); + } + } + sleep_until_tick = state.load(Ordering::Acquire) as Tick; + } else { + let actual = state.compare_and_swap(sleep_until_tick as usize, usize::MAX, Ordering::AcqRel) as Tick; + + if actual == sleep_until_tick { + trace!("setting readiness from wakeup thread"); + let _ = set_readiness.set_readiness(Ready::readable()); + sleep_until_tick = usize::MAX as Tick; + } else { + sleep_until_tick = actual as Tick; + } + } + } + }) +} + +fn duration_to_tick(elapsed: Duration, tick_ms: u64) -> Tick { + // Calculate tick rounding up to the closest one + let elapsed_ms = convert::millis(elapsed); + elapsed_ms.saturating_add(tick_ms / 2) / tick_ms +} + +fn current_tick(start: Instant, tick_ms: u64) -> Tick { + duration_to_tick(start.elapsed(), tick_ms) +} + +impl<T> Entry<T> { + fn new(state: T, tick: u64, next: Token) -> Entry<T> { + Entry { + state, + links: EntryLinks { + tick, + prev: EMPTY, + next, + }, + } + } +} + +impl fmt::Display for TimerError { + fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result { + // `TimerError` will never be constructed. + unreachable!(); + } +} + +impl error::Error for TimerError { + fn description(&self) -> &str { + // `TimerError` will never be constructed. + unreachable!(); + } +} + +impl fmt::Display for TimerErrorKind { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + match *self { + TimerOverflow => write!(fmt, "TimerOverflow"), + } + } +} diff --git a/third_party/rust/mio-0.6.23/src/token.rs b/third_party/rust/mio-0.6.23/src/token.rs new file mode 100644 index 0000000000..09e42450bc --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/token.rs @@ -0,0 +1,153 @@ +/// Associates readiness notifications with [`Evented`] handles. +/// +/// `Token` is a wrapper around `usize` and is used as an argument to +/// [`Poll::register`] and [`Poll::reregister`]. +/// +/// See [`Poll`] for more documentation on polling. +/// +/// # Example +/// +/// Using `Token` to track which socket generated the notification. In this +/// example, `HashMap` is used, but usually something like [`slab`] is better. +/// +/// ``` +/// # use std::error::Error; +/// # fn try_main() -> Result<(), Box<Error>> { +/// use mio::{Events, Ready, Poll, PollOpt, Token}; +/// use mio::net::TcpListener; +/// +/// use std::thread; +/// use std::io::{self, Read}; +/// use std::collections::HashMap; +/// +/// // After this number of sockets is accepted, the server will shutdown. +/// const MAX_SOCKETS: usize = 32; +/// +/// // Pick a token that will not be used by any other socket and use that one +/// // for the listener. +/// const LISTENER: Token = Token(1024); +/// +/// // Used to store the sockets. +/// let mut sockets = HashMap::new(); +/// +/// // This is used to generate a unique token for a socket +/// let mut next_socket_index = 0; +/// +/// // The `Poll` instance +/// let poll = Poll::new()?; +/// +/// // Tcp listener +/// let listener = TcpListener::bind(&"127.0.0.1:0".parse()?)?; +/// +/// // Register the listener +/// poll.register(&listener, +/// LISTENER, +/// Ready::readable(), +/// PollOpt::edge())?; +/// +/// // Spawn a thread that will connect a bunch of sockets then close them +/// let addr = listener.local_addr()?; +/// thread::spawn(move || { +/// use std::net::TcpStream; +/// +/// // +1 here is to connect an extra socket to signal the socket to close +/// for _ in 0..(MAX_SOCKETS+1) { +/// // Connect then drop the socket +/// let _ = TcpStream::connect(&addr).unwrap(); +/// } +/// }); +/// +/// // Event storage +/// let mut events = Events::with_capacity(1024); +/// +/// // Read buffer, this will never actually get filled +/// let mut buf = [0; 256]; +/// +/// // The main event loop +/// loop { +/// // Wait for events +/// poll.poll(&mut events, None)?; +/// +/// for event in &events { +/// match event.token() { +/// LISTENER => { +/// // Perform operations in a loop until `WouldBlock` is +/// // encountered. +/// loop { +/// match listener.accept() { +/// Ok((socket, _)) => { +/// // Shutdown the server +/// if next_socket_index == MAX_SOCKETS { +/// return Ok(()); +/// } +/// +/// // Get the token for the socket +/// let token = Token(next_socket_index); +/// next_socket_index += 1; +/// +/// // Register the new socket w/ poll +/// poll.register(&socket, +/// token, +/// Ready::readable(), +/// PollOpt::edge())?; +/// +/// // Store the socket +/// sockets.insert(token, socket); +/// } +/// Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => { +/// // Socket is not ready anymore, stop accepting +/// break; +/// } +/// e => panic!("err={:?}", e), // Unexpected error +/// } +/// } +/// } +/// token => { +/// // Always operate in a loop +/// loop { +/// match sockets.get_mut(&token).unwrap().read(&mut buf) { +/// Ok(0) => { +/// // Socket is closed, remove it from the map +/// sockets.remove(&token); +/// break; +/// } +/// // Data is not actually sent in this example +/// Ok(_) => unreachable!(), +/// Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => { +/// // Socket is not ready anymore, stop reading +/// break; +/// } +/// e => panic!("err={:?}", e), // Unexpected error +/// } +/// } +/// } +/// } +/// } +/// } +/// # Ok(()) +/// # } +/// # +/// # fn main() { +/// # try_main().unwrap(); +/// # } +/// ``` +/// +/// [`Evented`]: event/trait.Evented.html +/// [`Poll`]: struct.Poll.html +/// [`Poll::register`]: struct.Poll.html#method.register +/// [`Poll::reregister`]: struct.Poll.html#method.reregister +/// [`slab`]: https://crates.io/crates/slab +#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct Token(pub usize); + +impl From<usize> for Token { + fn from(val: usize) -> Token { + Token(val) + } +} + +impl From<Token> for usize { + fn from(val: Token) -> usize { + val.0 + } +} diff --git a/third_party/rust/mio-0.6.23/src/udp.rs b/third_party/rust/mio-0.6.23/src/udp.rs new file mode 100644 index 0000000000..a71bd21914 --- /dev/null +++ b/third_party/rust/mio-0.6.23/src/udp.rs @@ -0,0 +1,326 @@ +//! Primitives for working with UDP +//! +//! The types provided in this module are non-blocking by default and are +//! designed to be portable across all supported Mio platforms. As long as the +//! [portability guidelines] are followed, the behavior should be identical no +//! matter the target platform. +//! +//! [portability guidelines]: ../struct.Poll.html#portability + +#![allow(deprecated)] + +use {sys, Ready, Poll, PollOpt, Token}; +use io::{self, MapNonBlock}; +use event::Evented; +use poll::SelectorId; +use std::net::{self, Ipv4Addr, Ipv6Addr, SocketAddr}; + +/// A User Datagram Protocol socket. +/// +/// This is an implementation of a bound UDP socket. This supports both IPv4 and +/// IPv6 addresses, and there is no corresponding notion of a server because UDP +/// is a datagram protocol. +#[derive(Debug)] +pub struct UdpSocket { + sys: sys::UdpSocket, + selector_id: SelectorId, +} + +impl UdpSocket { + /// Creates a UDP socket from the given address. + pub fn bind(addr: &SocketAddr) -> io::Result<UdpSocket> { + let socket = net::UdpSocket::bind(addr)?; + UdpSocket::from_socket(socket) + } + + /// Creates a new mio-wrapped socket from an underlying and bound std + /// socket. + /// + /// This function requires that `socket` has previously been bound to an + /// address to work correctly, and returns an I/O object which can be used + /// with mio to send/receive UDP messages. + /// + /// This can be used in conjunction with net2's `UdpBuilder` interface to + /// configure a socket before it's handed off to mio, such as setting + /// options like `reuse_address` or binding to multiple addresses. + pub fn from_socket(socket: net::UdpSocket) -> io::Result<UdpSocket> { + Ok(UdpSocket { + sys: sys::UdpSocket::new(socket)?, + selector_id: SelectorId::new(), + }) + } + + /// Returns the socket address that this socket was created from. + pub fn local_addr(&self) -> io::Result<SocketAddr> { + self.sys.local_addr() + } + + /// Creates a new independently owned handle to the underlying socket. + /// + /// The returned `UdpSocket` is a reference to the same socket that this + /// object references. Both handles will read and write the same port, and + /// options set on one socket will be propagated to the other. + pub fn try_clone(&self) -> io::Result<UdpSocket> { + self.sys.try_clone() + .map(|s| { + UdpSocket { + sys: s, + selector_id: self.selector_id.clone(), + } + }) + } + + /// Sends data on the socket to the given address. On success, returns the + /// number of bytes written. + /// + /// Address type can be any implementor of `ToSocketAddrs` trait. See its + /// documentation for concrete examples. + pub fn send_to(&self, buf: &[u8], target: &SocketAddr) + -> io::Result<Option<usize>> { + self.sys.send_to(buf, target).map_non_block() + } + + /// Receives data from the socket and stores data in the supplied buffer `buf`. On success, + /// returns the number of bytes read and the address from whence the data came. + /// + /// The function must be called with valid byte array `buf` of sufficient size to + /// hold the message bytes. If a message is too long to fit in the supplied buffer, + /// excess bytes may be discarded. + /// + /// The function does not read from `buf`, but is overwriting previous content of `buf`. + /// + /// Assuming the function has read `n` bytes, slicing `&buf[..n]` provides + /// efficient access with iterators and boundary checks. + pub fn recv_from(&self, buf: &mut [u8]) + -> io::Result<Option<(usize, SocketAddr)>> { + self.sys.recv_from(buf).map_non_block() + } + + /// Sends data on the socket to the address previously bound via connect(). On success, + /// returns the number of bytes written. + pub fn send(&self, buf: &[u8]) + -> io::Result<Option<usize>> { + self.sys.send(buf).map_non_block() + } + + /// Receives data from the socket previously bound with connect() and stores data in + /// the supplied buffer `buf`. On success, returns the number of bytes read. + /// + /// The function must be called with valid byte array `buf` of sufficient size to + /// hold the message bytes. If a message is too long to fit in the supplied buffer, + /// excess bytes may be discarded. + /// + /// The function does not read from `buf`, but is overwriting previous content of `buf`. + /// + /// Assuming the function has read `n` bytes, slicing `&buf[..n]` provides + /// efficient access with iterators and boundary checks. + pub fn recv(&self, buf: &mut [u8]) + -> io::Result<Option<usize>> { + self.sys.recv(buf).map_non_block() + } + + /// Connects the UDP socket setting the default destination for `send()` + /// and limiting packets that are read via `recv` from the address specified + /// in `addr`. + pub fn connect(&self, addr: SocketAddr) + -> io::Result<()> { + self.sys.connect(addr) + } + + /// Gets the value of the `SO_BROADCAST` option for this socket. + /// + /// For more information about this option, see + /// [`set_broadcast`][link]. + /// + /// [link]: #method.set_broadcast + pub fn broadcast(&self) -> io::Result<bool> { + self.sys.broadcast() + } + + /// Sets the value of the `SO_BROADCAST` option for this socket. + /// + /// When enabled, this socket is allowed to send packets to a broadcast + /// address. + pub fn set_broadcast(&self, on: bool) -> io::Result<()> { + self.sys.set_broadcast(on) + } + + /// Gets the value of the `IP_MULTICAST_LOOP` option for this socket. + /// + /// For more information about this option, see + /// [`set_multicast_loop_v4`][link]. + /// + /// [link]: #method.set_multicast_loop_v4 + pub fn multicast_loop_v4(&self) -> io::Result<bool> { + self.sys.multicast_loop_v4() + } + + /// Sets the value of the `IP_MULTICAST_LOOP` option for this socket. + /// + /// If enabled, multicast packets will be looped back to the local socket. + /// Note that this may not have any affect on IPv6 sockets. + pub fn set_multicast_loop_v4(&self, on: bool) -> io::Result<()> { + self.sys.set_multicast_loop_v4(on) + } + + /// Gets the value of the `IP_MULTICAST_TTL` option for this socket. + /// + /// For more information about this option, see + /// [`set_multicast_ttl_v4`][link]. + /// + /// [link]: #method.set_multicast_ttl_v4 + pub fn multicast_ttl_v4(&self) -> io::Result<u32> { + self.sys.multicast_ttl_v4() + } + + /// Sets the value of the `IP_MULTICAST_TTL` option for this socket. + /// + /// Indicates the time-to-live value of outgoing multicast packets for + /// this socket. The default value is 1 which means that multicast packets + /// don't leave the local network unless explicitly requested. + /// + /// Note that this may not have any affect on IPv6 sockets. + pub fn set_multicast_ttl_v4(&self, ttl: u32) -> io::Result<()> { + self.sys.set_multicast_ttl_v4(ttl) + } + + /// Gets the value of the `IPV6_MULTICAST_LOOP` option for this socket. + /// + /// For more information about this option, see + /// [`set_multicast_loop_v6`][link]. + /// + /// [link]: #method.set_multicast_loop_v6 + pub fn multicast_loop_v6(&self) -> io::Result<bool> { + self.sys.multicast_loop_v6() + } + + /// Sets the value of the `IPV6_MULTICAST_LOOP` option for this socket. + /// + /// Controls whether this socket sees the multicast packets it sends itself. + /// Note that this may not have any affect on IPv4 sockets. + pub fn set_multicast_loop_v6(&self, on: bool) -> io::Result<()> { + self.sys.set_multicast_loop_v6(on) + } + + /// Gets the value of the `IP_TTL` option for this socket. + /// + /// For more information about this option, see [`set_ttl`][link]. + /// + /// [link]: #method.set_ttl + pub fn ttl(&self) -> io::Result<u32> { + self.sys.ttl() + } + + /// Sets the value for the `IP_TTL` option on this socket. + /// + /// This value sets the time-to-live field that is used in every packet sent + /// from this socket. + pub fn set_ttl(&self, ttl: u32) -> io::Result<()> { + self.sys.set_ttl(ttl) + } + + /// Executes an operation of the `IP_ADD_MEMBERSHIP` type. + /// + /// This function specifies a new multicast group for this socket to join. + /// The address must be a valid multicast address, and `interface` is the + /// address of the local interface with which the system should join the + /// multicast group. If it's equal to `INADDR_ANY` then an appropriate + /// interface is chosen by the system. + pub fn join_multicast_v4(&self, + multiaddr: &Ipv4Addr, + interface: &Ipv4Addr) -> io::Result<()> { + self.sys.join_multicast_v4(multiaddr, interface) + } + + /// Executes an operation of the `IPV6_ADD_MEMBERSHIP` type. + /// + /// This function specifies a new multicast group for this socket to join. + /// The address must be a valid multicast address, and `interface` is the + /// index of the interface to join/leave (or 0 to indicate any interface). + pub fn join_multicast_v6(&self, + multiaddr: &Ipv6Addr, + interface: u32) -> io::Result<()> { + self.sys.join_multicast_v6(multiaddr, interface) + } + + /// Executes an operation of the `IP_DROP_MEMBERSHIP` type. + /// + /// For more information about this option, see + /// [`join_multicast_v4`][link]. + /// + /// [link]: #method.join_multicast_v4 + pub fn leave_multicast_v4(&self, + multiaddr: &Ipv4Addr, + interface: &Ipv4Addr) -> io::Result<()> { + self.sys.leave_multicast_v4(multiaddr, interface) + } + + /// Executes an operation of the `IPV6_DROP_MEMBERSHIP` type. + /// + /// For more information about this option, see + /// [`join_multicast_v6`][link]. + /// + /// [link]: #method.join_multicast_v6 + pub fn leave_multicast_v6(&self, + multiaddr: &Ipv6Addr, + interface: u32) -> io::Result<()> { + self.sys.leave_multicast_v6(multiaddr, interface) + } + + /// Get the value of the `SO_ERROR` option on this socket. + /// + /// This will retrieve the stored error in the underlying socket, clearing + /// the field in the process. This can be useful for checking errors between + /// calls. + pub fn take_error(&self) -> io::Result<Option<io::Error>> { + self.sys.take_error() + } +} + +impl Evented for UdpSocket { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + self.selector_id.associate_selector(poll)?; + self.sys.register(poll, token, interest, opts) + } + + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + self.sys.reregister(poll, token, interest, opts) + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + self.sys.deregister(poll) + } +} + +/* + * + * ===== UNIX ext ===== + * + */ + +#[cfg(all(unix, not(target_os = "fuchsia")))] +use std::os::unix::io::{IntoRawFd, AsRawFd, FromRawFd, RawFd}; + +#[cfg(all(unix, not(target_os = "fuchsia")))] +impl IntoRawFd for UdpSocket { + fn into_raw_fd(self) -> RawFd { + self.sys.into_raw_fd() + } +} + +#[cfg(all(unix, not(target_os = "fuchsia")))] +impl AsRawFd for UdpSocket { + fn as_raw_fd(&self) -> RawFd { + self.sys.as_raw_fd() + } +} + +#[cfg(all(unix, not(target_os = "fuchsia")))] +impl FromRawFd for UdpSocket { + unsafe fn from_raw_fd(fd: RawFd) -> UdpSocket { + UdpSocket { + sys: FromRawFd::from_raw_fd(fd), + selector_id: SelectorId::new(), + } + } +} diff --git a/third_party/rust/mio-extras/.cargo-checksum.json b/third_party/rust/mio-extras/.cargo-checksum.json new file mode 100644 index 0000000000..cb15205f9b --- /dev/null +++ b/third_party/rust/mio-extras/.cargo-checksum.json @@ -0,0 +1 @@ +{"files":{"CHANGELOG.md":"499f8d84e8bee37198044301a5fdfe6a811dd19b62c2c771616185a7543b8334","Cargo.toml":"a4d1b4f5de2908b805a42b31472dfd5fee30a49dc4f575a174c581c7b57b25b7","LICENSE-APACHE":"406e5cbaa2ad1178c300cf28ac5258e8d0db0de4f061e78db559d30e6f38e25c","LICENSE-MIT":"8aa414e6c821efd8be6bade07368a5d9f51f5cc55718bc54e10a59eb826b8d58","README.md":"fa2642be7bd670014c5e25bafbee73b8be0667ddbd193c1cc344a71d7f59463f","src/channel.rs":"a9fb5bcf889b03766821011e94b30a351b80501523c4a9fe5c45796eae218968","src/lib.rs":"2ed1572d3255208681d017265df7f642eb4898b1c2dace91676935f55e03eb04","src/timer.rs":"a1e71e38ab983291557d534ce2454a0ba5872652f4e7c4161131ba5150ec8d57","test/mod.rs":"aa3afc2582f00e5e2a2e5b87d12eb9810b0eed3248b48abef7094fd8d02d9c41","test/test_poll_channel.rs":"508815e265ae44328fb3d7c98cdf210815a9946bde291dd896de81df0394de37","test/test_timer.rs":"d04b6f57e9a395ce190022c0158cc498805758101e9fdad18b63829eb9bb6510"},"package":"52403fe290012ce777c4626790c8951324a2b9e3316b3143779c72b029742f19"}
\ No newline at end of file diff --git a/third_party/rust/mio-extras/CHANGELOG.md b/third_party/rust/mio-extras/CHANGELOG.md new file mode 100644 index 0000000000..354b87584c --- /dev/null +++ b/third_party/rust/mio-extras/CHANGELOG.md @@ -0,0 +1,37 @@ +## 2.0.6 (7 Dec 2019) + +- fix license metadata in `Cargo.toml` (thanks @ignatenkobrain) + +## 2.0.5 (18 Jun 2018) + +- update `lazycell` from 0.6 -> 1.0 + +## 2.0.4 (7 Apr 2018) + +- Bump mio dependency (fixes minimal-versions build) + +## 2.0.3 (28 Dec 2017) + +- update `log` from 0.3 -> 0.4 + +## 2.0.2 + +- More docs tidying. + +## 2.0.1 + +- Another try at documenting the timer interface. + +## 2.0.0 + +- Remove channel implementation details from the API. Specifically, the + following are no longer public: + - `ctl_pair()` + - `SenderCtl` + - `ReceiverCtl` +- Document all APIs + +## 1.0.0 + +- Initial release. Essentially identical to + [mio-more](https://github.com/carllerche/mio-more). diff --git a/third_party/rust/mio-extras/Cargo.toml b/third_party/rust/mio-extras/Cargo.toml new file mode 100644 index 0000000000..d902a46019 --- /dev/null +++ b/third_party/rust/mio-extras/Cargo.toml @@ -0,0 +1,40 @@ +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies +# +# If you believe there's an error in this file please file an +# issue against the rust-lang/cargo repository. If you're +# editing this file be aware that the upstream Cargo.toml +# will likely look very different (and much more reasonable) + +[package] +edition = "2018" +name = "mio-extras" +version = "2.0.6" +authors = ["Carl Lerche <me@carllerche.com>", "David Hotham"] +exclude = [".gitignore"] +description = "Extra components for use with Mio" +documentation = "https://docs.rs/mio-extras" +readme = "README.md" +keywords = ["io", "async", "non-blocking"] +categories = ["asynchronous"] +license = "MIT OR Apache-2.0" +repository = "https://github.com/dimbleby/mio-extras" + +[[test]] +name = "test" +path = "test/mod.rs" +[dependencies.lazycell] +version = "1" + +[dependencies.log] +version = "0.4" + +[dependencies.mio] +version = "0.6.14" + +[dependencies.slab] +version = "0.4" diff --git a/third_party/rust/mio-extras/LICENSE-APACHE b/third_party/rust/mio-extras/LICENSE-APACHE new file mode 100644 index 0000000000..a6e8ded657 --- /dev/null +++ b/third_party/rust/mio-extras/LICENSE-APACHE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS + +APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + +Copyright 2017 Mio authors + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. diff --git a/third_party/rust/mio-extras/LICENSE-MIT b/third_party/rust/mio-extras/LICENSE-MIT new file mode 100644 index 0000000000..4cf193e73e --- /dev/null +++ b/third_party/rust/mio-extras/LICENSE-MIT @@ -0,0 +1,25 @@ +Copyright (c) 2017 Mio authors + +Permission is hereby granted, free of charge, to any +person obtaining a copy of this software and associated +documentation files (the "Software"), to deal in the +Software without restriction, including without +limitation the rights to use, copy, modify, merge, +publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software +is furnished to do so, subject to the following +conditions: + +The above copyright notice and this permission notice +shall be included in all copies or substantial portions +of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF +ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED +TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT +SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR +IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. diff --git a/third_party/rust/mio-extras/README.md b/third_party/rust/mio-extras/README.md new file mode 100644 index 0000000000..8ed136a079 --- /dev/null +++ b/third_party/rust/mio-extras/README.md @@ -0,0 +1,30 @@ +# mio-extras + +Extra components for use with [Mio](https://github.com/tokio-rs/mio): + +- a channel that implements `Evented` +- a timer that implements `Evented` + +[](https://travis-ci.org/dimbleby/mio-extras) +[](https://crates.io/crates/mio-extras) + +[Documentation](https://docs.rs/mio-extras). + +## History and maintenance + +This repository is forked from +[`mio-more`](https://github.com/carllerche/mio-more), which is unmaintained. + +I don't intend to do very much with this except for routine maintenance - bug +fixes, updating dependencies, and suchlike. + +However if you have some code that you think belongs here, then by all means +raise an issue or open a pull request. + +# License + +`mio-extras` is primarily distributed under the terms of both the MIT license +and the Apache License (Version 2.0), with portions covered by various BSD-like +licenses. + +See LICENSE-APACHE, and LICENSE-MIT for details. diff --git a/third_party/rust/mio-extras/src/channel.rs b/third_party/rust/mio-extras/src/channel.rs new file mode 100644 index 0000000000..561317ecbf --- /dev/null +++ b/third_party/rust/mio-extras/src/channel.rs @@ -0,0 +1,431 @@ +//! Thread safe communication channel implementing `Evented` +use lazycell::{AtomicLazyCell, LazyCell}; +use mio::{Evented, Poll, PollOpt, Ready, Registration, SetReadiness, Token}; +use std::any::Any; +use std::error; +use std::sync::atomic::{AtomicUsize, Ordering}; +use std::sync::{mpsc, Arc}; +use std::{fmt, io}; + +/// Creates a new asynchronous channel, where the `Receiver` can be registered +/// with `Poll`. +pub fn channel<T>() -> (Sender<T>, Receiver<T>) { + let (tx_ctl, rx_ctl) = ctl_pair(); + let (tx, rx) = mpsc::channel(); + + let tx = Sender { tx, ctl: tx_ctl }; + + let rx = Receiver { rx, ctl: rx_ctl }; + + (tx, rx) +} + +/// Creates a new synchronous, bounded channel where the `Receiver` can be +/// registered with `Poll`. +pub fn sync_channel<T>(bound: usize) -> (SyncSender<T>, Receiver<T>) { + let (tx_ctl, rx_ctl) = ctl_pair(); + let (tx, rx) = mpsc::sync_channel(bound); + + let tx = SyncSender { tx, ctl: tx_ctl }; + + let rx = Receiver { rx, ctl: rx_ctl }; + + (tx, rx) +} + +fn ctl_pair() -> (SenderCtl, ReceiverCtl) { + let inner = Arc::new(Inner { + pending: AtomicUsize::new(0), + senders: AtomicUsize::new(1), + set_readiness: AtomicLazyCell::new(), + }); + + let tx = SenderCtl { + inner: Arc::clone(&inner), + }; + + let rx = ReceiverCtl { + registration: LazyCell::new(), + inner, + }; + + (tx, rx) +} + +/// Tracks messages sent on a channel in order to update readiness. +struct SenderCtl { + inner: Arc<Inner>, +} + +/// Tracks messages received on a channel in order to track readiness. +struct ReceiverCtl { + registration: LazyCell<Registration>, + inner: Arc<Inner>, +} + +/// The sending half of a channel. +pub struct Sender<T> { + tx: mpsc::Sender<T>, + ctl: SenderCtl, +} + +/// The sending half of a synchronous channel. +pub struct SyncSender<T> { + tx: mpsc::SyncSender<T>, + ctl: SenderCtl, +} + +/// The receiving half of a channel. +pub struct Receiver<T> { + rx: mpsc::Receiver<T>, + ctl: ReceiverCtl, +} + +/// An error returned from the `Sender::send` or `SyncSender::send` function. +pub enum SendError<T> { + /// An IO error. + Io(io::Error), + + /// The receiving half of the channel has disconnected. + Disconnected(T), +} + +/// An error returned from the `SyncSender::try_send` function. +pub enum TrySendError<T> { + /// An IO error. + Io(io::Error), + + /// Data could not be sent because it would require the callee to block. + Full(T), + + /// The receiving half of the channel has disconnected. + Disconnected(T), +} + +struct Inner { + // The number of outstanding messages for the receiver to read + pending: AtomicUsize, + // The number of sender handles + senders: AtomicUsize, + // The set readiness handle + set_readiness: AtomicLazyCell<SetReadiness>, +} + +impl<T> Sender<T> { + /// Attempts to send a value on this channel, returning it back if it could not be sent. + pub fn send(&self, t: T) -> Result<(), SendError<T>> { + self.tx.send(t).map_err(SendError::from).and_then(|_| { + self.ctl.inc()?; + Ok(()) + }) + } +} + +impl<T> Clone for Sender<T> { + fn clone(&self) -> Sender<T> { + Sender { + tx: self.tx.clone(), + ctl: self.ctl.clone(), + } + } +} + +impl<T> SyncSender<T> { + /// Sends a value on this synchronous channel. + /// + /// This function will *block* until space in the internal buffer becomes + /// available or a receiver is available to hand off the message to. + pub fn send(&self, t: T) -> Result<(), SendError<T>> { + self.tx.send(t).map_err(From::from).and_then(|_| { + self.ctl.inc()?; + Ok(()) + }) + } + + /// Attempts to send a value on this channel without blocking. + /// + /// This method differs from `send` by returning immediately if the channel's + /// buffer is full or no receiver is waiting to acquire some data. + pub fn try_send(&self, t: T) -> Result<(), TrySendError<T>> { + self.tx.try_send(t).map_err(From::from).and_then(|_| { + self.ctl.inc()?; + Ok(()) + }) + } +} + +impl<T> Clone for SyncSender<T> { + fn clone(&self) -> SyncSender<T> { + SyncSender { + tx: self.tx.clone(), + ctl: self.ctl.clone(), + } + } +} + +impl<T> Receiver<T> { + /// Attempts to return a pending value on this receiver without blocking. + pub fn try_recv(&self) -> Result<T, mpsc::TryRecvError> { + self.rx.try_recv().and_then(|res| { + let _ = self.ctl.dec(); + Ok(res) + }) + } +} + +impl<T> Evented for Receiver<T> { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { + self.ctl.register(poll, token, interest, opts) + } + + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { + self.ctl.reregister(poll, token, interest, opts) + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + self.ctl.deregister(poll) + } +} + +/* + * + * ===== SenderCtl / ReceiverCtl ===== + * + */ + +impl SenderCtl { + /// Call to track that a message has been sent + fn inc(&self) -> io::Result<()> { + let cnt = self.inner.pending.fetch_add(1, Ordering::Acquire); + + if 0 == cnt { + // Toggle readiness to readable + if let Some(set_readiness) = self.inner.set_readiness.borrow() { + set_readiness.set_readiness(Ready::readable())?; + } + } + + Ok(()) + } +} + +impl Clone for SenderCtl { + fn clone(&self) -> SenderCtl { + self.inner.senders.fetch_add(1, Ordering::Relaxed); + SenderCtl { + inner: Arc::clone(&self.inner), + } + } +} + +impl Drop for SenderCtl { + fn drop(&mut self) { + if self.inner.senders.fetch_sub(1, Ordering::Release) == 1 { + let _ = self.inc(); + } + } +} + +impl ReceiverCtl { + fn dec(&self) -> io::Result<()> { + let first = self.inner.pending.load(Ordering::Acquire); + + if first == 1 { + // Unset readiness + if let Some(set_readiness) = self.inner.set_readiness.borrow() { + set_readiness.set_readiness(Ready::empty())?; + } + } + + // Decrement + let second = self.inner.pending.fetch_sub(1, Ordering::AcqRel); + + if first == 1 && second > 1 { + // There are still pending messages. Since readiness was + // previously unset, it must be reset here + if let Some(set_readiness) = self.inner.set_readiness.borrow() { + set_readiness.set_readiness(Ready::readable())?; + } + } + + Ok(()) + } +} + +impl Evented for ReceiverCtl { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { + if self.registration.borrow().is_some() { + return Err(io::Error::new( + io::ErrorKind::Other, + "receiver already registered", + )); + } + + let (registration, set_readiness) = Registration::new2(); + poll.register(®istration, token, interest, opts)?; + + if self.inner.pending.load(Ordering::Relaxed) > 0 { + // TODO: Don't drop readiness + let _ = set_readiness.set_readiness(Ready::readable()); + } + + self.registration + .fill(registration) + .expect("unexpected state encountered"); + self.inner + .set_readiness + .fill(set_readiness) + .expect("unexpected state encountered"); + + Ok(()) + } + + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { + match self.registration.borrow() { + Some(registration) => poll.reregister(registration, token, interest, opts), + None => Err(io::Error::new( + io::ErrorKind::Other, + "receiver not registered", + )), + } + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + match self.registration.borrow() { + Some(registration) => poll.deregister(registration), + None => Err(io::Error::new( + io::ErrorKind::Other, + "receiver not registered", + )), + } + } +} + +/* + * + * ===== Error conversions ===== + * + */ + +impl<T> From<mpsc::SendError<T>> for SendError<T> { + fn from(src: mpsc::SendError<T>) -> SendError<T> { + SendError::Disconnected(src.0) + } +} + +impl<T> From<io::Error> for SendError<T> { + fn from(src: io::Error) -> SendError<T> { + SendError::Io(src) + } +} + +impl<T> From<mpsc::TrySendError<T>> for TrySendError<T> { + fn from(src: mpsc::TrySendError<T>) -> TrySendError<T> { + match src { + mpsc::TrySendError::Full(v) => TrySendError::Full(v), + mpsc::TrySendError::Disconnected(v) => TrySendError::Disconnected(v), + } + } +} + +impl<T> From<mpsc::SendError<T>> for TrySendError<T> { + fn from(src: mpsc::SendError<T>) -> TrySendError<T> { + TrySendError::Disconnected(src.0) + } +} + +impl<T> From<io::Error> for TrySendError<T> { + fn from(src: io::Error) -> TrySendError<T> { + TrySendError::Io(src) + } +} + +/* + * + * ===== Implement Error, Debug and Display for Errors ===== + * + */ + +impl<T: Any> error::Error for SendError<T> { + fn description(&self) -> &str { + match *self { + SendError::Io(ref io_err) => io_err.description(), + SendError::Disconnected(..) => "Disconnected", + } + } +} + +impl<T: Any> error::Error for TrySendError<T> { + fn description(&self) -> &str { + match *self { + TrySendError::Io(ref io_err) => io_err.description(), + TrySendError::Full(..) => "Full", + TrySendError::Disconnected(..) => "Disconnected", + } + } +} + +impl<T> fmt::Debug for SendError<T> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + format_send_error(self, f) + } +} + +impl<T> fmt::Display for SendError<T> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + format_send_error(self, f) + } +} + +impl<T> fmt::Debug for TrySendError<T> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + format_try_send_error(self, f) + } +} + +impl<T> fmt::Display for TrySendError<T> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + format_try_send_error(self, f) + } +} + +#[inline] +fn format_send_error<T>(e: &SendError<T>, f: &mut fmt::Formatter) -> fmt::Result { + match *e { + SendError::Io(ref io_err) => write!(f, "{}", io_err), + SendError::Disconnected(..) => write!(f, "Disconnected"), + } +} + +#[inline] +fn format_try_send_error<T>(e: &TrySendError<T>, f: &mut fmt::Formatter) -> fmt::Result { + match *e { + TrySendError::Io(ref io_err) => write!(f, "{}", io_err), + TrySendError::Full(..) => write!(f, "Full"), + TrySendError::Disconnected(..) => write!(f, "Disconnected"), + } +} diff --git a/third_party/rust/mio-extras/src/lib.rs b/third_party/rust/mio-extras/src/lib.rs new file mode 100644 index 0000000000..69a000556c --- /dev/null +++ b/third_party/rust/mio-extras/src/lib.rs @@ -0,0 +1,33 @@ +//! Extra components for use with Mio. +#![deny(missing_docs)] +extern crate lazycell; +extern crate mio; +extern crate slab; + +#[macro_use] +extern crate log; + +pub mod channel; +pub mod timer; + +// Conversion utilities +mod convert { + use std::time::Duration; + + const NANOS_PER_MILLI: u32 = 1_000_000; + const MILLIS_PER_SEC: u64 = 1_000; + + /// Convert a `Duration` to milliseconds, rounding up and saturating at + /// `u64::MAX`. + /// + /// The saturating is fine because `u64::MAX` milliseconds are still many + /// million years. + pub fn millis(duration: Duration) -> u64 { + // Round up. + let millis = (duration.subsec_nanos() + NANOS_PER_MILLI - 1) / NANOS_PER_MILLI; + duration + .as_secs() + .saturating_mul(MILLIS_PER_SEC) + .saturating_add(u64::from(millis)) + } +} diff --git a/third_party/rust/mio-extras/src/timer.rs b/third_party/rust/mio-extras/src/timer.rs new file mode 100644 index 0000000000..876026c99c --- /dev/null +++ b/third_party/rust/mio-extras/src/timer.rs @@ -0,0 +1,751 @@ +//! Timer optimized for I/O related operations +use crate::convert; +use lazycell::LazyCell; +use mio::{Evented, Poll, PollOpt, Ready, Registration, SetReadiness, Token}; +use slab::Slab; +use std::sync::atomic::{AtomicUsize, Ordering}; +use std::sync::Arc; +use std::time::{Duration, Instant}; +use std::{cmp, fmt, io, iter, thread, u64, usize}; + +/// A timer. +/// +/// Typical usage goes like this: +/// +/// * register the timer with a `mio::Poll`. +/// * set a timeout, by calling `Timer::set_timeout`. Here you provide some +/// state to be associated with this timeout. +/// * poll the `Poll`, to learn when a timeout has occurred. +/// * retrieve state associated with the timeout by calling `Timer::poll`. +/// +/// You can omit use of the `Poll` altogether, if you like, and just poll the +/// `Timer` directly. +pub struct Timer<T> { + // Size of each tick in milliseconds + tick_ms: u64, + // Slab of timeout entries + entries: Slab<Entry<T>>, + // Timeout wheel. Each tick, the timer will look at the next slot for + // timeouts that match the current tick. + wheel: Vec<WheelEntry>, + // Tick 0's time instant + start: Instant, + // The current tick + tick: Tick, + // The next entry to possibly timeout + next: Token, + // Masks the target tick to get the slot + mask: u64, + // Set on registration with Poll + inner: LazyCell<Inner>, +} + +/// Used to create a `Timer`. +pub struct Builder { + // Approximate duration of each tick + tick: Duration, + // Number of slots in the timer wheel + num_slots: usize, + // Max number of timeouts that can be in flight at a given time. + capacity: usize, +} + +/// A timeout, as returned by `Timer::set_timeout`. +/// +/// Use this as the argument to `Timer::cancel_timeout`, to cancel this timeout. +#[derive(Clone, Debug)] +pub struct Timeout { + // Reference into the timer entry slab + token: Token, + // Tick that it should match up with + tick: u64, +} + +struct Inner { + registration: Registration, + set_readiness: SetReadiness, + wakeup_state: WakeupState, + wakeup_thread: thread::JoinHandle<()>, +} + +impl Drop for Inner { + fn drop(&mut self) { + // 1. Set wakeup state to TERMINATE_THREAD + self.wakeup_state.store(TERMINATE_THREAD, Ordering::Release); + // 2. Wake him up + self.wakeup_thread.thread().unpark(); + } +} + +#[derive(Copy, Clone, Debug)] +struct WheelEntry { + next_tick: Tick, + head: Token, +} + +// Doubly linked list of timer entries. Allows for efficient insertion / +// removal of timeouts. +struct Entry<T> { + state: T, + links: EntryLinks, +} + +#[derive(Copy, Clone)] +struct EntryLinks { + tick: Tick, + prev: Token, + next: Token, +} + +type Tick = u64; + +const TICK_MAX: Tick = u64::MAX; + +// Manages communication with wakeup thread +type WakeupState = Arc<AtomicUsize>; + +const TERMINATE_THREAD: usize = 0; +const EMPTY: Token = Token(usize::MAX); + +impl Builder { + /// Set the tick duration. Default is 100ms. + pub fn tick_duration(mut self, duration: Duration) -> Builder { + self.tick = duration; + self + } + + /// Set the number of slots. Default is 256. + pub fn num_slots(mut self, num_slots: usize) -> Builder { + self.num_slots = num_slots; + self + } + + /// Set the capacity. Default is 65536. + pub fn capacity(mut self, capacity: usize) -> Builder { + self.capacity = capacity; + self + } + + /// Build a `Timer` with the parameters set on this `Builder`. + pub fn build<T>(self) -> Timer<T> { + Timer::new( + convert::millis(self.tick), + self.num_slots, + self.capacity, + Instant::now(), + ) + } +} + +impl Default for Builder { + fn default() -> Builder { + Builder { + tick: Duration::from_millis(100), + num_slots: 1 << 8, + capacity: 1 << 16, + } + } +} + +impl<T> Timer<T> { + fn new(tick_ms: u64, num_slots: usize, capacity: usize, start: Instant) -> Timer<T> { + let num_slots = num_slots.next_power_of_two(); + let capacity = capacity.next_power_of_two(); + let mask = (num_slots as u64) - 1; + let wheel = iter::repeat(WheelEntry { + next_tick: TICK_MAX, + head: EMPTY, + }) + .take(num_slots) + .collect(); + + Timer { + tick_ms, + entries: Slab::with_capacity(capacity), + wheel, + start, + tick: 0, + next: EMPTY, + mask, + inner: LazyCell::new(), + } + } + + /// Set a timeout. + /// + /// When the timeout occurs, the given state becomes available via `poll`. + pub fn set_timeout(&mut self, delay_from_now: Duration, state: T) -> Timeout { + let delay_from_start = self.start.elapsed() + delay_from_now; + self.set_timeout_at(delay_from_start, state) + } + + fn set_timeout_at(&mut self, delay_from_start: Duration, state: T) -> Timeout { + let mut tick = duration_to_tick(delay_from_start, self.tick_ms); + trace!( + "setting timeout; delay={:?}; tick={:?}; current-tick={:?}", + delay_from_start, + tick, + self.tick + ); + + // Always target at least 1 tick in the future + if tick <= self.tick { + tick = self.tick + 1; + } + + self.insert(tick, state) + } + + fn insert(&mut self, tick: Tick, state: T) -> Timeout { + // Get the slot for the requested tick + let slot = (tick & self.mask) as usize; + let curr = self.wheel[slot]; + + // Insert the new entry + let entry = Entry::new(state, tick, curr.head); + let token = Token(self.entries.insert(entry)); + + if curr.head != EMPTY { + // If there was a previous entry, set its prev pointer to the new + // entry + self.entries[curr.head.into()].links.prev = token; + } + + // Update the head slot + self.wheel[slot] = WheelEntry { + next_tick: cmp::min(tick, curr.next_tick), + head: token, + }; + + self.schedule_readiness(tick); + + trace!("inserted timout; slot={}; token={:?}", slot, token); + + // Return the new timeout + Timeout { token, tick } + } + + /// Cancel a timeout. + /// + /// If the timeout has not yet occurred, the return value holds the + /// associated state. + pub fn cancel_timeout(&mut self, timeout: &Timeout) -> Option<T> { + let links = match self.entries.get(timeout.token.into()) { + Some(e) => e.links, + None => return None, + }; + + // Sanity check + if links.tick != timeout.tick { + return None; + } + + self.unlink(&links, timeout.token); + Some(self.entries.remove(timeout.token.into()).state) + } + + /// Poll for an expired timer. + /// + /// The return value holds the state associated with the first expired + /// timer, if any. + pub fn poll(&mut self) -> Option<T> { + let target_tick = current_tick(self.start, self.tick_ms); + self.poll_to(target_tick) + } + + fn poll_to(&mut self, mut target_tick: Tick) -> Option<T> { + trace!( + "tick_to; target_tick={}; current_tick={}", + target_tick, + self.tick + ); + + if target_tick < self.tick { + target_tick = self.tick; + } + + while self.tick <= target_tick { + let curr = self.next; + + trace!("ticking; curr={:?}", curr); + + if curr == EMPTY { + self.tick += 1; + + let slot = self.slot_for(self.tick); + self.next = self.wheel[slot].head; + + // Handle the case when a slot has a single timeout which gets + // canceled before the timeout expires. In this case, the + // slot's head is EMPTY but there is a value for next_tick. Not + // resetting next_tick here causes the timer to get stuck in a + // loop. + if self.next == EMPTY { + self.wheel[slot].next_tick = TICK_MAX; + } + } else { + let slot = self.slot_for(self.tick); + + if curr == self.wheel[slot].head { + self.wheel[slot].next_tick = TICK_MAX; + } + + let links = self.entries[curr.into()].links; + + if links.tick <= self.tick { + trace!("triggering; token={:?}", curr); + + // Unlink will also advance self.next + self.unlink(&links, curr); + + // Remove and return the token + return Some(self.entries.remove(curr.into()).state); + } else { + let next_tick = self.wheel[slot].next_tick; + self.wheel[slot].next_tick = cmp::min(next_tick, links.tick); + self.next = links.next; + } + } + } + + // No more timeouts to poll + if let Some(inner) = self.inner.borrow() { + trace!("unsetting readiness"); + let _ = inner.set_readiness.set_readiness(Ready::empty()); + + if let Some(tick) = self.next_tick() { + self.schedule_readiness(tick); + } + } + + None + } + + fn unlink(&mut self, links: &EntryLinks, token: Token) { + trace!( + "unlinking timeout; slot={}; token={:?}", + self.slot_for(links.tick), + token + ); + + if links.prev == EMPTY { + let slot = self.slot_for(links.tick); + self.wheel[slot].head = links.next; + } else { + self.entries[links.prev.into()].links.next = links.next; + } + + if links.next != EMPTY { + self.entries[links.next.into()].links.prev = links.prev; + + if token == self.next { + self.next = links.next; + } + } else if token == self.next { + self.next = EMPTY; + } + } + + fn schedule_readiness(&self, tick: Tick) { + if let Some(inner) = self.inner.borrow() { + // Coordinate setting readiness w/ the wakeup thread + let mut curr = inner.wakeup_state.load(Ordering::Acquire); + + loop { + if curr as Tick <= tick { + // Nothing to do, wakeup is already scheduled + return; + } + + // Attempt to move the wakeup time forward + trace!("advancing the wakeup time; target={}; curr={}", tick, curr); + let actual = + inner + .wakeup_state + .compare_and_swap(curr, tick as usize, Ordering::Release); + + if actual == curr { + // Signal to the wakeup thread that the wakeup time has + // been changed. + trace!("unparking wakeup thread"); + inner.wakeup_thread.thread().unpark(); + return; + } + + curr = actual; + } + } + } + + // Next tick containing a timeout + fn next_tick(&self) -> Option<Tick> { + if self.next != EMPTY { + let slot = self.slot_for(self.entries[self.next.into()].links.tick); + + if self.wheel[slot].next_tick == self.tick { + // There is data ready right now + return Some(self.tick); + } + } + + self.wheel.iter().map(|e| e.next_tick).min() + } + + fn slot_for(&self, tick: Tick) -> usize { + (self.mask & tick) as usize + } +} + +impl<T> Default for Timer<T> { + fn default() -> Timer<T> { + Builder::default().build() + } +} + +impl<T> Evented for Timer<T> { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { + if self.inner.borrow().is_some() { + return Err(io::Error::new( + io::ErrorKind::Other, + "timer already registered", + )); + } + + let (registration, set_readiness) = Registration::new2(); + poll.register(®istration, token, interest, opts)?; + let wakeup_state = Arc::new(AtomicUsize::new(usize::MAX)); + let thread_handle = spawn_wakeup_thread( + Arc::clone(&wakeup_state), + set_readiness.clone(), + self.start, + self.tick_ms, + ); + + self.inner + .fill(Inner { + registration, + set_readiness, + wakeup_state, + wakeup_thread: thread_handle, + }) + .expect("timer already registered"); + + if let Some(next_tick) = self.next_tick() { + self.schedule_readiness(next_tick); + } + + Ok(()) + } + + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { + match self.inner.borrow() { + Some(inner) => poll.reregister(&inner.registration, token, interest, opts), + None => Err(io::Error::new( + io::ErrorKind::Other, + "receiver not registered", + )), + } + } + + fn deregister(&self, poll: &Poll) -> io::Result<()> { + match self.inner.borrow() { + Some(inner) => poll.deregister(&inner.registration), + None => Err(io::Error::new( + io::ErrorKind::Other, + "receiver not registered", + )), + } + } +} + +impl fmt::Debug for Inner { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("Inner") + .field("registration", &self.registration) + .field("wakeup_state", &self.wakeup_state.load(Ordering::Relaxed)) + .finish() + } +} + +fn spawn_wakeup_thread( + state: WakeupState, + set_readiness: SetReadiness, + start: Instant, + tick_ms: u64, +) -> thread::JoinHandle<()> { + thread::spawn(move || { + let mut sleep_until_tick = state.load(Ordering::Acquire) as Tick; + + loop { + if sleep_until_tick == TERMINATE_THREAD as Tick { + return; + } + + let now_tick = current_tick(start, tick_ms); + + trace!( + "wakeup thread: sleep_until_tick={:?}; now_tick={:?}", + sleep_until_tick, + now_tick + ); + + if now_tick < sleep_until_tick { + // Calling park_timeout with u64::MAX leads to undefined + // behavior in pthread, causing the park to return immediately + // and causing the thread to tightly spin. Instead of u64::MAX + // on large values, simply use a blocking park. + match tick_ms.checked_mul(sleep_until_tick - now_tick) { + Some(sleep_duration) => { + trace!( + "sleeping; tick_ms={}; now_tick={}; sleep_until_tick={}; duration={:?}", + tick_ms, + now_tick, + sleep_until_tick, + sleep_duration + ); + thread::park_timeout(Duration::from_millis(sleep_duration)); + } + None => { + trace!( + "sleeping; tick_ms={}; now_tick={}; blocking sleep", + tick_ms, + now_tick + ); + thread::park(); + } + } + sleep_until_tick = state.load(Ordering::Acquire) as Tick; + } else { + let actual = + state.compare_and_swap(sleep_until_tick as usize, usize::MAX, Ordering::AcqRel) + as Tick; + + if actual == sleep_until_tick { + trace!("setting readiness from wakeup thread"); + let _ = set_readiness.set_readiness(Ready::readable()); + sleep_until_tick = usize::MAX as Tick; + } else { + sleep_until_tick = actual as Tick; + } + } + } + }) +} + +fn duration_to_tick(elapsed: Duration, tick_ms: u64) -> Tick { + // Calculate tick rounding up to the closest one + let elapsed_ms = convert::millis(elapsed); + elapsed_ms.saturating_add(tick_ms / 2) / tick_ms +} + +fn current_tick(start: Instant, tick_ms: u64) -> Tick { + duration_to_tick(start.elapsed(), tick_ms) +} + +impl<T> Entry<T> { + fn new(state: T, tick: u64, next: Token) -> Entry<T> { + Entry { + state, + links: EntryLinks { + tick, + prev: EMPTY, + next, + }, + } + } +} + +#[cfg(test)] +mod test { + use super::*; + use std::time::{Duration, Instant}; + + #[test] + pub fn test_timeout_next_tick() { + let mut t = timer(); + let mut tick; + + t.set_timeout_at(Duration::from_millis(100), "a"); + + tick = ms_to_tick(&t, 50); + assert_eq!(None, t.poll_to(tick)); + + tick = ms_to_tick(&t, 100); + assert_eq!(Some("a"), t.poll_to(tick)); + assert_eq!(None, t.poll_to(tick)); + + tick = ms_to_tick(&t, 150); + assert_eq!(None, t.poll_to(tick)); + + tick = ms_to_tick(&t, 200); + assert_eq!(None, t.poll_to(tick)); + + assert_eq!(count(&t), 0); + } + + #[test] + pub fn test_clearing_timeout() { + let mut t = timer(); + let mut tick; + + let to = t.set_timeout_at(Duration::from_millis(100), "a"); + assert_eq!("a", t.cancel_timeout(&to).unwrap()); + + tick = ms_to_tick(&t, 100); + assert_eq!(None, t.poll_to(tick)); + + tick = ms_to_tick(&t, 200); + assert_eq!(None, t.poll_to(tick)); + + assert_eq!(count(&t), 0); + } + + #[test] + pub fn test_multiple_timeouts_same_tick() { + let mut t = timer(); + let mut tick; + + t.set_timeout_at(Duration::from_millis(100), "a"); + t.set_timeout_at(Duration::from_millis(100), "b"); + + let mut rcv = vec![]; + + tick = ms_to_tick(&t, 100); + rcv.push(t.poll_to(tick).unwrap()); + rcv.push(t.poll_to(tick).unwrap()); + + assert_eq!(None, t.poll_to(tick)); + + rcv.sort(); + assert!(rcv == ["a", "b"], "actual={:?}", rcv); + + tick = ms_to_tick(&t, 200); + assert_eq!(None, t.poll_to(tick)); + + assert_eq!(count(&t), 0); + } + + #[test] + pub fn test_multiple_timeouts_diff_tick() { + let mut t = timer(); + let mut tick; + + t.set_timeout_at(Duration::from_millis(110), "a"); + t.set_timeout_at(Duration::from_millis(220), "b"); + t.set_timeout_at(Duration::from_millis(230), "c"); + t.set_timeout_at(Duration::from_millis(440), "d"); + t.set_timeout_at(Duration::from_millis(560), "e"); + + tick = ms_to_tick(&t, 100); + assert_eq!(Some("a"), t.poll_to(tick)); + assert_eq!(None, t.poll_to(tick)); + + tick = ms_to_tick(&t, 200); + assert_eq!(Some("c"), t.poll_to(tick)); + assert_eq!(Some("b"), t.poll_to(tick)); + assert_eq!(None, t.poll_to(tick)); + + tick = ms_to_tick(&t, 300); + assert_eq!(None, t.poll_to(tick)); + + tick = ms_to_tick(&t, 400); + assert_eq!(Some("d"), t.poll_to(tick)); + assert_eq!(None, t.poll_to(tick)); + + tick = ms_to_tick(&t, 500); + assert_eq!(None, t.poll_to(tick)); + + tick = ms_to_tick(&t, 600); + assert_eq!(Some("e"), t.poll_to(tick)); + assert_eq!(None, t.poll_to(tick)); + } + + #[test] + pub fn test_catching_up() { + let mut t = timer(); + + t.set_timeout_at(Duration::from_millis(110), "a"); + t.set_timeout_at(Duration::from_millis(220), "b"); + t.set_timeout_at(Duration::from_millis(230), "c"); + t.set_timeout_at(Duration::from_millis(440), "d"); + + let tick = ms_to_tick(&t, 600); + assert_eq!(Some("a"), t.poll_to(tick)); + assert_eq!(Some("c"), t.poll_to(tick)); + assert_eq!(Some("b"), t.poll_to(tick)); + assert_eq!(Some("d"), t.poll_to(tick)); + assert_eq!(None, t.poll_to(tick)); + } + + #[test] + pub fn test_timeout_hash_collision() { + let mut t = timer(); + let mut tick; + + t.set_timeout_at(Duration::from_millis(100), "a"); + t.set_timeout_at(Duration::from_millis(100 + TICK * SLOTS as u64), "b"); + + tick = ms_to_tick(&t, 100); + assert_eq!(Some("a"), t.poll_to(tick)); + assert_eq!(1, count(&t)); + + tick = ms_to_tick(&t, 200); + assert_eq!(None, t.poll_to(tick)); + assert_eq!(1, count(&t)); + + tick = ms_to_tick(&t, 100 + TICK * SLOTS as u64); + assert_eq!(Some("b"), t.poll_to(tick)); + assert_eq!(0, count(&t)); + } + + #[test] + pub fn test_clearing_timeout_between_triggers() { + let mut t = timer(); + let mut tick; + + let a = t.set_timeout_at(Duration::from_millis(100), "a"); + let _ = t.set_timeout_at(Duration::from_millis(100), "b"); + let _ = t.set_timeout_at(Duration::from_millis(200), "c"); + + tick = ms_to_tick(&t, 100); + assert_eq!(Some("b"), t.poll_to(tick)); + assert_eq!(2, count(&t)); + + t.cancel_timeout(&a); + assert_eq!(1, count(&t)); + + assert_eq!(None, t.poll_to(tick)); + + tick = ms_to_tick(&t, 200); + assert_eq!(Some("c"), t.poll_to(tick)); + assert_eq!(0, count(&t)); + } + + const TICK: u64 = 100; + const SLOTS: usize = 16; + const CAPACITY: usize = 32; + + fn count<T>(timer: &Timer<T>) -> usize { + timer.entries.len() + } + + fn timer() -> Timer<&'static str> { + Timer::new(TICK, SLOTS, CAPACITY, Instant::now()) + } + + fn ms_to_tick<T>(timer: &Timer<T>, ms: u64) -> u64 { + ms / timer.tick_ms + } +} diff --git a/third_party/rust/mio-extras/test/mod.rs b/third_party/rust/mio-extras/test/mod.rs new file mode 100644 index 0000000000..217069466a --- /dev/null +++ b/third_party/rust/mio-extras/test/mod.rs @@ -0,0 +1,45 @@ +extern crate mio; +extern crate mio_extras; + +use mio::event::Event; +use mio::{Events, Poll}; +use std::time::Duration; + +mod test_poll_channel; +mod test_timer; + +pub fn expect_events( + poll: &Poll, + event_buffer: &mut Events, + poll_try_count: usize, + mut expected: Vec<Event>, +) { + const MS: u64 = 1_000; + + for _ in 0..poll_try_count { + poll.poll(event_buffer, Some(Duration::from_millis(MS))) + .unwrap(); + for event in event_buffer.iter() { + let pos_opt = match expected.iter().position(|exp_event| { + (event.token() == exp_event.token()) + && event.readiness().contains(exp_event.readiness()) + }) { + Some(x) => Some(x), + None => None, + }; + if let Some(pos) = pos_opt { + expected.remove(pos); + } + } + + if expected.is_empty() { + break; + } + } + + assert!( + expected.is_empty(), + "The following expected events were not found: {:?}", + expected + ); +} diff --git a/third_party/rust/mio-extras/test/test_poll_channel.rs b/third_party/rust/mio-extras/test/test_poll_channel.rs new file mode 100644 index 0000000000..7314f26661 --- /dev/null +++ b/third_party/rust/mio-extras/test/test_poll_channel.rs @@ -0,0 +1,362 @@ +use crate::expect_events; +use mio::event::Event; +use mio::{Events, Poll, PollOpt, Ready, Token}; +use mio_extras::channel; +use std::sync::mpsc::TryRecvError; +use std::thread; +use std::time::Duration; + +#[test] +pub fn test_poll_channel_edge() { + let poll = Poll::new().unwrap(); + let mut events = Events::with_capacity(1024); + let (tx, rx) = channel::channel(); + + poll.register(&rx, Token(123), Ready::readable(), PollOpt::edge()) + .unwrap(); + + // Wait, but nothing should happen + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); + assert_eq!(0, num); + + // Push the value + tx.send("hello").unwrap(); + + // Polling will contain the event + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); + assert_eq!(1, num); + + let event = events.iter().next().unwrap(); + assert_eq!(event.token(), Token(123)); + assert_eq!(event.readiness(), Ready::readable()); + + // Poll again and there should be no events + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); + assert_eq!(0, num); + + // Read the value + assert_eq!("hello", rx.try_recv().unwrap()); + + // Poll again, nothing + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); + assert_eq!(0, num); + + // Push a value + tx.send("goodbye").unwrap(); + + // Have an event + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); + assert_eq!(1, num); + + let event = events.iter().next().unwrap(); + assert_eq!(event.token(), Token(123)); + assert_eq!(event.readiness(), Ready::readable()); + + // Read the value + rx.try_recv().unwrap(); + + // Drop the sender half + drop(tx); + + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); + assert_eq!(1, num); + + let event = events.iter().next().unwrap(); + assert_eq!(event.token(), Token(123)); + assert_eq!(event.readiness(), Ready::readable()); + + match rx.try_recv() { + Err(TryRecvError::Disconnected) => {} + no => panic!("unexpected value {:?}", no), + } +} + +#[test] +pub fn test_poll_channel_oneshot() { + let poll = Poll::new().unwrap(); + let mut events = Events::with_capacity(1024); + let (tx, rx) = channel::channel(); + + poll.register( + &rx, + Token(123), + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + ) + .unwrap(); + + // Wait, but nothing should happen + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); + assert_eq!(0, num); + + // Push the value + tx.send("hello").unwrap(); + + // Polling will contain the event + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); + assert_eq!(1, num); + + let event = events.iter().next().unwrap(); + assert_eq!(event.token(), Token(123)); + assert_eq!(event.readiness(), Ready::readable()); + + // Poll again and there should be no events + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); + assert_eq!(0, num); + + // Read the value + assert_eq!("hello", rx.try_recv().unwrap()); + + // Poll again, nothing + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); + assert_eq!(0, num); + + // Push a value + tx.send("goodbye").unwrap(); + + // Poll again, nothing + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); + assert_eq!(0, num); + + // Reregistering will re-trigger the notification + for _ in 0..3 { + poll.reregister( + &rx, + Token(123), + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + ) + .unwrap(); + + // Have an event + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); + assert_eq!(1, num); + + let event = events.iter().next().unwrap(); + assert_eq!(event.token(), Token(123)); + assert_eq!(event.readiness(), Ready::readable()); + } + + // Get the value + assert_eq!("goodbye", rx.try_recv().unwrap()); + + poll.reregister( + &rx, + Token(123), + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + ) + .unwrap(); + + // Have an event + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); + assert_eq!(0, num); + + poll.reregister( + &rx, + Token(123), + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + ) + .unwrap(); + + // Have an event + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); + assert_eq!(0, num); +} + +#[test] +pub fn test_poll_channel_level() { + let poll = Poll::new().unwrap(); + let mut events = Events::with_capacity(1024); + let (tx, rx) = channel::channel(); + + poll.register(&rx, Token(123), Ready::readable(), PollOpt::level()) + .unwrap(); + + // Wait, but nothing should happen + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); + assert_eq!(0, num); + + // Push the value + tx.send("hello").unwrap(); + + // Polling will contain the event + for i in 0..5 { + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); + assert!(1 == num, "actually got {} on iteration {}", num, i); + + let event = events.iter().next().unwrap(); + assert_eq!(event.token(), Token(123)); + assert_eq!(event.readiness(), Ready::readable()); + } + + // Read the value + assert_eq!("hello", rx.try_recv().unwrap()); + + // Wait, but nothing should happen + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); + assert_eq!(0, num); +} + +#[test] +pub fn test_poll_channel_writable() { + let poll = Poll::new().unwrap(); + let mut events = Events::with_capacity(1024); + let (tx, rx) = channel::channel(); + + poll.register(&rx, Token(123), Ready::writable(), PollOpt::edge()) + .unwrap(); + + // Wait, but nothing should happen + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); + assert_eq!(0, num); + + // Push the value + tx.send("hello").unwrap(); + + // Wait, but nothing should happen + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); + assert_eq!(0, num); +} + +#[test] +pub fn test_dropping_receive_before_poll() { + let poll = Poll::new().unwrap(); + let mut events = Events::with_capacity(1024); + let (tx, rx) = channel::channel(); + + poll.register(&rx, Token(123), Ready::readable(), PollOpt::edge()) + .unwrap(); + + // Push the value + tx.send("hello").unwrap(); + + // Drop the receive end + drop(rx); + + // Wait, but nothing should happen + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); + assert_eq!(0, num); +} + +#[test] +pub fn test_mixing_channel_with_socket() { + use mio::net::{TcpListener, TcpStream}; + + let poll = Poll::new().unwrap(); + let mut events = Events::with_capacity(1024); + let (tx, rx) = channel::channel(); + + // Create the listener + let l = TcpListener::bind(&"127.0.0.1:0".parse().unwrap()).unwrap(); + + // Register the listener with `Poll` + poll.register(&l, Token(0), Ready::readable(), PollOpt::edge()) + .unwrap(); + poll.register(&rx, Token(1), Ready::readable(), PollOpt::edge()) + .unwrap(); + + // Push a value onto the channel + tx.send("hello").unwrap(); + + // Connect a TCP socket + let s1 = TcpStream::connect(&l.local_addr().unwrap()).unwrap(); + + // Register the socket + poll.register(&s1, Token(2), Ready::readable(), PollOpt::edge()) + .unwrap(); + + // Sleep a bit to ensure it arrives at dest + thread::sleep(Duration::from_millis(250)); + + expect_events( + &poll, + &mut events, + 2, + vec![ + Event::new(Ready::empty(), Token(0)), + Event::new(Ready::empty(), Token(1)), + ], + ); +} + +#[test] +pub fn test_sending_from_other_thread_while_polling() { + const ITERATIONS: usize = 20; + const THREADS: usize = 5; + + // Make sure to run multiple times + let poll = Poll::new().unwrap(); + let mut events = Events::with_capacity(1024); + + for _ in 0..ITERATIONS { + let (tx, rx) = channel::channel(); + poll.register(&rx, Token(0), Ready::readable(), PollOpt::edge()) + .unwrap(); + + for _ in 0..THREADS { + let tx = tx.clone(); + + thread::spawn(move || { + thread::sleep(Duration::from_millis(50)); + tx.send("ping").unwrap(); + }); + } + + let mut recv = 0; + + while recv < THREADS { + let num = poll.poll(&mut events, None).unwrap(); + + if num != 0 { + assert_eq!(1, num); + assert_eq!(events.iter().next().unwrap().token(), Token(0)); + + while let Ok(_) = rx.try_recv() { + recv += 1; + } + } + } + } +} diff --git a/third_party/rust/mio-extras/test/test_timer.rs b/third_party/rust/mio-extras/test/test_timer.rs new file mode 100644 index 0000000000..ac49833523 --- /dev/null +++ b/third_party/rust/mio-extras/test/test_timer.rs @@ -0,0 +1,308 @@ +use mio::{Events, Poll, PollOpt, Ready, Token}; +use mio_extras::timer::{self, Timer}; + +use std::thread; +use std::time::Duration; + +#[test] +fn test_basic_timer_without_poll() { + let mut timer = Timer::default(); + + // Set the timeout + timer.set_timeout(Duration::from_millis(200), "hello"); + + // Nothing when polled immediately + assert!(timer.poll().is_none()); + + // Wait for the timeout + thread::sleep(Duration::from_millis(250)); + + assert_eq!(Some("hello"), timer.poll()); + assert!(timer.poll().is_none()); +} + +#[test] +fn test_basic_timer_with_poll_edge_set_timeout_after_register() { + let poll = Poll::new().unwrap(); + let mut events = Events::with_capacity(1024); + let mut timer = Timer::default(); + + poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge()) + .unwrap(); + timer.set_timeout(Duration::from_millis(200), "hello"); + + let elapsed = elapsed(|| { + let num = poll.poll(&mut events, None).unwrap(); + + assert_eq!(num, 1); + let event = events.iter().next().unwrap(); + assert_eq!(Token(0), event.token()); + assert_eq!(Ready::readable(), event.readiness()); + }); + + assert!(is_about(200, elapsed), "actual={:?}", elapsed); + assert_eq!("hello", timer.poll().unwrap()); + assert_eq!(None, timer.poll()); +} + +#[test] +fn test_basic_timer_with_poll_edge_set_timeout_before_register() { + let poll = Poll::new().unwrap(); + let mut events = Events::with_capacity(1024); + let mut timer = Timer::default(); + + timer.set_timeout(Duration::from_millis(200), "hello"); + poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge()) + .unwrap(); + + let elapsed = elapsed(|| { + let num = poll.poll(&mut events, None).unwrap(); + + assert_eq!(num, 1); + let event = events.iter().next().unwrap(); + assert_eq!(Token(0), event.token()); + assert_eq!(Ready::readable(), event.readiness()); + }); + + assert!(is_about(200, elapsed), "actual={:?}", elapsed); + assert_eq!("hello", timer.poll().unwrap()); + assert_eq!(None, timer.poll()); +} + +#[test] +fn test_setting_later_timeout_then_earlier_one() { + let poll = Poll::new().unwrap(); + let mut events = Events::with_capacity(1024); + let mut timer = Timer::default(); + + poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge()) + .unwrap(); + + timer.set_timeout(Duration::from_millis(600), "hello"); + timer.set_timeout(Duration::from_millis(200), "world"); + + let elapsed = elapsed(|| { + let num = poll.poll(&mut events, None).unwrap(); + + assert_eq!(num, 1); + let event = events.iter().next().unwrap(); + assert_eq!(Token(0), event.token()); + assert_eq!(Ready::readable(), event.readiness()); + }); + + assert!(is_about(200, elapsed), "actual={:?}", elapsed); + assert_eq!("world", timer.poll().unwrap()); + assert_eq!(None, timer.poll()); + + let elapsed = self::elapsed(|| { + let num = poll.poll(&mut events, None).unwrap(); + + assert_eq!(num, 1); + let event = events.iter().next().unwrap(); + assert_eq!(Token(0), event.token()); + assert_eq!(Ready::readable(), event.readiness()); + }); + + assert!(is_about(400, elapsed), "actual={:?}", elapsed); + assert_eq!("hello", timer.poll().unwrap()); + assert_eq!(None, timer.poll()); +} + +#[test] +fn test_timer_with_looping_wheel() { + let poll = Poll::new().unwrap(); + let mut events = Events::with_capacity(1024); + let mut timer = timer::Builder::default().num_slots(2).build(); + + poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge()) + .unwrap(); + + const TOKENS: &[&str] = &["hello", "world", "some", "thing"]; + + for (i, msg) in TOKENS.iter().enumerate() { + timer.set_timeout(Duration::from_millis(500 * (i as u64 + 1)), msg); + } + + for msg in TOKENS { + let elapsed = elapsed(|| { + let num = poll.poll(&mut events, None).unwrap(); + + assert_eq!(num, 1); + let event = events.iter().next().unwrap(); + assert_eq!(Token(0), event.token()); + assert_eq!(Ready::readable(), event.readiness()); + }); + + assert!( + is_about(500, elapsed), + "actual={:?}; msg={:?}", + elapsed, + msg + ); + assert_eq!(Some(msg), timer.poll()); + assert_eq!(None, timer.poll()); + } +} + +#[test] +fn test_edge_without_polling() { + let poll = Poll::new().unwrap(); + let mut events = Events::with_capacity(1024); + let mut timer = Timer::default(); + + poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge()) + .unwrap(); + + timer.set_timeout(Duration::from_millis(400), "hello"); + + let ms = elapsed(|| { + let num = poll.poll(&mut events, None).unwrap(); + assert_eq!(num, 1); + let event = events.iter().next().unwrap(); + assert_eq!(Token(0), event.token()); + assert_eq!(Ready::readable(), event.readiness()); + }); + + assert!(is_about(400, ms), "actual={:?}", ms); + + let ms = elapsed(|| { + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); + assert_eq!(num, 0); + }); + + assert!(is_about(300, ms), "actual={:?}", ms); +} + +#[test] +fn test_level_triggered() { + let poll = Poll::new().unwrap(); + let mut events = Events::with_capacity(1024); + let mut timer = Timer::default(); + + poll.register(&timer, Token(0), Ready::readable(), PollOpt::level()) + .unwrap(); + + timer.set_timeout(Duration::from_millis(400), "hello"); + + let ms = elapsed(|| { + let num = poll.poll(&mut events, None).unwrap(); + assert_eq!(num, 1); + let event = events.iter().next().unwrap(); + assert_eq!(Token(0), event.token()); + assert_eq!(Ready::readable(), event.readiness()); + }); + + assert!(is_about(400, ms), "actual={:?}", ms); + + let ms = elapsed(|| { + let num = poll.poll(&mut events, None).unwrap(); + assert_eq!(num, 1); + let event = events.iter().next().unwrap(); + assert_eq!(Token(0), event.token()); + assert_eq!(Ready::readable(), event.readiness()); + }); + + assert!(is_about(0, ms), "actual={:?}", ms); +} + +#[test] +fn test_edge_oneshot_triggered() { + let poll = Poll::new().unwrap(); + let mut events = Events::with_capacity(1024); + let mut timer = Timer::default(); + + poll.register( + &timer, + Token(0), + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + ) + .unwrap(); + + timer.set_timeout(Duration::from_millis(200), "hello"); + + let ms = elapsed(|| { + let num = poll.poll(&mut events, None).unwrap(); + assert_eq!(num, 1); + }); + + assert!(is_about(200, ms), "actual={:?}", ms); + + let ms = elapsed(|| { + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); + assert_eq!(num, 0); + }); + + assert!(is_about(300, ms), "actual={:?}", ms); + + poll.reregister( + &timer, + Token(0), + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + ) + .unwrap(); + + let ms = elapsed(|| { + let num = poll.poll(&mut events, None).unwrap(); + assert_eq!(num, 1); + }); + + assert!(is_about(0, ms)); +} + +#[test] +fn test_cancel_timeout() { + use std::time::Instant; + + let mut timer: Timer<u32> = Default::default(); + let timeout = timer.set_timeout(Duration::from_millis(200), 1); + timer.cancel_timeout(&timeout); + + let poll = Poll::new().unwrap(); + poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge()) + .unwrap(); + + let mut events = Events::with_capacity(16); + + let now = Instant::now(); + let dur = Duration::from_millis(500); + let mut i = 0; + + while Instant::now() - now < dur { + if i > 10 { + panic!("iterated too many times"); + } + + i += 1; + + let elapsed = Instant::now() - now; + + poll.poll(&mut events, Some(dur - elapsed)).unwrap(); + + while let Some(_) = timer.poll() { + panic!("did not expect to receive timeout"); + } + } +} + +fn elapsed<F: FnMut()>(mut f: F) -> u64 { + use std::time::Instant; + + let now = Instant::now(); + + f(); + + let elapsed = now.elapsed(); + elapsed.as_secs() * 1000 + u64::from(elapsed.subsec_millis()) +} + +fn is_about(expect: u64, val: u64) -> bool { + const WINDOW: i64 = 200; + + ((expect as i64) - (val as i64)).abs() <= WINDOW +} diff --git a/third_party/rust/mio/.cargo-checksum.json b/third_party/rust/mio/.cargo-checksum.json new file mode 100644 index 0000000000..db0a0e67ae --- /dev/null +++ b/third_party/rust/mio/.cargo-checksum.json @@ -0,0 +1 @@ +{"files":{"CHANGELOG.md":"3122f4f3d0a9037b7751165fd0f85dc4cb5f6ac477b125209592677b46dfd3e5","Cargo.lock":"63104f5dc52f4db8f3f07baf3f864981d0c8e81ab2ce48c42f77e2133a599750","Cargo.toml":"ec9040c14bcf46f749e9be6b6ddcd526747f7eaa4a1f7a528a2ce4e54e508973","LICENSE":"07919255c7e04793d8ea760d6c2ce32d19f9ff02bdbdde3ce90b1e1880929a9b","README.md":"cbdf6b961e2e6d708e4ce724c0e59b63e41644a1604e9d143d2a9bfff63f9ffa","examples/tcp_server.rs":"18b63bbde45de60f6bd402f0255a5ce6bc8ae13bc8ec98f41b8c635ee1f7a810","examples/udp_server.rs":"697037952d7e7cf1a83c63b81208e3d50bd405c138ad6a8eb021d5ad016916fd","src/event/event.rs":"d77844aa192a732ac049a789ebaac496a5c1342b9f07846907f215503edfbdbd","src/event/events.rs":"5cad85e0d0c9e619b6017f868c681ed0dc023e7aae8c0c5c0c7337b2fa96a8a6","src/event/mod.rs":"c129c42114867e3e7337a6605952db8cef8a7ef0938f67a28fa68e73fc420c6a","src/event/source.rs":"7ffe6d1ba738b5c671d7c450b8833abf0983f7294e0edec49c4203c2d7f44ddb","src/interest.rs":"ecffc07ae17e7f73d69628dd94678f2df2f766d807dbef867505ef390c47bcdf","src/io_source.rs":"f9e68e1dc65b322fbc471f57eecb7052351c5c9919d0b0aed1771c0a8e938b71","src/lib.rs":"fed93472856ce7a0b526bb80e80b0ed2f2017268c3fa440710d6aa396495b8fb","src/macros.rs":"c484744396b163555c8593cf15929201dd23b3ff75a4be03b8dc34e46f6d9caa","src/net/mod.rs":"2b1efac93ebdb7352e44d07645e1d28e3fb28a0938d85a71c4ce89c979008200","src/net/tcp/listener.rs":"51afbf8e3d565289df6164a64b13abde257654050bd59693cfbc9157767f9444","src/net/tcp/mod.rs":"f2c50c1d338a69d704e18727142d8495be2927b390d7bbb77cc0cf4e945ed83a","src/net/tcp/stream.rs":"8bcb20d1874ebc3e16c972107059a23fa0df5e451605ba65a47b28d792765284","src/net/udp.rs":"221bdffe16cf8478ecd9fb95fcb07b2490f20cd1b1b2cf0baf7ea51169d9fb03","src/net/uds/datagram.rs":"980944654a03f61311a7208043011db4831d40b92bd440ed57515cac6104ff2f","src/net/uds/listener.rs":"714b1638a522cc95bb70b137441bc1282684fbcde4432b6872ad052f66670164","src/net/uds/mod.rs":"70d4368adae74652d46771b29e633396e5f1b70e9b7d1370cf5fec9a78605c04","src/net/uds/stream.rs":"fa6dd11e5736c8372037945f96c5b0c7adee1a29c2b194bc9bf9f7cc2db7f1f4","src/poll.rs":"0aa428f111810b62080653bdc76c4f73a33d0e47b0368aa687e366588c839b8d","src/sys/mod.rs":"58d6750b37d4bd94ac90e9aaeb88aa79a65f379931857691ae5e7df16a55c15d","src/sys/shell/mod.rs":"6c8b107397e110e916c02e0f1f1f03344974456a7e929a731eeb462d5ba13968","src/sys/shell/selector.rs":"9f6eee2b858c68012962cfcd7ed747acd198c518ddb807ada2a30eb1faf4c052","src/sys/shell/tcp.rs":"020d1885c3bd8f6d74e69f4d068a186fadff605fedca3e811209d857e41f575b","src/sys/shell/udp.rs":"fc830fea77935d141f87179c5ceec95318c67d24060051c155deb5ace14d7134","src/sys/shell/uds.rs":"10c2933423e251fca678322ff9fc7501fcaacdfa769307399cb5dfc7bef63ec3","src/sys/shell/waker.rs":"81bc18cf52345a8d17e8142291e43dd70a36dfd9f5eb486f3e787998ee4451dc","src/sys/unix/mod.rs":"d2b03e3d166d174f1ad283e6a2aa1c3287b4d6e0affb3ed7ea7e033fbbfc5f1d","src/sys/unix/net.rs":"32c15a72d04b76c0c18944de590eb271787442c88a718b6e5f03b0830c533cd3","src/sys/unix/pipe.rs":"a0d308087b9258963014e3b7e61ece41eee0a7b0ee2240fe8b24f2d750238029","src/sys/unix/selector/epoll.rs":"1dfc3b77752f1948b34680f86c77073756cc212d04c209d53cb8cd895b6558c4","src/sys/unix/selector/kqueue.rs":"ce92b47c5dabf38da32cba155cdba74a52c853eb7938ed9cdeca8dc23d0e8714","src/sys/unix/selector/mod.rs":"d4eedd1e067b726fc8e2eb5d662ce540f46675810934a57085f3777901a2e6ce","src/sys/unix/sourcefd.rs":"18292d551d78a4ae6900ee31c969909a784d42b49184b7e0581c08f170dabf04","src/sys/unix/tcp.rs":"369d5520416eb4a7af0cc180bb2ebd2b1b4176f1e7276676427f00d95d78b8fd","src/sys/unix/udp.rs":"babf7d444eba0db29b130f0e254b0715e2566e7ea5b0f0e35cddf72d83f40b3b","src/sys/unix/uds/datagram.rs":"a7da7e4292ac42ccc2be5ad5909ced1d20377ace0198868fed89e086edc016f7","src/sys/unix/uds/listener.rs":"d98a223ed1c98c92cabe0124ae08fba2771cf801ed048a44408afb3afc459303","src/sys/unix/uds/mod.rs":"5b2cecdeada87caf1ef44dfe18d3536ac4883f4f72b3cae959bbf2044a6d2dcc","src/sys/unix/uds/socketaddr.rs":"c6784b61c6705c222e41db8abddc9458c05c70de3bc53e9a7b4aec0ea371058e","src/sys/unix/uds/stream.rs":"f785ff59f9e8ddec8519f5bfbd93150f26674efa91742909eb839d44250fe334","src/sys/unix/waker.rs":"10dda922b21ad0a32bf748bf9087121c4f57395452be0bb619503821f863dede","src/sys/windows/afd.rs":"27bf224b2626c5930a0a50043e95a13e3de29d73e360dc7dfa08ef581c670380","src/sys/windows/event.rs":"75539e2db54858605e565742a68242b2a69fe9b8cd8d60ff7a109cf43e5b5930","src/sys/windows/io_status_block.rs":"9920f2b12ebd90f1c42cd73fff775d015321dd2186d58fd10bca8f349489e5e0","src/sys/windows/mod.rs":"c324e7f2e07757563fa5e5ccf05a06ef0eac92394c23e36b155c70e895e53713","src/sys/windows/named_pipe.rs":"619101d86ca57a3a3a726ee465eed00840acef3d5b20e5fffefeaae1d1fa64d5","src/sys/windows/net.rs":"e1c526a18ea6319ac4b4736dbe0bd5ba85d6e601f708fed49174561d459617fb","src/sys/windows/overlapped.rs":"a041d2a6f03eb5e005ed14f23bc5cdf12dfc33036a7644dc925518ad944987f0","src/sys/windows/selector.rs":"d0718e495a85a67886ba3202b0a84df25aef23a4a8c53ff08b73e1795dded74e","src/sys/windows/tcp.rs":"2b90ec2950274bc4f15ba0166a6addbc447ad61e3eb4e66fbd8237c24983383b","src/sys/windows/udp.rs":"07b104a6be6cba40acf9933cd6283260a2e272b7d50743d836aa13f4bc4b07f3","src/sys/windows/waker.rs":"acae348778e4f60762b9e4cf083ff02305d9a7a14216456154a9be7f7af4c6c9","src/token.rs":"4e64c8e337fbee4e3a2f5e8661241b5261c9c5487e20fa73425d89e2e152e8de","src/waker.rs":"5faa61a35b413302d4c514abe4f4014abbe1665dff0f24a55feb62e9b521e26f"},"package":"ba272f85fa0b41fc91872be579b3bbe0f56b792aa361a380eb669469f68dafb2"}
\ No newline at end of file diff --git a/third_party/rust/mio/CHANGELOG.md b/third_party/rust/mio/CHANGELOG.md new file mode 100644 index 0000000000..65dce4f328 --- /dev/null +++ b/third_party/rust/mio/CHANGELOG.md @@ -0,0 +1,526 @@ +# 0.8.0 + +## Removed + +* Deprecated features (https://github.com/tokio-rs/mio/commit/105f8f2afb57b01ddea716a0aa9720f226c520e3): + * extra-docs (always enabled) + * tcp (replaced with "net" feature). + * udp (replaced with "net" feature). + * uds (replaced with "net" feature). + * pipe (replaced with "os-ext" feature). +* `TcpSocket` type + (https://github.com/tokio-rs/mio/commit/02e9be41f27daf822575444fdd2b3067433a5996). + The socket2 crate provides all the functionality and more. +* Support for Solaris, it never really worked anyway + (https://github.com/tokio-rs/mio/pull/1528). + +## Changes + +* Update minimum Rustc version (MSVR) to 1.46.0 + (https://github.com/tokio-rs/mio/commit/5c577efecd23750a9a3e0f6ad080ab98f14a255d). + +## Added + +* `UdpSocket::peer_addr` + (https://github.com/tokio-rs/mio/commit/5fc104d08e0e74c8a19247f7cba0f058699fc438). + +# 0.7.14 + +## Fixes + +* Remove use unsound internal macro (#1519). + +## Added + +* `sys::unix::SocketAddr::as_abstract_namespace()` (#1520). + +# 0.7.13 + +## Fixes + +* Fix `Registry::try_clone` invalid usage of `F_DUPFD_CLOEXEC` (#1497, + https://github.com/tokio-rs/mio/commit/2883f5c1f35bf1a59682c5ffc4afe6b97d7d6e68). + +# 0.7.12 (yanked) + +## Fixes + +* Set `FD_CLOEXEC` when calling `Registry::try_clone` + (https://github.com/tokio-rs/mio/commit/d1617b567ff6bc669d71e367d22e0e93ff7e2e24 for epoll and + (https://github.com/tokio-rs/mio/commit/b367a05e408ca90a26383c3aa16d8a16f019dc59 for kqueue). + +# 0.7.11 + +## Fixes + +* Fix missing feature of winapi. + (https://github.com/tokio-rs/mio/commit/a7e61db9e3c2b929ef1a33532bfcc22045d163ce). + +# 0.7.10 + +## Fixes + +* Fix an instance of not doc(cfg(.*)) + (https://github.com/tokio-rs/mio/commit/25e8f911357c740034f10a170dfa4ea1b28234ce). + +# 0.7.9 + +## Fixes + +* Fix error handling in `NamedPipe::write` + (https://github.com/tokio-rs/mio/commit/aec872be9732e5c6685100674278be27f54a271b). +* Use `accept(2)` on x86 Android instead of `accept4(2)` + (https://github.com/tokio-rs/mio/commit/6f86b925d3e48f30905d5cfa54348acf3f1fa036, + https://github.com/tokio-rs/mio/commit/8d5414880ab82178305ac1d2c16d715e58633d3e). +* Improve error message when opening AFD device + (https://github.com/tokio-rs/mio/commit/139f7c4422321eb4a17b14ae2c296fddd19a8804). + +# 0.7.8 + +## Fixes + +* Fix `TcpStream::set_linger` on macOS + (https://github.com/tokio-rs/mio/commit/175773ce02e85977db81224c782c8d140aba8543). +* Fix compilation on DragonFlyBSD + (https://github.com/tokio-rs/mio/commit/b51af46b28871f8dd3233b490ee62237ffed6a26). + +# 0.7.7 + +## Added + +* `UdpSocket::only_v6` + (https://github.com/tokio-rs/mio/commit/0101e05a800f17fb88f4315d9b9fe0f08cca6e57). +* `Clone` implementation for `Event` + (https://github.com/tokio-rs/mio/commit/26540ebbae89df6d4d08465c56f715d8f2addfc3). +* `AsRawFd` implementation for `Registry` + (https://github.com/tokio-rs/mio/commit/f70daa72da0042b1880256164774c3286d315a02). +* `Read` and `Write` implementation for `&unix::pipe::Sender` and `Receiver`, + that is on the reference to them, an implementation existed on the types + themselves already + (https://github.com/tokio-rs/mio/commit/1be481dcbbcb6906364008b5d61e7f53cddc3eb3). + +## Fixes + +* Underflow in `SocketAddr::address` + (https://github.com/tokio-rs/mio/commit/6d3fa69240cd4bb95e9d34605c660c30245a18bd). +* Android build with the net feature enabled, but with os-poll disabled + (https://github.com/tokio-rs/mio/commit/49d8fd33e026ad6e2c055d05d6667180ba2af7be). +* Solaris build with the net feature enabled, but with os-poll disabled + (https://github.com/tokio-rs/mio/commit/a6e025e9d9511639ec106ebedc0dd312bdc9be12). +* Ensure that `Waker::wake` works on illumos systems with poor `pipe(2)` and + `epoll(2)` interaction using `EPOLLET` + (https://github.com/tokio-rs/mio/commit/943d4249dcc17cd8b4d2250c4fa19116097248fa). +* Fix `unix::pipe` on illumos + (https://github.com/tokio-rs/mio/commit/0db49f6d5caf54b12176821363d154384357e70a). + +# 0.7.6 + +## Added + +* `net` feature, replaces `tcp`, `udp` and `uds` features + (https://github.com/tokio-rs/mio/commit/a301ba520a8479b459c4acdcefa4a7c5eea818c7). +* `os-ext` feature, replaces `os-util` and `pipe` features + (https://github.com/tokio-rs/mio/commit/f5017fae8a3d3bb4b4cada25b01a2d76a406badc). +* Added keepalive support to `TcpSocket` + (https://github.com/tokio-rs/mio/commit/290c43a96662d54ab7c4b8814e5a9f9a9e523fda). +* `TcpSocket::set_{send, recv}_buffer_size` + (https://github.com/tokio-rs/mio/commit/40c4af79bf5b32b8fbdbf6f2e5c16290e1d3d406). +* `TcpSocket::get_linger` + (https://github.com/tokio-rs/mio/commit/13e82ced655bbb6e2729226e485a7de9f2c2ccd9). +* Implement `IntoRawFd` for `TcpSocket` + (https://github.com/tokio-rs/mio/commit/50548ed45d0b2c98f1f2e003e210d14195284ef4). + +## Deprecated + +* The `tcp`, `udp` and `uds` features, replaced by a new `net` feature. + (https://github.com/tokio-rs/mio/commit/a301ba520a8479b459c4acdcefa4a7c5eea818c7). +* The `extra-docs` feature, now enabled by default. + (https://github.com/tokio-rs/mio/commit/25731e8688a2d91c5c700674a2c2d3841240ece1). +* The `os-util` and `pipe` features, replaced by a new `os-ext` feature. + (https://github.com/tokio-rs/mio/commit/f5017fae8a3d3bb4b4cada25b01a2d76a406badc). + +## Fixes + +* Incorrect assumption of the layout of `std::net::SocketAddr`. Previously Mio + would assume that `SocketAddrV{4,6}` had the same layout as + `libc::sockaddr_in(6)`, however this is not guaranteed by the standard + library. + (https://github.com/tokio-rs/mio/commit/152e0751f0be1c9b0cbd6778645b76bcb0eba93c). +* Also bumped the miow dependency to version 0.3.6 to solve the same problem as + above. + +# 0.7.5 + +## Added + +* `TcpSocket::get_localaddr()` retrieves local address + (https://github.com/tokio-rs/mio/commit/b41a022b2242eef1969c70c8ba93e04c528dba47). +* `TcpSocket::set_reuseport()` & `TcpSocket::get_reuseport()` configures and reads `SO_REUSEPORT` + (https://github.com/tokio-rs/mio/commit/183bbe409ab69cbf9db41d0263b41ec86202d9a0). +* `unix:pipe()` a wrapper around pipe(2) sys call + (https://github.com/tokio-rs/mio/commit/2b7c0967a7362303946deb3d4ca2ae507af6c72d). +* Add a check that a single Waker is active per Poll instance (only in debug mode) + (https://github.com/tokio-rs/mio/commit/f4874f28b32efcf4841691884c65a89734d96a56). +* Added `Interest:remove()` + (https://github.com/tokio-rs/mio/commit/b8639c3d9ac07bb7e2e27685680c8a6510fa1357). + +# 0.7.4 + +## Fixes + +* lost "socket closed" events on windows + (https://github.com/tokio-rs/mio/commit/50c299aca56c4a26e5ed20c283007239fbe6a7a7). + +## Added + +* `TcpSocket::set_linger()` configures SO_LINGER + (https://github.com/tokio-rs/mio/commit/3b4096565c1a879f651b8f8282ecdcbdbd5c92d3). + +# 0.7.3 + +## Added + +* `TcpSocket` for configuring a TCP socket before connecting or listening + (https://github.com/tokio-rs/mio/commit/5b09e60d0f64419b989bda88c86a3147334a03b3). + +# 0.7.2 + +## Added + +* Windows named pipe support. + (https://github.com/tokio-rs/mio/commit/52e8c2220e87696d20f13561402bcaabba4136ed). + +# 0.7.1 + +## Reduced support for 32-bit Apple targets + +In January 2020 Rust reduced its support for 32-bit Apple targets +(https://blog.rust-lang.org/2020/01/03/reducing-support-for-32-bit-apple-targets.html). +Starting with v0.7.1 Mio will do the same as we're no longer checking 32 bit +iOS/macOS on our CI. + +## Added + +* Support for illumos + (https://github.com/tokio-rs/mio/commit/976f2354d0e8fbbb64fba3bf017d7131f9c369a0). +* Report `epoll(2)`'s `EPOLLERR` event as `Event::is_write_closed` if it's the + only event + (https://github.com/tokio-rs/mio/commit/0c77b5712d675eeb9bd43928b5dd7d22b2c7ac0c). +* Optimised event::Iter::{size_hint, count} + (https://github.com/tokio-rs/mio/commit/40df934a11b05233a7796c4de19a4ee06bc4e03e). + +## Fixed + +* Work around Linux kernel < 2.6.37 bug on 32-bits making timeouts longer then + ~30 minutes effectively infinite + (https://github.com/tokio-rs/mio/commit/d555991f5ee81f6c1eec0fe481557d3d5b8d5ff4). +* Set `SO_NOSIGPIPE` on all sockets (not just UDP) on for Apple targets + (https://github.com/tokio-rs/mio/commit/b8bbdcb0d3236f4c4acb257996d42a88dc9987d9). +* Properly handle `POLL_ABORT` on Windows + (https://github.com/tokio-rs/mio/commit/a98da62b3ed1eeed1770aaca12f46d647e4fa749). +* Improved error handling around failing `SIO_BASE_HANDLE` calls on Windows + (https://github.com/tokio-rs/mio/commit/b15fc18458a79ef8a51f73effa92548650f4e5dc). + +## Changed + +* On NetBSD we now use `accept4(2)` + (https://github.com/tokio-rs/mio/commit/4e306addc7144f2e02a7e8397c220b179a006a19). +* The package uploaded to crates.io should be slightly smaller + (https://github.com/tokio-rs/mio/commit/eef8d3b9500bc0db957cd1ac68ee128ebc68351f). + +## Removed + +* Dependency on `lazy_static` on Windows + (https://github.com/tokio-rs/mio/commit/57e4c2a8ac153bc7bb87829e22cf0a21e3927e8a). + +# 0.7.0 + +Version 0.7 of Mio contains various major changes compared to version 0.6. +Overall a large number of API changes have been made to reduce the complexity of +the implementation and remove overhead where possible. + +Please refer to the [blog post about +0.7-alpha.1](https://tokio.rs/blog/2019-12-mio-v0.7-alpha.1/) for additional +information. + +## Added + +* `Interest` structure that replaces `Ready` in registering event sources. +* `Registry` structure that separates the registering and polling functionality. +* `Waker` structure that allows another thread to wake a thread polling `Poll`. +* Unix Domain Socket (UDS) types: `UnixDatagram`, `UnixListener` and + `UnixStream`. + +## Removed + +* All code deprecated in 0.6 was removed in 0.7. +* Support for Fuchsia was removed as the code was unmaintained. +* Support for Bitrig was removed, rustc dropped support for it also. +* `UnixReady` was merged into `Ready`. +* Custom user-space readiness queue was removed, this includes the public + `Registration` and `SetReadiness` types. +* `PollOpt` was removed and all registrations use edge-triggers. See the upgrade + guide on how to process event using edge-triggers. +* The network types (types in the `net` module) now support only the same API as + found in the standard library, various methods on the types were removed. +* `TcpStream` now supports vectored I/O. +* `Poll::poll_interruptible` was removed. Instead `Poll::poll` will now return + an error if one occurs. +* `From<usize>` is removed from `Token`, the internal field is still public, so + `Token(my_token)` can still be used. + +## Changed + +* Various documentation improvements were made around correct usage of `Poll` + and registered event sources. It is recommended to reread the documentation of + at least `event::Source` and `Poll`. +* Mio now uses Rust 2018 and rustfmt for all code. +* `Event` was changed to be a wrapper around the OS event. This means it can be + significantly larger on some OSes. +* `Ready` was removed and replaced with various `is_*` methods on `Event`. For + example instead checking for readable readiness using + `Event::ready().is_readable()`, you would call `Event::is_readable()`. +* `Ready::is_hup` was removed in favour of `Event::is_read_closed` and + `Event::is_write_closed`. +* The Iterator implementation of `Events` was changed to return `&Event`. +* `Evented` was renamed to `event::Source` and now takes mutable reference to + the source. +* Minimum supported Rust version was increased to 1.39. +* By default Mio now uses a shim implementation. To enable the full + implementation, that uses the OS, enable the `os-oll` feature. To enable the + network types use `tcp`, `udp` and/or `uds`. For more documentation on the + features see the `feature` module in the API documentation (requires the + `extra-docs` feature). +* The entire Windows implementation was rewritten. +* Various optimisation were made to reduce the number of system calls in + creating and using sockets, e.g. making use of `accept4(2)`. +* The `fmt::Debug` implementation of `Events` is now actually useful as it + prints all `Event`s. + +# 0.6.23 (Dec 01, 2020) + +### Changed +- **MSRV**: Increased the MSRV from 1.18.0 (Jun 8, 2017) to 1.31.0 (Dec 6, + 2018) + (https://github.com/tokio-rs/mio/commit/4879e0d32ddfd98e762fc87240e594a3ad8fca30). + +### Fixed +- Work around Linux kernel < 2.6.37 bug on 32-bits making timeouts longer then + ~30 minutes effectively infinite + (https://github.com/tokio-rs/mio/commit/e7cba59950e9c9fa6194e29b5b1e72029e3df455). +- Update miow and net2 depedencies to get rid of invalid memory layout assumption + (https://github.com/tokio-rs/mio/commit/13f02ac0a86d7c0c0001e5ff8960a0b4340d075c). + +# 0.6.22 (May 01, 2020) + +### Added +- Add support for illumos target (#1294) + +# 0.6.21 (November 27, 2019) + +### Fixed +- remove `=` dependency on `cfg-if`. + +# 0.6.20 (November 21, 2019) + +### Fixed +- Use default IOCP concurrency value (#1161). +- setting FD_CLOEXEC in pipe (#1095). + +# 0.6.19 (May 28, 2018) + +### Fixed +- Do not trigger HUP events on kqueue platforms (#958). + +# 0.6.18 (May 24, 2018) + +### Fixed +- Fix compilation on kqueue platforms with 32bit C long (#948). + +# 0.6.17 (May 15, 2018) + +### Fixed +- Don't report `RDHUP` as `HUP` (#939) +- Fix lazycell related compilation issues. +- Fix EPOLLPRI conflicting with READABLE +- Abort process on ref count overflows + +### Added +- Define PRI on all targets + +# 0.6.16 (September 5, 2018) + +* Add EPOLLPRI readiness to UnixReady on supported platforms (#867) +* Reduce spurious awaken calls (#875) + +# 0.6.15 (July 3, 2018) + +* Implement `Evented` for containers (#840). +* Fix android-aarch64 build (#850). + +# 0.6.14 (March 8, 2018) + +* Add `Poll::poll_interruptible` (#811) +* Add `Ready::all` and `usize` conversions (#825) + +# 0.6.13 (February 5, 2018) + +* Fix build on DragonFlyBSD. +* Add `TcpListener::from_std` that does not require the socket addr. +* Deprecate `TcpListener::from_listener` in favor of from_std. + +# 0.6.12 (January 5, 2018) + +* Add `TcpStream::peek` function (#773). +* Raise minimum Rust version to 1.18.0. +* `Poll`: retry select() when interrupted by a signal (#742). +* Deprecate `Events` index access (#713). +* Add `Events::clear` (#782). +* Add support for `lio_listio` (#780). + +# 0.6.11 (October 25, 2017) + +* Allow register to take empty interest (#640). +* Fix bug with TCP errors on windows (#725). +* Add TcpListener::accept_std (#733). +* Update IoVec to fix soundness bug -- includes behavior change. (#747). +* Minimum Rust version is now 1.14.0. +* Fix Android x86_64 build. +* Misc API & doc polish. + +# 0.6.10 (July 27, 2017) + +* Experimental support for Fuchsia +* Add `only_v6` option for UDP sockets +* Fix build on NetBSD +* Minimum Rust version is now 1.13.0 +* Assignment operators (e.g. `|=`) are now implemented for `Ready` + +# 0.6.9 (June 7, 2017) + +* More socket options are exposed through the TCP types, brought in through the + `net2` crate. + +# 0.6.8 (May 26, 2017) + +* Support Fuchia +* POSIX AIO support +* Fix memory leak caused by Register::new2 +* Windows: fix handling failed TCP connections +* Fix build on aarch64-linux-android +* Fix usage of `O_CLOEXEC` with `SETFL` + +# 0.6.7 (April 27, 2017) + +* Ignore EPIPE coming out of `kevent` +* Timer thread should exit when timer is dropped. + +# 0.6.6 (March 22, 2017) + +* Add send(), recv() and connect() to UDPSocket. +* Fix bug in custom readiness queue +* Move net types into `net` module + +# 0.6.5 (March 14, 2017) + +* Misc improvements to kqueue bindings +* Add official support for iOS, Android, BSD +* Reimplement custom readiness queue +* `Poll` is now `Sync` +* Officially deprecate non-core functionality (timers, channel, etc...) +* `Registration` now implements `Evented` +* Fix bug around error conditions with `connect` on windows. +* Use iovec crate for scatter / gather operations +* Only support readable and writable readiness on all platforms +* Expose additional readiness in a platform specific capacity + +# 0.6.4 (January 24, 2017) + +* Fix compilation on musl +* Add `TcpStream::from_stream` which converts a std TCP stream to Mio. + +# 0.6.3 (January 22, 2017) + +* Implement readv/writev for `TcpStream`, allowing vectored reads/writes to + work across platforms +* Remove `nix` dependency +* Implement `Display` and `Error` for some channel error types. +* Optimize TCP on Windows through `SetFileCompletionNotificationModes` + +# 0.6.2 (December 18, 2016) + +* Allow registration of custom handles on Windows (like `EventedFd` on Unix) +* Send only one byte for the awakener on Unix instead of four +* Fix a bug in the timer implementation which caused an infinite loop + +# 0.6.1 (October 30, 2016) + +* Update dependency of `libc` to 0.2.16 +* Fix channel `dec` logic +* Fix a timer bug around timeout cancellation +* Don't allocate buffers for TCP reads on Windows +* Touched up documentation in a few places +* Fix an infinite looping timer thread on OSX +* Fix compile on 32-bit OSX +* Fix compile on FreeBSD + +# 0.6.0 (September 2, 2016) + +* Shift primary API towards `Poll` +* `EventLoop` and types to `deprecated` mod. All contents of the + `deprecated` mod will be removed by Mio 1.0. +* Increase minimum supported Rust version to 1.9.0 +* Deprecate unix domain socket implementation in favor of using a + version external to Mio. For example: https://github.com/alexcrichton/mio-uds. +* Remove various types now included in `std` +* Updated TCP & UDP APIs to match the versions in `std` +* Enable implementing `Evented` for any type via `Registration` +* Rename `IoEvent` -> `Event` +* Access `Event` data via functions vs. public fields. +* Expose `Events` as a public type that is passed into `Poll` +* Use `std::time::Duration` for all APIs that require a time duration. +* Polled events are now retrieved via `Events` type. +* Implement `std::error::Error` for `TimerError` +* Relax `Send` bound on notify messages. +* Remove `Clone` impl for `Timeout` (future proof) +* Remove `mio::prelude` +* Remove `mio::util` +* Remove dependency on bytes + +# 0.5.0 (December 3, 2015) + +* Windows support (#239) +* NetBSD support (#306) +* Android support (#295) +* Don't re-export bytes types +* Renamed `EventLoop::register_opt` to `EventLoop::register` (#257) +* `EventLoopConfig` is now a builder instead of having public struct fields. It + is also no longer `Copy`. (#259) +* `TcpSocket` is no longer exported in the public API (#262) +* Integrate with net2. (#262) +* `TcpListener` now returns the remote peer address from `accept` as well (#275) +* The `UdpSocket::{send_to, recv_from}` methods are no longer generic over `Buf` + or `MutBuf` but instead take slices directly. The return types have also been + updated to return the number of bytes transferred. (#260) +* Fix bug with kqueue where an error on registration prevented the + changelist from getting flushed (#276) +* Support sending/receiving FDs over UNIX sockets (#291) +* Mio's socket types are permanently associated with an EventLoop (#308) +* Reduce unnecessary poll wakeups (#314) + + +# 0.4.1 (July 21, 2015) + +* [BUGFIX] Fix notify channel concurrency bug (#216) + +# 0.4.0 (July 16, 2015) + +* [BUGFIX] EventLoop::register requests all events, not just readable. +* [BUGFIX] Attempting to send a message to a shutdown event loop fails correctly. +* [FEATURE] Expose TCP shutdown +* [IMPROVEMENT] Coalesce readable & writable into `ready` event (#184) +* [IMPROVEMENT] Rename TryRead & TryWrite function names to avoid conflict with std. +* [IMPROVEMENT] Provide TCP and UDP types in Mio (path to windows #155) +* [IMPROVEMENT] Use clock_ticks crate instead of time (path to windows #155) +* [IMPROVEMENT] Move unix specific features into mio::unix module +* [IMPROVEMENT] TcpListener sets SO_REUSEADDR by default diff --git a/third_party/rust/mio/Cargo.lock b/third_party/rust/mio/Cargo.lock new file mode 100644 index 0000000000..6f63e4a68e --- /dev/null +++ b/third_party/rust/mio/Cargo.lock @@ -0,0 +1,147 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +[[package]] +name = "cfg-if" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" + +[[package]] +name = "env_logger" +version = "0.8.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a19187fea3ac7e84da7dacf48de0c45d63c6a76f9490dae389aead16c243fce3" +dependencies = [ + "log", +] + +[[package]] +name = "getrandom" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753" +dependencies = [ + "cfg-if", + "libc", + "wasi", +] + +[[package]] +name = "libc" +version = "0.2.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fbe5e23404da5b4f555ef85ebed98fb4083e55a00c317800bc2a50ede9f3d219" + +[[package]] +name = "log" +version = "0.4.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "mio" +version = "0.8.0" +dependencies = [ + "env_logger", + "libc", + "log", + "miow", + "ntapi", + "rand", + "winapi", +] + +[[package]] +name = "miow" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9f1c5b025cda876f66ef43a113f91ebc9f4ccef34843000e0adf6ebbab84e21" +dependencies = [ + "winapi", +] + +[[package]] +name = "ntapi" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f6bb902e437b6d86e03cce10a7e2af662292c5dfef23b65899ea3ac9354ad44" +dependencies = [ + "winapi", +] + +[[package]] +name = "ppv-lite86" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed0cfbc8191465bed66e1718596ee0b0b35d5ee1f41c5df2189d0fe8bde535ba" + +[[package]] +name = "rand" +version = "0.8.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2e7573632e6454cf6b99d7aac4ccca54be06da05aca2ef7423d22d27d4d4bcd8" +dependencies = [ + "libc", + "rand_chacha", + "rand_core", + "rand_hc", +] + +[[package]] +name = "rand_chacha" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" +dependencies = [ + "ppv-lite86", + "rand_core", +] + +[[package]] +name = "rand_core" +version = "0.6.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7" +dependencies = [ + "getrandom", +] + +[[package]] +name = "rand_hc" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d51e9f596de227fda2ea6c84607f5558e196eeaf43c986b724ba4fb8fdf497e7" +dependencies = [ + "rand_core", +] + +[[package]] +name = "wasi" +version = "0.10.2+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6" + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" diff --git a/third_party/rust/mio/Cargo.toml b/third_party/rust/mio/Cargo.toml new file mode 100644 index 0000000000..78b6418022 --- /dev/null +++ b/third_party/rust/mio/Cargo.toml @@ -0,0 +1,64 @@ +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies. +# +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +edition = "2018" +name = "mio" +version = "0.8.0" +authors = ["Carl Lerche <me@carllerche.com>", "Thomas de Zeeuw <thomasdezeeuw@gmail.com>", "Tokio Contributors <team@tokio.rs>"] +include = ["Cargo.toml", "LICENSE", "README.md", "CHANGELOG.md", "src/**/*.rs", "examples/**/*.rs"] +description = "Lightweight non-blocking IO" +homepage = "https://github.com/tokio-rs/mio" +readme = "README.md" +keywords = ["io", "async", "non-blocking"] +categories = ["asynchronous"] +license = "MIT" +repository = "https://github.com/tokio-rs/mio" +[package.metadata.docs.rs] +all-features = true +rustdoc-args = ["--cfg", "docsrs"] +targets = ["aarch64-apple-ios", "aarch64-linux-android", "x86_64-apple-darwin", "x86_64-pc-windows-msvc", "x86_64-unknown-dragonfly", "x86_64-unknown-freebsd", "x86_64-unknown-illumos", "x86_64-unknown-linux-gnu", "x86_64-unknown-netbsd", "x86_64-unknown-openbsd"] + +[package.metadata.playground] +features = ["os-poll", "os-ext", "net"] + +[[example]] +name = "tcp_server" +required-features = ["os-poll", "net"] + +[[example]] +name = "udp_server" +required-features = ["os-poll", "net"] +[dependencies.log] +version = "0.4.8" +[dev-dependencies.env_logger] +version = "0.8.4" +default-features = false + +[dev-dependencies.rand] +version = "0.8" + +[features] +default = [] +net = [] +os-ext = ["os-poll"] +os-poll = [] +[target."cfg(unix)".dependencies.libc] +version = "0.2.86" +[target."cfg(windows)".dependencies.miow] +version = "0.3.6" + +[target."cfg(windows)".dependencies.ntapi] +version = "0.3" + +[target."cfg(windows)".dependencies.winapi] +version = "0.3" +features = ["winsock2", "mswsock"] diff --git a/third_party/rust/mio/LICENSE b/third_party/rust/mio/LICENSE new file mode 100644 index 0000000000..3516413824 --- /dev/null +++ b/third_party/rust/mio/LICENSE @@ -0,0 +1,19 @@ +Copyright (c) 2014 Carl Lerche and other MIO contributors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/third_party/rust/mio/README.md b/third_party/rust/mio/README.md new file mode 100644 index 0000000000..c18b300ab8 --- /dev/null +++ b/third_party/rust/mio/README.md @@ -0,0 +1,179 @@ +# Mio – Metal IO + +Mio is a fast, low-level I/O library for Rust focusing on non-blocking APIs and +event notification for building high performance I/O apps with as little +overhead as possible over the OS abstractions. + +[![Crates.io][crates-badge]][crates-url] +[![MIT licensed][mit-badge]][mit-url] +[![Build Status][azure-badge]][azure-url] +[![Build Status][cirrus-badge]][cirrus-url] + +[crates-badge]: https://img.shields.io/crates/v/mio.svg +[crates-url]: https://crates.io/crates/mio +[mit-badge]: https://img.shields.io/badge/license-MIT-blue.svg +[mit-url]: LICENSE +[azure-badge]: https://dev.azure.com/tokio-rs/Tokio/_apis/build/status/tokio-rs.mio?branchName=master +[azure-url]: https://dev.azure.com/tokio-rs/Tokio/_build/latest?definitionId=2&branchName=master +[cirrus-badge]: https://api.cirrus-ci.com/github/tokio-rs/mio.svg +[cirrus-url]: https://cirrus-ci.com/github/tokio-rs/mio + +**API documentation** + +* [master](https://tokio-rs.github.io/mio/doc/mio/) +* [v0.7](https://docs.rs/mio/^0.7) +* [v0.6](https://docs.rs/mio/^0.6) + +This is a low level library, if you are looking for something easier to get +started with, see [Tokio](https://tokio.rs). + +## Usage + +To use `mio`, first add this to your `Cargo.toml`: + +```toml +[dependencies] +mio = "0.7" +``` + +Next we can start using Mio. The following is quick introduction using +`TcpListener` and `TcpStream`. Note that `features = ["os-poll", "net"]` must be +specified for this example. + +```rust +use std::error::Error; + +use mio::net::{TcpListener, TcpStream}; +use mio::{Events, Interest, Poll, Token}; + +// Some tokens to allow us to identify which event is for which socket. +const SERVER: Token = Token(0); +const CLIENT: Token = Token(1); + +fn main() -> Result<(), Box<dyn Error>> { + // Create a poll instance. + let mut poll = Poll::new()?; + // Create storage for events. + let mut events = Events::with_capacity(128); + + // Setup the server socket. + let addr = "127.0.0.1:13265".parse()?; + let mut server = TcpListener::bind(addr)?; + // Start listening for incoming connections. + poll.registry() + .register(&mut server, SERVER, Interest::READABLE)?; + + // Setup the client socket. + let mut client = TcpStream::connect(addr)?; + // Register the socket. + poll.registry() + .register(&mut client, CLIENT, Interest::READABLE | Interest::WRITABLE)?; + + // Start an event loop. + loop { + // Poll Mio for events, blocking until we get an event. + poll.poll(&mut events, None)?; + + // Process each event. + for event in events.iter() { + // We can use the token we previously provided to `register` to + // determine for which socket the event is. + match event.token() { + SERVER => { + // If this is an event for the server, it means a connection + // is ready to be accepted. + // + // Accept the connection and drop it immediately. This will + // close the socket and notify the client of the EOF. + let connection = server.accept(); + drop(connection); + } + CLIENT => { + if event.is_writable() { + // We can (likely) write to the socket without blocking. + } + + if event.is_readable() { + // We can (likely) read from the socket without blocking. + } + + // Since the server just shuts down the connection, let's + // just exit from our event loop. + return Ok(()); + } + // We don't expect any events with tokens other than those we provided. + _ => unreachable!(), + } + } + } +} +``` + +## Features + +* Non-blocking TCP, UDP +* I/O event queue backed by epoll, kqueue, and IOCP +* Zero allocations at runtime +* Platform specific extensions + +## Non-goals + +The following are specifically omitted from Mio and are left to the user +or higher-level libraries. + +* File operations +* Thread pools / multi-threaded event loop +* Timers + +## Platforms + +Currently supported platforms: + +* Android (API level 21) +* DragonFly BSD +* FreeBSD +* Linux +* NetBSD +* OpenBSD +* Solaris +* Windows +* iOS +* macOS +* Wine (version 6.11+, see [issue #1444]) + +There are potentially others. If you find that Mio works on another +platform, submit a PR to update the list! + +Mio can handle interfacing with each of the event systems of the aforementioned +platforms. The details of their implementation are further discussed in the +`Poll` type of the API documentation (see above). + +The Windows implementation for polling sockets is using the [wepoll] strategy. +This uses the Windows AFD system to access socket readiness events. + +[wepoll]: https://github.com/piscisaureus/wepoll +[issue #1444]: https://github.com/tokio-rs/mio/issues/1444 + +### Unsupported + +* Haiku, see [issue #1472] + +[issue #1472]: https://github.com/tokio-rs/mio/issues/1472 + +## Community + +A group of Mio users hang out on [Discord], this can be a good place to go for +questions. + +[Discord]: https://discord.gg/tokio + +## Contributing + +Interested in getting involved? We would love to help you! For simple +bug fixes, just submit a PR with the fix and we can discuss the fix +directly in the PR. If the fix is more complex, start with an issue. + +If you want to propose an API change, create an issue to start a +discussion with the community. Also, feel free to talk with us in Discord. + +Finally, be kind. We support the [Rust Code of Conduct](https://www.rust-lang.org/policies/code-of-conduct). diff --git a/third_party/rust/mio/examples/tcp_server.rs b/third_party/rust/mio/examples/tcp_server.rs new file mode 100644 index 0000000000..6347ab6de0 --- /dev/null +++ b/third_party/rust/mio/examples/tcp_server.rs @@ -0,0 +1,183 @@ +// You can run this example from the root of the mio repo: +// cargo run --example tcp_server --features="os-poll net" +use mio::event::Event; +use mio::net::{TcpListener, TcpStream}; +use mio::{Events, Interest, Poll, Registry, Token}; +use std::collections::HashMap; +use std::io::{self, Read, Write}; +use std::str::from_utf8; + +// Setup some tokens to allow us to identify which event is for which socket. +const SERVER: Token = Token(0); + +// Some data we'll send over the connection. +const DATA: &[u8] = b"Hello world!\n"; + +fn main() -> io::Result<()> { + env_logger::init(); + + // Create a poll instance. + let mut poll = Poll::new()?; + // Create storage for events. + let mut events = Events::with_capacity(128); + + // Setup the TCP server socket. + let addr = "127.0.0.1:9000".parse().unwrap(); + let mut server = TcpListener::bind(addr)?; + + // Register the server with poll we can receive events for it. + poll.registry() + .register(&mut server, SERVER, Interest::READABLE)?; + + // Map of `Token` -> `TcpStream`. + let mut connections = HashMap::new(); + // Unique token for each incoming connection. + let mut unique_token = Token(SERVER.0 + 1); + + println!("You can connect to the server using `nc`:"); + println!(" $ nc 127.0.0.1 9000"); + println!("You'll see our welcome message and anything you type will be printed here."); + + loop { + poll.poll(&mut events, None)?; + + for event in events.iter() { + match event.token() { + SERVER => loop { + // Received an event for the TCP server socket, which + // indicates we can accept an connection. + let (mut connection, address) = match server.accept() { + Ok((connection, address)) => (connection, address), + Err(e) if e.kind() == io::ErrorKind::WouldBlock => { + // If we get a `WouldBlock` error we know our + // listener has no more incoming connections queued, + // so we can return to polling and wait for some + // more. + break; + } + Err(e) => { + // If it was any other kind of error, something went + // wrong and we terminate with an error. + return Err(e); + } + }; + + println!("Accepted connection from: {}", address); + + let token = next(&mut unique_token); + poll.registry().register( + &mut connection, + token, + Interest::READABLE.add(Interest::WRITABLE), + )?; + + connections.insert(token, connection); + }, + token => { + // Maybe received an event for a TCP connection. + let done = if let Some(connection) = connections.get_mut(&token) { + handle_connection_event(poll.registry(), connection, event)? + } else { + // Sporadic events happen, we can safely ignore them. + false + }; + if done { + if let Some(mut connection) = connections.remove(&token) { + poll.registry().deregister(&mut connection)?; + } + } + } + } + } + } +} + +fn next(current: &mut Token) -> Token { + let next = current.0; + current.0 += 1; + Token(next) +} + +/// Returns `true` if the connection is done. +fn handle_connection_event( + registry: &Registry, + connection: &mut TcpStream, + event: &Event, +) -> io::Result<bool> { + if event.is_writable() { + // We can (maybe) write to the connection. + match connection.write(DATA) { + // We want to write the entire `DATA` buffer in a single go. If we + // write less we'll return a short write error (same as + // `io::Write::write_all` does). + Ok(n) if n < DATA.len() => return Err(io::ErrorKind::WriteZero.into()), + Ok(_) => { + // After we've written something we'll reregister the connection + // to only respond to readable events. + registry.reregister(connection, event.token(), Interest::READABLE)? + } + // Would block "errors" are the OS's way of saying that the + // connection is not actually ready to perform this I/O operation. + Err(ref err) if would_block(err) => {} + // Got interrupted (how rude!), we'll try again. + Err(ref err) if interrupted(err) => { + return handle_connection_event(registry, connection, event) + } + // Other errors we'll consider fatal. + Err(err) => return Err(err), + } + } + + if event.is_readable() { + let mut connection_closed = false; + let mut received_data = vec![0; 4096]; + let mut bytes_read = 0; + // We can (maybe) read from the connection. + loop { + match connection.read(&mut received_data[bytes_read..]) { + Ok(0) => { + // Reading 0 bytes means the other side has closed the + // connection or is done writing, then so are we. + connection_closed = true; + break; + } + Ok(n) => { + bytes_read += n; + if bytes_read == received_data.len() { + received_data.resize(received_data.len() + 1024, 0); + } + } + // Would block "errors" are the OS's way of saying that the + // connection is not actually ready to perform this I/O operation. + Err(ref err) if would_block(err) => break, + Err(ref err) if interrupted(err) => continue, + // Other errors we'll consider fatal. + Err(err) => return Err(err), + } + } + + if bytes_read != 0 { + let received_data = &received_data[..bytes_read]; + if let Ok(str_buf) = from_utf8(received_data) { + println!("Received data: {}", str_buf.trim_end()); + } else { + println!("Received (none UTF-8) data: {:?}", received_data); + } + } + + if connection_closed { + println!("Connection closed"); + return Ok(true); + } + } + + Ok(false) +} + +fn would_block(err: &io::Error) -> bool { + err.kind() == io::ErrorKind::WouldBlock +} + +fn interrupted(err: &io::Error) -> bool { + err.kind() == io::ErrorKind::Interrupted +} diff --git a/third_party/rust/mio/examples/udp_server.rs b/third_party/rust/mio/examples/udp_server.rs new file mode 100644 index 0000000000..ed6881d99c --- /dev/null +++ b/third_party/rust/mio/examples/udp_server.rs @@ -0,0 +1,77 @@ +// You can run this example from the root of the mio repo: +// cargo run --example udp_server --features="os-poll net" +use log::warn; +use mio::net::UdpSocket; +use mio::{Events, Interest, Poll, Token}; +use std::io; + +// A token to allow us to identify which event is for the `UdpSocket`. +const UDP_SOCKET: Token = Token(0); + +fn main() -> io::Result<()> { + env_logger::init(); + + // Create a poll instance. + let mut poll = Poll::new()?; + // Create storage for events. Since we will only register a single socket, a + // capacity of 1 will do. + let mut events = Events::with_capacity(1); + + // Setup the UDP socket. + let addr = "127.0.0.1:9000".parse().unwrap(); + let mut socket = UdpSocket::bind(addr)?; + + // Register our socket with the token defined above and an interest in being + // `READABLE`. + poll.registry() + .register(&mut socket, UDP_SOCKET, Interest::READABLE)?; + + println!("You can connect to the server using `nc`:"); + println!(" $ nc -u 127.0.0.1 9000"); + println!("Anything you type will be echoed back to you."); + + // Initialize a buffer for the UDP packet. We use the maximum size of a UDP + // packet, which is the maximum value of 16 a bit integer. + let mut buf = [0; 1 << 16]; + + // Our event loop. + loop { + // Poll to check if we have events waiting for us. + poll.poll(&mut events, None)?; + + // Process each event. + for event in events.iter() { + // Validate the token we registered our socket with, + // in this example it will only ever be one but we + // make sure it's valid none the less. + match event.token() { + UDP_SOCKET => loop { + // In this loop we receive all packets queued for the socket. + match socket.recv_from(&mut buf) { + Ok((packet_size, source_address)) => { + // Echo the data. + socket.send_to(&buf[..packet_size], source_address)?; + } + Err(e) if e.kind() == io::ErrorKind::WouldBlock => { + // If we get a `WouldBlock` error we know our socket + // has no more packets queued, so we can return to + // polling and wait for some more. + break; + } + Err(e) => { + // If it was any other kind of error, something went + // wrong and we terminate with an error. + return Err(e); + } + } + }, + _ => { + // This should never happen as we only registered our + // `UdpSocket` using the `UDP_SOCKET` token, but if it ever + // does we'll log it. + warn!("Got event for unexpected token: {:?}", event); + } + } + } + } +} diff --git a/third_party/rust/mio/src/event/event.rs b/third_party/rust/mio/src/event/event.rs new file mode 100644 index 0000000000..1b4f7b7fbc --- /dev/null +++ b/third_party/rust/mio/src/event/event.rs @@ -0,0 +1,230 @@ +use crate::{sys, Token}; + +use std::fmt; + +/// A readiness event. +/// +/// `Event` is a readiness state paired with a [`Token`]. It is returned by +/// [`Poll::poll`]. +/// +/// For more documentation on polling and events, see [`Poll`]. +/// +/// [`Poll::poll`]: ../struct.Poll.html#method.poll +/// [`Poll`]: ../struct.Poll.html +/// [`Token`]: ../struct.Token.html +#[derive(Clone)] +#[repr(transparent)] +pub struct Event { + inner: sys::Event, +} + +impl Event { + /// Returns the event's token. + pub fn token(&self) -> Token { + sys::event::token(&self.inner) + } + + /// Returns true if the event contains readable readiness. + /// + /// # Notes + /// + /// Out-of-band (OOB) data also triggers readable events. But must + /// application don't actually read OOB data, this could leave an + /// application open to a Denial-of-Service (Dos) attack, see + /// <https://github.com/sandstorm-io/sandstorm-website/blob/58f93346028c0576e8147627667328eaaf4be9fa/_posts/2015-04-08-osx-security-bug.md>. + /// However because Mio uses edge-triggers it will not result in an infinite + /// loop as described in the article above. + pub fn is_readable(&self) -> bool { + sys::event::is_readable(&self.inner) + } + + /// Returns true if the event contains writable readiness. + pub fn is_writable(&self) -> bool { + sys::event::is_writable(&self.inner) + } + + /// Returns true if the event contains error readiness. + /// + /// Error events occur when the socket enters an error state. In this case, + /// the socket will also receive a readable or writable event. Reading or + /// writing to the socket will result in an error. + /// + /// # Notes + /// + /// Method is available on all platforms, but not all platforms trigger the + /// error event. + /// + /// The table below shows what flags are checked on what OS. + /// + /// | [OS selector] | Flag(s) checked | + /// |---------------|-----------------| + /// | [epoll] | `EPOLLERR` | + /// | [kqueue] | `EV_ERROR` and `EV_EOF` with `fflags` set to `0`. | + /// + /// [OS selector]: ../struct.Poll.html#implementation-notes + /// [epoll]: http://man7.org/linux/man-pages/man7/epoll.7.html + /// [kqueue]: https://www.freebsd.org/cgi/man.cgi?query=kqueue&sektion=2 + pub fn is_error(&self) -> bool { + sys::event::is_error(&self.inner) + } + + /// Returns true if the event contains read closed readiness. + /// + /// # Notes + /// + /// Read closed readiness can be expected after any of the following have + /// occurred: + /// * The local stream has shutdown the read half of its socket + /// * The local stream has shutdown both the read half and the write half + /// of its socket + /// * The peer stream has shutdown the write half its socket; this sends a + /// `FIN` packet that has been received by the local stream + /// + /// Method is a best effort implementation. While some platforms may not + /// return readiness when read half is closed, it is guaranteed that + /// false-positives will not occur. + /// + /// The table below shows what flags are checked on what OS. + /// + /// | [OS selector] | Flag(s) checked | + /// |---------------|-----------------| + /// | [epoll] | `EPOLLHUP`, or | + /// | | `EPOLLIN` and `EPOLLRDHUP` | + /// | [kqueue] | `EV_EOF` | + /// + /// [OS selector]: ../struct.Poll.html#implementation-notes + /// [epoll]: http://man7.org/linux/man-pages/man7/epoll.7.html + /// [kqueue]: https://www.freebsd.org/cgi/man.cgi?query=kqueue&sektion=2 + pub fn is_read_closed(&self) -> bool { + sys::event::is_read_closed(&self.inner) + } + + /// Returns true if the event contains write closed readiness. + /// + /// # Notes + /// + /// On [epoll] this is essentially a check for `EPOLLHUP` flag as the + /// local stream shutting down its write half does not trigger this event. + /// + /// On [kqueue] the local stream shutting down the write half of its + /// socket will trigger this event. + /// + /// Method is a best effort implementation. While some platforms may not + /// return readiness when write half is closed, it is guaranteed that + /// false-positives will not occur. + /// + /// The table below shows what flags are checked on what OS. + /// + /// | [OS selector] | Flag(s) checked | + /// |---------------|-----------------| + /// | [epoll] | `EPOLLHUP`, or | + /// | | only `EPOLLERR`, or | + /// | | `EPOLLOUT` and `EPOLLERR` | + /// | [kqueue] | `EV_EOF` | + /// + /// [OS selector]: ../struct.Poll.html#implementation-notes + /// [epoll]: http://man7.org/linux/man-pages/man7/epoll.7.html + /// [kqueue]: https://www.freebsd.org/cgi/man.cgi?query=kqueue&sektion=2 + pub fn is_write_closed(&self) -> bool { + sys::event::is_write_closed(&self.inner) + } + + /// Returns true if the event contains priority readiness. + /// + /// # Notes + /// + /// Method is available on all platforms, but not all platforms trigger the + /// priority event. + /// + /// The table below shows what flags are checked on what OS. + /// + /// | [OS selector] | Flag(s) checked | + /// |---------------|-----------------| + /// | [epoll] | `EPOLLPRI` | + /// | [kqueue] | *Not supported* | + /// + /// [OS selector]: ../struct.Poll.html#implementation-notes + /// [epoll]: http://man7.org/linux/man-pages/man7/epoll.7.html + /// [kqueue]: https://www.freebsd.org/cgi/man.cgi?query=kqueue&sektion=2 + #[inline] + pub fn is_priority(&self) -> bool { + sys::event::is_priority(&self.inner) + } + + /// Returns true if the event contains AIO readiness. + /// + /// # Notes + /// + /// Method is available on all platforms, but not all platforms support AIO. + /// + /// The table below shows what flags are checked on what OS. + /// + /// | [OS selector] | Flag(s) checked | + /// |---------------|-----------------| + /// | [epoll] | *Not supported* | + /// | [kqueue]<sup>1</sup> | `EVFILT_AIO` | + /// + /// 1: Only supported on DragonFly BSD, FreeBSD, iOS and macOS. + /// + /// [OS selector]: ../struct.Poll.html#implementation-notes + /// [epoll]: http://man7.org/linux/man-pages/man7/epoll.7.html + /// [kqueue]: https://www.freebsd.org/cgi/man.cgi?query=kqueue&sektion=2 + pub fn is_aio(&self) -> bool { + sys::event::is_aio(&self.inner) + } + + /// Returns true if the event contains LIO readiness. + /// + /// # Notes + /// + /// Method is available on all platforms, but only FreeBSD supports LIO. On + /// FreeBSD this method checks the `EVFILT_LIO` flag. + pub fn is_lio(&self) -> bool { + sys::event::is_lio(&self.inner) + } + + /// Create a reference to an `Event` from a platform specific event. + pub(crate) fn from_sys_event_ref(sys_event: &sys::Event) -> &Event { + unsafe { + // This is safe because the memory layout of `Event` is + // the same as `sys::Event` due to the `repr(transparent)` attribute. + &*(sys_event as *const sys::Event as *const Event) + } + } +} + +/// When the [alternate] flag is enabled this will print platform specific +/// details, for example the fields of the `kevent` structure on platforms that +/// use `kqueue(2)`. Note however that the output of this implementation is +/// **not** consider a part of the stable API. +/// +/// [alternate]: fmt::Formatter::alternate +impl fmt::Debug for Event { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let alternate = f.alternate(); + let mut d = f.debug_struct("Event"); + d.field("token", &self.token()) + .field("readable", &self.is_readable()) + .field("writable", &self.is_writable()) + .field("error", &self.is_error()) + .field("read_closed", &self.is_read_closed()) + .field("write_closed", &self.is_write_closed()) + .field("priority", &self.is_priority()) + .field("aio", &self.is_aio()) + .field("lio", &self.is_lio()); + + if alternate { + struct EventDetails<'a>(&'a sys::Event); + + impl<'a> fmt::Debug for EventDetails<'a> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + sys::event::debug_details(f, self.0) + } + } + + d.field("details", &EventDetails(&self.inner)).finish() + } else { + d.finish() + } + } +} diff --git a/third_party/rust/mio/src/event/events.rs b/third_party/rust/mio/src/event/events.rs new file mode 100644 index 0000000000..f3c5a2f02f --- /dev/null +++ b/third_party/rust/mio/src/event/events.rs @@ -0,0 +1,230 @@ +use crate::event::Event; +use crate::sys; + +use std::fmt; + +/// A collection of readiness events. +/// +/// `Events` is passed as an argument to [`Poll::poll`] and will be used to +/// receive any new readiness events received since the last poll. Usually, a +/// single `Events` instance is created at the same time as a [`Poll`] and +/// reused on each call to [`Poll::poll`]. +/// +/// See [`Poll`] for more documentation on polling. +/// +/// [`Poll::poll`]: ../struct.Poll.html#method.poll +/// [`Poll`]: ../struct.Poll.html +/// +/// # Examples +/// +#[cfg_attr(feature = "os-poll", doc = "```")] +#[cfg_attr(not(feature = "os-poll"), doc = "```ignore")] +/// # use std::error::Error; +/// # fn main() -> Result<(), Box<dyn Error>> { +/// use mio::{Events, Poll}; +/// use std::time::Duration; +/// +/// let mut events = Events::with_capacity(1024); +/// let mut poll = Poll::new()?; +/// # +/// # assert!(events.is_empty()); +/// +/// // Register `event::Source`s with `poll`. +/// +/// poll.poll(&mut events, Some(Duration::from_millis(100)))?; +/// +/// for event in events.iter() { +/// println!("Got an event for {:?}", event.token()); +/// } +/// # Ok(()) +/// # } +/// ``` +pub struct Events { + inner: sys::Events, +} + +/// [`Events`] iterator. +/// +/// This struct is created by the [`iter`] method on [`Events`]. +/// +/// [`Events`]: struct.Events.html +/// [`iter`]: struct.Events.html#method.iter +/// +/// # Examples +/// +#[cfg_attr(feature = "os-poll", doc = "```")] +#[cfg_attr(not(feature = "os-poll"), doc = "```ignore")] +/// # use std::error::Error; +/// # fn main() -> Result<(), Box<dyn Error>> { +/// use mio::{Events, Poll}; +/// use std::time::Duration; +/// +/// let mut events = Events::with_capacity(1024); +/// let mut poll = Poll::new()?; +/// +/// // Register handles with `poll`. +/// +/// poll.poll(&mut events, Some(Duration::from_millis(100)))?; +/// +/// for event in events.iter() { +/// println!("Got an event for {:?}", event.token()); +/// } +/// # Ok(()) +/// # } +/// ``` +#[derive(Debug, Clone)] +pub struct Iter<'a> { + inner: &'a Events, + pos: usize, +} + +impl Events { + /// Return a new `Events` capable of holding up to `capacity` events. + /// + /// # Examples + /// + /// ``` + /// use mio::Events; + /// + /// let events = Events::with_capacity(1024); + /// assert_eq!(1024, events.capacity()); + /// ``` + pub fn with_capacity(capacity: usize) -> Events { + Events { + inner: sys::Events::with_capacity(capacity), + } + } + + /// Returns the number of `Event` values that `self` can hold. + /// + /// ``` + /// use mio::Events; + /// + /// let events = Events::with_capacity(1024); + /// assert_eq!(1024, events.capacity()); + /// ``` + pub fn capacity(&self) -> usize { + self.inner.capacity() + } + + /// Returns `true` if `self` contains no `Event` values. + /// + /// # Examples + /// + /// ``` + /// use mio::Events; + /// + /// let events = Events::with_capacity(1024); + /// assert!(events.is_empty()); + /// ``` + pub fn is_empty(&self) -> bool { + self.inner.is_empty() + } + + /// Returns an iterator over the `Event` values. + /// + /// # Examples + /// + #[cfg_attr(feature = "os-poll", doc = "```")] + #[cfg_attr(not(feature = "os-poll"), doc = "```ignore")] + /// # use std::error::Error; + /// # fn main() -> Result<(), Box<dyn Error>> { + /// use mio::{Events, Poll}; + /// use std::time::Duration; + /// + /// let mut events = Events::with_capacity(1024); + /// let mut poll = Poll::new()?; + /// + /// // Register handles with `poll`. + /// + /// poll.poll(&mut events, Some(Duration::from_millis(100)))?; + /// + /// for event in events.iter() { + /// println!("Got an event for {:?}", event.token()); + /// } + /// # Ok(()) + /// # } + /// ``` + pub fn iter(&self) -> Iter<'_> { + Iter { + inner: self, + pos: 0, + } + } + + /// Clearing all `Event` values from container explicitly. + /// + /// # Notes + /// + /// Events are cleared before every `poll`, so it is not required to call + /// this manually. + /// + /// # Examples + /// + #[cfg_attr(feature = "os-poll", doc = "```")] + #[cfg_attr(not(feature = "os-poll"), doc = "```ignore")] + /// # use std::error::Error; + /// # fn main() -> Result<(), Box<dyn Error>> { + /// use mio::{Events, Poll}; + /// use std::time::Duration; + /// + /// let mut events = Events::with_capacity(1024); + /// let mut poll = Poll::new()?; + /// + /// // Register handles with `poll`. + /// + /// poll.poll(&mut events, Some(Duration::from_millis(100)))?; + /// + /// // Clear all events. + /// events.clear(); + /// assert!(events.is_empty()); + /// # Ok(()) + /// # } + /// ``` + pub fn clear(&mut self) { + self.inner.clear(); + } + + /// Returns the inner `sys::Events`. + pub(crate) fn sys(&mut self) -> &mut sys::Events { + &mut self.inner + } +} + +impl<'a> IntoIterator for &'a Events { + type Item = &'a Event; + type IntoIter = Iter<'a>; + + fn into_iter(self) -> Self::IntoIter { + self.iter() + } +} + +impl<'a> Iterator for Iter<'a> { + type Item = &'a Event; + + fn next(&mut self) -> Option<Self::Item> { + let ret = self + .inner + .inner + .get(self.pos) + .map(Event::from_sys_event_ref); + self.pos += 1; + ret + } + + fn size_hint(&self) -> (usize, Option<usize>) { + let size = self.inner.inner.len(); + (size, Some(size)) + } + + fn count(self) -> usize { + self.inner.inner.len() + } +} + +impl fmt::Debug for Events { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_list().entries(self).finish() + } +} diff --git a/third_party/rust/mio/src/event/mod.rs b/third_party/rust/mio/src/event/mod.rs new file mode 100644 index 0000000000..8e17f82ee5 --- /dev/null +++ b/third_party/rust/mio/src/event/mod.rs @@ -0,0 +1,10 @@ +//! Readiness event types and utilities. + +#[allow(clippy::module_inception)] +mod event; +mod events; +mod source; + +pub use self::event::Event; +pub use self::events::{Events, Iter}; +pub use self::source::Source; diff --git a/third_party/rust/mio/src/event/source.rs b/third_party/rust/mio/src/event/source.rs new file mode 100644 index 0000000000..4f9c6635a1 --- /dev/null +++ b/third_party/rust/mio/src/event/source.rs @@ -0,0 +1,139 @@ +use crate::{Interest, Registry, Token}; + +use std::io; + +/// An event source that may be registered with [`Registry`]. +/// +/// Types that implement `event::Source` can be registered with +/// `Registry`. Users of Mio **should not** use the `event::Source` trait +/// functions directly. Instead, the equivalent functions on `Registry` should +/// be used. +/// +/// See [`Registry`] for more details. +/// +/// [`Registry`]: ../struct.Registry.html +/// +/// # Implementing `event::Source` +/// +/// Event sources are always backed by system handles, such as sockets or other +/// system handles. These `event::Source`s will be monitored by the system +/// selector. An implementation of `Source` will almost always delegates to a +/// lower level handle. Examples of this are [`TcpStream`]s, or the *unix only* +/// [`SourceFd`]. +/// +/// [`TcpStream`]: ../net/struct.TcpStream.html +/// [`SourceFd`]: ../unix/struct.SourceFd.html +/// +/// # Dropping `event::Source`s +/// +/// All `event::Source`s, unless otherwise specified, need to be [deregistered] +/// before being dropped for them to not leak resources. This goes against the +/// normal drop behaviour of types in Rust which cleanup after themselves, e.g. +/// a `File` will close itself. However since deregistering needs access to +/// [`Registry`] this cannot be done while being dropped. +/// +/// [deregistered]: ../struct.Registry.html#method.deregister +/// +/// # Examples +/// +/// Implementing `Source` on a struct containing a socket: +/// +#[cfg_attr(all(feature = "os-poll", feature = "net"), doc = "```")] +#[cfg_attr(not(all(feature = "os-poll", feature = "net")), doc = "```ignore")] +/// use mio::{Interest, Registry, Token}; +/// use mio::event::Source; +/// use mio::net::TcpStream; +/// +/// use std::io; +/// +/// # #[allow(dead_code)] +/// pub struct MySource { +/// socket: TcpStream, +/// } +/// +/// impl Source for MySource { +/// fn register(&mut self, registry: &Registry, token: Token, interests: Interest) +/// -> io::Result<()> +/// { +/// // Delegate the `register` call to `socket` +/// self.socket.register(registry, token, interests) +/// } +/// +/// fn reregister(&mut self, registry: &Registry, token: Token, interests: Interest) +/// -> io::Result<()> +/// { +/// // Delegate the `reregister` call to `socket` +/// self.socket.reregister(registry, token, interests) +/// } +/// +/// fn deregister(&mut self, registry: &Registry) -> io::Result<()> { +/// // Delegate the `deregister` call to `socket` +/// self.socket.deregister(registry) +/// } +/// } +/// ``` +pub trait Source { + /// Register `self` with the given `Registry` instance. + /// + /// This function should not be called directly. Use [`Registry::register`] + /// instead. Implementors should handle registration by delegating the call + /// to another `Source` type. + /// + /// [`Registry::register`]: ../struct.Registry.html#method.register + fn register( + &mut self, + registry: &Registry, + token: Token, + interests: Interest, + ) -> io::Result<()>; + + /// Re-register `self` with the given `Registry` instance. + /// + /// This function should not be called directly. Use + /// [`Registry::reregister`] instead. Implementors should handle + /// re-registration by either delegating the call to another `Source` type. + /// + /// [`Registry::reregister`]: ../struct.Registry.html#method.reregister + fn reregister( + &mut self, + registry: &Registry, + token: Token, + interests: Interest, + ) -> io::Result<()>; + + /// Deregister `self` from the given `Registry` instance. + /// + /// This function should not be called directly. Use + /// [`Registry::deregister`] instead. Implementors should handle + /// deregistration by delegating the call to another `Source` type. + /// + /// [`Registry::deregister`]: ../struct.Registry.html#method.deregister + fn deregister(&mut self, registry: &Registry) -> io::Result<()>; +} + +impl<T> Source for Box<T> +where + T: Source + ?Sized, +{ + fn register( + &mut self, + registry: &Registry, + token: Token, + interests: Interest, + ) -> io::Result<()> { + (&mut **self).register(registry, token, interests) + } + + fn reregister( + &mut self, + registry: &Registry, + token: Token, + interests: Interest, + ) -> io::Result<()> { + (&mut **self).reregister(registry, token, interests) + } + + fn deregister(&mut self, registry: &Registry) -> io::Result<()> { + (&mut **self).deregister(registry) + } +} diff --git a/third_party/rust/mio/src/interest.rs b/third_party/rust/mio/src/interest.rs new file mode 100644 index 0000000000..0aa0bda895 --- /dev/null +++ b/third_party/rust/mio/src/interest.rs @@ -0,0 +1,179 @@ +use std::num::NonZeroU8; +use std::{fmt, ops}; + +/// Interest used in registering. +/// +/// Interest are used in [registering] [`event::Source`]s with [`Poll`], they +/// indicate what readiness should be monitored for. For example if a socket is +/// registered with [readable] interests and the socket becomes writable, no +/// event will be returned from a call to [`poll`]. +/// +/// [registering]: struct.Registry.html#method.register +/// [`event::Source`]: ./event/trait.Source.html +/// [`Poll`]: struct.Poll.html +/// [readable]: struct.Interest.html#associatedconstant.READABLE +/// [`poll`]: struct.Poll.html#method.poll +#[derive(Copy, PartialEq, Eq, Clone, PartialOrd, Ord)] +pub struct Interest(NonZeroU8); + +// These must be unique. +const READABLE: u8 = 0b0001; +const WRITABLE: u8 = 0b0010; +// The following are not available on all platforms. +#[cfg_attr( + not(any( + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos" + )), + allow(dead_code) +)] +const AIO: u8 = 0b0100; +#[cfg_attr(not(target_os = "freebsd"), allow(dead_code))] +const LIO: u8 = 0b1000; + +impl Interest { + /// Returns a `Interest` set representing readable interests. + pub const READABLE: Interest = Interest(unsafe { NonZeroU8::new_unchecked(READABLE) }); + + /// Returns a `Interest` set representing writable interests. + pub const WRITABLE: Interest = Interest(unsafe { NonZeroU8::new_unchecked(WRITABLE) }); + + /// Returns a `Interest` set representing AIO completion interests. + #[cfg(any( + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos" + ))] + pub const AIO: Interest = Interest(unsafe { NonZeroU8::new_unchecked(AIO) }); + + /// Returns a `Interest` set representing LIO completion interests. + #[cfg(target_os = "freebsd")] + pub const LIO: Interest = Interest(unsafe { NonZeroU8::new_unchecked(LIO) }); + + /// Add together two `Interest`. + /// + /// This does the same thing as the `BitOr` implementation, but is a + /// constant function. + /// + /// ``` + /// use mio::Interest; + /// + /// const INTERESTS: Interest = Interest::READABLE.add(Interest::WRITABLE); + /// # fn silent_dead_code_warning(_: Interest) { } + /// # silent_dead_code_warning(INTERESTS) + /// ``` + #[allow(clippy::should_implement_trait)] + pub const fn add(self, other: Interest) -> Interest { + Interest(unsafe { NonZeroU8::new_unchecked(self.0.get() | other.0.get()) }) + } + + /// Removes `other` `Interest` from `self`. + /// + /// Returns `None` if the set would be empty after removing `other`. + /// + /// ``` + /// use mio::Interest; + /// + /// const RW_INTERESTS: Interest = Interest::READABLE.add(Interest::WRITABLE); + /// + /// // As long a one interest remain this will return `Some`. + /// let w_interest = RW_INTERESTS.remove(Interest::READABLE).unwrap(); + /// assert!(!w_interest.is_readable()); + /// assert!(w_interest.is_writable()); + /// + /// // Removing all interests from the set will return `None`. + /// assert_eq!(w_interest.remove(Interest::WRITABLE), None); + /// + /// // Its also possible to remove multiple interests at once. + /// assert_eq!(RW_INTERESTS.remove(RW_INTERESTS), None); + /// ``` + pub fn remove(self, other: Interest) -> Option<Interest> { + NonZeroU8::new(self.0.get() & !other.0.get()).map(Interest) + } + + /// Returns true if the value includes readable readiness. + pub const fn is_readable(self) -> bool { + (self.0.get() & READABLE) != 0 + } + + /// Returns true if the value includes writable readiness. + pub const fn is_writable(self) -> bool { + (self.0.get() & WRITABLE) != 0 + } + + /// Returns true if `Interest` contains AIO readiness + pub const fn is_aio(self) -> bool { + (self.0.get() & AIO) != 0 + } + + /// Returns true if `Interest` contains LIO readiness + pub const fn is_lio(self) -> bool { + (self.0.get() & LIO) != 0 + } +} + +impl ops::BitOr for Interest { + type Output = Self; + + #[inline] + fn bitor(self, other: Self) -> Self { + self.add(other) + } +} + +impl ops::BitOrAssign for Interest { + #[inline] + fn bitor_assign(&mut self, other: Self) { + self.0 = (*self | other).0; + } +} + +impl fmt::Debug for Interest { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { + let mut one = false; + if self.is_readable() { + if one { + write!(fmt, " | ")? + } + write!(fmt, "READABLE")?; + one = true + } + if self.is_writable() { + if one { + write!(fmt, " | ")? + } + write!(fmt, "WRITABLE")?; + one = true + } + #[cfg(any( + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos" + ))] + { + if self.is_aio() { + if one { + write!(fmt, " | ")? + } + write!(fmt, "AIO")?; + one = true + } + } + #[cfg(any(target_os = "freebsd"))] + { + if self.is_lio() { + if one { + write!(fmt, " | ")? + } + write!(fmt, "LIO")?; + one = true + } + } + debug_assert!(one, "printing empty interests"); + Ok(()) + } +} diff --git a/third_party/rust/mio/src/io_source.rs b/third_party/rust/mio/src/io_source.rs new file mode 100644 index 0000000000..ae1cbf3767 --- /dev/null +++ b/third_party/rust/mio/src/io_source.rs @@ -0,0 +1,294 @@ +use std::ops::{Deref, DerefMut}; +#[cfg(unix)] +use std::os::unix::io::AsRawFd; +#[cfg(windows)] +use std::os::windows::io::AsRawSocket; +#[cfg(debug_assertions)] +use std::sync::atomic::{AtomicUsize, Ordering}; +use std::{fmt, io}; + +use crate::sys::IoSourceState; +use crate::{event, Interest, Registry, Token}; + +/// Adapter for a [`RawFd`] or [`RawSocket`] providing an [`event::Source`] +/// implementation. +/// +/// `IoSource` enables registering any FD or socket wrapper with [`Poll`]. +/// +/// While only implementations for TCP, UDP, and UDS (Unix only) are provided, +/// Mio supports registering any FD or socket that can be registered with the +/// underlying OS selector. `IoSource` provides the necessary bridge. +/// +/// [`RawFd`]: std::os::unix::io::RawFd +/// [`RawSocket`]: std::os::windows::io::RawSocket +/// +/// # Notes +/// +/// To handle the registrations and events properly **all** I/O operations (such +/// as `read`, `write`, etc.) must go through the [`do_io`] method to ensure the +/// internal state is updated accordingly. +/// +/// [`Poll`]: crate::Poll +/// [`do_io`]: IoSource::do_io +/* +/// +/// # Examples +/// +/// Basic usage. +/// +/// ``` +/// # use std::error::Error; +/// # fn main() -> Result<(), Box<dyn Error>> { +/// use mio::{Interest, Poll, Token}; +/// use mio::IoSource; +/// +/// use std::net; +/// +/// let poll = Poll::new()?; +/// +/// // Bind a std TCP listener. +/// let listener = net::TcpListener::bind("127.0.0.1:0")?; +/// // Wrap it in the `IoSource` type. +/// let mut listener = IoSource::new(listener); +/// +/// // Register the listener. +/// poll.registry().register(&mut listener, Token(0), Interest::READABLE)?; +/// # Ok(()) +/// # } +/// ``` +*/ +pub struct IoSource<T> { + state: IoSourceState, + inner: T, + #[cfg(debug_assertions)] + selector_id: SelectorId, +} + +impl<T> IoSource<T> { + /// Create a new `IoSource`. + pub fn new(io: T) -> IoSource<T> { + IoSource { + state: IoSourceState::new(), + inner: io, + #[cfg(debug_assertions)] + selector_id: SelectorId::new(), + } + } + + /// Execute an I/O operations ensuring that the socket receives more events + /// if it hits a [`WouldBlock`] error. + /// + /// # Notes + /// + /// This method is required to be called for **all** I/O operations to + /// ensure the user will receive events once the socket is ready again after + /// returning a [`WouldBlock`] error. + /// + /// [`WouldBlock`]: io::ErrorKind::WouldBlock + pub fn do_io<F, R>(&self, f: F) -> io::Result<R> + where + F: FnOnce(&T) -> io::Result<R>, + { + self.state.do_io(f, &self.inner) + } + + /// Returns the I/O source, dropping the state. + /// + /// # Notes + /// + /// To ensure no more events are to be received for this I/O source first + /// [`deregister`] it. + /// + /// [`deregister`]: Registry::deregister + pub fn into_inner(self) -> T { + self.inner + } +} + +/// Be careful when using this method. All I/O operations that may block must go +/// through the [`do_io`] method. +/// +/// [`do_io`]: IoSource::do_io +impl<T> Deref for IoSource<T> { + type Target = T; + + fn deref(&self) -> &Self::Target { + &self.inner + } +} + +/// Be careful when using this method. All I/O operations that may block must go +/// through the [`do_io`] method. +/// +/// [`do_io`]: IoSource::do_io +impl<T> DerefMut for IoSource<T> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} + +#[cfg(unix)] +impl<T> event::Source for IoSource<T> +where + T: AsRawFd, +{ + fn register( + &mut self, + registry: &Registry, + token: Token, + interests: Interest, + ) -> io::Result<()> { + #[cfg(debug_assertions)] + self.selector_id.associate(registry)?; + registry + .selector() + .register(self.inner.as_raw_fd(), token, interests) + } + + fn reregister( + &mut self, + registry: &Registry, + token: Token, + interests: Interest, + ) -> io::Result<()> { + #[cfg(debug_assertions)] + self.selector_id.check_association(registry)?; + registry + .selector() + .reregister(self.inner.as_raw_fd(), token, interests) + } + + fn deregister(&mut self, registry: &Registry) -> io::Result<()> { + #[cfg(debug_assertions)] + self.selector_id.remove_association(registry)?; + registry.selector().deregister(self.inner.as_raw_fd()) + } +} + +#[cfg(windows)] +impl<T> event::Source for IoSource<T> +where + T: AsRawSocket, +{ + fn register( + &mut self, + registry: &Registry, + token: Token, + interests: Interest, + ) -> io::Result<()> { + #[cfg(debug_assertions)] + self.selector_id.associate(registry)?; + self.state + .register(registry, token, interests, self.inner.as_raw_socket()) + } + + fn reregister( + &mut self, + registry: &Registry, + token: Token, + interests: Interest, + ) -> io::Result<()> { + #[cfg(debug_assertions)] + self.selector_id.check_association(registry)?; + self.state.reregister(registry, token, interests) + } + + fn deregister(&mut self, _registry: &Registry) -> io::Result<()> { + #[cfg(debug_assertions)] + self.selector_id.remove_association(_registry)?; + self.state.deregister() + } +} + +impl<T> fmt::Debug for IoSource<T> +where + T: fmt::Debug, +{ + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.inner.fmt(f) + } +} + +/// Used to associate an `IoSource` with a `sys::Selector`. +#[cfg(debug_assertions)] +#[derive(Debug)] +struct SelectorId { + id: AtomicUsize, +} + +#[cfg(debug_assertions)] +impl SelectorId { + /// Value of `id` if `SelectorId` is not associated with any + /// `sys::Selector`. Valid selector ids start at 1. + const UNASSOCIATED: usize = 0; + + /// Create a new `SelectorId`. + const fn new() -> SelectorId { + SelectorId { + id: AtomicUsize::new(Self::UNASSOCIATED), + } + } + + /// Associate an I/O source with `registry`, returning an error if its + /// already registered. + fn associate(&self, registry: &Registry) -> io::Result<()> { + let registry_id = registry.selector().id(); + let previous_id = self.id.swap(registry_id, Ordering::AcqRel); + + if previous_id == Self::UNASSOCIATED { + Ok(()) + } else { + Err(io::Error::new( + io::ErrorKind::AlreadyExists, + "I/O source already registered with a `Registry`", + )) + } + } + + /// Check the association of an I/O source with `registry`, returning an + /// error if its registered with a different `Registry` or not registered at + /// all. + fn check_association(&self, registry: &Registry) -> io::Result<()> { + let registry_id = registry.selector().id(); + let id = self.id.load(Ordering::Acquire); + + if id == registry_id { + Ok(()) + } else if id == Self::UNASSOCIATED { + Err(io::Error::new( + io::ErrorKind::NotFound, + "I/O source not registered with `Registry`", + )) + } else { + Err(io::Error::new( + io::ErrorKind::AlreadyExists, + "I/O source already registered with a different `Registry`", + )) + } + } + + /// Remove a previously made association from `registry`, returns an error + /// if it was not previously associated with `registry`. + fn remove_association(&self, registry: &Registry) -> io::Result<()> { + let registry_id = registry.selector().id(); + let previous_id = self.id.swap(Self::UNASSOCIATED, Ordering::AcqRel); + + if previous_id == registry_id { + Ok(()) + } else { + Err(io::Error::new( + io::ErrorKind::NotFound, + "I/O source not registered with `Registry`", + )) + } + } +} + +#[cfg(debug_assertions)] +impl Clone for SelectorId { + fn clone(&self) -> SelectorId { + SelectorId { + id: AtomicUsize::new(self.id.load(Ordering::Acquire)), + } + } +} diff --git a/third_party/rust/mio/src/lib.rs b/third_party/rust/mio/src/lib.rs new file mode 100644 index 0000000000..7a0797c77f --- /dev/null +++ b/third_party/rust/mio/src/lib.rs @@ -0,0 +1,264 @@ +#![deny( + missing_docs, + missing_debug_implementations, + rust_2018_idioms, + unused_imports, + dead_code +)] +#![cfg_attr(docsrs, feature(doc_cfg))] +// Disallow warnings when running tests. +#![cfg_attr(test, deny(warnings))] +// Disallow warnings in examples. +#![doc(test(attr(deny(warnings))))] + +//! Mio is a fast, low-level I/O library for Rust focusing on non-blocking APIs +//! and event notification for building high performance I/O apps with as little +//! overhead as possible over the OS abstractions. +//! +//! # Usage +//! +//! Using Mio starts by creating a [`Poll`], which reads events from the OS and +//! puts them into [`Events`]. You can handle I/O events from the OS with it. +//! +//! For more detail, see [`Poll`]. +//! +//! [`Poll`]: ../mio/struct.Poll.html +//! [`Events`]: ../mio/event/struct.Events.html +//! +//! ## Examples +//! +//! Examples can found in the `examples` directory of the source code, or [on +//! GitHub]. +//! +//! [on GitHub]: https://github.com/tokio-rs/mio/tree/master/examples +//! +//! ## Guide +//! +//! A getting started guide is available in the [`guide`] module. +//! +//! ## Available features +//! +//! The available features are described in the [`features`] module. + +// macros used internally +#[macro_use] +mod macros; + +mod interest; +mod poll; +mod sys; +mod token; +mod waker; + +pub mod event; + +cfg_io_source! { + mod io_source; +} + +cfg_net! { + pub mod net; +} + +#[doc(no_inline)] +pub use event::Events; +pub use interest::Interest; +pub use poll::{Poll, Registry}; +pub use token::Token; +pub use waker::Waker; + +#[cfg(all(unix, feature = "os-ext"))] +#[cfg_attr(docsrs, doc(cfg(all(unix, feature = "os-ext"))))] +pub mod unix { + //! Unix only extensions. + + pub mod pipe { + //! Unix pipe. + //! + //! See the [`new`] function for documentation. + + pub use crate::sys::pipe::{new, Receiver, Sender}; + } + + pub use crate::sys::SourceFd; +} + +#[cfg(all(windows, feature = "os-ext"))] +#[cfg_attr(docsrs, doc(cfg(all(windows, feature = "os-ext"))))] +pub mod windows { + //! Windows only extensions. + + pub use crate::sys::named_pipe::NamedPipe; +} + +pub mod features { + //! # Mio's optional features. + //! + //! This document describes the available features in Mio. + //! + #![cfg_attr(feature = "os-poll", doc = "## `os-poll` (enabled)")] + #![cfg_attr(not(feature = "os-poll"), doc = "## `os-poll` (disabled)")] + //! + //! Mio by default provides only a shell implementation, that `panic!`s the + //! moment it is actually run. To run it requires OS support, this is + //! enabled by activating the `os-poll` feature. + //! + //! This makes `Poll`, `Registry` and `Waker` functional. + //! + #![cfg_attr(feature = "os-ext", doc = "## `os-ext` (enabled)")] + #![cfg_attr(not(feature = "os-ext"), doc = "## `os-ext` (disabled)")] + //! + //! `os-ext` enables additional OS specific facilities. These facilities can + //! be found in the `unix` and `windows` module. + //! + #![cfg_attr(feature = "net", doc = "## Network types (enabled)")] + #![cfg_attr(not(feature = "net"), doc = "## Network types (disabled)")] + //! + //! The `net` feature enables networking primitives in the `net` module. +} + +pub mod guide { + //! # Getting started guide. + //! + //! In this guide we'll do the following: + //! + //! 1. Create a [`Poll`] instance (and learn what it is). + //! 2. Register an [event source]. + //! 3. Create an event loop. + //! + //! At the end you'll have a very small (but quick) TCP server that accepts + //! connections and then drops (disconnects) them. + //! + //! ## 1. Creating a `Poll` instance + //! + //! Using Mio starts by creating a [`Poll`] instance, which monitors events + //! from the OS and puts them into [`Events`]. This allows us to execute I/O + //! operations based on what operations are ready. + //! + //! [`Poll`]: ../struct.Poll.html + //! [`Events`]: ../event/struct.Events.html + //! + #![cfg_attr(feature = "os-poll", doc = "```")] + #![cfg_attr(not(feature = "os-poll"), doc = "```ignore")] + //! # use mio::{Poll, Events}; + //! # fn main() -> std::io::Result<()> { + //! // `Poll` allows for polling of readiness events. + //! let poll = Poll::new()?; + //! // `Events` is collection of readiness `Event`s and can be filled by + //! // calling `Poll::poll`. + //! let events = Events::with_capacity(128); + //! # drop((poll, events)); + //! # Ok(()) + //! # } + //! ``` + //! + //! For example if we're using a [`TcpListener`], we'll only want to + //! attempt to accept an incoming connection *iff* any connections are + //! queued and ready to be accepted. We don't want to waste our time if no + //! connections are ready. + //! + //! [`TcpListener`]: ../net/struct.TcpListener.html + //! + //! ## 2. Registering event source + //! + //! After we've created a [`Poll`] instance that monitors events from the OS + //! for us, we need to provide it with a source of events. This is done by + //! registering an [event source]. As the name “event source” suggests it is + //! a source of events which can be polled using a `Poll` instance. On Unix + //! systems this is usually a file descriptor, or a socket/handle on + //! Windows. + //! + //! In the example below we'll use a [`TcpListener`] for which we'll receive + //! an event (from [`Poll`]) once a connection is ready to be accepted. + //! + //! [event source]: ../event/trait.Source.html + //! + #![cfg_attr(all(feature = "os-poll", feature = "net"), doc = "```")] + #![cfg_attr(not(all(feature = "os-poll", feature = "net")), doc = "```ignore")] + //! # use mio::net::TcpListener; + //! # use mio::{Poll, Token, Interest}; + //! # fn main() -> std::io::Result<()> { + //! # let poll = Poll::new()?; + //! # let address = "127.0.0.1:0".parse().unwrap(); + //! // Create a `TcpListener`, binding it to `address`. + //! let mut listener = TcpListener::bind(address)?; + //! + //! // Next we register it with `Poll` to receive events for it. The `SERVER` + //! // `Token` is used to determine that we received an event for the listener + //! // later on. + //! const SERVER: Token = Token(0); + //! poll.registry().register(&mut listener, SERVER, Interest::READABLE)?; + //! # Ok(()) + //! # } + //! ``` + //! + //! Multiple event sources can be [registered] (concurrently), so we can + //! monitor multiple sources at a time. + //! + //! [registered]: ../struct.Registry.html#method.register + //! + //! ## 3. Creating the event loop + //! + //! After we've created a [`Poll`] instance and registered one or more + //! [event sources] with it, we can [poll] it for events. Polling for events + //! is simple, we need a container to store the events: [`Events`] and need + //! to do something based on the polled events (this part is up to you, we + //! can't do it all!). If we do this in a loop we've got ourselves an event + //! loop. + //! + //! The example below shows the event loop in action, completing our small + //! TCP server. + //! + //! [poll]: ../struct.Poll.html#method.poll + //! [event sources]: ../event/trait.Source.html + //! + #![cfg_attr(all(feature = "os-poll", feature = "net"), doc = "```")] + #![cfg_attr(not(all(feature = "os-poll", feature = "net")), doc = "```ignore")] + //! # use std::io; + //! # use std::time::Duration; + //! # use mio::net::TcpListener; + //! # use mio::{Poll, Token, Interest, Events}; + //! # fn main() -> io::Result<()> { + //! # let mut poll = Poll::new()?; + //! # let mut events = Events::with_capacity(128); + //! # let address = "127.0.0.1:0".parse().unwrap(); + //! # let mut listener = TcpListener::bind(address)?; + //! # const SERVER: Token = Token(0); + //! # poll.registry().register(&mut listener, SERVER, Interest::READABLE)?; + //! // Start our event loop. + //! loop { + //! // Poll the OS for events, waiting at most 100 milliseconds. + //! poll.poll(&mut events, Some(Duration::from_millis(100)))?; + //! + //! // Process each event. + //! for event in events.iter() { + //! // We can use the token we previously provided to `register` to + //! // determine for which type the event is. + //! match event.token() { + //! SERVER => loop { + //! // One or more connections are ready, so we'll attempt to + //! // accept them (in a loop). + //! match listener.accept() { + //! Ok((connection, address)) => { + //! println!("Got a connection from: {}", address); + //! # drop(connection); + //! }, + //! // A "would block error" is returned if the operation + //! // is not ready, so we'll stop trying to accept + //! // connections. + //! Err(ref err) if would_block(err) => break, + //! Err(err) => return Err(err), + //! } + //! } + //! # _ => unreachable!(), + //! } + //! } + //! # return Ok(()); + //! } + //! + //! fn would_block(err: &io::Error) -> bool { + //! err.kind() == io::ErrorKind::WouldBlock + //! } + //! # } + //! ``` +} diff --git a/third_party/rust/mio/src/macros.rs b/third_party/rust/mio/src/macros.rs new file mode 100644 index 0000000000..f97f90911f --- /dev/null +++ b/third_party/rust/mio/src/macros.rs @@ -0,0 +1,70 @@ +//! Macros to ease conditional code based on enabled features. + +// Depending on the features not all macros are used. +#![allow(unused_macros)] + +/// The `os-poll` feature is enabled. +macro_rules! cfg_os_poll { + ($($item:item)*) => { + $( + #[cfg(feature = "os-poll")] + #[cfg_attr(docsrs, doc(cfg(feature = "os-poll")))] + $item + )* + } +} + +/// The `os-poll` feature is disabled. +macro_rules! cfg_not_os_poll { + ($($item:item)*) => { + $( + #[cfg(not(feature = "os-poll"))] + $item + )* + } +} + +/// The `os-ext` feature is enabled. +macro_rules! cfg_os_ext { + ($($item:item)*) => { + $( + #[cfg(feature = "os-ext")] + #[cfg_attr(docsrs, doc(cfg(feature = "os-ext")))] + $item + )* + } +} + +/// The `net` feature is enabled. +macro_rules! cfg_net { + ($($item:item)*) => { + $( + #[cfg(feature = "net")] + #[cfg_attr(docsrs, doc(cfg(feature = "net")))] + $item + )* + } +} + +/// One of the features enabled that needs `IoSource`. That is `net` or `os-ext` +/// on Unix (for `pipe`). +macro_rules! cfg_io_source { + ($($item:item)*) => { + $( + #[cfg(any(feature = "net", all(unix, feature = "os-ext")))] + #[cfg_attr(docsrs, doc(cfg(any(feature = "net", all(unix, feature = "os-ext")))))] + $item + )* + } +} + +/// The `os-ext` feature is enabled, or one of the features that need `os-ext`. +macro_rules! cfg_any_os_ext { + ($($item:item)*) => { + $( + #[cfg(any(feature = "os-ext", feature = "net"))] + #[cfg_attr(docsrs, doc(cfg(any(feature = "os-ext", feature = "net"))))] + $item + )* + } +} diff --git a/third_party/rust/mio/src/net/mod.rs b/third_party/rust/mio/src/net/mod.rs new file mode 100644 index 0000000000..c8cef17e98 --- /dev/null +++ b/third_party/rust/mio/src/net/mod.rs @@ -0,0 +1,37 @@ +//! Networking primitives. +//! +//! The types provided in this module are non-blocking by default and are +//! designed to be portable across all supported Mio platforms. As long as the +//! [portability guidelines] are followed, the behavior should be identical no +//! matter the target platform. +//! +//! [portability guidelines]: ../struct.Poll.html#portability +//! +//! # Notes +//! +//! When using a datagram based socket, i.e. [`UdpSocket`] or [`UnixDatagram`], +//! its only possible to receive a packet once. This means that if you provide a +//! buffer that is too small you won't be able to receive the data anymore. How +//! OSs deal with this situation is different for each OS: +//! * Unixes, such as Linux, FreeBSD and macOS, will simply fill the buffer and +//! return the amount of bytes written. This means that if the returned value +//! is equal to the size of the buffer it may have only written a part of the +//! packet (or the packet has the same size as the buffer). +//! * Windows returns an `WSAEMSGSIZE` error. +//! +//! Mio does not change the value (either ok or error) returned by the OS, it's +//! up to the user handle this. How to deal with these difference is still up +//! for debate, specifically in +//! <https://github.com/rust-lang/rust/issues/55794>. The best advice we can +//! give is to always call receive with a large enough buffer. + +mod tcp; +pub use self::tcp::{TcpListener, TcpStream}; + +mod udp; +pub use self::udp::UdpSocket; + +#[cfg(unix)] +mod uds; +#[cfg(unix)] +pub use self::uds::{SocketAddr, UnixDatagram, UnixListener, UnixStream}; diff --git a/third_party/rust/mio/src/net/tcp/listener.rs b/third_party/rust/mio/src/net/tcp/listener.rs new file mode 100644 index 0000000000..21bffbaffc --- /dev/null +++ b/third_party/rust/mio/src/net/tcp/listener.rs @@ -0,0 +1,217 @@ +use std::net::{self, SocketAddr}; +#[cfg(unix)] +use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; +#[cfg(windows)] +use std::os::windows::io::{AsRawSocket, FromRawSocket, IntoRawSocket, RawSocket}; +use std::{fmt, io}; + +use crate::io_source::IoSource; +use crate::net::TcpStream; +#[cfg(unix)] +use crate::sys::tcp::set_reuseaddr; +use crate::sys::tcp::{bind, listen, new_for_addr}; +use crate::{event, sys, Interest, Registry, Token}; + +/// A structure representing a socket server +/// +/// # Examples +/// +#[cfg_attr(feature = "os-poll", doc = "```")] +#[cfg_attr(not(feature = "os-poll"), doc = "```ignore")] +/// # use std::error::Error; +/// # fn main() -> Result<(), Box<dyn Error>> { +/// use mio::{Events, Interest, Poll, Token}; +/// use mio::net::TcpListener; +/// use std::time::Duration; +/// +/// let mut listener = TcpListener::bind("127.0.0.1:34255".parse()?)?; +/// +/// let mut poll = Poll::new()?; +/// let mut events = Events::with_capacity(128); +/// +/// // Register the socket with `Poll` +/// poll.registry().register(&mut listener, Token(0), Interest::READABLE)?; +/// +/// poll.poll(&mut events, Some(Duration::from_millis(100)))?; +/// +/// // There may be a socket ready to be accepted +/// # Ok(()) +/// # } +/// ``` +pub struct TcpListener { + inner: IoSource<net::TcpListener>, +} + +impl TcpListener { + /// Convenience method to bind a new TCP listener to the specified address + /// to receive new connections. + /// + /// This function will take the following steps: + /// + /// 1. Create a new TCP socket. + /// 2. Set the `SO_REUSEADDR` option on the socket on Unix. + /// 3. Bind the socket to the specified address. + /// 4. Calls `listen` on the socket to prepare it to receive new connections. + pub fn bind(addr: SocketAddr) -> io::Result<TcpListener> { + let socket = new_for_addr(addr)?; + #[cfg(unix)] + let listener = unsafe { TcpListener::from_raw_fd(socket) }; + #[cfg(windows)] + let listener = unsafe { TcpListener::from_raw_socket(socket as _) }; + + // On platforms with Berkeley-derived sockets, this allows to quickly + // rebind a socket, without needing to wait for the OS to clean up the + // previous one. + // + // On Windows, this allows rebinding sockets which are actively in use, + // which allows “socket hijacking”, so we explicitly don't set it here. + // https://docs.microsoft.com/en-us/windows/win32/winsock/using-so-reuseaddr-and-so-exclusiveaddruse + #[cfg(not(windows))] + set_reuseaddr(&listener.inner, true)?; + + bind(&listener.inner, addr)?; + listen(&listener.inner, 1024)?; + Ok(listener) + } + + /// Creates a new `TcpListener` from a standard `net::TcpListener`. + /// + /// This function is intended to be used to wrap a TCP listener from the + /// standard library in the Mio equivalent. The conversion assumes nothing + /// about the underlying listener; ; it is left up to the user to set it + /// in non-blocking mode. + pub fn from_std(listener: net::TcpListener) -> TcpListener { + TcpListener { + inner: IoSource::new(listener), + } + } + + /// Accepts a new `TcpStream`. + /// + /// This may return an `Err(e)` where `e.kind()` is + /// `io::ErrorKind::WouldBlock`. This means a stream may be ready at a later + /// point and one should wait for an event before calling `accept` again. + /// + /// If an accepted stream is returned, the remote address of the peer is + /// returned along with it. + pub fn accept(&self) -> io::Result<(TcpStream, SocketAddr)> { + self.inner.do_io(|inner| { + sys::tcp::accept(inner).map(|(stream, addr)| (TcpStream::from_std(stream), addr)) + }) + } + + /// Returns the local socket address of this listener. + pub fn local_addr(&self) -> io::Result<SocketAddr> { + self.inner.local_addr() + } + + /// Sets the value for the `IP_TTL` option on this socket. + /// + /// This value sets the time-to-live field that is used in every packet sent + /// from this socket. + pub fn set_ttl(&self, ttl: u32) -> io::Result<()> { + self.inner.set_ttl(ttl) + } + + /// Gets the value of the `IP_TTL` option for this socket. + /// + /// For more information about this option, see [`set_ttl`][link]. + /// + /// [link]: #method.set_ttl + pub fn ttl(&self) -> io::Result<u32> { + self.inner.ttl() + } + + /// Get the value of the `SO_ERROR` option on this socket. + /// + /// This will retrieve the stored error in the underlying socket, clearing + /// the field in the process. This can be useful for checking errors between + /// calls. + pub fn take_error(&self) -> io::Result<Option<io::Error>> { + self.inner.take_error() + } +} + +impl event::Source for TcpListener { + fn register( + &mut self, + registry: &Registry, + token: Token, + interests: Interest, + ) -> io::Result<()> { + self.inner.register(registry, token, interests) + } + + fn reregister( + &mut self, + registry: &Registry, + token: Token, + interests: Interest, + ) -> io::Result<()> { + self.inner.reregister(registry, token, interests) + } + + fn deregister(&mut self, registry: &Registry) -> io::Result<()> { + self.inner.deregister(registry) + } +} + +impl fmt::Debug for TcpListener { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.inner.fmt(f) + } +} + +#[cfg(unix)] +impl IntoRawFd for TcpListener { + fn into_raw_fd(self) -> RawFd { + self.inner.into_inner().into_raw_fd() + } +} + +#[cfg(unix)] +impl AsRawFd for TcpListener { + fn as_raw_fd(&self) -> RawFd { + self.inner.as_raw_fd() + } +} + +#[cfg(unix)] +impl FromRawFd for TcpListener { + /// Converts a `RawFd` to a `TcpListener`. + /// + /// # Notes + /// + /// The caller is responsible for ensuring that the socket is in + /// non-blocking mode. + unsafe fn from_raw_fd(fd: RawFd) -> TcpListener { + TcpListener::from_std(FromRawFd::from_raw_fd(fd)) + } +} + +#[cfg(windows)] +impl IntoRawSocket for TcpListener { + fn into_raw_socket(self) -> RawSocket { + self.inner.into_inner().into_raw_socket() + } +} + +#[cfg(windows)] +impl AsRawSocket for TcpListener { + fn as_raw_socket(&self) -> RawSocket { + self.inner.as_raw_socket() + } +} + +#[cfg(windows)] +impl FromRawSocket for TcpListener { + /// Converts a `RawSocket` to a `TcpListener`. + /// + /// # Notes + /// + /// The caller is responsible for ensuring that the socket is in + /// non-blocking mode. + unsafe fn from_raw_socket(socket: RawSocket) -> TcpListener { + TcpListener::from_std(FromRawSocket::from_raw_socket(socket)) + } +} diff --git a/third_party/rust/mio/src/net/tcp/mod.rs b/third_party/rust/mio/src/net/tcp/mod.rs new file mode 100644 index 0000000000..94af5c10e8 --- /dev/null +++ b/third_party/rust/mio/src/net/tcp/mod.rs @@ -0,0 +1,5 @@ +mod listener; +pub use self::listener::TcpListener; + +mod stream; +pub use self::stream::TcpStream; diff --git a/third_party/rust/mio/src/net/tcp/stream.rs b/third_party/rust/mio/src/net/tcp/stream.rs new file mode 100644 index 0000000000..029f186b42 --- /dev/null +++ b/third_party/rust/mio/src/net/tcp/stream.rs @@ -0,0 +1,334 @@ +use std::fmt; +use std::io::{self, IoSlice, IoSliceMut, Read, Write}; +use std::net::{self, Shutdown, SocketAddr}; +#[cfg(unix)] +use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; +#[cfg(windows)] +use std::os::windows::io::{AsRawSocket, FromRawSocket, IntoRawSocket, RawSocket}; + +use crate::io_source::IoSource; +use crate::sys::tcp::{connect, new_for_addr}; +use crate::{event, Interest, Registry, Token}; + +/// A non-blocking TCP stream between a local socket and a remote socket. +/// +/// The socket will be closed when the value is dropped. +/// +/// # Examples +/// +#[cfg_attr(feature = "os-poll", doc = "```")] +#[cfg_attr(not(feature = "os-poll"), doc = "```ignore")] +/// # use std::net::{TcpListener, SocketAddr}; +/// # use std::error::Error; +/// # +/// # fn main() -> Result<(), Box<dyn Error>> { +/// let address: SocketAddr = "127.0.0.1:0".parse()?; +/// let listener = TcpListener::bind(address)?; +/// use mio::{Events, Interest, Poll, Token}; +/// use mio::net::TcpStream; +/// use std::time::Duration; +/// +/// let mut stream = TcpStream::connect(listener.local_addr()?)?; +/// +/// let mut poll = Poll::new()?; +/// let mut events = Events::with_capacity(128); +/// +/// // Register the socket with `Poll` +/// poll.registry().register(&mut stream, Token(0), Interest::WRITABLE)?; +/// +/// poll.poll(&mut events, Some(Duration::from_millis(100)))?; +/// +/// // The socket might be ready at this point +/// # Ok(()) +/// # } +/// ``` +pub struct TcpStream { + inner: IoSource<net::TcpStream>, +} + +impl TcpStream { + /// Create a new TCP stream and issue a non-blocking connect to the + /// specified address. + /// + /// # Notes + /// + /// The returned `TcpStream` may not be connected (and thus usable), unlike + /// the API found in `std::net::TcpStream`. Because Mio issues a + /// *non-blocking* connect it will not block the thread and instead return + /// an unconnected `TcpStream`. + /// + /// Ensuring the returned stream is connected is surprisingly complex when + /// considering cross-platform support. Doing this properly should follow + /// the steps below, an example implementation can be found + /// [here](https://github.com/Thomasdezeeuw/heph/blob/0c4f1ab3eaf08bea1d65776528bfd6114c9f8374/src/net/tcp/stream.rs#L560-L622). + /// + /// 1. Call `TcpStream::connect` + /// 2. Register the returned stream with at least [read interest]. + /// 3. Wait for a (readable) event. + /// 4. Check `TcpStream::peer_addr`. If it returns `libc::EINPROGRESS` or + /// `ErrorKind::NotConnected` it means the stream is not yet connected, + /// go back to step 3. If it returns an address it means the stream is + /// connected, go to step 5. If another error is returned something + /// whent wrong. + /// 5. Now the stream can be used. + /// + /// [read interest]: Interest::READABLE + pub fn connect(addr: SocketAddr) -> io::Result<TcpStream> { + let socket = new_for_addr(addr)?; + #[cfg(unix)] + let stream = unsafe { TcpStream::from_raw_fd(socket) }; + #[cfg(windows)] + let stream = unsafe { TcpStream::from_raw_socket(socket as _) }; + connect(&stream.inner, addr)?; + Ok(stream) + } + + /// Creates a new `TcpStream` from a standard `net::TcpStream`. + /// + /// This function is intended to be used to wrap a TCP stream from the + /// standard library in the Mio equivalent. The conversion assumes nothing + /// about the underlying stream; it is left up to the user to set it in + /// non-blocking mode. + /// + /// # Note + /// + /// The TCP stream here will not have `connect` called on it, so it + /// should already be connected via some other means (be it manually, or + /// the standard library). + pub fn from_std(stream: net::TcpStream) -> TcpStream { + TcpStream { + inner: IoSource::new(stream), + } + } + + /// Returns the socket address of the remote peer of this TCP connection. + pub fn peer_addr(&self) -> io::Result<SocketAddr> { + self.inner.peer_addr() + } + + /// Returns the socket address of the local half of this TCP connection. + pub fn local_addr(&self) -> io::Result<SocketAddr> { + self.inner.local_addr() + } + + /// Shuts down the read, write, or both halves of this connection. + /// + /// This function will cause all pending and future I/O on the specified + /// portions to return immediately with an appropriate value (see the + /// documentation of `Shutdown`). + pub fn shutdown(&self, how: Shutdown) -> io::Result<()> { + self.inner.shutdown(how) + } + + /// Sets the value of the `TCP_NODELAY` option on this socket. + /// + /// If set, this option disables the Nagle algorithm. This means that + /// segments are always sent as soon as possible, even if there is only a + /// small amount of data. When not set, data is buffered until there is a + /// sufficient amount to send out, thereby avoiding the frequent sending of + /// small packets. + /// + /// # Notes + /// + /// On Windows make sure the stream is connected before calling this method, + /// by receiving an (writable) event. Trying to set `nodelay` on an + /// unconnected `TcpStream` is unspecified behavior. + pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> { + self.inner.set_nodelay(nodelay) + } + + /// Gets the value of the `TCP_NODELAY` option on this socket. + /// + /// For more information about this option, see [`set_nodelay`][link]. + /// + /// [link]: #method.set_nodelay + /// + /// # Notes + /// + /// On Windows make sure the stream is connected before calling this method, + /// by receiving an (writable) event. Trying to get `nodelay` on an + /// unconnected `TcpStream` is unspecified behavior. + pub fn nodelay(&self) -> io::Result<bool> { + self.inner.nodelay() + } + + /// Sets the value for the `IP_TTL` option on this socket. + /// + /// This value sets the time-to-live field that is used in every packet sent + /// from this socket. + /// + /// # Notes + /// + /// On Windows make sure the stream is connected before calling this method, + /// by receiving an (writable) event. Trying to set `ttl` on an + /// unconnected `TcpStream` is unspecified behavior. + pub fn set_ttl(&self, ttl: u32) -> io::Result<()> { + self.inner.set_ttl(ttl) + } + + /// Gets the value of the `IP_TTL` option for this socket. + /// + /// For more information about this option, see [`set_ttl`][link]. + /// + /// # Notes + /// + /// On Windows make sure the stream is connected before calling this method, + /// by receiving an (writable) event. Trying to get `ttl` on an + /// unconnected `TcpStream` is unspecified behavior. + /// + /// [link]: #method.set_ttl + pub fn ttl(&self) -> io::Result<u32> { + self.inner.ttl() + } + + /// Get the value of the `SO_ERROR` option on this socket. + /// + /// This will retrieve the stored error in the underlying socket, clearing + /// the field in the process. This can be useful for checking errors between + /// calls. + pub fn take_error(&self) -> io::Result<Option<io::Error>> { + self.inner.take_error() + } + + /// Receives data on the socket from the remote address to which it is + /// connected, without removing that data from the queue. On success, + /// returns the number of bytes peeked. + /// + /// Successive calls return the same data. This is accomplished by passing + /// `MSG_PEEK` as a flag to the underlying recv system call. + pub fn peek(&self, buf: &mut [u8]) -> io::Result<usize> { + self.inner.peek(buf) + } +} + +impl Read for TcpStream { + fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { + self.inner.do_io(|inner| (&*inner).read(buf)) + } + + fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> { + self.inner.do_io(|inner| (&*inner).read_vectored(bufs)) + } +} + +impl<'a> Read for &'a TcpStream { + fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { + self.inner.do_io(|inner| (&*inner).read(buf)) + } + + fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> { + self.inner.do_io(|inner| (&*inner).read_vectored(bufs)) + } +} + +impl Write for TcpStream { + fn write(&mut self, buf: &[u8]) -> io::Result<usize> { + self.inner.do_io(|inner| (&*inner).write(buf)) + } + + fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> { + self.inner.do_io(|inner| (&*inner).write_vectored(bufs)) + } + + fn flush(&mut self) -> io::Result<()> { + self.inner.do_io(|inner| (&*inner).flush()) + } +} + +impl<'a> Write for &'a TcpStream { + fn write(&mut self, buf: &[u8]) -> io::Result<usize> { + self.inner.do_io(|inner| (&*inner).write(buf)) + } + + fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> { + self.inner.do_io(|inner| (&*inner).write_vectored(bufs)) + } + + fn flush(&mut self) -> io::Result<()> { + self.inner.do_io(|inner| (&*inner).flush()) + } +} + +impl event::Source for TcpStream { + fn register( + &mut self, + registry: &Registry, + token: Token, + interests: Interest, + ) -> io::Result<()> { + self.inner.register(registry, token, interests) + } + + fn reregister( + &mut self, + registry: &Registry, + token: Token, + interests: Interest, + ) -> io::Result<()> { + self.inner.reregister(registry, token, interests) + } + + fn deregister(&mut self, registry: &Registry) -> io::Result<()> { + self.inner.deregister(registry) + } +} + +impl fmt::Debug for TcpStream { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.inner.fmt(f) + } +} + +#[cfg(unix)] +impl IntoRawFd for TcpStream { + fn into_raw_fd(self) -> RawFd { + self.inner.into_inner().into_raw_fd() + } +} + +#[cfg(unix)] +impl AsRawFd for TcpStream { + fn as_raw_fd(&self) -> RawFd { + self.inner.as_raw_fd() + } +} + +#[cfg(unix)] +impl FromRawFd for TcpStream { + /// Converts a `RawFd` to a `TcpStream`. + /// + /// # Notes + /// + /// The caller is responsible for ensuring that the socket is in + /// non-blocking mode. + unsafe fn from_raw_fd(fd: RawFd) -> TcpStream { + TcpStream::from_std(FromRawFd::from_raw_fd(fd)) + } +} + +#[cfg(windows)] +impl IntoRawSocket for TcpStream { + fn into_raw_socket(self) -> RawSocket { + self.inner.into_inner().into_raw_socket() + } +} + +#[cfg(windows)] +impl AsRawSocket for TcpStream { + fn as_raw_socket(&self) -> RawSocket { + self.inner.as_raw_socket() + } +} + +#[cfg(windows)] +impl FromRawSocket for TcpStream { + /// Converts a `RawSocket` to a `TcpStream`. + /// + /// # Notes + /// + /// The caller is responsible for ensuring that the socket is in + /// non-blocking mode. + unsafe fn from_raw_socket(socket: RawSocket) -> TcpStream { + TcpStream::from_std(FromRawSocket::from_raw_socket(socket)) + } +} diff --git a/third_party/rust/mio/src/net/udp.rs b/third_party/rust/mio/src/net/udp.rs new file mode 100644 index 0000000000..8cfe4e456c --- /dev/null +++ b/third_party/rust/mio/src/net/udp.rs @@ -0,0 +1,635 @@ +//! Primitives for working with UDP. +//! +//! The types provided in this module are non-blocking by default and are +//! designed to be portable across all supported Mio platforms. As long as the +//! [portability guidelines] are followed, the behavior should be identical no +//! matter the target platform. +//! +//! [portability guidelines]: ../struct.Poll.html#portability + +use crate::io_source::IoSource; +use crate::{event, sys, Interest, Registry, Token}; + +use std::fmt; +use std::io; +use std::net; +use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr}; +#[cfg(unix)] +use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; +#[cfg(windows)] +use std::os::windows::io::{AsRawSocket, FromRawSocket, IntoRawSocket, RawSocket}; + +/// A User Datagram Protocol socket. +/// +/// This is an implementation of a bound UDP socket. This supports both IPv4 and +/// IPv6 addresses, and there is no corresponding notion of a server because UDP +/// is a datagram protocol. +/// +/// # Examples +/// +#[cfg_attr(feature = "os-poll", doc = "```")] +#[cfg_attr(not(feature = "os-poll"), doc = "```ignore")] +/// # use std::error::Error; +/// # +/// # fn main() -> Result<(), Box<dyn Error>> { +/// // An Echo program: +/// // SENDER -> sends a message. +/// // ECHOER -> listens and prints the message received. +/// +/// use mio::net::UdpSocket; +/// use mio::{Events, Interest, Poll, Token}; +/// use std::time::Duration; +/// +/// const SENDER: Token = Token(0); +/// const ECHOER: Token = Token(1); +/// +/// // This operation will fail if the address is in use, so we select different ports for each +/// // socket. +/// let mut sender_socket = UdpSocket::bind("127.0.0.1:0".parse()?)?; +/// let mut echoer_socket = UdpSocket::bind("127.0.0.1:0".parse()?)?; +/// +/// // If we do not use connect here, SENDER and ECHOER would need to call send_to and recv_from +/// // respectively. +/// sender_socket.connect(echoer_socket.local_addr()?)?; +/// +/// // We need a Poll to check if SENDER is ready to be written into, and if ECHOER is ready to be +/// // read from. +/// let mut poll = Poll::new()?; +/// +/// // We register our sockets here so that we can check if they are ready to be written/read. +/// poll.registry().register(&mut sender_socket, SENDER, Interest::WRITABLE)?; +/// poll.registry().register(&mut echoer_socket, ECHOER, Interest::READABLE)?; +/// +/// let msg_to_send = [9; 9]; +/// let mut buffer = [0; 9]; +/// +/// let mut events = Events::with_capacity(128); +/// loop { +/// poll.poll(&mut events, Some(Duration::from_millis(100)))?; +/// for event in events.iter() { +/// match event.token() { +/// // Our SENDER is ready to be written into. +/// SENDER => { +/// let bytes_sent = sender_socket.send(&msg_to_send)?; +/// assert_eq!(bytes_sent, 9); +/// println!("sent {:?} -> {:?} bytes", msg_to_send, bytes_sent); +/// }, +/// // Our ECHOER is ready to be read from. +/// ECHOER => { +/// let num_recv = echoer_socket.recv(&mut buffer)?; +/// println!("echo {:?} -> {:?}", buffer, num_recv); +/// buffer = [0; 9]; +/// # drop(buffer); // Silence unused assignment warning. +/// # return Ok(()); +/// } +/// _ => unreachable!() +/// } +/// } +/// } +/// # } +/// ``` +pub struct UdpSocket { + inner: IoSource<net::UdpSocket>, +} + +impl UdpSocket { + /// Creates a UDP socket from the given address. + /// + /// # Examples + /// + #[cfg_attr(feature = "os-poll", doc = "```")] + #[cfg_attr(not(feature = "os-poll"), doc = "```ignore")] + /// # use std::error::Error; + /// # + /// # fn main() -> Result<(), Box<dyn Error>> { + /// use mio::net::UdpSocket; + /// + /// // We must bind it to an open address. + /// let socket = match UdpSocket::bind("127.0.0.1:0".parse()?) { + /// Ok(new_socket) => new_socket, + /// Err(fail) => { + /// // We panic! here, but you could try to bind it again on another address. + /// panic!("Failed to bind socket. {:?}", fail); + /// } + /// }; + /// + /// // Our socket was created, but we should not use it before checking it's readiness. + /// # drop(socket); // Silence unused variable warning. + /// # Ok(()) + /// # } + /// ``` + pub fn bind(addr: SocketAddr) -> io::Result<UdpSocket> { + sys::udp::bind(addr).map(UdpSocket::from_std) + } + + /// Creates a new `UdpSocket` from a standard `net::UdpSocket`. + /// + /// This function is intended to be used to wrap a UDP socket from the + /// standard library in the Mio equivalent. The conversion assumes nothing + /// about the underlying socket; it is left up to the user to set it in + /// non-blocking mode. + pub fn from_std(socket: net::UdpSocket) -> UdpSocket { + UdpSocket { + inner: IoSource::new(socket), + } + } + + /// Returns the socket address that this socket was created from. + /// + /// # Examples + /// + // This assertion is almost, but not quite, universal. It fails on + // shared-IP FreeBSD jails. It's hard for mio to know whether we're jailed, + // so simply disable the test on FreeBSD. + #[cfg_attr(all(feature = "os-poll", not(target_os = "freebsd")), doc = "```")] + #[cfg_attr( + any(not(feature = "os-poll"), target_os = "freebsd"), + doc = "```ignore" + )] + /// # use std::error::Error; + /// # + /// # fn main() -> Result<(), Box<dyn Error>> { + /// use mio::net::UdpSocket; + /// + /// let addr = "127.0.0.1:0".parse()?; + /// let socket = UdpSocket::bind(addr)?; + /// assert_eq!(socket.local_addr()?.ip(), addr.ip()); + /// # Ok(()) + /// # } + /// ``` + pub fn local_addr(&self) -> io::Result<SocketAddr> { + self.inner.local_addr() + } + + /// Returns the socket address of the remote peer this socket was connected to. + /// + /// # Examples + /// + #[cfg_attr(feature = "os-poll", doc = "```")] + #[cfg_attr(not(feature = "os-poll"), doc = "```ignore")] + /// # use std::error::Error; + /// # + /// # fn main() -> Result<(), Box<dyn Error>> { + /// use mio::net::UdpSocket; + /// + /// let addr = "127.0.0.1:0".parse()?; + /// let peer_addr = "127.0.0.1:11100".parse()?; + /// let socket = UdpSocket::bind(addr)?; + /// socket.connect(peer_addr)?; + /// assert_eq!(socket.peer_addr()?.ip(), peer_addr.ip()); + /// # Ok(()) + /// # } + /// ``` + pub fn peer_addr(&self) -> io::Result<SocketAddr> { + self.inner.peer_addr() + } + + /// Sends data on the socket to the given address. On success, returns the + /// number of bytes written. + /// + /// Address type can be any implementor of `ToSocketAddrs` trait. See its + /// documentation for concrete examples. + /// + /// # Examples + /// + /// ```no_run + /// # use std::error::Error; + /// # fn main() -> Result<(), Box<dyn Error>> { + /// use mio::net::UdpSocket; + /// + /// let socket = UdpSocket::bind("127.0.0.1:0".parse()?)?; + /// + /// // We must check if the socket is writable before calling send_to, + /// // or we could run into a WouldBlock error. + /// + /// let bytes_sent = socket.send_to(&[9; 9], "127.0.0.1:11100".parse()?)?; + /// assert_eq!(bytes_sent, 9); + /// # + /// # Ok(()) + /// # } + /// ``` + pub fn send_to(&self, buf: &[u8], target: SocketAddr) -> io::Result<usize> { + self.inner.do_io(|inner| inner.send_to(buf, target)) + } + + /// Receives data from the socket. On success, returns the number of bytes + /// read and the address from whence the data came. + /// + /// # Notes + /// + /// On Windows, if the data is larger than the buffer specified, the buffer + /// is filled with the first part of the data, and recv_from returns the error + /// WSAEMSGSIZE(10040). The excess data is lost. + /// Make sure to always use a sufficiently large buffer to hold the + /// maximum UDP packet size, which can be up to 65536 bytes in size. + /// + /// # Examples + /// + /// ```no_run + /// # use std::error::Error; + /// # + /// # fn main() -> Result<(), Box<dyn Error>> { + /// use mio::net::UdpSocket; + /// + /// let socket = UdpSocket::bind("127.0.0.1:0".parse()?)?; + /// + /// // We must check if the socket is readable before calling recv_from, + /// // or we could run into a WouldBlock error. + /// + /// let mut buf = [0; 9]; + /// let (num_recv, from_addr) = socket.recv_from(&mut buf)?; + /// println!("Received {:?} -> {:?} bytes from {:?}", buf, num_recv, from_addr); + /// # + /// # Ok(()) + /// # } + /// ``` + pub fn recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> { + self.inner.do_io(|inner| inner.recv_from(buf)) + } + + /// Receives data from the socket, without removing it from the input queue. + /// On success, returns the number of bytes read and the address from whence + /// the data came. + /// + /// # Notes + /// + /// On Windows, if the data is larger than the buffer specified, the buffer + /// is filled with the first part of the data, and peek_from returns the error + /// WSAEMSGSIZE(10040). The excess data is lost. + /// Make sure to always use a sufficiently large buffer to hold the + /// maximum UDP packet size, which can be up to 65536 bytes in size. + /// + /// # Examples + /// + /// ```no_run + /// # use std::error::Error; + /// # + /// # fn main() -> Result<(), Box<dyn Error>> { + /// use mio::net::UdpSocket; + /// + /// let socket = UdpSocket::bind("127.0.0.1:0".parse()?)?; + /// + /// // We must check if the socket is readable before calling recv_from, + /// // or we could run into a WouldBlock error. + /// + /// let mut buf = [0; 9]; + /// let (num_recv, from_addr) = socket.peek_from(&mut buf)?; + /// println!("Received {:?} -> {:?} bytes from {:?}", buf, num_recv, from_addr); + /// # + /// # Ok(()) + /// # } + /// ``` + pub fn peek_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> { + self.inner.do_io(|inner| inner.peek_from(buf)) + } + + /// Sends data on the socket to the address previously bound via connect(). On success, + /// returns the number of bytes written. + pub fn send(&self, buf: &[u8]) -> io::Result<usize> { + self.inner.do_io(|inner| inner.send(buf)) + } + + /// Receives data from the socket previously bound with connect(). On success, returns + /// the number of bytes read. + /// + /// # Notes + /// + /// On Windows, if the data is larger than the buffer specified, the buffer + /// is filled with the first part of the data, and recv returns the error + /// WSAEMSGSIZE(10040). The excess data is lost. + /// Make sure to always use a sufficiently large buffer to hold the + /// maximum UDP packet size, which can be up to 65536 bytes in size. + pub fn recv(&self, buf: &mut [u8]) -> io::Result<usize> { + self.inner.do_io(|inner| inner.recv(buf)) + } + + /// Receives data from the socket, without removing it from the input queue. + /// On success, returns the number of bytes read. + /// + /// # Notes + /// + /// On Windows, if the data is larger than the buffer specified, the buffer + /// is filled with the first part of the data, and peek returns the error + /// WSAEMSGSIZE(10040). The excess data is lost. + /// Make sure to always use a sufficiently large buffer to hold the + /// maximum UDP packet size, which can be up to 65536 bytes in size. + pub fn peek(&self, buf: &mut [u8]) -> io::Result<usize> { + self.inner.do_io(|inner| inner.peek(buf)) + } + + /// Connects the UDP socket setting the default destination for `send()` + /// and limiting packets that are read via `recv` from the address specified + /// in `addr`. + pub fn connect(&self, addr: SocketAddr) -> io::Result<()> { + self.inner.connect(addr) + } + + /// Sets the value of the `SO_BROADCAST` option for this socket. + /// + /// When enabled, this socket is allowed to send packets to a broadcast + /// address. + /// + /// # Examples + /// + #[cfg_attr(feature = "os-poll", doc = "```")] + #[cfg_attr(not(feature = "os-poll"), doc = "```ignore")] + /// # use std::error::Error; + /// # + /// # fn main() -> Result<(), Box<dyn Error>> { + /// use mio::net::UdpSocket; + /// + /// let broadcast_socket = UdpSocket::bind("127.0.0.1:0".parse()?)?; + /// if broadcast_socket.broadcast()? == false { + /// broadcast_socket.set_broadcast(true)?; + /// } + /// + /// assert_eq!(broadcast_socket.broadcast()?, true); + /// # + /// # Ok(()) + /// # } + /// ``` + pub fn set_broadcast(&self, on: bool) -> io::Result<()> { + self.inner.set_broadcast(on) + } + + /// Gets the value of the `SO_BROADCAST` option for this socket. + /// + /// For more information about this option, see + /// [`set_broadcast`][link]. + /// + /// [link]: #method.set_broadcast + /// + /// # Examples + /// + #[cfg_attr(feature = "os-poll", doc = "```")] + #[cfg_attr(not(feature = "os-poll"), doc = "```ignore")] + /// # use std::error::Error; + /// # + /// # fn main() -> Result<(), Box<dyn Error>> { + /// use mio::net::UdpSocket; + /// + /// let broadcast_socket = UdpSocket::bind("127.0.0.1:0".parse()?)?; + /// assert_eq!(broadcast_socket.broadcast()?, false); + /// # + /// # Ok(()) + /// # } + /// ``` + pub fn broadcast(&self) -> io::Result<bool> { + self.inner.broadcast() + } + + /// Sets the value of the `IP_MULTICAST_LOOP` option for this socket. + /// + /// If enabled, multicast packets will be looped back to the local socket. + /// Note that this may not have any affect on IPv6 sockets. + pub fn set_multicast_loop_v4(&self, on: bool) -> io::Result<()> { + self.inner.set_multicast_loop_v4(on) + } + + /// Gets the value of the `IP_MULTICAST_LOOP` option for this socket. + /// + /// For more information about this option, see + /// [`set_multicast_loop_v4`][link]. + /// + /// [link]: #method.set_multicast_loop_v4 + pub fn multicast_loop_v4(&self) -> io::Result<bool> { + self.inner.multicast_loop_v4() + } + + /// Sets the value of the `IP_MULTICAST_TTL` option for this socket. + /// + /// Indicates the time-to-live value of outgoing multicast packets for + /// this socket. The default value is 1 which means that multicast packets + /// don't leave the local network unless explicitly requested. + /// + /// Note that this may not have any affect on IPv6 sockets. + pub fn set_multicast_ttl_v4(&self, ttl: u32) -> io::Result<()> { + self.inner.set_multicast_ttl_v4(ttl) + } + + /// Gets the value of the `IP_MULTICAST_TTL` option for this socket. + /// + /// For more information about this option, see + /// [`set_multicast_ttl_v4`][link]. + /// + /// [link]: #method.set_multicast_ttl_v4 + pub fn multicast_ttl_v4(&self) -> io::Result<u32> { + self.inner.multicast_ttl_v4() + } + + /// Sets the value of the `IPV6_MULTICAST_LOOP` option for this socket. + /// + /// Controls whether this socket sees the multicast packets it sends itself. + /// Note that this may not have any affect on IPv4 sockets. + pub fn set_multicast_loop_v6(&self, on: bool) -> io::Result<()> { + self.inner.set_multicast_loop_v6(on) + } + + /// Gets the value of the `IPV6_MULTICAST_LOOP` option for this socket. + /// + /// For more information about this option, see + /// [`set_multicast_loop_v6`][link]. + /// + /// [link]: #method.set_multicast_loop_v6 + pub fn multicast_loop_v6(&self) -> io::Result<bool> { + self.inner.multicast_loop_v6() + } + + /// Sets the value for the `IP_TTL` option on this socket. + /// + /// This value sets the time-to-live field that is used in every packet sent + /// from this socket. + /// + /// # Examples + /// + #[cfg_attr(feature = "os-poll", doc = "```")] + #[cfg_attr(not(feature = "os-poll"), doc = "```ignore")] + /// # use std::error::Error; + /// # + /// # fn main() -> Result<(), Box<dyn Error>> { + /// use mio::net::UdpSocket; + /// + /// let socket = UdpSocket::bind("127.0.0.1:0".parse()?)?; + /// if socket.ttl()? < 255 { + /// socket.set_ttl(255)?; + /// } + /// + /// assert_eq!(socket.ttl()?, 255); + /// # + /// # Ok(()) + /// # } + /// ``` + pub fn set_ttl(&self, ttl: u32) -> io::Result<()> { + self.inner.set_ttl(ttl) + } + + /// Gets the value of the `IP_TTL` option for this socket. + /// + /// For more information about this option, see [`set_ttl`][link]. + /// + /// [link]: #method.set_ttl + /// + /// # Examples + /// + #[cfg_attr(feature = "os-poll", doc = "```")] + #[cfg_attr(not(feature = "os-poll"), doc = "```ignore")] + /// # use std::error::Error; + /// # + /// # fn main() -> Result<(), Box<dyn Error>> { + /// use mio::net::UdpSocket; + /// + /// let socket = UdpSocket::bind("127.0.0.1:0".parse()?)?; + /// socket.set_ttl(255)?; + /// + /// assert_eq!(socket.ttl()?, 255); + /// # + /// # Ok(()) + /// # } + /// ``` + pub fn ttl(&self) -> io::Result<u32> { + self.inner.ttl() + } + + /// Executes an operation of the `IP_ADD_MEMBERSHIP` type. + /// + /// This function specifies a new multicast group for this socket to join. + /// The address must be a valid multicast address, and `interface` is the + /// address of the local interface with which the system should join the + /// multicast group. If it's equal to `INADDR_ANY` then an appropriate + /// interface is chosen by the system. + #[allow(clippy::trivially_copy_pass_by_ref)] + pub fn join_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> { + self.inner.join_multicast_v4(multiaddr, interface) + } + + /// Executes an operation of the `IPV6_ADD_MEMBERSHIP` type. + /// + /// This function specifies a new multicast group for this socket to join. + /// The address must be a valid multicast address, and `interface` is the + /// index of the interface to join/leave (or 0 to indicate any interface). + #[allow(clippy::trivially_copy_pass_by_ref)] + pub fn join_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> { + self.inner.join_multicast_v6(multiaddr, interface) + } + + /// Executes an operation of the `IP_DROP_MEMBERSHIP` type. + /// + /// For more information about this option, see + /// [`join_multicast_v4`][link]. + /// + /// [link]: #method.join_multicast_v4 + #[allow(clippy::trivially_copy_pass_by_ref)] + pub fn leave_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> { + self.inner.leave_multicast_v4(multiaddr, interface) + } + + /// Executes an operation of the `IPV6_DROP_MEMBERSHIP` type. + /// + /// For more information about this option, see + /// [`join_multicast_v6`][link]. + /// + /// [link]: #method.join_multicast_v6 + #[allow(clippy::trivially_copy_pass_by_ref)] + pub fn leave_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> { + self.inner.leave_multicast_v6(multiaddr, interface) + } + + /// Get the value of the `IPV6_V6ONLY` option on this socket. + #[allow(clippy::trivially_copy_pass_by_ref)] + pub fn only_v6(&self) -> io::Result<bool> { + sys::udp::only_v6(&self.inner) + } + + /// Get the value of the `SO_ERROR` option on this socket. + /// + /// This will retrieve the stored error in the underlying socket, clearing + /// the field in the process. This can be useful for checking errors between + /// calls. + pub fn take_error(&self) -> io::Result<Option<io::Error>> { + self.inner.take_error() + } +} + +impl event::Source for UdpSocket { + fn register( + &mut self, + registry: &Registry, + token: Token, + interests: Interest, + ) -> io::Result<()> { + self.inner.register(registry, token, interests) + } + + fn reregister( + &mut self, + registry: &Registry, + token: Token, + interests: Interest, + ) -> io::Result<()> { + self.inner.reregister(registry, token, interests) + } + + fn deregister(&mut self, registry: &Registry) -> io::Result<()> { + self.inner.deregister(registry) + } +} + +impl fmt::Debug for UdpSocket { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.inner.fmt(f) + } +} + +#[cfg(unix)] +impl IntoRawFd for UdpSocket { + fn into_raw_fd(self) -> RawFd { + self.inner.into_inner().into_raw_fd() + } +} + +#[cfg(unix)] +impl AsRawFd for UdpSocket { + fn as_raw_fd(&self) -> RawFd { + self.inner.as_raw_fd() + } +} + +#[cfg(unix)] +impl FromRawFd for UdpSocket { + /// Converts a `RawFd` to a `UdpSocket`. + /// + /// # Notes + /// + /// The caller is responsible for ensuring that the socket is in + /// non-blocking mode. + unsafe fn from_raw_fd(fd: RawFd) -> UdpSocket { + UdpSocket::from_std(FromRawFd::from_raw_fd(fd)) + } +} + +#[cfg(windows)] +impl IntoRawSocket for UdpSocket { + fn into_raw_socket(self) -> RawSocket { + self.inner.into_inner().into_raw_socket() + } +} + +#[cfg(windows)] +impl AsRawSocket for UdpSocket { + fn as_raw_socket(&self) -> RawSocket { + self.inner.as_raw_socket() + } +} + +#[cfg(windows)] +impl FromRawSocket for UdpSocket { + /// Converts a `RawSocket` to a `UdpSocket`. + /// + /// # Notes + /// + /// The caller is responsible for ensuring that the socket is in + /// non-blocking mode. + unsafe fn from_raw_socket(socket: RawSocket) -> UdpSocket { + UdpSocket::from_std(FromRawSocket::from_raw_socket(socket)) + } +} diff --git a/third_party/rust/mio/src/net/uds/datagram.rs b/third_party/rust/mio/src/net/uds/datagram.rs new file mode 100644 index 0000000000..0c8f5ffa6a --- /dev/null +++ b/third_party/rust/mio/src/net/uds/datagram.rs @@ -0,0 +1,165 @@ +use crate::io_source::IoSource; +use crate::{event, sys, Interest, Registry, Token}; + +use std::net::Shutdown; +use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; +use std::os::unix::net; +use std::path::Path; +use std::{fmt, io}; + +/// A Unix datagram socket. +pub struct UnixDatagram { + inner: IoSource<net::UnixDatagram>, +} + +impl UnixDatagram { + /// Creates a Unix datagram socket bound to the given path. + pub fn bind<P: AsRef<Path>>(path: P) -> io::Result<UnixDatagram> { + sys::uds::datagram::bind(path.as_ref()).map(UnixDatagram::from_std) + } + + /// Creates a new `UnixDatagram` from a standard `net::UnixDatagram`. + /// + /// This function is intended to be used to wrap a Unix datagram from the + /// standard library in the Mio equivalent. The conversion assumes nothing + /// about the underlying datagram; ; it is left up to the user to set it + /// in non-blocking mode. + pub fn from_std(socket: net::UnixDatagram) -> UnixDatagram { + UnixDatagram { + inner: IoSource::new(socket), + } + } + + /// Connects the socket to the specified address. + pub fn connect<P: AsRef<Path>>(&self, path: P) -> io::Result<()> { + self.inner.connect(path) + } + + /// Creates a Unix Datagram socket which is not bound to any address. + pub fn unbound() -> io::Result<UnixDatagram> { + sys::uds::datagram::unbound().map(UnixDatagram::from_std) + } + + /// Create an unnamed pair of connected sockets. + pub fn pair() -> io::Result<(UnixDatagram, UnixDatagram)> { + sys::uds::datagram::pair().map(|(socket1, socket2)| { + ( + UnixDatagram::from_std(socket1), + UnixDatagram::from_std(socket2), + ) + }) + } + + /// Returns the address of this socket. + pub fn local_addr(&self) -> io::Result<sys::SocketAddr> { + sys::uds::datagram::local_addr(&self.inner) + } + + /// Returns the address of this socket's peer. + /// + /// The `connect` method will connect the socket to a peer. + pub fn peer_addr(&self) -> io::Result<sys::SocketAddr> { + sys::uds::datagram::peer_addr(&self.inner) + } + + /// Receives data from the socket. + /// + /// On success, returns the number of bytes read and the address from + /// whence the data came. + pub fn recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, sys::SocketAddr)> { + self.inner + .do_io(|inner| sys::uds::datagram::recv_from(inner, buf)) + } + + /// Receives data from the socket. + /// + /// On success, returns the number of bytes read. + pub fn recv(&self, buf: &mut [u8]) -> io::Result<usize> { + self.inner.do_io(|inner| inner.recv(buf)) + } + + /// Sends data on the socket to the specified address. + /// + /// On success, returns the number of bytes written. + pub fn send_to<P: AsRef<Path>>(&self, buf: &[u8], path: P) -> io::Result<usize> { + self.inner.do_io(|inner| inner.send_to(buf, path)) + } + + /// Sends data on the socket to the socket's peer. + /// + /// The peer address may be set by the `connect` method, and this method + /// will return an error if the socket has not already been connected. + /// + /// On success, returns the number of bytes written. + pub fn send(&self, buf: &[u8]) -> io::Result<usize> { + self.inner.do_io(|inner| inner.send(buf)) + } + + /// Returns the value of the `SO_ERROR` option. + pub fn take_error(&self) -> io::Result<Option<io::Error>> { + self.inner.take_error() + } + + /// Shut down the read, write, or both halves of this connection. + /// + /// This function will cause all pending and future I/O calls on the + /// specified portions to immediately return with an appropriate value + /// (see the documentation of `Shutdown`). + pub fn shutdown(&self, how: Shutdown) -> io::Result<()> { + self.inner.shutdown(how) + } +} + +impl event::Source for UnixDatagram { + fn register( + &mut self, + registry: &Registry, + token: Token, + interests: Interest, + ) -> io::Result<()> { + self.inner.register(registry, token, interests) + } + + fn reregister( + &mut self, + registry: &Registry, + token: Token, + interests: Interest, + ) -> io::Result<()> { + self.inner.reregister(registry, token, interests) + } + + fn deregister(&mut self, registry: &Registry) -> io::Result<()> { + self.inner.deregister(registry) + } +} + +impl fmt::Debug for UnixDatagram { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.inner.fmt(f) + } +} + +impl IntoRawFd for UnixDatagram { + fn into_raw_fd(self) -> RawFd { + self.inner.into_inner().into_raw_fd() + } +} + +impl AsRawFd for UnixDatagram { + fn as_raw_fd(&self) -> RawFd { + self.inner.as_raw_fd() + } +} + +impl FromRawFd for UnixDatagram { + /// Converts a `RawFd` to a `UnixDatagram`. + /// + /// # Notes + /// + /// The caller is responsible for ensuring that the socket is in + /// non-blocking mode. + unsafe fn from_raw_fd(fd: RawFd) -> UnixDatagram { + UnixDatagram::from_std(FromRawFd::from_raw_fd(fd)) + } +} diff --git a/third_party/rust/mio/src/net/uds/listener.rs b/third_party/rust/mio/src/net/uds/listener.rs new file mode 100644 index 0000000000..37e8106d89 --- /dev/null +++ b/third_party/rust/mio/src/net/uds/listener.rs @@ -0,0 +1,104 @@ +use crate::io_source::IoSource; +use crate::net::{SocketAddr, UnixStream}; +use crate::{event, sys, Interest, Registry, Token}; + +use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; +use std::os::unix::net; +use std::path::Path; +use std::{fmt, io}; + +/// A non-blocking Unix domain socket server. +pub struct UnixListener { + inner: IoSource<net::UnixListener>, +} + +impl UnixListener { + /// Creates a new `UnixListener` bound to the specified socket. + pub fn bind<P: AsRef<Path>>(path: P) -> io::Result<UnixListener> { + sys::uds::listener::bind(path.as_ref()).map(UnixListener::from_std) + } + + /// Creates a new `UnixListener` from a standard `net::UnixListener`. + /// + /// This function is intended to be used to wrap a Unix listener from the + /// standard library in the Mio equivalent. The conversion assumes nothing + /// about the underlying listener; it is left up to the user to set it in + /// non-blocking mode. + pub fn from_std(listener: net::UnixListener) -> UnixListener { + UnixListener { + inner: IoSource::new(listener), + } + } + + /// Accepts a new incoming connection to this listener. + /// + /// The call is responsible for ensuring that the listening socket is in + /// non-blocking mode. + pub fn accept(&self) -> io::Result<(UnixStream, SocketAddr)> { + sys::uds::listener::accept(&self.inner) + } + + /// Returns the local socket address of this listener. + pub fn local_addr(&self) -> io::Result<sys::SocketAddr> { + sys::uds::listener::local_addr(&self.inner) + } + + /// Returns the value of the `SO_ERROR` option. + pub fn take_error(&self) -> io::Result<Option<io::Error>> { + self.inner.take_error() + } +} + +impl event::Source for UnixListener { + fn register( + &mut self, + registry: &Registry, + token: Token, + interests: Interest, + ) -> io::Result<()> { + self.inner.register(registry, token, interests) + } + + fn reregister( + &mut self, + registry: &Registry, + token: Token, + interests: Interest, + ) -> io::Result<()> { + self.inner.reregister(registry, token, interests) + } + + fn deregister(&mut self, registry: &Registry) -> io::Result<()> { + self.inner.deregister(registry) + } +} + +impl fmt::Debug for UnixListener { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.inner.fmt(f) + } +} + +impl IntoRawFd for UnixListener { + fn into_raw_fd(self) -> RawFd { + self.inner.into_inner().into_raw_fd() + } +} + +impl AsRawFd for UnixListener { + fn as_raw_fd(&self) -> RawFd { + self.inner.as_raw_fd() + } +} + +impl FromRawFd for UnixListener { + /// Converts a `RawFd` to a `UnixListener`. + /// + /// # Notes + /// + /// The caller is responsible for ensuring that the socket is in + /// non-blocking mode. + unsafe fn from_raw_fd(fd: RawFd) -> UnixListener { + UnixListener::from_std(FromRawFd::from_raw_fd(fd)) + } +} diff --git a/third_party/rust/mio/src/net/uds/mod.rs b/third_party/rust/mio/src/net/uds/mod.rs new file mode 100644 index 0000000000..6b4ffdc430 --- /dev/null +++ b/third_party/rust/mio/src/net/uds/mod.rs @@ -0,0 +1,10 @@ +mod datagram; +pub use self::datagram::UnixDatagram; + +mod listener; +pub use self::listener::UnixListener; + +mod stream; +pub use self::stream::UnixStream; + +pub use crate::sys::SocketAddr; diff --git a/third_party/rust/mio/src/net/uds/stream.rs b/third_party/rust/mio/src/net/uds/stream.rs new file mode 100644 index 0000000000..f21d9e7ba5 --- /dev/null +++ b/third_party/rust/mio/src/net/uds/stream.rs @@ -0,0 +1,174 @@ +use crate::io_source::IoSource; +use crate::{event, sys, Interest, Registry, Token}; + +use std::fmt; +use std::io::{self, IoSlice, IoSliceMut, Read, Write}; +use std::net::Shutdown; +use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; +use std::os::unix::net; +use std::path::Path; + +/// A non-blocking Unix stream socket. +pub struct UnixStream { + inner: IoSource<net::UnixStream>, +} + +impl UnixStream { + /// Connects to the socket named by `path`. + pub fn connect<P: AsRef<Path>>(path: P) -> io::Result<UnixStream> { + sys::uds::stream::connect(path.as_ref()).map(UnixStream::from_std) + } + + /// Creates a new `UnixStream` from a standard `net::UnixStream`. + /// + /// This function is intended to be used to wrap a Unix stream from the + /// standard library in the Mio equivalent. The conversion assumes nothing + /// about the underlying stream; it is left up to the user to set it in + /// non-blocking mode. + /// + /// # Note + /// + /// The Unix stream here will not have `connect` called on it, so it + /// should already be connected via some other means (be it manually, or + /// the standard library). + pub fn from_std(stream: net::UnixStream) -> UnixStream { + UnixStream { + inner: IoSource::new(stream), + } + } + + /// Creates an unnamed pair of connected sockets. + /// + /// Returns two `UnixStream`s which are connected to each other. + pub fn pair() -> io::Result<(UnixStream, UnixStream)> { + sys::uds::stream::pair().map(|(stream1, stream2)| { + (UnixStream::from_std(stream1), UnixStream::from_std(stream2)) + }) + } + + /// Returns the socket address of the local half of this connection. + pub fn local_addr(&self) -> io::Result<sys::SocketAddr> { + sys::uds::stream::local_addr(&self.inner) + } + + /// Returns the socket address of the remote half of this connection. + pub fn peer_addr(&self) -> io::Result<sys::SocketAddr> { + sys::uds::stream::peer_addr(&self.inner) + } + + /// Returns the value of the `SO_ERROR` option. + pub fn take_error(&self) -> io::Result<Option<io::Error>> { + self.inner.take_error() + } + + /// Shuts down the read, write, or both halves of this connection. + /// + /// This function will cause all pending and future I/O calls on the + /// specified portions to immediately return with an appropriate value + /// (see the documentation of `Shutdown`). + pub fn shutdown(&self, how: Shutdown) -> io::Result<()> { + self.inner.shutdown(how) + } +} + +impl Read for UnixStream { + fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { + self.inner.do_io(|inner| (&*inner).read(buf)) + } + + fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> { + self.inner.do_io(|inner| (&*inner).read_vectored(bufs)) + } +} + +impl<'a> Read for &'a UnixStream { + fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { + self.inner.do_io(|inner| (&*inner).read(buf)) + } + + fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> { + self.inner.do_io(|inner| (&*inner).read_vectored(bufs)) + } +} + +impl Write for UnixStream { + fn write(&mut self, buf: &[u8]) -> io::Result<usize> { + self.inner.do_io(|inner| (&*inner).write(buf)) + } + + fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> { + self.inner.do_io(|inner| (&*inner).write_vectored(bufs)) + } + + fn flush(&mut self) -> io::Result<()> { + self.inner.do_io(|inner| (&*inner).flush()) + } +} + +impl<'a> Write for &'a UnixStream { + fn write(&mut self, buf: &[u8]) -> io::Result<usize> { + self.inner.do_io(|inner| (&*inner).write(buf)) + } + + fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> { + self.inner.do_io(|inner| (&*inner).write_vectored(bufs)) + } + + fn flush(&mut self) -> io::Result<()> { + self.inner.do_io(|inner| (&*inner).flush()) + } +} + +impl event::Source for UnixStream { + fn register( + &mut self, + registry: &Registry, + token: Token, + interests: Interest, + ) -> io::Result<()> { + self.inner.register(registry, token, interests) + } + + fn reregister( + &mut self, + registry: &Registry, + token: Token, + interests: Interest, + ) -> io::Result<()> { + self.inner.reregister(registry, token, interests) + } + + fn deregister(&mut self, registry: &Registry) -> io::Result<()> { + self.inner.deregister(registry) + } +} + +impl fmt::Debug for UnixStream { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.inner.fmt(f) + } +} + +impl IntoRawFd for UnixStream { + fn into_raw_fd(self) -> RawFd { + self.inner.into_inner().into_raw_fd() + } +} + +impl AsRawFd for UnixStream { + fn as_raw_fd(&self) -> RawFd { + self.inner.as_raw_fd() + } +} + +impl FromRawFd for UnixStream { + /// Converts a `RawFd` to a `UnixStream`. + /// + /// # Notes + /// + /// The caller is responsible for ensuring that the socket is in + /// non-blocking mode. + unsafe fn from_raw_fd(fd: RawFd) -> UnixStream { + UnixStream::from_std(FromRawFd::from_raw_fd(fd)) + } +} diff --git a/third_party/rust/mio/src/poll.rs b/third_party/rust/mio/src/poll.rs new file mode 100644 index 0000000000..fd643fdd00 --- /dev/null +++ b/third_party/rust/mio/src/poll.rs @@ -0,0 +1,682 @@ +use crate::{event, sys, Events, Interest, Token}; +use log::trace; +#[cfg(unix)] +use std::os::unix::io::{AsRawFd, RawFd}; +use std::time::Duration; +use std::{fmt, io}; + +/// Polls for readiness events on all registered values. +/// +/// `Poll` allows a program to monitor a large number of [`event::Source`]s, +/// waiting until one or more become "ready" for some class of operations; e.g. +/// reading and writing. An event source is considered ready if it is possible +/// to immediately perform a corresponding operation; e.g. [`read`] or +/// [`write`]. +/// +/// To use `Poll`, an `event::Source` must first be registered with the `Poll` +/// instance using the [`register`] method on its associated `Register`, +/// supplying readiness interest. The readiness interest tells `Poll` which +/// specific operations on the handle to monitor for readiness. A `Token` is +/// also passed to the [`register`] function. When `Poll` returns a readiness +/// event, it will include this token. This associates the event with the +/// event source that generated the event. +/// +/// [`event::Source`]: ./event/trait.Source.html +/// [`read`]: ./net/struct.TcpStream.html#method.read +/// [`write`]: ./net/struct.TcpStream.html#method.write +/// [`register`]: struct.Registry.html#method.register +/// +/// # Examples +/// +/// A basic example -- establishing a `TcpStream` connection. +/// +#[cfg_attr(all(feature = "os-poll", feature = "net"), doc = "```")] +#[cfg_attr(not(all(feature = "os-poll", feature = "net")), doc = "```ignore")] +/// # use std::error::Error; +/// # fn main() -> Result<(), Box<dyn Error>> { +/// use mio::{Events, Poll, Interest, Token}; +/// use mio::net::TcpStream; +/// +/// use std::net::{self, SocketAddr}; +/// +/// // Bind a server socket to connect to. +/// let addr: SocketAddr = "127.0.0.1:0".parse()?; +/// let server = net::TcpListener::bind(addr)?; +/// +/// // Construct a new `Poll` handle as well as the `Events` we'll store into +/// let mut poll = Poll::new()?; +/// let mut events = Events::with_capacity(1024); +/// +/// // Connect the stream +/// let mut stream = TcpStream::connect(server.local_addr()?)?; +/// +/// // Register the stream with `Poll` +/// poll.registry().register(&mut stream, Token(0), Interest::READABLE | Interest::WRITABLE)?; +/// +/// // Wait for the socket to become ready. This has to happens in a loop to +/// // handle spurious wakeups. +/// loop { +/// poll.poll(&mut events, None)?; +/// +/// for event in &events { +/// if event.token() == Token(0) && event.is_writable() { +/// // The socket connected (probably, it could still be a spurious +/// // wakeup) +/// return Ok(()); +/// } +/// } +/// } +/// # } +/// ``` +/// +/// # Portability +/// +/// Using `Poll` provides a portable interface across supported platforms as +/// long as the caller takes the following into consideration: +/// +/// ### Spurious events +/// +/// [`Poll::poll`] may return readiness events even if the associated +/// event source is not actually ready. Given the same code, this may +/// happen more on some platforms than others. It is important to never assume +/// that, just because a readiness event was received, that the associated +/// operation will succeed as well. +/// +/// If operation fails with [`WouldBlock`], then the caller should not treat +/// this as an error, but instead should wait until another readiness event is +/// received. +/// +/// ### Draining readiness +/// +/// Once a readiness event is received, the corresponding operation must be +/// performed repeatedly until it returns [`WouldBlock`]. Unless this is done, +/// there is no guarantee that another readiness event will be delivered, even +/// if further data is received for the event source. +/// +/// [`WouldBlock`]: std::io::ErrorKind::WouldBlock +/// +/// ### Readiness operations +/// +/// The only readiness operations that are guaranteed to be present on all +/// supported platforms are [`readable`] and [`writable`]. All other readiness +/// operations may have false negatives and as such should be considered +/// **hints**. This means that if a socket is registered with [`readable`] +/// interest and either an error or close is received, a readiness event will +/// be generated for the socket, but it **may** only include `readable` +/// readiness. Also note that, given the potential for spurious events, +/// receiving a readiness event with `read_closed`, `write_closed`, or `error` +/// doesn't actually mean that a `read` on the socket will return a result +/// matching the readiness event. +/// +/// In other words, portable programs that explicitly check for [`read_closed`], +/// [`write_closed`], or [`error`] readiness should be doing so as an +/// **optimization** and always be able to handle an error or close situation +/// when performing the actual read operation. +/// +/// [`readable`]: ./event/struct.Event.html#method.is_readable +/// [`writable`]: ./event/struct.Event.html#method.is_writable +/// [`error`]: ./event/struct.Event.html#method.is_error +/// [`read_closed`]: ./event/struct.Event.html#method.is_read_closed +/// [`write_closed`]: ./event/struct.Event.html#method.is_write_closed +/// +/// ### Registering handles +/// +/// Unless otherwise noted, it should be assumed that types implementing +/// [`event::Source`] will never become ready unless they are registered with +/// `Poll`. +/// +/// For example: +/// +#[cfg_attr(all(feature = "os-poll", feature = "net"), doc = "```")] +#[cfg_attr(not(all(feature = "os-poll", feature = "net")), doc = "```ignore")] +/// # use std::error::Error; +/// # use std::net; +/// # fn main() -> Result<(), Box<dyn Error>> { +/// use mio::{Poll, Interest, Token}; +/// use mio::net::TcpStream; +/// use std::net::SocketAddr; +/// use std::time::Duration; +/// use std::thread; +/// +/// let address: SocketAddr = "127.0.0.1:0".parse()?; +/// let listener = net::TcpListener::bind(address)?; +/// let mut sock = TcpStream::connect(listener.local_addr()?)?; +/// +/// thread::sleep(Duration::from_secs(1)); +/// +/// let poll = Poll::new()?; +/// +/// // The connect is not guaranteed to have started until it is registered at +/// // this point +/// poll.registry().register(&mut sock, Token(0), Interest::READABLE | Interest::WRITABLE)?; +/// # Ok(()) +/// # } +/// ``` +/// +/// ### Dropping `Poll` +/// +/// When the `Poll` instance is dropped it may cancel in-flight operations for +/// the registered [event sources], meaning that no further events for them may +/// be received. It also means operations on the registered event sources may no +/// longer work. It is up to the user to keep the `Poll` instance alive while +/// registered event sources are being used. +/// +/// [event sources]: ./event/trait.Source.html +/// +/// ### Accessing raw fd/socket/handle +/// +/// Mio makes it possible for many types to be converted into a raw file +/// descriptor (fd, Unix), socket (Windows) or handle (Windows). This makes it +/// possible to support more operations on the type than Mio supports, for +/// example it makes [mio-aio] possible. However accessing the raw fd is not +/// without it's pitfalls. +/// +/// Specifically performing I/O operations outside of Mio on these types (via +/// the raw fd) has unspecified behaviour. It could cause no more events to be +/// generated for the type even though it returned `WouldBlock` (in an operation +/// directly accessing the fd). The behaviour is OS specific and Mio can only +/// guarantee cross-platform behaviour if it can control the I/O. +/// +/// [mio-aio]: https://github.com/asomers/mio-aio +/// +/// *The following is **not** guaranteed, just a description of the current +/// situation!* Mio is allowed to change the following without it being considered +/// a breaking change, don't depend on this, it's just here to inform the user. +/// Currently the kqueue and epoll implementation support direct I/O operations +/// on the fd without Mio's knowledge. Windows however needs **all** I/O +/// operations to go through Mio otherwise it is not able to update it's +/// internal state properly and won't generate events. +/// +/// # Implementation notes +/// +/// `Poll` is backed by the selector provided by the operating system. +/// +/// | OS | Selector | +/// |---------------|-----------| +/// | Android | [epoll] | +/// | DragonFly BSD | [kqueue] | +/// | FreeBSD | [kqueue] | +/// | iOS | [kqueue] | +/// | illumos | [epoll] | +/// | Linux | [epoll] | +/// | NetBSD | [kqueue] | +/// | OpenBSD | [kqueue] | +/// | Windows | [IOCP] | +/// | macOS | [kqueue] | +/// +/// On all supported platforms, socket operations are handled by using the +/// system selector. Platform specific extensions (e.g. [`SourceFd`]) allow +/// accessing other features provided by individual system selectors. For +/// example, Linux's [`signalfd`] feature can be used by registering the FD with +/// `Poll` via [`SourceFd`]. +/// +/// On all platforms except windows, a call to [`Poll::poll`] is mostly just a +/// direct call to the system selector. However, [IOCP] uses a completion model +/// instead of a readiness model. In this case, `Poll` must adapt the completion +/// model Mio's API. While non-trivial, the bridge layer is still quite +/// efficient. The most expensive part being calls to `read` and `write` require +/// data to be copied into an intermediate buffer before it is passed to the +/// kernel. +/// +/// [epoll]: http://man7.org/linux/man-pages/man7/epoll.7.html +/// [kqueue]: https://www.freebsd.org/cgi/man.cgi?query=kqueue&sektion=2 +/// [IOCP]: https://msdn.microsoft.com/en-us/library/windows/desktop/aa365198(v=vs.85).aspx +/// [`signalfd`]: http://man7.org/linux/man-pages/man2/signalfd.2.html +/// [`SourceFd`]: unix/struct.SourceFd.html +/// [`Poll::poll`]: struct.Poll.html#method.poll +pub struct Poll { + registry: Registry, +} + +/// Registers I/O resources. +pub struct Registry { + selector: sys::Selector, +} + +impl Poll { + /// Create a separate `Registry` which can be used to register + /// `event::Source`s. + pub fn registry(&self) -> &Registry { + &self.registry + } + + /// Wait for readiness events + /// + /// Blocks the current thread and waits for readiness events for any of the + /// [`event::Source`]s that have been registered with this `Poll` instance. + /// The function will block until either at least one readiness event has + /// been received or `timeout` has elapsed. A `timeout` of `None` means that + /// `poll` will block until a readiness event has been received. + /// + /// The supplied `events` will be cleared and newly received readiness events + /// will be pushed onto the end. At most `events.capacity()` events will be + /// returned. If there are further pending readiness events, they will be + /// returned on the next call to `poll`. + /// + /// A single call to `poll` may result in multiple readiness events being + /// returned for a single event source. For example, if a TCP socket becomes + /// both readable and writable, it may be possible for a single readiness + /// event to be returned with both [`readable`] and [`writable`] readiness + /// **OR** two separate events may be returned, one with [`readable`] set + /// and one with [`writable`] set. + /// + /// Note that the `timeout` will be rounded up to the system clock + /// granularity (usually 1ms), and kernel scheduling delays mean that + /// the blocking interval may be overrun by a small amount. + /// + /// See the [struct] level documentation for a higher level discussion of + /// polling. + /// + /// [`event::Source`]: ./event/trait.Source.html + /// [`readable`]: struct.Interest.html#associatedconstant.READABLE + /// [`writable`]: struct.Interest.html#associatedconstant.WRITABLE + /// [struct]: struct.Poll.html + /// [`iter`]: ./event/struct.Events.html#method.iter + /// + /// # Notes + /// + /// This returns any errors without attempting to retry, previous versions + /// of Mio would automatically retry the poll call if it was interrupted + /// (if `EINTR` was returned). + /// + /// # Examples + /// + /// A basic example -- establishing a `TcpStream` connection. + /// + #[cfg_attr(all(feature = "os-poll", feature = "net"), doc = "```")] + #[cfg_attr(not(all(feature = "os-poll", feature = "net")), doc = "```ignore")] + /// # use std::error::Error; + /// # fn main() -> Result<(), Box<dyn Error>> { + /// use mio::{Events, Poll, Interest, Token}; + /// use mio::net::TcpStream; + /// + /// use std::net::{TcpListener, SocketAddr}; + /// use std::thread; + /// + /// // Bind a server socket to connect to. + /// let addr: SocketAddr = "127.0.0.1:0".parse()?; + /// let server = TcpListener::bind(addr)?; + /// let addr = server.local_addr()?.clone(); + /// + /// // Spawn a thread to accept the socket + /// thread::spawn(move || { + /// let _ = server.accept(); + /// }); + /// + /// // Construct a new `Poll` handle as well as the `Events` we'll store into + /// let mut poll = Poll::new()?; + /// let mut events = Events::with_capacity(1024); + /// + /// // Connect the stream + /// let mut stream = TcpStream::connect(addr)?; + /// + /// // Register the stream with `Poll` + /// poll.registry().register( + /// &mut stream, + /// Token(0), + /// Interest::READABLE | Interest::WRITABLE)?; + /// + /// // Wait for the socket to become ready. This has to happens in a loop to + /// // handle spurious wakeups. + /// loop { + /// poll.poll(&mut events, None)?; + /// + /// for event in &events { + /// if event.token() == Token(0) && event.is_writable() { + /// // The socket connected (probably, it could still be a spurious + /// // wakeup) + /// return Ok(()); + /// } + /// } + /// } + /// # } + /// ``` + /// + /// [struct]: # + pub fn poll(&mut self, events: &mut Events, timeout: Option<Duration>) -> io::Result<()> { + self.registry.selector.select(events.sys(), timeout) + } +} + +cfg_os_poll! { + impl Poll { + /// Return a new `Poll` handle. + /// + /// This function will make a syscall to the operating system to create + /// the system selector. If this syscall fails, `Poll::new` will return + /// with the error. + /// + /// See [struct] level docs for more details. + /// + /// [struct]: struct.Poll.html + /// + /// # Examples + /// + /// ``` + /// # use std::error::Error; + /// # fn main() -> Result<(), Box<dyn Error>> { + /// use mio::{Poll, Events}; + /// use std::time::Duration; + /// + /// let mut poll = match Poll::new() { + /// Ok(poll) => poll, + /// Err(e) => panic!("failed to create Poll instance; err={:?}", e), + /// }; + /// + /// // Create a structure to receive polled events + /// let mut events = Events::with_capacity(1024); + /// + /// // Wait for events, but none will be received because no + /// // `event::Source`s have been registered with this `Poll` instance. + /// poll.poll(&mut events, Some(Duration::from_millis(500)))?; + /// assert!(events.is_empty()); + /// # Ok(()) + /// # } + /// ``` + pub fn new() -> io::Result<Poll> { + sys::Selector::new().map(|selector| Poll { + registry: Registry { selector }, + }) + } + } +} + +#[cfg(unix)] +impl AsRawFd for Poll { + fn as_raw_fd(&self) -> RawFd { + self.registry.as_raw_fd() + } +} + +impl fmt::Debug for Poll { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt.debug_struct("Poll").finish() + } +} + +impl Registry { + /// Register an [`event::Source`] with the `Poll` instance. + /// + /// Once registered, the `Poll` instance will monitor the event source for + /// readiness state changes. When it notices a state change, it will return + /// a readiness event for the handle the next time [`poll`] is called. + /// + /// See [`Poll`] docs for a high level overview. + /// + /// # Arguments + /// + /// `source: &mut S: event::Source`: This is the source of events that the + /// `Poll` instance should monitor for readiness state changes. + /// + /// `token: Token`: The caller picks a token to associate with the socket. + /// When [`poll`] returns an event for the handle, this token is included. + /// This allows the caller to map the event to its source. The token + /// associated with the `event::Source` can be changed at any time by + /// calling [`reregister`]. + /// + /// See documentation on [`Token`] for an example showing how to pick + /// [`Token`] values. + /// + /// `interest: Interest`: Specifies which operations `Poll` should monitor + /// for readiness. `Poll` will only return readiness events for operations + /// specified by this argument. + /// + /// If a socket is registered with readable interest and the socket becomes + /// writable, no event will be returned from [`poll`]. + /// + /// The readiness interest for an `event::Source` can be changed at any time + /// by calling [`reregister`]. + /// + /// # Notes + /// + /// Callers must ensure that if a source being registered with a `Poll` + /// instance was previously registered with that `Poll` instance, then a + /// call to [`deregister`] has already occurred. Consecutive calls to + /// `register` is unspecified behavior. + /// + /// Unless otherwise specified, the caller should assume that once an event + /// source is registered with a `Poll` instance, it is bound to that `Poll` + /// instance for the lifetime of the event source. This remains true even + /// if the event source is deregistered from the poll instance using + /// [`deregister`]. + /// + /// [`event::Source`]: ./event/trait.Source.html + /// [`poll`]: struct.Poll.html#method.poll + /// [`reregister`]: struct.Registry.html#method.reregister + /// [`deregister`]: struct.Registry.html#method.deregister + /// [`Token`]: struct.Token.html + /// + /// # Examples + /// + #[cfg_attr(all(feature = "os-poll", feature = "net"), doc = "```")] + #[cfg_attr(not(all(feature = "os-poll", feature = "net")), doc = "```ignore")] + /// # use std::error::Error; + /// # use std::net; + /// # fn main() -> Result<(), Box<dyn Error>> { + /// use mio::{Events, Poll, Interest, Token}; + /// use mio::net::TcpStream; + /// use std::net::SocketAddr; + /// use std::time::{Duration, Instant}; + /// + /// let mut poll = Poll::new()?; + /// + /// let address: SocketAddr = "127.0.0.1:0".parse()?; + /// let listener = net::TcpListener::bind(address)?; + /// let mut socket = TcpStream::connect(listener.local_addr()?)?; + /// + /// // Register the socket with `poll` + /// poll.registry().register( + /// &mut socket, + /// Token(0), + /// Interest::READABLE | Interest::WRITABLE)?; + /// + /// let mut events = Events::with_capacity(1024); + /// let start = Instant::now(); + /// let timeout = Duration::from_millis(500); + /// + /// loop { + /// let elapsed = start.elapsed(); + /// + /// if elapsed >= timeout { + /// // Connection timed out + /// return Ok(()); + /// } + /// + /// let remaining = timeout - elapsed; + /// poll.poll(&mut events, Some(remaining))?; + /// + /// for event in &events { + /// if event.token() == Token(0) { + /// // Something (probably) happened on the socket. + /// return Ok(()); + /// } + /// } + /// } + /// # } + /// ``` + pub fn register<S>(&self, source: &mut S, token: Token, interests: Interest) -> io::Result<()> + where + S: event::Source + ?Sized, + { + trace!( + "registering event source with poller: token={:?}, interests={:?}", + token, + interests + ); + source.register(self, token, interests) + } + + /// Re-register an [`event::Source`] with the `Poll` instance. + /// + /// Re-registering an event source allows changing the details of the + /// registration. Specifically, it allows updating the associated `token` + /// and `interests` specified in previous `register` and `reregister` calls. + /// + /// The `reregister` arguments fully override the previous values. In other + /// words, if a socket is registered with [`readable`] interest and the call + /// to `reregister` specifies [`writable`], then read interest is no longer + /// requested for the handle. + /// + /// The event source must have previously been registered with this instance + /// of `Poll`, otherwise the behavior is unspecified. + /// + /// See the [`register`] documentation for details about the function + /// arguments and see the [`struct`] docs for a high level overview of + /// polling. + /// + /// # Examples + /// + #[cfg_attr(all(feature = "os-poll", feature = "net"), doc = "```")] + #[cfg_attr(not(all(feature = "os-poll", feature = "net")), doc = "```ignore")] + /// # use std::error::Error; + /// # use std::net; + /// # fn main() -> Result<(), Box<dyn Error>> { + /// use mio::{Poll, Interest, Token}; + /// use mio::net::TcpStream; + /// use std::net::SocketAddr; + /// + /// let poll = Poll::new()?; + /// + /// let address: SocketAddr = "127.0.0.1:0".parse()?; + /// let listener = net::TcpListener::bind(address)?; + /// let mut socket = TcpStream::connect(listener.local_addr()?)?; + /// + /// // Register the socket with `poll`, requesting readable + /// poll.registry().register( + /// &mut socket, + /// Token(0), + /// Interest::READABLE)?; + /// + /// // Reregister the socket specifying write interest instead. Even though + /// // the token is the same it must be specified. + /// poll.registry().reregister( + /// &mut socket, + /// Token(0), + /// Interest::WRITABLE)?; + /// # Ok(()) + /// # } + /// ``` + /// + /// [`event::Source`]: ./event/trait.Source.html + /// [`struct`]: struct.Poll.html + /// [`register`]: struct.Registry.html#method.register + /// [`readable`]: ./event/struct.Event.html#is_readable + /// [`writable`]: ./event/struct.Event.html#is_writable + pub fn reregister<S>(&self, source: &mut S, token: Token, interests: Interest) -> io::Result<()> + where + S: event::Source + ?Sized, + { + trace!( + "reregistering event source with poller: token={:?}, interests={:?}", + token, + interests + ); + source.reregister(self, token, interests) + } + + /// Deregister an [`event::Source`] with the `Poll` instance. + /// + /// When an event source is deregistered, the `Poll` instance will no longer + /// monitor it for readiness state changes. Deregistering clears up any + /// internal resources needed to track the handle. After an explicit call + /// to this method completes, it is guaranteed that the token previously + /// registered to this handle will not be returned by a future poll, so long + /// as a happens-before relationship is established between this call and + /// the poll. + /// + /// The event source must have previously been registered with this instance + /// of `Poll`, otherwise the behavior is unspecified. + /// + /// A handle can be passed back to `register` after it has been + /// deregistered; however, it must be passed back to the **same** `Poll` + /// instance, otherwise the behavior is unspecified. + /// + /// # Examples + /// + #[cfg_attr(all(feature = "os-poll", feature = "net"), doc = "```")] + #[cfg_attr(not(all(feature = "os-poll", feature = "net")), doc = "```ignore")] + /// # use std::error::Error; + /// # use std::net; + /// # fn main() -> Result<(), Box<dyn Error>> { + /// use mio::{Events, Poll, Interest, Token}; + /// use mio::net::TcpStream; + /// use std::net::SocketAddr; + /// use std::time::Duration; + /// + /// let mut poll = Poll::new()?; + /// + /// let address: SocketAddr = "127.0.0.1:0".parse()?; + /// let listener = net::TcpListener::bind(address)?; + /// let mut socket = TcpStream::connect(listener.local_addr()?)?; + /// + /// // Register the socket with `poll` + /// poll.registry().register( + /// &mut socket, + /// Token(0), + /// Interest::READABLE)?; + /// + /// poll.registry().deregister(&mut socket)?; + /// + /// let mut events = Events::with_capacity(1024); + /// + /// // Set a timeout because this poll should never receive any events. + /// poll.poll(&mut events, Some(Duration::from_secs(1)))?; + /// assert!(events.is_empty()); + /// # Ok(()) + /// # } + /// ``` + pub fn deregister<S>(&self, source: &mut S) -> io::Result<()> + where + S: event::Source + ?Sized, + { + trace!("deregistering event source from poller"); + source.deregister(self) + } + + /// Creates a new independently owned `Registry`. + /// + /// Event sources registered with this `Registry` will be registered with + /// the original `Registry` and `Poll` instance. + pub fn try_clone(&self) -> io::Result<Registry> { + self.selector + .try_clone() + .map(|selector| Registry { selector }) + } + + /// Internal check to ensure only a single `Waker` is active per [`Poll`] + /// instance. + #[cfg(debug_assertions)] + pub(crate) fn register_waker(&self) { + assert!( + !self.selector.register_waker(), + "Only a single `Waker` can be active per `Poll` instance" + ); + } + + /// Get access to the `sys::Selector`. + pub(crate) fn selector(&self) -> &sys::Selector { + &self.selector + } +} + +impl fmt::Debug for Registry { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt.debug_struct("Registry").finish() + } +} + +#[cfg(unix)] +impl AsRawFd for Registry { + fn as_raw_fd(&self) -> RawFd { + self.selector.as_raw_fd() + } +} + +cfg_os_poll! { + #[cfg(unix)] + #[test] + pub fn as_raw_fd() { + let poll = Poll::new().unwrap(); + assert!(poll.as_raw_fd() > 0); + } +} diff --git a/third_party/rust/mio/src/sys/mod.rs b/third_party/rust/mio/src/sys/mod.rs new file mode 100644 index 0000000000..81ae6d2e61 --- /dev/null +++ b/third_party/rust/mio/src/sys/mod.rs @@ -0,0 +1,80 @@ +//! Module with system specific types. +//! +//! Required types: +//! +//! * `Event`: a type alias for the system specific event, e.g. `kevent` or +//! `epoll_event`. +//! * `event`: a module with various helper functions for `Event`, see +//! [`crate::event::Event`] for the required functions. +//! * `Events`: collection of `Event`s, see [`crate::Events`]. +//! * `IoSourceState`: state for the `IoSource` type. +//! * `Selector`: selector used to register event sources and poll for events, +//! see [`crate::Poll`] and [`crate::Registry`] for required +//! methods. +//! * `tcp` and `udp` modules: see the [`crate::net`] module. +//! * `Waker`: see [`crate::Waker`]. + +cfg_os_poll! { + macro_rules! debug_detail { + ( + $type: ident ($event_type: ty), $test: path, + $($(#[$target: meta])* $libc: ident :: $flag: ident),+ $(,)* + ) => { + struct $type($event_type); + + impl fmt::Debug for $type { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let mut written_one = false; + $( + $(#[$target])* + #[allow(clippy::bad_bit_mask)] // Apparently some flags are zero. + { + // Windows doesn't use `libc` but the `afd` module. + if $test(&self.0, &$libc :: $flag) { + if !written_one { + write!(f, "{}", stringify!($flag))?; + written_one = true; + } else { + write!(f, "|{}", stringify!($flag))?; + } + } + } + )+ + if !written_one { + write!(f, "(empty)") + } else { + Ok(()) + } + } + } + }; + } +} + +#[cfg(unix)] +cfg_os_poll! { + mod unix; + pub use self::unix::*; +} + +#[cfg(windows)] +cfg_os_poll! { + mod windows; + pub use self::windows::*; +} + +cfg_not_os_poll! { + mod shell; + pub(crate) use self::shell::*; + + #[cfg(unix)] + cfg_any_os_ext! { + mod unix; + pub use self::unix::SourceFd; + } + + #[cfg(unix)] + cfg_net! { + pub use self::unix::SocketAddr; + } +} diff --git a/third_party/rust/mio/src/sys/shell/mod.rs b/third_party/rust/mio/src/sys/shell/mod.rs new file mode 100644 index 0000000000..7e1533f452 --- /dev/null +++ b/third_party/rust/mio/src/sys/shell/mod.rs @@ -0,0 +1,70 @@ +macro_rules! os_required { + () => { + panic!("mio must be compiled with `os-poll` to run.") + }; +} + +mod selector; +pub(crate) use self::selector::{event, Event, Events, Selector}; + +mod waker; +pub(crate) use self::waker::Waker; + +cfg_net! { + pub(crate) mod tcp; + pub(crate) mod udp; + #[cfg(unix)] + pub(crate) mod uds; +} + +cfg_io_source! { + use std::io; + #[cfg(windows)] + use std::os::windows::io::RawSocket; + + #[cfg(windows)] + use crate::{Registry, Token, Interest}; + + pub(crate) struct IoSourceState; + + impl IoSourceState { + pub fn new() -> IoSourceState { + IoSourceState + } + + pub fn do_io<T, F, R>(&self, f: F, io: &T) -> io::Result<R> + where + F: FnOnce(&T) -> io::Result<R>, + { + // We don't hold state, so we can just call the function and + // return. + f(io) + } + } + + #[cfg(windows)] + impl IoSourceState { + pub fn register( + &mut self, + _: &Registry, + _: Token, + _: Interest, + _: RawSocket, + ) -> io::Result<()> { + os_required!() + } + + pub fn reregister( + &mut self, + _: &Registry, + _: Token, + _: Interest, + ) -> io::Result<()> { + os_required!() + } + + pub fn deregister(&mut self) -> io::Result<()> { + os_required!() + } + } +} diff --git a/third_party/rust/mio/src/sys/shell/selector.rs b/third_party/rust/mio/src/sys/shell/selector.rs new file mode 100644 index 0000000000..91fc0bf47c --- /dev/null +++ b/third_party/rust/mio/src/sys/shell/selector.rs @@ -0,0 +1,108 @@ +use std::io; +#[cfg(unix)] +use std::os::unix::io::{AsRawFd, RawFd}; +use std::time::Duration; + +pub type Event = usize; + +pub type Events = Vec<Event>; + +#[derive(Debug)] +pub struct Selector {} + +impl Selector { + pub fn try_clone(&self) -> io::Result<Selector> { + os_required!(); + } + + pub fn select(&self, _: &mut Events, _: Option<Duration>) -> io::Result<()> { + os_required!(); + } + + #[cfg(debug_assertions)] + pub fn register_waker(&self) -> bool { + os_required!(); + } +} + +#[cfg(unix)] +cfg_any_os_ext! { + use crate::{Interest, Token}; + + impl Selector { + pub fn register(&self, _: RawFd, _: Token, _: Interest) -> io::Result<()> { + os_required!(); + } + + pub fn reregister(&self, _: RawFd, _: Token, _: Interest) -> io::Result<()> { + os_required!(); + } + + pub fn deregister(&self, _: RawFd) -> io::Result<()> { + os_required!(); + } + } +} + +cfg_io_source! { + #[cfg(debug_assertions)] + impl Selector { + pub fn id(&self) -> usize { + os_required!(); + } + } +} + +#[cfg(unix)] +impl AsRawFd for Selector { + fn as_raw_fd(&self) -> RawFd { + os_required!() + } +} + +#[allow(clippy::trivially_copy_pass_by_ref)] +pub mod event { + use crate::sys::Event; + use crate::Token; + use std::fmt; + + pub fn token(_: &Event) -> Token { + os_required!(); + } + + pub fn is_readable(_: &Event) -> bool { + os_required!(); + } + + pub fn is_writable(_: &Event) -> bool { + os_required!(); + } + + pub fn is_error(_: &Event) -> bool { + os_required!(); + } + + pub fn is_read_closed(_: &Event) -> bool { + os_required!(); + } + + pub fn is_write_closed(_: &Event) -> bool { + os_required!(); + } + + pub fn is_priority(_: &Event) -> bool { + os_required!(); + } + + pub fn is_aio(_: &Event) -> bool { + os_required!(); + } + + pub fn is_lio(_: &Event) -> bool { + os_required!(); + } + + pub fn debug_details(_: &mut fmt::Formatter<'_>, _: &Event) -> fmt::Result { + os_required!(); + } +} diff --git a/third_party/rust/mio/src/sys/shell/tcp.rs b/third_party/rust/mio/src/sys/shell/tcp.rs new file mode 100644 index 0000000000..60dfe70f67 --- /dev/null +++ b/third_party/rust/mio/src/sys/shell/tcp.rs @@ -0,0 +1,27 @@ +use std::io; +use std::net::{self, SocketAddr}; + +pub(crate) fn new_for_addr(_: SocketAddr) -> io::Result<i32> { + os_required!(); +} + +pub(crate) fn bind(_: &net::TcpListener, _: SocketAddr) -> io::Result<()> { + os_required!(); +} + +pub(crate) fn connect(_: &net::TcpStream, _: SocketAddr) -> io::Result<()> { + os_required!(); +} + +pub(crate) fn listen(_: &net::TcpListener, _: u32) -> io::Result<()> { + os_required!(); +} + +#[cfg(unix)] +pub(crate) fn set_reuseaddr(_: &net::TcpListener, _: bool) -> io::Result<()> { + os_required!(); +} + +pub(crate) fn accept(_: &net::TcpListener) -> io::Result<(net::TcpStream, SocketAddr)> { + os_required!(); +} diff --git a/third_party/rust/mio/src/sys/shell/udp.rs b/third_party/rust/mio/src/sys/shell/udp.rs new file mode 100644 index 0000000000..48ccac740f --- /dev/null +++ b/third_party/rust/mio/src/sys/shell/udp.rs @@ -0,0 +1,10 @@ +use std::io; +use std::net::{self, SocketAddr}; + +pub fn bind(_: SocketAddr) -> io::Result<net::UdpSocket> { + os_required!() +} + +pub(crate) fn only_v6(_: &net::UdpSocket) -> io::Result<bool> { + os_required!() +} diff --git a/third_party/rust/mio/src/sys/shell/uds.rs b/third_party/rust/mio/src/sys/shell/uds.rs new file mode 100644 index 0000000000..c18aca042f --- /dev/null +++ b/third_party/rust/mio/src/sys/shell/uds.rs @@ -0,0 +1,75 @@ +pub(crate) mod datagram { + use crate::net::SocketAddr; + use std::io; + use std::os::unix::net; + use std::path::Path; + + pub(crate) fn bind(_: &Path) -> io::Result<net::UnixDatagram> { + os_required!() + } + + pub(crate) fn unbound() -> io::Result<net::UnixDatagram> { + os_required!() + } + + pub(crate) fn pair() -> io::Result<(net::UnixDatagram, net::UnixDatagram)> { + os_required!() + } + + pub(crate) fn local_addr(_: &net::UnixDatagram) -> io::Result<SocketAddr> { + os_required!() + } + + pub(crate) fn peer_addr(_: &net::UnixDatagram) -> io::Result<SocketAddr> { + os_required!() + } + + pub(crate) fn recv_from( + _: &net::UnixDatagram, + _: &mut [u8], + ) -> io::Result<(usize, SocketAddr)> { + os_required!() + } +} + +pub(crate) mod listener { + use crate::net::{SocketAddr, UnixStream}; + use std::io; + use std::os::unix::net; + use std::path::Path; + + pub(crate) fn bind(_: &Path) -> io::Result<net::UnixListener> { + os_required!() + } + + pub(crate) fn accept(_: &net::UnixListener) -> io::Result<(UnixStream, SocketAddr)> { + os_required!() + } + + pub(crate) fn local_addr(_: &net::UnixListener) -> io::Result<SocketAddr> { + os_required!() + } +} + +pub(crate) mod stream { + use crate::net::SocketAddr; + use std::io; + use std::os::unix::net; + use std::path::Path; + + pub(crate) fn connect(_: &Path) -> io::Result<net::UnixStream> { + os_required!() + } + + pub(crate) fn pair() -> io::Result<(net::UnixStream, net::UnixStream)> { + os_required!() + } + + pub(crate) fn local_addr(_: &net::UnixStream) -> io::Result<SocketAddr> { + os_required!() + } + + pub(crate) fn peer_addr(_: &net::UnixStream) -> io::Result<SocketAddr> { + os_required!() + } +} diff --git a/third_party/rust/mio/src/sys/shell/waker.rs b/third_party/rust/mio/src/sys/shell/waker.rs new file mode 100644 index 0000000000..bbdd7c33af --- /dev/null +++ b/third_party/rust/mio/src/sys/shell/waker.rs @@ -0,0 +1,16 @@ +use crate::sys::Selector; +use crate::Token; +use std::io; + +#[derive(Debug)] +pub struct Waker {} + +impl Waker { + pub fn new(_: &Selector, _: Token) -> io::Result<Waker> { + os_required!(); + } + + pub fn wake(&self) -> io::Result<()> { + os_required!(); + } +} diff --git a/third_party/rust/mio/src/sys/unix/mod.rs b/third_party/rust/mio/src/sys/unix/mod.rs new file mode 100644 index 0000000000..231480a5da --- /dev/null +++ b/third_party/rust/mio/src/sys/unix/mod.rs @@ -0,0 +1,72 @@ +/// Helper macro to execute a system call that returns an `io::Result`. +// +// Macro must be defined before any modules that uses them. +#[allow(unused_macros)] +macro_rules! syscall { + ($fn: ident ( $($arg: expr),* $(,)* ) ) => {{ + let res = unsafe { libc::$fn($($arg, )*) }; + if res == -1 { + Err(std::io::Error::last_os_error()) + } else { + Ok(res) + } + }}; +} + +cfg_os_poll! { + mod selector; + pub(crate) use self::selector::{event, Event, Events, Selector}; + + mod sourcefd; + pub use self::sourcefd::SourceFd; + + mod waker; + pub(crate) use self::waker::Waker; + + cfg_net! { + mod net; + + pub(crate) mod tcp; + pub(crate) mod udp; + pub(crate) mod uds; + pub use self::uds::SocketAddr; + } + + cfg_io_source! { + use std::io; + + // Both `kqueue` and `epoll` don't need to hold any user space state. + pub(crate) struct IoSourceState; + + impl IoSourceState { + pub fn new() -> IoSourceState { + IoSourceState + } + + pub fn do_io<T, F, R>(&self, f: F, io: &T) -> io::Result<R> + where + F: FnOnce(&T) -> io::Result<R>, + { + // We don't hold state, so we can just call the function and + // return. + f(io) + } + } + } + + cfg_os_ext! { + pub(crate) mod pipe; + } +} + +cfg_not_os_poll! { + cfg_net! { + mod uds; + pub use self::uds::SocketAddr; + } + + cfg_any_os_ext! { + mod sourcefd; + pub use self::sourcefd::SourceFd; + } +} diff --git a/third_party/rust/mio/src/sys/unix/net.rs b/third_party/rust/mio/src/sys/unix/net.rs new file mode 100644 index 0000000000..78f1387b1f --- /dev/null +++ b/third_party/rust/mio/src/sys/unix/net.rs @@ -0,0 +1,168 @@ +use std::io; +use std::mem::size_of; +use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6}; + +pub(crate) fn new_ip_socket(addr: SocketAddr, socket_type: libc::c_int) -> io::Result<libc::c_int> { + let domain = match addr { + SocketAddr::V4(..) => libc::AF_INET, + SocketAddr::V6(..) => libc::AF_INET6, + }; + + new_socket(domain, socket_type) +} + +/// Create a new non-blocking socket. +pub(crate) fn new_socket(domain: libc::c_int, socket_type: libc::c_int) -> io::Result<libc::c_int> { + #[cfg(any( + target_os = "android", + target_os = "dragonfly", + target_os = "freebsd", + target_os = "illumos", + target_os = "linux", + target_os = "netbsd", + target_os = "openbsd" + ))] + let socket_type = socket_type | libc::SOCK_NONBLOCK | libc::SOCK_CLOEXEC; + + // Gives a warning for platforms without SOCK_NONBLOCK. + #[allow(clippy::let_and_return)] + let socket = syscall!(socket(domain, socket_type, 0)); + + // Mimick `libstd` and set `SO_NOSIGPIPE` on apple systems. + #[cfg(target_vendor = "apple")] + let socket = socket.and_then(|socket| { + syscall!(setsockopt( + socket, + libc::SOL_SOCKET, + libc::SO_NOSIGPIPE, + &1 as *const libc::c_int as *const libc::c_void, + size_of::<libc::c_int>() as libc::socklen_t + )) + .map(|_| socket) + }); + + // Darwin doesn't have SOCK_NONBLOCK or SOCK_CLOEXEC. + #[cfg(any(target_os = "ios", target_os = "macos"))] + let socket = socket.and_then(|socket| { + // For platforms that don't support flags in socket, we need to + // set the flags ourselves. + syscall!(fcntl(socket, libc::F_SETFL, libc::O_NONBLOCK)) + .and_then(|_| syscall!(fcntl(socket, libc::F_SETFD, libc::FD_CLOEXEC)).map(|_| socket)) + .map_err(|e| { + // If either of the `fcntl` calls failed, ensure the socket is + // closed and return the error. + let _ = syscall!(close(socket)); + e + }) + }); + + socket +} + +/// A type with the same memory layout as `libc::sockaddr`. Used in converting Rust level +/// SocketAddr* types into their system representation. The benefit of this specific +/// type over using `libc::sockaddr_storage` is that this type is exactly as large as it +/// needs to be and not a lot larger. And it can be initialized cleaner from Rust. +#[repr(C)] +pub(crate) union SocketAddrCRepr { + v4: libc::sockaddr_in, + v6: libc::sockaddr_in6, +} + +impl SocketAddrCRepr { + pub(crate) fn as_ptr(&self) -> *const libc::sockaddr { + self as *const _ as *const libc::sockaddr + } +} + +/// Converts a Rust `SocketAddr` into the system representation. +pub(crate) fn socket_addr(addr: &SocketAddr) -> (SocketAddrCRepr, libc::socklen_t) { + match addr { + SocketAddr::V4(ref addr) => { + // `s_addr` is stored as BE on all machine and the array is in BE order. + // So the native endian conversion method is used so that it's never swapped. + let sin_addr = libc::in_addr { + s_addr: u32::from_ne_bytes(addr.ip().octets()), + }; + + let sockaddr_in = libc::sockaddr_in { + sin_family: libc::AF_INET as libc::sa_family_t, + sin_port: addr.port().to_be(), + sin_addr, + sin_zero: [0; 8], + #[cfg(any( + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos", + target_os = "netbsd", + target_os = "openbsd" + ))] + sin_len: 0, + }; + + let sockaddr = SocketAddrCRepr { v4: sockaddr_in }; + let socklen = size_of::<libc::sockaddr_in>() as libc::socklen_t; + (sockaddr, socklen) + } + SocketAddr::V6(ref addr) => { + let sockaddr_in6 = libc::sockaddr_in6 { + sin6_family: libc::AF_INET6 as libc::sa_family_t, + sin6_port: addr.port().to_be(), + sin6_addr: libc::in6_addr { + s6_addr: addr.ip().octets(), + }, + sin6_flowinfo: addr.flowinfo(), + sin6_scope_id: addr.scope_id(), + #[cfg(any( + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos", + target_os = "netbsd", + target_os = "openbsd" + ))] + sin6_len: 0, + #[cfg(target_os = "illumos")] + __sin6_src_id: 0, + }; + + let sockaddr = SocketAddrCRepr { v6: sockaddr_in6 }; + let socklen = size_of::<libc::sockaddr_in6>() as libc::socklen_t; + (sockaddr, socklen) + } + } +} + +/// Converts a `libc::sockaddr` compatible struct into a native Rust `SocketAddr`. +/// +/// # Safety +/// +/// `storage` must have the `ss_family` field correctly initialized. +/// `storage` must be initialised to a `sockaddr_in` or `sockaddr_in6`. +pub(crate) unsafe fn to_socket_addr( + storage: *const libc::sockaddr_storage, +) -> io::Result<SocketAddr> { + match (*storage).ss_family as libc::c_int { + libc::AF_INET => { + // Safety: if the ss_family field is AF_INET then storage must be a sockaddr_in. + let addr: &libc::sockaddr_in = &*(storage as *const libc::sockaddr_in); + let ip = Ipv4Addr::from(addr.sin_addr.s_addr.to_ne_bytes()); + let port = u16::from_be(addr.sin_port); + Ok(SocketAddr::V4(SocketAddrV4::new(ip, port))) + } + libc::AF_INET6 => { + // Safety: if the ss_family field is AF_INET6 then storage must be a sockaddr_in6. + let addr: &libc::sockaddr_in6 = &*(storage as *const libc::sockaddr_in6); + let ip = Ipv6Addr::from(addr.sin6_addr.s6_addr); + let port = u16::from_be(addr.sin6_port); + Ok(SocketAddr::V6(SocketAddrV6::new( + ip, + port, + addr.sin6_flowinfo, + addr.sin6_scope_id, + ))) + } + _ => Err(io::ErrorKind::InvalidInput.into()), + } +} diff --git a/third_party/rust/mio/src/sys/unix/pipe.rs b/third_party/rust/mio/src/sys/unix/pipe.rs new file mode 100644 index 0000000000..c899dfb2da --- /dev/null +++ b/third_party/rust/mio/src/sys/unix/pipe.rs @@ -0,0 +1,431 @@ +//! Unix pipe. +//! +//! See the [`new`] function for documentation. + +use std::fs::File; +use std::io::{self, IoSlice, IoSliceMut, Read, Write}; +use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; +use std::process::{ChildStderr, ChildStdin, ChildStdout}; + +use crate::io_source::IoSource; +use crate::{event, Interest, Registry, Token}; + +/// Create a new non-blocking Unix pipe. +/// +/// This is a wrapper around Unix's [`pipe(2)`] system call and can be used as +/// inter-process or thread communication channel. +/// +/// This channel may be created before forking the process and then one end used +/// in each process, e.g. the parent process has the sending end to send command +/// to the child process. +/// +/// [`pipe(2)`]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/pipe.html +/// +/// # Events +/// +/// The [`Sender`] can be registered with [`WRITABLE`] interest to receive +/// [writable events], the [`Receiver`] with [`READABLE`] interest. Once data is +/// written to the `Sender` the `Receiver` will receive an [readable event]. +/// +/// In addition to those events, events will also be generated if the other side +/// is dropped. To check if the `Sender` is dropped you'll need to check +/// [`is_read_closed`] on events for the `Receiver`, if it returns true the +/// `Sender` is dropped. On the `Sender` end check [`is_write_closed`], if it +/// returns true the `Receiver` was dropped. Also see the second example below. +/// +/// [`WRITABLE`]: Interest::WRITABLE +/// [writable events]: event::Event::is_writable +/// [`READABLE`]: Interest::READABLE +/// [readable event]: event::Event::is_readable +/// [`is_read_closed`]: event::Event::is_read_closed +/// [`is_write_closed`]: event::Event::is_write_closed +/// +/// # Deregistering +/// +/// Both `Sender` and `Receiver` will deregister themselves when dropped, +/// **iff** the file descriptors are not duplicated (via [`dup(2)`]). +/// +/// [`dup(2)`]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/dup.html +/// +/// # Examples +/// +/// Simple example that writes data into the sending end and read it from the +/// receiving end. +/// +/// ``` +/// use std::io::{self, Read, Write}; +/// +/// use mio::{Poll, Events, Interest, Token}; +/// use mio::unix::pipe; +/// +/// // Unique tokens for the two ends of the channel. +/// const PIPE_RECV: Token = Token(0); +/// const PIPE_SEND: Token = Token(1); +/// +/// # fn main() -> io::Result<()> { +/// // Create our `Poll` instance and the `Events` container. +/// let mut poll = Poll::new()?; +/// let mut events = Events::with_capacity(8); +/// +/// // Create a new pipe. +/// let (mut sender, mut receiver) = pipe::new()?; +/// +/// // Register both ends of the channel. +/// poll.registry().register(&mut receiver, PIPE_RECV, Interest::READABLE)?; +/// poll.registry().register(&mut sender, PIPE_SEND, Interest::WRITABLE)?; +/// +/// const MSG: &[u8; 11] = b"Hello world"; +/// +/// loop { +/// poll.poll(&mut events, None)?; +/// +/// for event in events.iter() { +/// match event.token() { +/// PIPE_SEND => sender.write(MSG) +/// .and_then(|n| if n != MSG.len() { +/// // We'll consider a short write an error in this +/// // example. NOTE: we can't use `write_all` with +/// // non-blocking I/O. +/// Err(io::ErrorKind::WriteZero.into()) +/// } else { +/// Ok(()) +/// })?, +/// PIPE_RECV => { +/// let mut buf = [0; 11]; +/// let n = receiver.read(&mut buf)?; +/// println!("received: {:?}", &buf[0..n]); +/// assert_eq!(n, MSG.len()); +/// assert_eq!(&buf, &*MSG); +/// return Ok(()); +/// }, +/// _ => unreachable!(), +/// } +/// } +/// } +/// # } +/// ``` +/// +/// Example that receives an event once the `Sender` is dropped. +/// +/// ``` +/// # use std::io; +/// # +/// # use mio::{Poll, Events, Interest, Token}; +/// # use mio::unix::pipe; +/// # +/// # const PIPE_RECV: Token = Token(0); +/// # const PIPE_SEND: Token = Token(1); +/// # +/// # fn main() -> io::Result<()> { +/// // Same setup as in the example above. +/// let mut poll = Poll::new()?; +/// let mut events = Events::with_capacity(8); +/// +/// let (mut sender, mut receiver) = pipe::new()?; +/// +/// poll.registry().register(&mut receiver, PIPE_RECV, Interest::READABLE)?; +/// poll.registry().register(&mut sender, PIPE_SEND, Interest::WRITABLE)?; +/// +/// // Drop the sender. +/// drop(sender); +/// +/// poll.poll(&mut events, None)?; +/// +/// for event in events.iter() { +/// match event.token() { +/// PIPE_RECV if event.is_read_closed() => { +/// // Detected that the sender was dropped. +/// println!("Sender dropped!"); +/// return Ok(()); +/// }, +/// _ => unreachable!(), +/// } +/// } +/// # unreachable!(); +/// # } +/// ``` +pub fn new() -> io::Result<(Sender, Receiver)> { + let mut fds: [RawFd; 2] = [-1, -1]; + + #[cfg(any( + target_os = "android", + target_os = "dragonfly", + target_os = "freebsd", + target_os = "linux", + target_os = "netbsd", + target_os = "openbsd", + target_os = "illumos", + ))] + unsafe { + if libc::pipe2(fds.as_mut_ptr(), libc::O_CLOEXEC | libc::O_NONBLOCK) != 0 { + return Err(io::Error::last_os_error()); + } + } + + #[cfg(any(target_os = "ios", target_os = "macos"))] + unsafe { + // For platforms that don't have `pipe2(2)` we need to manually set the + // correct flags on the file descriptor. + if libc::pipe(fds.as_mut_ptr()) != 0 { + return Err(io::Error::last_os_error()); + } + + for fd in &fds { + if libc::fcntl(*fd, libc::F_SETFL, libc::O_NONBLOCK) != 0 + || libc::fcntl(*fd, libc::F_SETFD, libc::FD_CLOEXEC) != 0 + { + let err = io::Error::last_os_error(); + // Don't leak file descriptors. Can't handle error though. + let _ = libc::close(fds[0]); + let _ = libc::close(fds[1]); + return Err(err); + } + } + } + + #[cfg(not(any( + target_os = "android", + target_os = "dragonfly", + target_os = "freebsd", + target_os = "linux", + target_os = "netbsd", + target_os = "openbsd", + target_os = "ios", + target_os = "macos", + target_os = "illumos", + )))] + compile_error!("unsupported target for `mio::unix::pipe`"); + + // Safety: we just initialised the `fds` above. + let r = unsafe { Receiver::from_raw_fd(fds[0]) }; + let w = unsafe { Sender::from_raw_fd(fds[1]) }; + Ok((w, r)) +} + +/// Sending end of an Unix pipe. +/// +/// See [`new`] for documentation, including examples. +#[derive(Debug)] +pub struct Sender { + inner: IoSource<File>, +} + +impl Sender { + /// Set the `Sender` into or out of non-blocking mode. + pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> { + set_nonblocking(self.inner.as_raw_fd(), nonblocking) + } +} + +impl event::Source for Sender { + fn register( + &mut self, + registry: &Registry, + token: Token, + interests: Interest, + ) -> io::Result<()> { + self.inner.register(registry, token, interests) + } + + fn reregister( + &mut self, + registry: &Registry, + token: Token, + interests: Interest, + ) -> io::Result<()> { + self.inner.reregister(registry, token, interests) + } + + fn deregister(&mut self, registry: &Registry) -> io::Result<()> { + self.inner.deregister(registry) + } +} + +impl Write for Sender { + fn write(&mut self, buf: &[u8]) -> io::Result<usize> { + self.inner.do_io(|sender| (&*sender).write(buf)) + } + + fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> { + self.inner.do_io(|sender| (&*sender).write_vectored(bufs)) + } + + fn flush(&mut self) -> io::Result<()> { + self.inner.do_io(|sender| (&*sender).flush()) + } +} + +impl Write for &Sender { + fn write(&mut self, buf: &[u8]) -> io::Result<usize> { + self.inner.do_io(|sender| (&*sender).write(buf)) + } + + fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> { + self.inner.do_io(|sender| (&*sender).write_vectored(bufs)) + } + + fn flush(&mut self) -> io::Result<()> { + self.inner.do_io(|sender| (&*sender).flush()) + } +} + +/// # Notes +/// +/// The underlying pipe is **not** set to non-blocking. +impl From<ChildStdin> for Sender { + fn from(stdin: ChildStdin) -> Sender { + // Safety: `ChildStdin` is guaranteed to be a valid file descriptor. + unsafe { Sender::from_raw_fd(stdin.into_raw_fd()) } + } +} + +impl FromRawFd for Sender { + unsafe fn from_raw_fd(fd: RawFd) -> Sender { + Sender { + inner: IoSource::new(File::from_raw_fd(fd)), + } + } +} + +impl AsRawFd for Sender { + fn as_raw_fd(&self) -> RawFd { + self.inner.as_raw_fd() + } +} + +impl IntoRawFd for Sender { + fn into_raw_fd(self) -> RawFd { + self.inner.into_inner().into_raw_fd() + } +} + +/// Receiving end of an Unix pipe. +/// +/// See [`new`] for documentation, including examples. +#[derive(Debug)] +pub struct Receiver { + inner: IoSource<File>, +} + +impl Receiver { + /// Set the `Receiver` into or out of non-blocking mode. + pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> { + set_nonblocking(self.inner.as_raw_fd(), nonblocking) + } +} + +impl event::Source for Receiver { + fn register( + &mut self, + registry: &Registry, + token: Token, + interests: Interest, + ) -> io::Result<()> { + self.inner.register(registry, token, interests) + } + + fn reregister( + &mut self, + registry: &Registry, + token: Token, + interests: Interest, + ) -> io::Result<()> { + self.inner.reregister(registry, token, interests) + } + + fn deregister(&mut self, registry: &Registry) -> io::Result<()> { + self.inner.deregister(registry) + } +} + +impl Read for Receiver { + fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { + self.inner.do_io(|sender| (&*sender).read(buf)) + } + + fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> { + self.inner.do_io(|sender| (&*sender).read_vectored(bufs)) + } +} + +impl Read for &Receiver { + fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { + self.inner.do_io(|sender| (&*sender).read(buf)) + } + + fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> { + self.inner.do_io(|sender| (&*sender).read_vectored(bufs)) + } +} + +/// # Notes +/// +/// The underlying pipe is **not** set to non-blocking. +impl From<ChildStdout> for Receiver { + fn from(stdout: ChildStdout) -> Receiver { + // Safety: `ChildStdout` is guaranteed to be a valid file descriptor. + unsafe { Receiver::from_raw_fd(stdout.into_raw_fd()) } + } +} + +/// # Notes +/// +/// The underlying pipe is **not** set to non-blocking. +impl From<ChildStderr> for Receiver { + fn from(stderr: ChildStderr) -> Receiver { + // Safety: `ChildStderr` is guaranteed to be a valid file descriptor. + unsafe { Receiver::from_raw_fd(stderr.into_raw_fd()) } + } +} + +impl FromRawFd for Receiver { + unsafe fn from_raw_fd(fd: RawFd) -> Receiver { + Receiver { + inner: IoSource::new(File::from_raw_fd(fd)), + } + } +} + +impl AsRawFd for Receiver { + fn as_raw_fd(&self) -> RawFd { + self.inner.as_raw_fd() + } +} + +impl IntoRawFd for Receiver { + fn into_raw_fd(self) -> RawFd { + self.inner.into_inner().into_raw_fd() + } +} + +#[cfg(not(target_os = "illumos"))] +fn set_nonblocking(fd: RawFd, nonblocking: bool) -> io::Result<()> { + let value = nonblocking as libc::c_int; + if unsafe { libc::ioctl(fd, libc::FIONBIO, &value) } == -1 { + Err(io::Error::last_os_error()) + } else { + Ok(()) + } +} + +#[cfg(target_os = "illumos")] +fn set_nonblocking(fd: RawFd, nonblocking: bool) -> io::Result<()> { + let flags = unsafe { libc::fcntl(fd, libc::F_GETFL) }; + if flags < 0 { + return Err(io::Error::last_os_error()); + } + + let nflags = if nonblocking { + flags | libc::O_NONBLOCK + } else { + flags & !libc::O_NONBLOCK + }; + + if flags != nflags { + if unsafe { libc::fcntl(fd, libc::F_SETFL, nflags) } < 0 { + return Err(io::Error::last_os_error()); + } + } + + Ok(()) +} diff --git a/third_party/rust/mio/src/sys/unix/selector/epoll.rs b/third_party/rust/mio/src/sys/unix/selector/epoll.rs new file mode 100644 index 0000000000..f4430909b0 --- /dev/null +++ b/third_party/rust/mio/src/sys/unix/selector/epoll.rs @@ -0,0 +1,246 @@ +use crate::{Interest, Token}; + +use libc::{EPOLLET, EPOLLIN, EPOLLOUT, EPOLLRDHUP}; +use log::error; +use std::os::unix::io::{AsRawFd, RawFd}; +#[cfg(debug_assertions)] +use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; +use std::time::Duration; +use std::{cmp, i32, io, ptr}; + +/// Unique id for use as `SelectorId`. +#[cfg(debug_assertions)] +static NEXT_ID: AtomicUsize = AtomicUsize::new(1); + +#[derive(Debug)] +pub struct Selector { + #[cfg(debug_assertions)] + id: usize, + ep: RawFd, + #[cfg(debug_assertions)] + has_waker: AtomicBool, +} + +impl Selector { + pub fn new() -> io::Result<Selector> { + // According to libuv, `EPOLL_CLOEXEC` is not defined on Android API < + // 21. But `EPOLL_CLOEXEC` is an alias for `O_CLOEXEC` on that platform, + // so we use it instead. + #[cfg(target_os = "android")] + let flag = libc::O_CLOEXEC; + #[cfg(not(target_os = "android"))] + let flag = libc::EPOLL_CLOEXEC; + + syscall!(epoll_create1(flag)).map(|ep| Selector { + #[cfg(debug_assertions)] + id: NEXT_ID.fetch_add(1, Ordering::Relaxed), + ep, + #[cfg(debug_assertions)] + has_waker: AtomicBool::new(false), + }) + } + + pub fn try_clone(&self) -> io::Result<Selector> { + syscall!(fcntl(self.ep, libc::F_DUPFD_CLOEXEC, super::LOWEST_FD)).map(|ep| Selector { + // It's the same selector, so we use the same id. + #[cfg(debug_assertions)] + id: self.id, + ep, + #[cfg(debug_assertions)] + has_waker: AtomicBool::new(self.has_waker.load(Ordering::Acquire)), + }) + } + + pub fn select(&self, events: &mut Events, timeout: Option<Duration>) -> io::Result<()> { + // A bug in kernels < 2.6.37 makes timeouts larger than LONG_MAX / CONFIG_HZ + // (approx. 30 minutes with CONFIG_HZ=1200) effectively infinite on 32 bits + // architectures. The magic number is the same constant used by libuv. + #[cfg(target_pointer_width = "32")] + const MAX_SAFE_TIMEOUT: u128 = 1789569; + #[cfg(not(target_pointer_width = "32"))] + const MAX_SAFE_TIMEOUT: u128 = libc::c_int::max_value() as u128; + + let timeout = timeout + .map(|to| cmp::min(to.as_millis(), MAX_SAFE_TIMEOUT) as libc::c_int) + .unwrap_or(-1); + + events.clear(); + syscall!(epoll_wait( + self.ep, + events.as_mut_ptr(), + events.capacity() as i32, + timeout, + )) + .map(|n_events| { + // This is safe because `epoll_wait` ensures that `n_events` are + // assigned. + unsafe { events.set_len(n_events as usize) }; + }) + } + + pub fn register(&self, fd: RawFd, token: Token, interests: Interest) -> io::Result<()> { + let mut event = libc::epoll_event { + events: interests_to_epoll(interests), + u64: usize::from(token) as u64, + }; + + syscall!(epoll_ctl(self.ep, libc::EPOLL_CTL_ADD, fd, &mut event)).map(|_| ()) + } + + pub fn reregister(&self, fd: RawFd, token: Token, interests: Interest) -> io::Result<()> { + let mut event = libc::epoll_event { + events: interests_to_epoll(interests), + u64: usize::from(token) as u64, + }; + + syscall!(epoll_ctl(self.ep, libc::EPOLL_CTL_MOD, fd, &mut event)).map(|_| ()) + } + + pub fn deregister(&self, fd: RawFd) -> io::Result<()> { + syscall!(epoll_ctl(self.ep, libc::EPOLL_CTL_DEL, fd, ptr::null_mut())).map(|_| ()) + } + + #[cfg(debug_assertions)] + pub fn register_waker(&self) -> bool { + self.has_waker.swap(true, Ordering::AcqRel) + } +} + +cfg_io_source! { + impl Selector { + #[cfg(debug_assertions)] + pub fn id(&self) -> usize { + self.id + } + } +} + +impl AsRawFd for Selector { + fn as_raw_fd(&self) -> RawFd { + self.ep + } +} + +impl Drop for Selector { + fn drop(&mut self) { + if let Err(err) = syscall!(close(self.ep)) { + error!("error closing epoll: {}", err); + } + } +} + +fn interests_to_epoll(interests: Interest) -> u32 { + let mut kind = EPOLLET; + + if interests.is_readable() { + kind = kind | EPOLLIN | EPOLLRDHUP; + } + + if interests.is_writable() { + kind |= EPOLLOUT; + } + + kind as u32 +} + +pub type Event = libc::epoll_event; +pub type Events = Vec<Event>; + +pub mod event { + use std::fmt; + + use crate::sys::Event; + use crate::Token; + + pub fn token(event: &Event) -> Token { + Token(event.u64 as usize) + } + + pub fn is_readable(event: &Event) -> bool { + (event.events as libc::c_int & libc::EPOLLIN) != 0 + || (event.events as libc::c_int & libc::EPOLLPRI) != 0 + } + + pub fn is_writable(event: &Event) -> bool { + (event.events as libc::c_int & libc::EPOLLOUT) != 0 + } + + pub fn is_error(event: &Event) -> bool { + (event.events as libc::c_int & libc::EPOLLERR) != 0 + } + + pub fn is_read_closed(event: &Event) -> bool { + // Both halves of the socket have closed + event.events as libc::c_int & libc::EPOLLHUP != 0 + // Socket has received FIN or called shutdown(SHUT_RD) + || (event.events as libc::c_int & libc::EPOLLIN != 0 + && event.events as libc::c_int & libc::EPOLLRDHUP != 0) + } + + pub fn is_write_closed(event: &Event) -> bool { + // Both halves of the socket have closed + event.events as libc::c_int & libc::EPOLLHUP != 0 + // Unix pipe write end has closed + || (event.events as libc::c_int & libc::EPOLLOUT != 0 + && event.events as libc::c_int & libc::EPOLLERR != 0) + // The other side (read end) of a Unix pipe has closed. + || event.events as libc::c_int == libc::EPOLLERR + } + + pub fn is_priority(event: &Event) -> bool { + (event.events as libc::c_int & libc::EPOLLPRI) != 0 + } + + pub fn is_aio(_: &Event) -> bool { + // Not supported in the kernel, only in libc. + false + } + + pub fn is_lio(_: &Event) -> bool { + // Not supported. + false + } + + pub fn debug_details(f: &mut fmt::Formatter<'_>, event: &Event) -> fmt::Result { + #[allow(clippy::trivially_copy_pass_by_ref)] + fn check_events(got: &u32, want: &libc::c_int) -> bool { + (*got as libc::c_int & want) != 0 + } + debug_detail!( + EventsDetails(u32), + check_events, + libc::EPOLLIN, + libc::EPOLLPRI, + libc::EPOLLOUT, + libc::EPOLLRDNORM, + libc::EPOLLRDBAND, + libc::EPOLLWRNORM, + libc::EPOLLWRBAND, + libc::EPOLLMSG, + libc::EPOLLERR, + libc::EPOLLHUP, + libc::EPOLLET, + libc::EPOLLRDHUP, + libc::EPOLLONESHOT, + #[cfg(target_os = "linux")] + libc::EPOLLEXCLUSIVE, + #[cfg(any(target_os = "android", target_os = "linux"))] + libc::EPOLLWAKEUP, + libc::EPOLL_CLOEXEC, + ); + + // Can't reference fields in packed structures. + let e_u64 = event.u64; + f.debug_struct("epoll_event") + .field("events", &EventsDetails(event.events)) + .field("u64", &e_u64) + .finish() + } +} + +#[cfg(target_os = "android")] +#[test] +fn assert_close_on_exec_flag() { + // This assertion need to be true for Selector::new. + assert_eq!(libc::O_CLOEXEC, libc::EPOLL_CLOEXEC); +} diff --git a/third_party/rust/mio/src/sys/unix/selector/kqueue.rs b/third_party/rust/mio/src/sys/unix/selector/kqueue.rs new file mode 100644 index 0000000000..b7a01a51c6 --- /dev/null +++ b/third_party/rust/mio/src/sys/unix/selector/kqueue.rs @@ -0,0 +1,688 @@ +use crate::{Interest, Token}; +use log::error; +use std::mem::MaybeUninit; +use std::ops::{Deref, DerefMut}; +use std::os::unix::io::{AsRawFd, RawFd}; +#[cfg(debug_assertions)] +use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; +use std::time::Duration; +use std::{cmp, io, ptr, slice}; + +/// Unique id for use as `SelectorId`. +#[cfg(debug_assertions)] +static NEXT_ID: AtomicUsize = AtomicUsize::new(1); + +// Type of the `nchanges` and `nevents` parameters in the `kevent` function. +#[cfg(not(target_os = "netbsd"))] +type Count = libc::c_int; +#[cfg(target_os = "netbsd")] +type Count = libc::size_t; + +// Type of the `filter` field in the `kevent` structure. +#[cfg(any(target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd"))] +type Filter = libc::c_short; +#[cfg(any(target_os = "macos", target_os = "ios"))] +type Filter = i16; +#[cfg(target_os = "netbsd")] +type Filter = u32; + +// Type of the `flags` field in the `kevent` structure. +#[cfg(any(target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd"))] +type Flags = libc::c_ushort; +#[cfg(any(target_os = "macos", target_os = "ios"))] +type Flags = u16; +#[cfg(target_os = "netbsd")] +type Flags = u32; + +// Type of the `data` field in the `kevent` structure. +#[cfg(any( + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos" +))] +type Data = libc::intptr_t; +#[cfg(any(target_os = "netbsd", target_os = "openbsd"))] +type Data = i64; + +// Type of the `udata` field in the `kevent` structure. +#[cfg(not(target_os = "netbsd"))] +type UData = *mut libc::c_void; +#[cfg(target_os = "netbsd")] +type UData = libc::intptr_t; + +macro_rules! kevent { + ($id: expr, $filter: expr, $flags: expr, $data: expr) => { + libc::kevent { + ident: $id as libc::uintptr_t, + filter: $filter as Filter, + flags: $flags, + fflags: 0, + data: 0, + udata: $data as UData, + } + }; +} + +#[derive(Debug)] +pub struct Selector { + #[cfg(debug_assertions)] + id: usize, + kq: RawFd, + #[cfg(debug_assertions)] + has_waker: AtomicBool, +} + +impl Selector { + pub fn new() -> io::Result<Selector> { + syscall!(kqueue()) + .and_then(|kq| syscall!(fcntl(kq, libc::F_SETFD, libc::FD_CLOEXEC)).map(|_| kq)) + .map(|kq| Selector { + #[cfg(debug_assertions)] + id: NEXT_ID.fetch_add(1, Ordering::Relaxed), + kq, + #[cfg(debug_assertions)] + has_waker: AtomicBool::new(false), + }) + } + + pub fn try_clone(&self) -> io::Result<Selector> { + syscall!(fcntl(self.kq, libc::F_DUPFD_CLOEXEC, super::LOWEST_FD)).map(|kq| Selector { + // It's the same selector, so we use the same id. + #[cfg(debug_assertions)] + id: self.id, + kq, + #[cfg(debug_assertions)] + has_waker: AtomicBool::new(self.has_waker.load(Ordering::Acquire)), + }) + } + + pub fn select(&self, events: &mut Events, timeout: Option<Duration>) -> io::Result<()> { + let timeout = timeout.map(|to| libc::timespec { + tv_sec: cmp::min(to.as_secs(), libc::time_t::max_value() as u64) as libc::time_t, + // `Duration::subsec_nanos` is guaranteed to be less than one + // billion (the number of nanoseconds in a second), making the + // cast to i32 safe. The cast itself is needed for platforms + // where C's long is only 32 bits. + tv_nsec: libc::c_long::from(to.subsec_nanos() as i32), + }); + let timeout = timeout + .as_ref() + .map(|s| s as *const _) + .unwrap_or(ptr::null_mut()); + + events.clear(); + syscall!(kevent( + self.kq, + ptr::null(), + 0, + events.as_mut_ptr(), + events.capacity() as Count, + timeout, + )) + .map(|n_events| { + // This is safe because `kevent` ensures that `n_events` are + // assigned. + unsafe { events.set_len(n_events as usize) }; + }) + } + + pub fn register(&self, fd: RawFd, token: Token, interests: Interest) -> io::Result<()> { + let flags = libc::EV_CLEAR | libc::EV_RECEIPT | libc::EV_ADD; + // At most we need two changes, but maybe we only need 1. + let mut changes: [MaybeUninit<libc::kevent>; 2] = + [MaybeUninit::uninit(), MaybeUninit::uninit()]; + let mut n_changes = 0; + + if interests.is_writable() { + let kevent = kevent!(fd, libc::EVFILT_WRITE, flags, token.0); + changes[n_changes] = MaybeUninit::new(kevent); + n_changes += 1; + } + + if interests.is_readable() { + let kevent = kevent!(fd, libc::EVFILT_READ, flags, token.0); + changes[n_changes] = MaybeUninit::new(kevent); + n_changes += 1; + } + + // Older versions of macOS (OS X 10.11 and 10.10 have been witnessed) + // can return EPIPE when registering a pipe file descriptor where the + // other end has already disappeared. For example code that creates a + // pipe, closes a file descriptor, and then registers the other end will + // see an EPIPE returned from `register`. + // + // It also turns out that kevent will still report events on the file + // descriptor, telling us that it's readable/hup at least after we've + // done this registration. As a result we just ignore `EPIPE` here + // instead of propagating it. + // + // More info can be found at tokio-rs/mio#582. + let changes = unsafe { + // This is safe because we ensure that at least `n_changes` are in + // the array. + slice::from_raw_parts_mut(changes[0].as_mut_ptr(), n_changes) + }; + kevent_register(self.kq, changes, &[libc::EPIPE as Data]) + } + + pub fn reregister(&self, fd: RawFd, token: Token, interests: Interest) -> io::Result<()> { + let flags = libc::EV_CLEAR | libc::EV_RECEIPT; + let write_flags = if interests.is_writable() { + flags | libc::EV_ADD + } else { + flags | libc::EV_DELETE + }; + let read_flags = if interests.is_readable() { + flags | libc::EV_ADD + } else { + flags | libc::EV_DELETE + }; + + let mut changes: [libc::kevent; 2] = [ + kevent!(fd, libc::EVFILT_WRITE, write_flags, token.0), + kevent!(fd, libc::EVFILT_READ, read_flags, token.0), + ]; + + // Since there is no way to check with which interests the fd was + // registered we modify both readable and write, adding it when required + // and removing it otherwise, ignoring the ENOENT error when it comes + // up. The ENOENT error informs us that a filter we're trying to remove + // wasn't there in first place, but we don't really care since our goal + // is accomplished. + // + // For the explanation of ignoring `EPIPE` see `register`. + kevent_register( + self.kq, + &mut changes, + &[libc::ENOENT as Data, libc::EPIPE as Data], + ) + } + + pub fn deregister(&self, fd: RawFd) -> io::Result<()> { + let flags = libc::EV_DELETE | libc::EV_RECEIPT; + let mut changes: [libc::kevent; 2] = [ + kevent!(fd, libc::EVFILT_WRITE, flags, 0), + kevent!(fd, libc::EVFILT_READ, flags, 0), + ]; + + // Since there is no way to check with which interests the fd was + // registered we remove both filters (readable and writeable) and ignore + // the ENOENT error when it comes up. The ENOENT error informs us that + // the filter wasn't there in first place, but we don't really care + // about that since our goal is to remove it. + kevent_register(self.kq, &mut changes, &[libc::ENOENT as Data]) + } + + #[cfg(debug_assertions)] + pub fn register_waker(&self) -> bool { + self.has_waker.swap(true, Ordering::AcqRel) + } + + // Used by `Waker`. + #[cfg(any(target_os = "freebsd", target_os = "ios", target_os = "macos"))] + pub fn setup_waker(&self, token: Token) -> io::Result<()> { + // First attempt to accept user space notifications. + let mut kevent = kevent!( + 0, + libc::EVFILT_USER, + libc::EV_ADD | libc::EV_CLEAR | libc::EV_RECEIPT, + token.0 + ); + + syscall!(kevent(self.kq, &kevent, 1, &mut kevent, 1, ptr::null())).and_then(|_| { + if (kevent.flags & libc::EV_ERROR) != 0 && kevent.data != 0 { + Err(io::Error::from_raw_os_error(kevent.data as i32)) + } else { + Ok(()) + } + }) + } + + // Used by `Waker`. + #[cfg(any(target_os = "freebsd", target_os = "ios", target_os = "macos"))] + pub fn wake(&self, token: Token) -> io::Result<()> { + let mut kevent = kevent!( + 0, + libc::EVFILT_USER, + libc::EV_ADD | libc::EV_RECEIPT, + token.0 + ); + kevent.fflags = libc::NOTE_TRIGGER; + + syscall!(kevent(self.kq, &kevent, 1, &mut kevent, 1, ptr::null())).and_then(|_| { + if (kevent.flags & libc::EV_ERROR) != 0 && kevent.data != 0 { + Err(io::Error::from_raw_os_error(kevent.data as i32)) + } else { + Ok(()) + } + }) + } +} + +/// Register `changes` with `kq`ueue. +fn kevent_register( + kq: RawFd, + changes: &mut [libc::kevent], + ignored_errors: &[Data], +) -> io::Result<()> { + syscall!(kevent( + kq, + changes.as_ptr(), + changes.len() as Count, + changes.as_mut_ptr(), + changes.len() as Count, + ptr::null(), + )) + .map(|_| ()) + .or_else(|err| { + // According to the manual page of FreeBSD: "When kevent() call fails + // with EINTR error, all changes in the changelist have been applied", + // so we can safely ignore it. + if err.raw_os_error() == Some(libc::EINTR) { + Ok(()) + } else { + Err(err) + } + }) + .and_then(|()| check_errors(changes, ignored_errors)) +} + +/// Check all events for possible errors, it returns the first error found. +fn check_errors(events: &[libc::kevent], ignored_errors: &[Data]) -> io::Result<()> { + for event in events { + // We can't use references to packed structures (in checking the ignored + // errors), so we need copy the data out before use. + let data = event.data; + // Check for the error flag, the actual error will be in the `data` + // field. + if (event.flags & libc::EV_ERROR != 0) && data != 0 && !ignored_errors.contains(&data) { + return Err(io::Error::from_raw_os_error(data as i32)); + } + } + Ok(()) +} + +cfg_io_source! { + #[cfg(debug_assertions)] + impl Selector { + pub fn id(&self) -> usize { + self.id + } + } +} + +impl AsRawFd for Selector { + fn as_raw_fd(&self) -> RawFd { + self.kq + } +} + +impl Drop for Selector { + fn drop(&mut self) { + if let Err(err) = syscall!(close(self.kq)) { + error!("error closing kqueue: {}", err); + } + } +} + +pub type Event = libc::kevent; +pub struct Events(Vec<libc::kevent>); + +impl Events { + pub fn with_capacity(capacity: usize) -> Events { + Events(Vec::with_capacity(capacity)) + } +} + +impl Deref for Events { + type Target = Vec<libc::kevent>; + + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +impl DerefMut for Events { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} + +// `Events` cannot derive `Send` or `Sync` because of the +// `udata: *mut ::c_void` field in `libc::kevent`. However, `Events`'s public +// API treats the `udata` field as a `uintptr_t` which is `Send`. `Sync` is +// safe because with a `events: &Events` value, the only access to the `udata` +// field is through `fn token(event: &Event)` which cannot mutate the field. +unsafe impl Send for Events {} +unsafe impl Sync for Events {} + +pub mod event { + use std::fmt; + + use crate::sys::Event; + use crate::Token; + + use super::{Filter, Flags}; + + pub fn token(event: &Event) -> Token { + Token(event.udata as usize) + } + + pub fn is_readable(event: &Event) -> bool { + event.filter == libc::EVFILT_READ || { + #[cfg(any(target_os = "freebsd", target_os = "ios", target_os = "macos"))] + // Used by the `Awakener`. On platforms that use `eventfd` or a unix + // pipe it will emit a readable event so we'll fake that here as + // well. + { + event.filter == libc::EVFILT_USER + } + #[cfg(not(any(target_os = "freebsd", target_os = "ios", target_os = "macos")))] + { + false + } + } + } + + pub fn is_writable(event: &Event) -> bool { + event.filter == libc::EVFILT_WRITE + } + + pub fn is_error(event: &Event) -> bool { + (event.flags & libc::EV_ERROR) != 0 || + // When the read end of the socket is closed, EV_EOF is set on + // flags, and fflags contains the error if there is one. + (event.flags & libc::EV_EOF) != 0 && event.fflags != 0 + } + + pub fn is_read_closed(event: &Event) -> bool { + event.filter == libc::EVFILT_READ && event.flags & libc::EV_EOF != 0 + } + + pub fn is_write_closed(event: &Event) -> bool { + event.filter == libc::EVFILT_WRITE && event.flags & libc::EV_EOF != 0 + } + + pub fn is_priority(_: &Event) -> bool { + // kqueue doesn't have priority indicators. + false + } + + #[allow(unused_variables)] // `event` is not used on some platforms. + pub fn is_aio(event: &Event) -> bool { + #[cfg(any( + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos" + ))] + { + event.filter == libc::EVFILT_AIO + } + #[cfg(not(any( + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos" + )))] + { + false + } + } + + #[allow(unused_variables)] // `event` is only used on FreeBSD. + pub fn is_lio(event: &Event) -> bool { + #[cfg(target_os = "freebsd")] + { + event.filter == libc::EVFILT_LIO + } + #[cfg(not(target_os = "freebsd"))] + { + false + } + } + + pub fn debug_details(f: &mut fmt::Formatter<'_>, event: &Event) -> fmt::Result { + debug_detail!( + FilterDetails(Filter), + PartialEq::eq, + libc::EVFILT_READ, + libc::EVFILT_WRITE, + libc::EVFILT_AIO, + libc::EVFILT_VNODE, + libc::EVFILT_PROC, + libc::EVFILT_SIGNAL, + libc::EVFILT_TIMER, + #[cfg(target_os = "freebsd")] + libc::EVFILT_PROCDESC, + #[cfg(any( + target_os = "freebsd", + target_os = "dragonfly", + target_os = "ios", + target_os = "macos" + ))] + libc::EVFILT_FS, + #[cfg(target_os = "freebsd")] + libc::EVFILT_LIO, + #[cfg(any( + target_os = "freebsd", + target_os = "dragonfly", + target_os = "ios", + target_os = "macos" + ))] + libc::EVFILT_USER, + #[cfg(target_os = "freebsd")] + libc::EVFILT_SENDFILE, + #[cfg(target_os = "freebsd")] + libc::EVFILT_EMPTY, + #[cfg(target_os = "dragonfly")] + libc::EVFILT_EXCEPT, + #[cfg(any(target_os = "ios", target_os = "macos"))] + libc::EVFILT_MACHPORT, + #[cfg(any(target_os = "ios", target_os = "macos"))] + libc::EVFILT_VM, + ); + + #[allow(clippy::trivially_copy_pass_by_ref)] + fn check_flag(got: &Flags, want: &Flags) -> bool { + (got & want) != 0 + } + debug_detail!( + FlagsDetails(Flags), + check_flag, + libc::EV_ADD, + libc::EV_DELETE, + libc::EV_ENABLE, + libc::EV_DISABLE, + libc::EV_ONESHOT, + libc::EV_CLEAR, + libc::EV_RECEIPT, + libc::EV_DISPATCH, + #[cfg(target_os = "freebsd")] + libc::EV_DROP, + libc::EV_FLAG1, + libc::EV_ERROR, + libc::EV_EOF, + libc::EV_SYSFLAGS, + #[cfg(any(target_os = "ios", target_os = "macos"))] + libc::EV_FLAG0, + #[cfg(any(target_os = "ios", target_os = "macos"))] + libc::EV_POLL, + #[cfg(any(target_os = "ios", target_os = "macos"))] + libc::EV_OOBAND, + #[cfg(target_os = "dragonfly")] + libc::EV_NODATA, + ); + + #[allow(clippy::trivially_copy_pass_by_ref)] + fn check_fflag(got: &u32, want: &u32) -> bool { + (got & want) != 0 + } + debug_detail!( + FflagsDetails(u32), + check_fflag, + #[cfg(any( + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos" + ))] + libc::NOTE_TRIGGER, + #[cfg(any( + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos" + ))] + libc::NOTE_FFNOP, + #[cfg(any( + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos" + ))] + libc::NOTE_FFAND, + #[cfg(any( + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos" + ))] + libc::NOTE_FFOR, + #[cfg(any( + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos" + ))] + libc::NOTE_FFCOPY, + #[cfg(any( + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos" + ))] + libc::NOTE_FFCTRLMASK, + #[cfg(any( + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos" + ))] + libc::NOTE_FFLAGSMASK, + libc::NOTE_LOWAT, + libc::NOTE_DELETE, + libc::NOTE_WRITE, + #[cfg(target_os = "dragonfly")] + libc::NOTE_OOB, + #[cfg(target_os = "openbsd")] + libc::NOTE_EOF, + #[cfg(any(target_os = "ios", target_os = "macos"))] + libc::NOTE_EXTEND, + libc::NOTE_ATTRIB, + libc::NOTE_LINK, + libc::NOTE_RENAME, + libc::NOTE_REVOKE, + #[cfg(any(target_os = "ios", target_os = "macos"))] + libc::NOTE_NONE, + #[cfg(any(target_os = "openbsd"))] + libc::NOTE_TRUNCATE, + libc::NOTE_EXIT, + libc::NOTE_FORK, + libc::NOTE_EXEC, + #[cfg(any(target_os = "ios", target_os = "macos"))] + libc::NOTE_SIGNAL, + #[cfg(any(target_os = "ios", target_os = "macos"))] + libc::NOTE_EXITSTATUS, + #[cfg(any(target_os = "ios", target_os = "macos"))] + libc::NOTE_EXIT_DETAIL, + libc::NOTE_PDATAMASK, + libc::NOTE_PCTRLMASK, + #[cfg(any( + target_os = "dragonfly", + target_os = "freebsd", + target_os = "netbsd", + target_os = "openbsd" + ))] + libc::NOTE_TRACK, + #[cfg(any( + target_os = "dragonfly", + target_os = "freebsd", + target_os = "netbsd", + target_os = "openbsd" + ))] + libc::NOTE_TRACKERR, + #[cfg(any( + target_os = "dragonfly", + target_os = "freebsd", + target_os = "netbsd", + target_os = "openbsd" + ))] + libc::NOTE_CHILD, + #[cfg(any(target_os = "ios", target_os = "macos"))] + libc::NOTE_EXIT_DETAIL_MASK, + #[cfg(any(target_os = "ios", target_os = "macos"))] + libc::NOTE_EXIT_DECRYPTFAIL, + #[cfg(any(target_os = "ios", target_os = "macos"))] + libc::NOTE_EXIT_MEMORY, + #[cfg(any(target_os = "ios", target_os = "macos"))] + libc::NOTE_EXIT_CSERROR, + #[cfg(any(target_os = "ios", target_os = "macos"))] + libc::NOTE_VM_PRESSURE, + #[cfg(any(target_os = "ios", target_os = "macos"))] + libc::NOTE_VM_PRESSURE_TERMINATE, + #[cfg(any(target_os = "ios", target_os = "macos"))] + libc::NOTE_VM_PRESSURE_SUDDEN_TERMINATE, + #[cfg(any(target_os = "ios", target_os = "macos"))] + libc::NOTE_VM_ERROR, + #[cfg(any(target_os = "freebsd", target_os = "ios", target_os = "macos"))] + libc::NOTE_SECONDS, + #[cfg(any(target_os = "freebsd"))] + libc::NOTE_MSECONDS, + #[cfg(any(target_os = "freebsd", target_os = "ios", target_os = "macos"))] + libc::NOTE_USECONDS, + #[cfg(any(target_os = "freebsd", target_os = "ios", target_os = "macos"))] + libc::NOTE_NSECONDS, + #[cfg(any(target_os = "ios", target_os = "macos"))] + #[cfg(any(target_os = "freebsd", target_os = "ios", target_os = "macos"))] + libc::NOTE_ABSOLUTE, + #[cfg(any(target_os = "ios", target_os = "macos"))] + libc::NOTE_LEEWAY, + #[cfg(any(target_os = "ios", target_os = "macos"))] + libc::NOTE_CRITICAL, + #[cfg(any(target_os = "ios", target_os = "macos"))] + libc::NOTE_BACKGROUND, + ); + + // Can't reference fields in packed structures. + let ident = event.ident; + let data = event.data; + let udata = event.udata; + f.debug_struct("kevent") + .field("ident", &ident) + .field("filter", &FilterDetails(event.filter)) + .field("flags", &FlagsDetails(event.flags)) + .field("fflags", &FflagsDetails(event.fflags)) + .field("data", &data) + .field("udata", &udata) + .finish() + } +} + +#[test] +#[cfg(feature = "os-ext")] +fn does_not_register_rw() { + use crate::unix::SourceFd; + use crate::{Poll, Token}; + + let kq = unsafe { libc::kqueue() }; + let mut kqf = SourceFd(&kq); + let poll = Poll::new().unwrap(); + + // Registering kqueue fd will fail if write is requested (On anything but + // some versions of macOS). + poll.registry() + .register(&mut kqf, Token(1234), Interest::READABLE) + .unwrap(); +} diff --git a/third_party/rust/mio/src/sys/unix/selector/mod.rs b/third_party/rust/mio/src/sys/unix/selector/mod.rs new file mode 100644 index 0000000000..da61e14d7e --- /dev/null +++ b/third_party/rust/mio/src/sys/unix/selector/mod.rs @@ -0,0 +1,35 @@ +#[cfg(any(target_os = "android", target_os = "illumos", target_os = "linux"))] +mod epoll; + +#[cfg(any(target_os = "android", target_os = "illumos", target_os = "linux"))] +pub(crate) use self::epoll::{event, Event, Events, Selector}; + +#[cfg(any( + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos", + target_os = "netbsd", + target_os = "openbsd" +))] +mod kqueue; + +#[cfg(any( + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos", + target_os = "netbsd", + target_os = "openbsd" +))] +pub(crate) use self::kqueue::{event, Event, Events, Selector}; + +/// Lowest file descriptor used in `Selector::try_clone`. +/// +/// # Notes +/// +/// Usually fds 0, 1 and 2 are standard in, out and error. Some application +/// blindly assume this to be true, which means using any one of those a select +/// could result in some interesting and unexpected errors. Avoid that by using +/// an fd that doesn't have a pre-determined usage. +const LOWEST_FD: libc::c_int = 3; diff --git a/third_party/rust/mio/src/sys/unix/sourcefd.rs b/third_party/rust/mio/src/sys/unix/sourcefd.rs new file mode 100644 index 0000000000..84e776d21d --- /dev/null +++ b/third_party/rust/mio/src/sys/unix/sourcefd.rs @@ -0,0 +1,116 @@ +use crate::{event, Interest, Registry, Token}; + +use std::io; +use std::os::unix::io::RawFd; + +/// Adapter for [`RawFd`] providing an [`event::Source`] implementation. +/// +/// `SourceFd` enables registering any type with an FD with [`Poll`]. +/// +/// While only implementations for TCP and UDP are provided, Mio supports +/// registering any FD that can be registered with the underlying OS selector. +/// `SourceFd` provides the necessary bridge. +/// +/// Note that `SourceFd` takes a `&RawFd`. This is because `SourceFd` **does +/// not** take ownership of the FD. Specifically, it will not manage any +/// lifecycle related operations, such as closing the FD on drop. It is expected +/// that the `SourceFd` is constructed right before a call to +/// [`Registry::register`]. See the examples for more detail. +/// +/// [`event::Source`]: ../event/trait.Source.html +/// [`Poll`]: ../struct.Poll.html +/// [`Registry::register`]: ../struct.Registry.html#method.register +/// +/// # Examples +/// +/// Basic usage. +/// +#[cfg_attr( + all(feature = "os-poll", feature = "net", feature = "os-ext"), + doc = "```" +)] +#[cfg_attr( + not(all(feature = "os-poll", feature = "net", feature = "os-ext")), + doc = "```ignore" +)] +/// # use std::error::Error; +/// # fn main() -> Result<(), Box<dyn Error>> { +/// use mio::{Interest, Poll, Token}; +/// use mio::unix::SourceFd; +/// +/// use std::os::unix::io::AsRawFd; +/// use std::net::TcpListener; +/// +/// // Bind a std listener +/// let listener = TcpListener::bind("127.0.0.1:0")?; +/// +/// let poll = Poll::new()?; +/// +/// // Register the listener +/// poll.registry().register( +/// &mut SourceFd(&listener.as_raw_fd()), +/// Token(0), +/// Interest::READABLE)?; +/// # Ok(()) +/// # } +/// ``` +/// +/// Implementing [`event::Source`] for a custom type backed by a [`RawFd`]. +/// +#[cfg_attr(all(feature = "os-poll", feature = "os-ext"), doc = "```")] +#[cfg_attr(not(all(feature = "os-poll", feature = "os-ext")), doc = "```ignore")] +/// use mio::{event, Interest, Registry, Token}; +/// use mio::unix::SourceFd; +/// +/// use std::os::unix::io::RawFd; +/// use std::io; +/// +/// # #[allow(dead_code)] +/// pub struct MyIo { +/// fd: RawFd, +/// } +/// +/// impl event::Source for MyIo { +/// fn register(&mut self, registry: &Registry, token: Token, interests: Interest) +/// -> io::Result<()> +/// { +/// SourceFd(&self.fd).register(registry, token, interests) +/// } +/// +/// fn reregister(&mut self, registry: &Registry, token: Token, interests: Interest) +/// -> io::Result<()> +/// { +/// SourceFd(&self.fd).reregister(registry, token, interests) +/// } +/// +/// fn deregister(&mut self, registry: &Registry) -> io::Result<()> { +/// SourceFd(&self.fd).deregister(registry) +/// } +/// } +/// ``` +#[derive(Debug)] +pub struct SourceFd<'a>(pub &'a RawFd); + +impl<'a> event::Source for SourceFd<'a> { + fn register( + &mut self, + registry: &Registry, + token: Token, + interests: Interest, + ) -> io::Result<()> { + registry.selector().register(*self.0, token, interests) + } + + fn reregister( + &mut self, + registry: &Registry, + token: Token, + interests: Interest, + ) -> io::Result<()> { + registry.selector().reregister(*self.0, token, interests) + } + + fn deregister(&mut self, registry: &Registry) -> io::Result<()> { + registry.selector().deregister(*self.0) + } +} diff --git a/third_party/rust/mio/src/sys/unix/tcp.rs b/third_party/rust/mio/src/sys/unix/tcp.rs new file mode 100644 index 0000000000..5b02cfcb52 --- /dev/null +++ b/third_party/rust/mio/src/sys/unix/tcp.rs @@ -0,0 +1,113 @@ +use std::convert::TryInto; +use std::io; +use std::mem::{size_of, MaybeUninit}; +use std::net::{self, SocketAddr}; +use std::os::unix::io::{AsRawFd, FromRawFd}; + +use crate::sys::unix::net::{new_socket, socket_addr, to_socket_addr}; + +pub(crate) fn new_for_addr(address: SocketAddr) -> io::Result<libc::c_int> { + let domain = match address { + SocketAddr::V4(_) => libc::AF_INET, + SocketAddr::V6(_) => libc::AF_INET6, + }; + new_socket(domain, libc::SOCK_STREAM) +} + +pub(crate) fn bind(socket: &net::TcpListener, addr: SocketAddr) -> io::Result<()> { + let (raw_addr, raw_addr_length) = socket_addr(&addr); + syscall!(bind(socket.as_raw_fd(), raw_addr.as_ptr(), raw_addr_length))?; + Ok(()) +} + +pub(crate) fn connect(socket: &net::TcpStream, addr: SocketAddr) -> io::Result<()> { + let (raw_addr, raw_addr_length) = socket_addr(&addr); + + match syscall!(connect( + socket.as_raw_fd(), + raw_addr.as_ptr(), + raw_addr_length + )) { + Err(err) if err.raw_os_error() != Some(libc::EINPROGRESS) => Err(err), + _ => Ok(()), + } +} + +pub(crate) fn listen(socket: &net::TcpListener, backlog: u32) -> io::Result<()> { + let backlog = backlog.try_into().unwrap_or(i32::max_value()); + syscall!(listen(socket.as_raw_fd(), backlog))?; + Ok(()) +} + +pub(crate) fn set_reuseaddr(socket: &net::TcpListener, reuseaddr: bool) -> io::Result<()> { + let val: libc::c_int = if reuseaddr { 1 } else { 0 }; + syscall!(setsockopt( + socket.as_raw_fd(), + libc::SOL_SOCKET, + libc::SO_REUSEADDR, + &val as *const libc::c_int as *const libc::c_void, + size_of::<libc::c_int>() as libc::socklen_t, + ))?; + Ok(()) +} + +pub(crate) fn accept(listener: &net::TcpListener) -> io::Result<(net::TcpStream, SocketAddr)> { + let mut addr: MaybeUninit<libc::sockaddr_storage> = MaybeUninit::uninit(); + let mut length = size_of::<libc::sockaddr_storage>() as libc::socklen_t; + + // On platforms that support it we can use `accept4(2)` to set `NONBLOCK` + // and `CLOEXEC` in the call to accept the connection. + #[cfg(any( + // Android x86's seccomp profile forbids calls to `accept4(2)` + // See https://github.com/tokio-rs/mio/issues/1445 for details + all( + not(target_arch="x86"), + target_os = "android" + ), + target_os = "dragonfly", + target_os = "freebsd", + target_os = "illumos", + target_os = "linux", + target_os = "netbsd", + target_os = "openbsd" + ))] + let stream = { + syscall!(accept4( + listener.as_raw_fd(), + addr.as_mut_ptr() as *mut _, + &mut length, + libc::SOCK_CLOEXEC | libc::SOCK_NONBLOCK, + )) + .map(|socket| unsafe { net::TcpStream::from_raw_fd(socket) }) + }?; + + // But not all platforms have the `accept4(2)` call. Luckily BSD (derived) + // OSes inherit the non-blocking flag from the listener, so we just have to + // set `CLOEXEC`. + #[cfg(any( + all(target_arch = "x86", target_os = "android"), + target_os = "ios", + target_os = "macos", + ))] + let stream = { + syscall!(accept( + listener.as_raw_fd(), + addr.as_mut_ptr() as *mut _, + &mut length + )) + .map(|socket| unsafe { net::TcpStream::from_raw_fd(socket) }) + .and_then(|s| { + syscall!(fcntl(s.as_raw_fd(), libc::F_SETFD, libc::FD_CLOEXEC))?; + + // See https://github.com/tokio-rs/mio/issues/1450 + #[cfg(all(target_arch = "x86", target_os = "android"))] + syscall!(fcntl(s.as_raw_fd(), libc::F_SETFL, libc::O_NONBLOCK))?; + + Ok(s) + }) + }?; + + // This is safe because `accept` calls above ensures the address + // initialised. + unsafe { to_socket_addr(addr.as_ptr()) }.map(|addr| (stream, addr)) +} diff --git a/third_party/rust/mio/src/sys/unix/udp.rs b/third_party/rust/mio/src/sys/unix/udp.rs new file mode 100644 index 0000000000..5a97cbd897 --- /dev/null +++ b/third_party/rust/mio/src/sys/unix/udp.rs @@ -0,0 +1,39 @@ +use crate::sys::unix::net::{new_ip_socket, socket_addr}; + +use std::io; +use std::mem; +use std::net::{self, SocketAddr}; +use std::os::unix::io::{AsRawFd, FromRawFd}; + +pub fn bind(addr: SocketAddr) -> io::Result<net::UdpSocket> { + // Gives a warning for non Apple platforms. + #[allow(clippy::let_and_return)] + let socket = new_ip_socket(addr, libc::SOCK_DGRAM); + + socket.and_then(|socket| { + let (raw_addr, raw_addr_length) = socket_addr(&addr); + syscall!(bind(socket, raw_addr.as_ptr(), raw_addr_length)) + .map_err(|err| { + // Close the socket if we hit an error, ignoring the error + // from closing since we can't pass back two errors. + let _ = unsafe { libc::close(socket) }; + err + }) + .map(|_| unsafe { net::UdpSocket::from_raw_fd(socket) }) + }) +} + +pub(crate) fn only_v6(socket: &net::UdpSocket) -> io::Result<bool> { + let mut optval: libc::c_int = 0; + let mut optlen = mem::size_of::<libc::c_int>() as libc::socklen_t; + + syscall!(getsockopt( + socket.as_raw_fd(), + libc::IPPROTO_IPV6, + libc::IPV6_V6ONLY, + &mut optval as *mut _ as *mut _, + &mut optlen, + ))?; + + Ok(optval != 0) +} diff --git a/third_party/rust/mio/src/sys/unix/uds/datagram.rs b/third_party/rust/mio/src/sys/unix/uds/datagram.rs new file mode 100644 index 0000000000..d3e5314fe3 --- /dev/null +++ b/third_party/rust/mio/src/sys/unix/uds/datagram.rs @@ -0,0 +1,56 @@ +use super::{socket_addr, SocketAddr}; +use crate::sys::unix::net::new_socket; + +use std::io; +use std::os::unix::io::{AsRawFd, FromRawFd}; +use std::os::unix::net; +use std::path::Path; + +pub(crate) fn bind(path: &Path) -> io::Result<net::UnixDatagram> { + let fd = new_socket(libc::AF_UNIX, libc::SOCK_DGRAM)?; + // Ensure the fd is closed. + let socket = unsafe { net::UnixDatagram::from_raw_fd(fd) }; + let (sockaddr, socklen) = socket_addr(path)?; + let sockaddr = &sockaddr as *const libc::sockaddr_un as *const _; + syscall!(bind(fd, sockaddr, socklen))?; + Ok(socket) +} + +pub(crate) fn unbound() -> io::Result<net::UnixDatagram> { + new_socket(libc::AF_UNIX, libc::SOCK_DGRAM) + .map(|socket| unsafe { net::UnixDatagram::from_raw_fd(socket) }) +} + +pub(crate) fn pair() -> io::Result<(net::UnixDatagram, net::UnixDatagram)> { + super::pair(libc::SOCK_DGRAM) +} + +pub(crate) fn local_addr(socket: &net::UnixDatagram) -> io::Result<SocketAddr> { + super::local_addr(socket.as_raw_fd()) +} + +pub(crate) fn peer_addr(socket: &net::UnixDatagram) -> io::Result<SocketAddr> { + super::peer_addr(socket.as_raw_fd()) +} + +pub(crate) fn recv_from( + socket: &net::UnixDatagram, + dst: &mut [u8], +) -> io::Result<(usize, SocketAddr)> { + let mut count = 0; + let socketaddr = SocketAddr::new(|sockaddr, socklen| { + syscall!(recvfrom( + socket.as_raw_fd(), + dst.as_mut_ptr() as *mut _, + dst.len(), + 0, + sockaddr, + socklen, + )) + .map(|c| { + count = c; + c as libc::c_int + }) + })?; + Ok((count as usize, socketaddr)) +} diff --git a/third_party/rust/mio/src/sys/unix/uds/listener.rs b/third_party/rust/mio/src/sys/unix/uds/listener.rs new file mode 100644 index 0000000000..b6218427f2 --- /dev/null +++ b/third_party/rust/mio/src/sys/unix/uds/listener.rs @@ -0,0 +1,94 @@ +use super::socket_addr; +use crate::net::{SocketAddr, UnixStream}; +use crate::sys::unix::net::new_socket; +use std::os::unix::io::{AsRawFd, FromRawFd}; +use std::os::unix::net; +use std::path::Path; +use std::{io, mem}; + +pub(crate) fn bind(path: &Path) -> io::Result<net::UnixListener> { + let socket = new_socket(libc::AF_UNIX, libc::SOCK_STREAM)?; + let (sockaddr, socklen) = socket_addr(path)?; + let sockaddr = &sockaddr as *const libc::sockaddr_un as *const libc::sockaddr; + + syscall!(bind(socket, sockaddr, socklen)) + .and_then(|_| syscall!(listen(socket, 1024))) + .map_err(|err| { + // Close the socket if we hit an error, ignoring the error from + // closing since we can't pass back two errors. + let _ = unsafe { libc::close(socket) }; + err + }) + .map(|_| unsafe { net::UnixListener::from_raw_fd(socket) }) +} + +pub(crate) fn accept(listener: &net::UnixListener) -> io::Result<(UnixStream, SocketAddr)> { + let sockaddr = mem::MaybeUninit::<libc::sockaddr_un>::zeroed(); + + // This is safe to assume because a `libc::sockaddr_un` filled with `0` + // bytes is properly initialized. + // + // `0` is a valid value for `sockaddr_un::sun_family`; it is + // `libc::AF_UNSPEC`. + // + // `[0; 108]` is a valid value for `sockaddr_un::sun_path`; it begins an + // abstract path. + let mut sockaddr = unsafe { sockaddr.assume_init() }; + + sockaddr.sun_family = libc::AF_UNIX as libc::sa_family_t; + let mut socklen = mem::size_of_val(&sockaddr) as libc::socklen_t; + + #[cfg(not(any( + target_os = "ios", + target_os = "macos", + target_os = "netbsd", + // Android x86's seccomp profile forbids calls to `accept4(2)` + // See https://github.com/tokio-rs/mio/issues/1445 for details + all( + target_arch = "x86", + target_os = "android" + ) + )))] + let socket = { + let flags = libc::SOCK_NONBLOCK | libc::SOCK_CLOEXEC; + syscall!(accept4( + listener.as_raw_fd(), + &mut sockaddr as *mut libc::sockaddr_un as *mut libc::sockaddr, + &mut socklen, + flags + )) + .map(|socket| unsafe { net::UnixStream::from_raw_fd(socket) }) + }; + + #[cfg(any( + target_os = "ios", + target_os = "macos", + target_os = "netbsd", + all(target_arch = "x86", target_os = "android") + ))] + let socket = syscall!(accept( + listener.as_raw_fd(), + &mut sockaddr as *mut libc::sockaddr_un as *mut libc::sockaddr, + &mut socklen, + )) + .and_then(|socket| { + // Ensure the socket is closed if either of the `fcntl` calls + // error below. + let s = unsafe { net::UnixStream::from_raw_fd(socket) }; + syscall!(fcntl(socket, libc::F_SETFD, libc::FD_CLOEXEC))?; + + // See https://github.com/tokio-rs/mio/issues/1450 + #[cfg(all(target_arch = "x86", target_os = "android"))] + syscall!(fcntl(socket, libc::F_SETFL, libc::O_NONBLOCK))?; + + Ok(s) + }); + + socket + .map(UnixStream::from_std) + .map(|stream| (stream, SocketAddr::from_parts(sockaddr, socklen))) +} + +pub(crate) fn local_addr(listener: &net::UnixListener) -> io::Result<SocketAddr> { + super::local_addr(listener.as_raw_fd()) +} diff --git a/third_party/rust/mio/src/sys/unix/uds/mod.rs b/third_party/rust/mio/src/sys/unix/uds/mod.rs new file mode 100644 index 0000000000..8e28a9573a --- /dev/null +++ b/third_party/rust/mio/src/sys/unix/uds/mod.rs @@ -0,0 +1,149 @@ +mod socketaddr; +pub use self::socketaddr::SocketAddr; + +/// Get the `sun_path` field offset of `sockaddr_un` for the target OS. +/// +/// On Linux, this funtion equates to the same value as +/// `size_of::<sa_family_t>()`, but some other implementations include +/// other fields before `sun_path`, so the expression more portably +/// describes the size of the address structure. +pub(in crate::sys) fn path_offset(sockaddr: &libc::sockaddr_un) -> usize { + let base = sockaddr as *const _ as usize; + let path = &sockaddr.sun_path as *const _ as usize; + path - base +} + +cfg_os_poll! { + use std::cmp::Ordering; + use std::os::unix::ffi::OsStrExt; + use std::os::unix::io::{RawFd, FromRawFd}; + use std::path::Path; + use std::{io, mem}; + + pub(crate) mod datagram; + pub(crate) mod listener; + pub(crate) mod stream; + + pub(in crate::sys) fn socket_addr(path: &Path) -> io::Result<(libc::sockaddr_un, libc::socklen_t)> { + let sockaddr = mem::MaybeUninit::<libc::sockaddr_un>::zeroed(); + + // This is safe to assume because a `libc::sockaddr_un` filled with `0` + // bytes is properly initialized. + // + // `0` is a valid value for `sockaddr_un::sun_family`; it is + // `libc::AF_UNSPEC`. + // + // `[0; 108]` is a valid value for `sockaddr_un::sun_path`; it begins an + // abstract path. + let mut sockaddr = unsafe { sockaddr.assume_init() }; + + sockaddr.sun_family = libc::AF_UNIX as libc::sa_family_t; + + let bytes = path.as_os_str().as_bytes(); + match (bytes.get(0), bytes.len().cmp(&sockaddr.sun_path.len())) { + // Abstract paths don't need a null terminator + (Some(&0), Ordering::Greater) => { + return Err(io::Error::new( + io::ErrorKind::InvalidInput, + "path must be no longer than libc::sockaddr_un.sun_path", + )); + } + (_, Ordering::Greater) | (_, Ordering::Equal) => { + return Err(io::Error::new( + io::ErrorKind::InvalidInput, + "path must be shorter than libc::sockaddr_un.sun_path", + )); + } + _ => {} + } + + for (dst, src) in sockaddr.sun_path.iter_mut().zip(bytes.iter()) { + *dst = *src as libc::c_char; + } + + let offset = path_offset(&sockaddr); + let mut socklen = offset + bytes.len(); + + match bytes.get(0) { + // The struct has already been zeroes so the null byte for pathname + // addresses is already there. + Some(&0) | None => {} + Some(_) => socklen += 1, + } + + Ok((sockaddr, socklen as libc::socklen_t)) + } + + fn pair<T>(flags: libc::c_int) -> io::Result<(T, T)> + where T: FromRawFd, + { + #[cfg(not(any(target_os = "ios", target_os = "macos")))] + let flags = flags | libc::SOCK_NONBLOCK | libc::SOCK_CLOEXEC; + + let mut fds = [-1; 2]; + syscall!(socketpair(libc::AF_UNIX, flags, 0, fds.as_mut_ptr()))?; + let pair = unsafe { (T::from_raw_fd(fds[0]), T::from_raw_fd(fds[1])) }; + + // Darwin doesn't have SOCK_NONBLOCK or SOCK_CLOEXEC. + // + // In order to set those flags, additional `fcntl` sys calls must be + // performed. If a `fnctl` fails after the sockets have been created, + // the file descriptors will leak. Creating `pair` above ensures that if + // there is an error, the file descriptors are closed. + #[cfg(any(target_os = "ios", target_os = "macos"))] + { + syscall!(fcntl(fds[0], libc::F_SETFL, libc::O_NONBLOCK))?; + syscall!(fcntl(fds[0], libc::F_SETFD, libc::FD_CLOEXEC))?; + syscall!(fcntl(fds[1], libc::F_SETFL, libc::O_NONBLOCK))?; + syscall!(fcntl(fds[1], libc::F_SETFD, libc::FD_CLOEXEC))?; + } + Ok(pair) + } + + // The following functions can't simply be replaced with a call to + // `net::UnixDatagram` because of our `SocketAddr` type. + + fn local_addr(socket: RawFd) -> io::Result<SocketAddr> { + SocketAddr::new(|sockaddr, socklen| syscall!(getsockname(socket, sockaddr, socklen))) + } + + fn peer_addr(socket: RawFd) -> io::Result<SocketAddr> { + SocketAddr::new(|sockaddr, socklen| syscall!(getpeername(socket, sockaddr, socklen))) + } + + #[cfg(test)] + mod tests { + use super::{path_offset, socket_addr}; + use std::path::Path; + use std::str; + + #[test] + fn pathname_address() { + const PATH: &str = "./foo/bar.txt"; + const PATH_LEN: usize = 13; + + // Pathname addresses do have a null terminator, so `socklen` is + // expected to be `PATH_LEN` + `offset` + 1. + let path = Path::new(PATH); + let (sockaddr, actual) = socket_addr(path).unwrap(); + let offset = path_offset(&sockaddr); + let expected = PATH_LEN + offset + 1; + assert_eq!(expected as libc::socklen_t, actual) + } + + #[test] + fn abstract_address() { + const PATH: &[u8] = &[0, 116, 111, 107, 105, 111]; + const PATH_LEN: usize = 6; + + // Abstract addresses do not have a null terminator, so `socklen` is + // expected to be `PATH_LEN` + `offset`. + let abstract_path = str::from_utf8(PATH).unwrap(); + let path = Path::new(abstract_path); + let (sockaddr, actual) = socket_addr(path).unwrap(); + let offset = path_offset(&sockaddr); + let expected = PATH_LEN + offset; + assert_eq!(expected as libc::socklen_t, actual) + } + } +} diff --git a/third_party/rust/mio/src/sys/unix/uds/socketaddr.rs b/third_party/rust/mio/src/sys/unix/uds/socketaddr.rs new file mode 100644 index 0000000000..4c7c411618 --- /dev/null +++ b/third_party/rust/mio/src/sys/unix/uds/socketaddr.rs @@ -0,0 +1,130 @@ +use super::path_offset; +use std::ffi::OsStr; +use std::os::unix::ffi::OsStrExt; +use std::path::Path; +use std::{ascii, fmt}; + +/// An address associated with a `mio` specific Unix socket. +/// +/// This is implemented instead of imported from [`net::SocketAddr`] because +/// there is no way to create a [`net::SocketAddr`]. One must be returned by +/// [`accept`], so this is returned instead. +/// +/// [`net::SocketAddr`]: std::os::unix::net::SocketAddr +/// [`accept`]: #method.accept +pub struct SocketAddr { + sockaddr: libc::sockaddr_un, + socklen: libc::socklen_t, +} + +struct AsciiEscaped<'a>(&'a [u8]); + +enum AddressKind<'a> { + Unnamed, + Pathname(&'a Path), + Abstract(&'a [u8]), +} + +impl SocketAddr { + fn address(&self) -> AddressKind<'_> { + let offset = path_offset(&self.sockaddr); + // Don't underflow in `len` below. + if (self.socklen as usize) < offset { + return AddressKind::Unnamed; + } + let len = self.socklen as usize - offset; + let path = unsafe { &*(&self.sockaddr.sun_path as *const [libc::c_char] as *const [u8]) }; + + // macOS seems to return a len of 16 and a zeroed sun_path for unnamed addresses + if len == 0 + || (cfg!(not(any(target_os = "linux", target_os = "android"))) + && self.sockaddr.sun_path[0] == 0) + { + AddressKind::Unnamed + } else if self.sockaddr.sun_path[0] == 0 { + AddressKind::Abstract(&path[1..len]) + } else { + AddressKind::Pathname(OsStr::from_bytes(&path[..len - 1]).as_ref()) + } + } +} + +cfg_os_poll! { + use std::{io, mem}; + + impl SocketAddr { + pub(crate) fn new<F>(f: F) -> io::Result<SocketAddr> + where + F: FnOnce(*mut libc::sockaddr, &mut libc::socklen_t) -> io::Result<libc::c_int>, + { + let mut sockaddr = { + let sockaddr = mem::MaybeUninit::<libc::sockaddr_un>::zeroed(); + unsafe { sockaddr.assume_init() } + }; + + let raw_sockaddr = &mut sockaddr as *mut libc::sockaddr_un as *mut libc::sockaddr; + let mut socklen = mem::size_of_val(&sockaddr) as libc::socklen_t; + + f(raw_sockaddr, &mut socklen)?; + Ok(SocketAddr::from_parts(sockaddr, socklen)) + } + + pub(crate) fn from_parts(sockaddr: libc::sockaddr_un, socklen: libc::socklen_t) -> SocketAddr { + SocketAddr { sockaddr, socklen } + } + + /// Returns `true` if the address is unnamed. + /// + /// Documentation reflected in [`SocketAddr`] + /// + /// [`SocketAddr`]: std::os::unix::net::SocketAddr + pub fn is_unnamed(&self) -> bool { + matches!(self.address(), AddressKind::Unnamed) + } + + /// Returns the contents of this address if it is a `pathname` address. + /// + /// Documentation reflected in [`SocketAddr`] + /// + /// [`SocketAddr`]: std::os::unix::net::SocketAddr + pub fn as_pathname(&self) -> Option<&Path> { + if let AddressKind::Pathname(path) = self.address() { + Some(path) + } else { + None + } + } + + /// Returns the contents of this address if it is an abstract namespace + /// without the leading null byte. + // Link to std::os::unix::net::SocketAddr pending + // https://github.com/rust-lang/rust/issues/85410. + pub fn as_abstract_namespace(&self) -> Option<&[u8]> { + if let AddressKind::Abstract(path) = self.address() { + Some(path) + } else { + None + } + } + } +} + +impl fmt::Debug for SocketAddr { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { + match self.address() { + AddressKind::Unnamed => write!(fmt, "(unnamed)"), + AddressKind::Abstract(name) => write!(fmt, "{} (abstract)", AsciiEscaped(name)), + AddressKind::Pathname(path) => write!(fmt, "{:?} (pathname)", path), + } + } +} + +impl<'a> fmt::Display for AsciiEscaped<'a> { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(fmt, "\"")?; + for byte in self.0.iter().cloned().flat_map(ascii::escape_default) { + write!(fmt, "{}", byte as char)?; + } + write!(fmt, "\"") + } +} diff --git a/third_party/rust/mio/src/sys/unix/uds/stream.rs b/third_party/rust/mio/src/sys/unix/uds/stream.rs new file mode 100644 index 0000000000..149dd14e1d --- /dev/null +++ b/third_party/rust/mio/src/sys/unix/uds/stream.rs @@ -0,0 +1,39 @@ +use super::{socket_addr, SocketAddr}; +use crate::sys::unix::net::new_socket; + +use std::io; +use std::os::unix::io::{AsRawFd, FromRawFd}; +use std::os::unix::net; +use std::path::Path; + +pub(crate) fn connect(path: &Path) -> io::Result<net::UnixStream> { + let socket = new_socket(libc::AF_UNIX, libc::SOCK_STREAM)?; + let (sockaddr, socklen) = socket_addr(path)?; + let sockaddr = &sockaddr as *const libc::sockaddr_un as *const libc::sockaddr; + + match syscall!(connect(socket, sockaddr, socklen)) { + Ok(_) => {} + Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {} + Err(e) => { + // Close the socket if we hit an error, ignoring the error + // from closing since we can't pass back two errors. + let _ = unsafe { libc::close(socket) }; + + return Err(e); + } + } + + Ok(unsafe { net::UnixStream::from_raw_fd(socket) }) +} + +pub(crate) fn pair() -> io::Result<(net::UnixStream, net::UnixStream)> { + super::pair(libc::SOCK_STREAM) +} + +pub(crate) fn local_addr(socket: &net::UnixStream) -> io::Result<SocketAddr> { + super::local_addr(socket.as_raw_fd()) +} + +pub(crate) fn peer_addr(socket: &net::UnixStream) -> io::Result<SocketAddr> { + super::peer_addr(socket.as_raw_fd()) +} diff --git a/third_party/rust/mio/src/sys/unix/waker.rs b/third_party/rust/mio/src/sys/unix/waker.rs new file mode 100644 index 0000000000..684fee981e --- /dev/null +++ b/third_party/rust/mio/src/sys/unix/waker.rs @@ -0,0 +1,178 @@ +#[cfg(any(target_os = "linux", target_os = "android"))] +mod eventfd { + use crate::sys::Selector; + use crate::{Interest, Token}; + + use std::fs::File; + use std::io::{self, Read, Write}; + use std::os::unix::io::FromRawFd; + + /// Waker backed by `eventfd`. + /// + /// `eventfd` is effectively an 64 bit counter. All writes must be of 8 + /// bytes (64 bits) and are converted (native endian) into an 64 bit + /// unsigned integer and added to the count. Reads must also be 8 bytes and + /// reset the count to 0, returning the count. + #[derive(Debug)] + pub struct Waker { + fd: File, + } + + impl Waker { + pub fn new(selector: &Selector, token: Token) -> io::Result<Waker> { + syscall!(eventfd(0, libc::EFD_CLOEXEC | libc::EFD_NONBLOCK)).and_then(|fd| { + // Turn the file descriptor into a file first so we're ensured + // it's closed when dropped, e.g. when register below fails. + let file = unsafe { File::from_raw_fd(fd) }; + selector + .register(fd, token, Interest::READABLE) + .map(|()| Waker { fd: file }) + }) + } + + pub fn wake(&self) -> io::Result<()> { + let buf: [u8; 8] = 1u64.to_ne_bytes(); + match (&self.fd).write(&buf) { + Ok(_) => Ok(()), + Err(ref err) if err.kind() == io::ErrorKind::WouldBlock => { + // Writing only blocks if the counter is going to overflow. + // So we'll reset the counter to 0 and wake it again. + self.reset()?; + self.wake() + } + Err(err) => Err(err), + } + } + + /// Reset the eventfd object, only need to call this if `wake` fails. + fn reset(&self) -> io::Result<()> { + let mut buf: [u8; 8] = 0u64.to_ne_bytes(); + match (&self.fd).read(&mut buf) { + Ok(_) => Ok(()), + // If the `Waker` hasn't been awoken yet this will return a + // `WouldBlock` error which we can safely ignore. + Err(ref err) if err.kind() == io::ErrorKind::WouldBlock => Ok(()), + Err(err) => Err(err), + } + } + } +} + +#[cfg(any(target_os = "linux", target_os = "android"))] +pub use self::eventfd::Waker; + +#[cfg(any(target_os = "freebsd", target_os = "ios", target_os = "macos"))] +mod kqueue { + use crate::sys::Selector; + use crate::Token; + + use std::io; + + /// Waker backed by kqueue user space notifications (`EVFILT_USER`). + /// + /// The implementation is fairly simple, first the kqueue must be setup to + /// receive waker events this done by calling `Selector.setup_waker`. Next + /// we need access to kqueue, thus we need to duplicate the file descriptor. + /// Now waking is as simple as adding an event to the kqueue. + #[derive(Debug)] + pub struct Waker { + selector: Selector, + token: Token, + } + + impl Waker { + pub fn new(selector: &Selector, token: Token) -> io::Result<Waker> { + selector.try_clone().and_then(|selector| { + selector + .setup_waker(token) + .map(|()| Waker { selector, token }) + }) + } + + pub fn wake(&self) -> io::Result<()> { + self.selector.wake(self.token) + } + } +} + +#[cfg(any(target_os = "freebsd", target_os = "ios", target_os = "macos"))] +pub use self::kqueue::Waker; + +#[cfg(any( + target_os = "dragonfly", + target_os = "illumos", + target_os = "netbsd", + target_os = "openbsd", +))] +mod pipe { + use crate::sys::unix::Selector; + use crate::{Interest, Token}; + + use std::fs::File; + use std::io::{self, Read, Write}; + use std::os::unix::io::FromRawFd; + + /// Waker backed by a unix pipe. + /// + /// Waker controls both the sending and receiving ends and empties the pipe + /// if writing to it (waking) fails. + #[derive(Debug)] + pub struct Waker { + sender: File, + receiver: File, + } + + impl Waker { + pub fn new(selector: &Selector, token: Token) -> io::Result<Waker> { + let mut fds = [-1; 2]; + syscall!(pipe2(fds.as_mut_ptr(), libc::O_NONBLOCK | libc::O_CLOEXEC))?; + // Turn the file descriptors into files first so we're ensured + // they're closed when dropped, e.g. when register below fails. + let sender = unsafe { File::from_raw_fd(fds[1]) }; + let receiver = unsafe { File::from_raw_fd(fds[0]) }; + selector + .register(fds[0], token, Interest::READABLE) + .map(|()| Waker { sender, receiver }) + } + + pub fn wake(&self) -> io::Result<()> { + // The epoll emulation on some illumos systems currently requires + // the pipe buffer to be completely empty for an edge-triggered + // wakeup on the pipe read side. + #[cfg(target_os = "illumos")] + self.empty(); + + match (&self.sender).write(&[1]) { + Ok(_) => Ok(()), + Err(ref err) if err.kind() == io::ErrorKind::WouldBlock => { + // The reading end is full so we'll empty the buffer and try + // again. + self.empty(); + self.wake() + } + Err(ref err) if err.kind() == io::ErrorKind::Interrupted => self.wake(), + Err(err) => Err(err), + } + } + + /// Empty the pipe's buffer, only need to call this if `wake` fails. + /// This ignores any errors. + fn empty(&self) { + let mut buf = [0; 4096]; + loop { + match (&self.receiver).read(&mut buf) { + Ok(n) if n > 0 => continue, + _ => return, + } + } + } + } +} + +#[cfg(any( + target_os = "dragonfly", + target_os = "illumos", + target_os = "netbsd", + target_os = "openbsd", +))] +pub use self::pipe::Waker; diff --git a/third_party/rust/mio/src/sys/windows/afd.rs b/third_party/rust/mio/src/sys/windows/afd.rs new file mode 100644 index 0000000000..6eae3bc035 --- /dev/null +++ b/third_party/rust/mio/src/sys/windows/afd.rs @@ -0,0 +1,237 @@ +use ntapi::ntioapi::{IO_STATUS_BLOCK_u, IO_STATUS_BLOCK}; +use ntapi::ntioapi::{NtCancelIoFileEx, NtDeviceIoControlFile}; +use ntapi::ntrtl::RtlNtStatusToDosError; +use std::fmt; +use std::fs::File; +use std::io; +use std::mem::size_of; +use std::os::windows::io::AsRawHandle; +use std::ptr::null_mut; +use winapi::shared::ntdef::{HANDLE, LARGE_INTEGER, NTSTATUS, PVOID, ULONG}; +use winapi::shared::ntstatus::{STATUS_NOT_FOUND, STATUS_PENDING, STATUS_SUCCESS}; + +const IOCTL_AFD_POLL: ULONG = 0x00012024; + +/// Winsock2 AFD driver instance. +/// +/// All operations are unsafe due to IO_STATUS_BLOCK parameter are being used by Afd driver during STATUS_PENDING before I/O Completion Port returns its result. +#[derive(Debug)] +pub struct Afd { + fd: File, +} + +#[repr(C)] +#[derive(Debug)] +pub struct AfdPollHandleInfo { + pub handle: HANDLE, + pub events: ULONG, + pub status: NTSTATUS, +} + +unsafe impl Send for AfdPollHandleInfo {} + +#[repr(C)] +pub struct AfdPollInfo { + pub timeout: LARGE_INTEGER, + // Can have only value 1. + pub number_of_handles: ULONG, + pub exclusive: ULONG, + pub handles: [AfdPollHandleInfo; 1], +} + +impl fmt::Debug for AfdPollInfo { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("AfdPollInfo").finish() + } +} + +impl Afd { + /// Poll `Afd` instance with `AfdPollInfo`. + /// + /// # Unsafety + /// + /// This function is unsafe due to memory of `IO_STATUS_BLOCK` still being used by `Afd` instance while `Ok(false)` (`STATUS_PENDING`). + /// `iosb` needs to be untouched after the call while operation is in effective at ALL TIME except for `cancel` method. + /// So be careful not to `poll` twice while polling. + /// User should deallocate there overlapped value when error to prevent memory leak. + pub unsafe fn poll( + &self, + info: &mut AfdPollInfo, + iosb: *mut IO_STATUS_BLOCK, + overlapped: PVOID, + ) -> io::Result<bool> { + let info_ptr: PVOID = info as *mut _ as PVOID; + (*iosb).u.Status = STATUS_PENDING; + let status = NtDeviceIoControlFile( + self.fd.as_raw_handle(), + null_mut(), + None, + overlapped, + iosb, + IOCTL_AFD_POLL, + info_ptr, + size_of::<AfdPollInfo>() as u32, + info_ptr, + size_of::<AfdPollInfo>() as u32, + ); + match status { + STATUS_SUCCESS => Ok(true), + STATUS_PENDING => Ok(false), + _ => Err(io::Error::from_raw_os_error( + RtlNtStatusToDosError(status) as i32 + )), + } + } + + /// Cancel previous polled request of `Afd`. + /// + /// iosb needs to be used by `poll` first for valid `cancel`. + /// + /// # Unsafety + /// + /// This function is unsafe due to memory of `IO_STATUS_BLOCK` still being used by `Afd` instance while `Ok(false)` (`STATUS_PENDING`). + /// Use it only with request is still being polled so that you have valid `IO_STATUS_BLOCK` to use. + /// User should NOT deallocate there overlapped value after the `cancel` to prevent double free. + pub unsafe fn cancel(&self, iosb: *mut IO_STATUS_BLOCK) -> io::Result<()> { + if (*iosb).u.Status != STATUS_PENDING { + return Ok(()); + } + + let mut cancel_iosb = IO_STATUS_BLOCK { + u: IO_STATUS_BLOCK_u { Status: 0 }, + Information: 0, + }; + let status = NtCancelIoFileEx(self.fd.as_raw_handle(), iosb, &mut cancel_iosb); + if status == STATUS_SUCCESS || status == STATUS_NOT_FOUND { + return Ok(()); + } + Err(io::Error::from_raw_os_error( + RtlNtStatusToDosError(status) as i32 + )) + } +} + +cfg_io_source! { + use std::mem::zeroed; + use std::os::windows::io::{FromRawHandle, RawHandle}; + use std::sync::atomic::{AtomicUsize, Ordering}; + + use miow::iocp::CompletionPort; + use ntapi::ntioapi::{NtCreateFile, FILE_OPEN}; + use winapi::shared::ntdef::{OBJECT_ATTRIBUTES, UNICODE_STRING, USHORT, WCHAR}; + use winapi::um::handleapi::INVALID_HANDLE_VALUE; + use winapi::um::winbase::{SetFileCompletionNotificationModes, FILE_SKIP_SET_EVENT_ON_HANDLE}; + use winapi::um::winnt::{SYNCHRONIZE, FILE_SHARE_READ, FILE_SHARE_WRITE}; + + const AFD_HELPER_ATTRIBUTES: OBJECT_ATTRIBUTES = OBJECT_ATTRIBUTES { + Length: size_of::<OBJECT_ATTRIBUTES>() as ULONG, + RootDirectory: null_mut(), + ObjectName: &AFD_OBJ_NAME as *const _ as *mut _, + Attributes: 0, + SecurityDescriptor: null_mut(), + SecurityQualityOfService: null_mut(), + }; + + const AFD_OBJ_NAME: UNICODE_STRING = UNICODE_STRING { + Length: (AFD_HELPER_NAME.len() * size_of::<WCHAR>()) as USHORT, + MaximumLength: (AFD_HELPER_NAME.len() * size_of::<WCHAR>()) as USHORT, + Buffer: AFD_HELPER_NAME.as_ptr() as *mut _, + }; + + const AFD_HELPER_NAME: &[WCHAR] = &[ + '\\' as _, + 'D' as _, + 'e' as _, + 'v' as _, + 'i' as _, + 'c' as _, + 'e' as _, + '\\' as _, + 'A' as _, + 'f' as _, + 'd' as _, + '\\' as _, + 'M' as _, + 'i' as _, + 'o' as _ + ]; + + static NEXT_TOKEN: AtomicUsize = AtomicUsize::new(0); + + impl AfdPollInfo { + pub fn zeroed() -> AfdPollInfo { + unsafe { zeroed() } + } + } + + impl Afd { + /// Create new Afd instance. + pub fn new(cp: &CompletionPort) -> io::Result<Afd> { + let mut afd_helper_handle: HANDLE = INVALID_HANDLE_VALUE; + let mut iosb = IO_STATUS_BLOCK { + u: IO_STATUS_BLOCK_u { Status: 0 }, + Information: 0, + }; + + unsafe { + let status = NtCreateFile( + &mut afd_helper_handle as *mut _, + SYNCHRONIZE, + &AFD_HELPER_ATTRIBUTES as *const _ as *mut _, + &mut iosb, + null_mut(), + 0, + FILE_SHARE_READ | FILE_SHARE_WRITE, + FILE_OPEN, + 0, + null_mut(), + 0, + ); + if status != STATUS_SUCCESS { + let raw_err = io::Error::from_raw_os_error( + RtlNtStatusToDosError(status) as i32 + ); + let msg = format!("Failed to open \\Device\\Afd\\Mio: {}", raw_err); + return Err(io::Error::new(raw_err.kind(), msg)); + } + let fd = File::from_raw_handle(afd_helper_handle as RawHandle); + // Increment by 2 to reserve space for other types of handles. + // Non-AFD types (currently only NamedPipe), use odd numbered + // tokens. This allows the selector to differentate between them + // and dispatch events accordingly. + let token = NEXT_TOKEN.fetch_add(2, Ordering::Relaxed) + 2; + let afd = Afd { fd }; + cp.add_handle(token, &afd.fd)?; + match SetFileCompletionNotificationModes( + afd_helper_handle, + FILE_SKIP_SET_EVENT_ON_HANDLE, + ) { + 0 => Err(io::Error::last_os_error()), + _ => Ok(afd), + } + } + } + } +} + +pub const POLL_RECEIVE: u32 = 0b0_0000_0001; +pub const POLL_RECEIVE_EXPEDITED: u32 = 0b0_0000_0010; +pub const POLL_SEND: u32 = 0b0_0000_0100; +pub const POLL_DISCONNECT: u32 = 0b0_0000_1000; +pub const POLL_ABORT: u32 = 0b0_0001_0000; +pub const POLL_LOCAL_CLOSE: u32 = 0b0_0010_0000; +// Not used as it indicated in each event where a connection is connected, not +// just the first time a connection is established. +// Also see https://github.com/piscisaureus/wepoll/commit/8b7b340610f88af3d83f40fb728e7b850b090ece. +pub const POLL_CONNECT: u32 = 0b0_0100_0000; +pub const POLL_ACCEPT: u32 = 0b0_1000_0000; +pub const POLL_CONNECT_FAIL: u32 = 0b1_0000_0000; + +pub const KNOWN_EVENTS: u32 = POLL_RECEIVE + | POLL_RECEIVE_EXPEDITED + | POLL_SEND + | POLL_DISCONNECT + | POLL_ABORT + | POLL_LOCAL_CLOSE + | POLL_ACCEPT + | POLL_CONNECT_FAIL; diff --git a/third_party/rust/mio/src/sys/windows/event.rs b/third_party/rust/mio/src/sys/windows/event.rs new file mode 100644 index 0000000000..a49252a296 --- /dev/null +++ b/third_party/rust/mio/src/sys/windows/event.rs @@ -0,0 +1,162 @@ +use std::fmt; + +use miow::iocp::CompletionStatus; + +use super::afd; +use crate::Token; + +#[derive(Clone)] +pub struct Event { + pub flags: u32, + pub data: u64, +} + +pub fn token(event: &Event) -> Token { + Token(event.data as usize) +} + +impl Event { + pub(super) fn new(token: Token) -> Event { + Event { + flags: 0, + data: usize::from(token) as u64, + } + } + + pub(super) fn set_readable(&mut self) { + self.flags |= afd::POLL_RECEIVE + } + + #[cfg(feature = "os-ext")] + pub(super) fn set_writable(&mut self) { + self.flags |= afd::POLL_SEND; + } + + pub(super) fn from_completion_status(status: &CompletionStatus) -> Event { + Event { + flags: status.bytes_transferred(), + data: status.token() as u64, + } + } + + pub(super) fn to_completion_status(&self) -> CompletionStatus { + CompletionStatus::new(self.flags, self.data as usize, std::ptr::null_mut()) + } +} + +pub(crate) const READABLE_FLAGS: u32 = afd::POLL_RECEIVE + | afd::POLL_DISCONNECT + | afd::POLL_ACCEPT + | afd::POLL_ABORT + | afd::POLL_CONNECT_FAIL; +pub(crate) const WRITABLE_FLAGS: u32 = afd::POLL_SEND | afd::POLL_ABORT | afd::POLL_CONNECT_FAIL; +pub(crate) const ERROR_FLAGS: u32 = afd::POLL_CONNECT_FAIL; +pub(crate) const READ_CLOSED_FLAGS: u32 = + afd::POLL_DISCONNECT | afd::POLL_ABORT | afd::POLL_CONNECT_FAIL; +pub(crate) const WRITE_CLOSED_FLAGS: u32 = afd::POLL_ABORT | afd::POLL_CONNECT_FAIL; + +pub fn is_readable(event: &Event) -> bool { + event.flags & READABLE_FLAGS != 0 +} + +pub fn is_writable(event: &Event) -> bool { + event.flags & WRITABLE_FLAGS != 0 +} + +pub fn is_error(event: &Event) -> bool { + event.flags & ERROR_FLAGS != 0 +} + +pub fn is_read_closed(event: &Event) -> bool { + event.flags & READ_CLOSED_FLAGS != 0 +} + +pub fn is_write_closed(event: &Event) -> bool { + event.flags & WRITE_CLOSED_FLAGS != 0 +} + +pub fn is_priority(event: &Event) -> bool { + event.flags & afd::POLL_RECEIVE_EXPEDITED != 0 +} + +pub fn is_aio(_: &Event) -> bool { + // Not supported. + false +} + +pub fn is_lio(_: &Event) -> bool { + // Not supported. + false +} + +pub fn debug_details(f: &mut fmt::Formatter<'_>, event: &Event) -> fmt::Result { + #[allow(clippy::trivially_copy_pass_by_ref)] + fn check_flags(got: &u32, want: &u32) -> bool { + (got & want) != 0 + } + debug_detail!( + FlagsDetails(u32), + check_flags, + afd::POLL_RECEIVE, + afd::POLL_RECEIVE_EXPEDITED, + afd::POLL_SEND, + afd::POLL_DISCONNECT, + afd::POLL_ABORT, + afd::POLL_LOCAL_CLOSE, + afd::POLL_CONNECT, + afd::POLL_ACCEPT, + afd::POLL_CONNECT_FAIL, + ); + + f.debug_struct("event") + .field("flags", &FlagsDetails(event.flags)) + .field("data", &event.data) + .finish() +} + +pub struct Events { + /// Raw I/O event completions are filled in here by the call to `get_many` + /// on the completion port above. These are then processed to run callbacks + /// which figure out what to do after the event is done. + pub statuses: Box<[CompletionStatus]>, + + /// Literal events returned by `get` to the upwards `EventLoop`. This file + /// doesn't really modify this (except for the waker), instead almost all + /// events are filled in by the `ReadinessQueue` from the `poll` module. + pub events: Vec<Event>, +} + +impl Events { + pub fn with_capacity(cap: usize) -> Events { + // Note that it's possible for the output `events` to grow beyond the + // capacity as it can also include deferred events, but that's certainly + // not the end of the world! + Events { + statuses: vec![CompletionStatus::zero(); cap].into_boxed_slice(), + events: Vec::with_capacity(cap), + } + } + + pub fn is_empty(&self) -> bool { + self.events.is_empty() + } + + pub fn capacity(&self) -> usize { + self.events.capacity() + } + + pub fn len(&self) -> usize { + self.events.len() + } + + pub fn get(&self, idx: usize) -> Option<&Event> { + self.events.get(idx) + } + + pub fn clear(&mut self) { + self.events.clear(); + for status in self.statuses.iter_mut() { + *status = CompletionStatus::zero(); + } + } +} diff --git a/third_party/rust/mio/src/sys/windows/io_status_block.rs b/third_party/rust/mio/src/sys/windows/io_status_block.rs new file mode 100644 index 0000000000..3e60334961 --- /dev/null +++ b/third_party/rust/mio/src/sys/windows/io_status_block.rs @@ -0,0 +1,40 @@ +use std::fmt; +use std::ops::{Deref, DerefMut}; + +use ntapi::ntioapi::IO_STATUS_BLOCK; + +pub struct IoStatusBlock(IO_STATUS_BLOCK); + +cfg_io_source! { + use ntapi::ntioapi::IO_STATUS_BLOCK_u; + + impl IoStatusBlock { + pub fn zeroed() -> Self { + Self(IO_STATUS_BLOCK { + u: IO_STATUS_BLOCK_u { Status: 0 }, + Information: 0, + }) + } + } +} + +unsafe impl Send for IoStatusBlock {} + +impl Deref for IoStatusBlock { + type Target = IO_STATUS_BLOCK; + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +impl DerefMut for IoStatusBlock { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} + +impl fmt::Debug for IoStatusBlock { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("IoStatusBlock").finish() + } +} diff --git a/third_party/rust/mio/src/sys/windows/mod.rs b/third_party/rust/mio/src/sys/windows/mod.rs new file mode 100644 index 0000000000..7048351355 --- /dev/null +++ b/third_party/rust/mio/src/sys/windows/mod.rs @@ -0,0 +1,147 @@ +mod afd; +mod io_status_block; + +pub mod event; +pub use event::{Event, Events}; + +mod selector; +pub use selector::{Selector, SelectorInner, SockState}; + +mod overlapped; +use overlapped::Overlapped; + +// Macros must be defined before the modules that use them +cfg_net! { + /// Helper macro to execute a system call that returns an `io::Result`. + // + // Macro must be defined before any modules that uses them. + macro_rules! syscall { + ($fn: ident ( $($arg: expr),* $(,)* ), $err_test: path, $err_value: expr) => {{ + let res = unsafe { $fn($($arg, )*) }; + if $err_test(&res, &$err_value) { + Err(io::Error::last_os_error()) + } else { + Ok(res) + } + }}; + } + + mod net; + + pub(crate) mod tcp; + pub(crate) mod udp; +} + +cfg_os_ext! { + pub(crate) mod named_pipe; +} + +mod waker; +pub(crate) use waker::Waker; + +cfg_io_source! { + use std::io; + use std::os::windows::io::RawSocket; + use std::pin::Pin; + use std::sync::{Arc, Mutex}; + + use crate::{Interest, Registry, Token}; + + struct InternalState { + selector: Arc<SelectorInner>, + token: Token, + interests: Interest, + sock_state: Pin<Arc<Mutex<SockState>>>, + } + + impl Drop for InternalState { + fn drop(&mut self) { + let mut sock_state = self.sock_state.lock().unwrap(); + sock_state.mark_delete(); + } + } + + pub struct IoSourceState { + // This is `None` if the socket has not yet been registered. + // + // We box the internal state to not increase the size on the stack as the + // type might move around a lot. + inner: Option<Box<InternalState>>, + } + + impl IoSourceState { + pub fn new() -> IoSourceState { + IoSourceState { inner: None } + } + + pub fn do_io<T, F, R>(&self, f: F, io: &T) -> io::Result<R> + where + F: FnOnce(&T) -> io::Result<R>, + { + let result = f(io); + if let Err(ref e) = result { + if e.kind() == io::ErrorKind::WouldBlock { + self.inner.as_ref().map_or(Ok(()), |state| { + state + .selector + .reregister(state.sock_state.clone(), state.token, state.interests) + })?; + } + } + result + } + + pub fn register( + &mut self, + registry: &Registry, + token: Token, + interests: Interest, + socket: RawSocket, + ) -> io::Result<()> { + if self.inner.is_some() { + Err(io::ErrorKind::AlreadyExists.into()) + } else { + registry + .selector() + .register(socket, token, interests) + .map(|state| { + self.inner = Some(Box::new(state)); + }) + } + } + + pub fn reregister( + &mut self, + registry: &Registry, + token: Token, + interests: Interest, + ) -> io::Result<()> { + match self.inner.as_mut() { + Some(state) => { + registry + .selector() + .reregister(state.sock_state.clone(), token, interests) + .map(|()| { + state.token = token; + state.interests = interests; + }) + } + None => Err(io::ErrorKind::NotFound.into()), + } + } + + pub fn deregister(&mut self) -> io::Result<()> { + match self.inner.as_mut() { + Some(state) => { + { + let mut sock_state = state.sock_state.lock().unwrap(); + sock_state.mark_delete(); + } + self.inner = None; + Ok(()) + } + None => Err(io::ErrorKind::NotFound.into()), + } + } + } +} diff --git a/third_party/rust/mio/src/sys/windows/named_pipe.rs b/third_party/rust/mio/src/sys/windows/named_pipe.rs new file mode 100644 index 0000000000..adda51f23c --- /dev/null +++ b/third_party/rust/mio/src/sys/windows/named_pipe.rs @@ -0,0 +1,782 @@ +use std::ffi::OsStr; +use std::io::{self, Read, Write}; +use std::os::windows::io::{AsRawHandle, FromRawHandle, IntoRawHandle, RawHandle}; +use std::sync::atomic::Ordering::{Relaxed, SeqCst}; +use std::sync::atomic::{AtomicBool, AtomicUsize}; +use std::sync::{Arc, Mutex}; +use std::{fmt, mem, slice}; + +use miow::iocp::{CompletionPort, CompletionStatus}; +use miow::pipe; +use winapi::shared::winerror::{ERROR_BROKEN_PIPE, ERROR_PIPE_LISTENING}; +use winapi::um::ioapiset::CancelIoEx; +use winapi::um::minwinbase::{OVERLAPPED, OVERLAPPED_ENTRY}; + +use crate::event::Source; +use crate::sys::windows::{Event, Overlapped}; +use crate::Registry; +use crate::{Interest, Token}; + +/// Non-blocking windows named pipe. +/// +/// This structure internally contains a `HANDLE` which represents the named +/// pipe, and also maintains state associated with the mio event loop and active +/// I/O operations that have been scheduled to translate IOCP to a readiness +/// model. +/// +/// Note, IOCP is a *completion* based model whereas mio is a *readiness* based +/// model. To bridge this, `NamedPipe` performs internal buffering. Writes are +/// written to an internal buffer and the buffer is submitted to IOCP. IOCP +/// reads are submitted using internal buffers and `NamedPipe::read` reads from +/// this internal buffer. +/// +/// # Trait implementations +/// +/// The `Read` and `Write` traits are implemented for `NamedPipe` and for +/// `&NamedPipe`. This represents that a named pipe can be concurrently read and +/// written to and also can be read and written to at all. Typically a named +/// pipe needs to be connected to a client before it can be read or written, +/// however. +/// +/// Note that for I/O operations on a named pipe to succeed then the named pipe +/// needs to be associated with an event loop. Until this happens all I/O +/// operations will return a "would block" error. +/// +/// # Managing connections +/// +/// The `NamedPipe` type supports a `connect` method to connect to a client and +/// a `disconnect` method to disconnect from that client. These two methods only +/// work once a named pipe is associated with an event loop. +/// +/// The `connect` method will succeed asynchronously and a completion can be +/// detected once the object receives a writable notification. +/// +/// # Named pipe clients +/// +/// Currently to create a client of a named pipe server then you can use the +/// `OpenOptions` type in the standard library to create a `File` that connects +/// to a named pipe. Afterwards you can use the `into_raw_handle` method coupled +/// with the `NamedPipe::from_raw_handle` method to convert that to a named pipe +/// that can operate asynchronously. Don't forget to pass the +/// `FILE_FLAG_OVERLAPPED` flag when opening the `File`. +pub struct NamedPipe { + inner: Arc<Inner>, +} + +/// # Notes +/// +/// The memory layout of this structure must be fixed as the +/// `ptr_from_*_overlapped` methods depend on it, see the `ptr_from` test. +#[repr(C)] +struct Inner { + // NOTE: careful modifying the order of these three fields, the `ptr_from_*` + // methods depend on the layout! + connect: Overlapped, + read: Overlapped, + write: Overlapped, + // END NOTE. + handle: pipe::NamedPipe, + connecting: AtomicBool, + io: Mutex<Io>, + pool: Mutex<BufferPool>, +} + +impl Inner { + /// Converts a pointer to `Inner.connect` to a pointer to `Inner`. + /// + /// # Unsafety + /// + /// Caller must ensure `ptr` is pointing to `Inner.connect`. + unsafe fn ptr_from_conn_overlapped(ptr: *mut OVERLAPPED) -> *const Inner { + // `connect` is the first field, so the pointer are the same. + ptr.cast() + } + + /// Same as [`ptr_from_conn_overlapped`] but for `Inner.read`. + unsafe fn ptr_from_read_overlapped(ptr: *mut OVERLAPPED) -> *const Inner { + // `read` is after `connect: Overlapped`. + (ptr as *mut Overlapped).wrapping_sub(1) as *const Inner + } + + /// Same as [`ptr_from_conn_overlapped`] but for `Inner.write`. + unsafe fn ptr_from_write_overlapped(ptr: *mut OVERLAPPED) -> *const Inner { + // `read` is after `connect: Overlapped` and `read: Overlapped`. + (ptr as *mut Overlapped).wrapping_sub(2) as *const Inner + } +} + +#[test] +fn ptr_from() { + use std::mem::ManuallyDrop; + use std::ptr; + + let pipe = unsafe { ManuallyDrop::new(NamedPipe::from_raw_handle(ptr::null_mut())) }; + let inner: &Inner = &pipe.inner; + assert_eq!( + inner as *const Inner, + unsafe { Inner::ptr_from_conn_overlapped(&inner.connect as *const _ as *mut OVERLAPPED) }, + "`ptr_from_conn_overlapped` incorrect" + ); + assert_eq!( + inner as *const Inner, + unsafe { Inner::ptr_from_read_overlapped(&inner.read as *const _ as *mut OVERLAPPED) }, + "`ptr_from_read_overlapped` incorrect" + ); + assert_eq!( + inner as *const Inner, + unsafe { Inner::ptr_from_write_overlapped(&inner.write as *const _ as *mut OVERLAPPED) }, + "`ptr_from_write_overlapped` incorrect" + ); +} + +struct Io { + // Uniquely identifies the selector associated with this named pipe + cp: Option<Arc<CompletionPort>>, + // Token used to identify events + token: Option<Token>, + read: State, + write: State, + connect_error: Option<io::Error>, +} + +#[derive(Debug)] +enum State { + None, + Pending(Vec<u8>, usize), + Ok(Vec<u8>, usize), + Err(io::Error), +} + +// Odd tokens are for named pipes +static NEXT_TOKEN: AtomicUsize = AtomicUsize::new(1); + +fn would_block() -> io::Error { + io::ErrorKind::WouldBlock.into() +} + +impl NamedPipe { + /// Creates a new named pipe at the specified `addr` given a "reasonable + /// set" of initial configuration options. + pub fn new<A: AsRef<OsStr>>(addr: A) -> io::Result<NamedPipe> { + let pipe = pipe::NamedPipe::new(addr)?; + // Safety: nothing actually unsafe about this. The trait fn includes + // `unsafe`. + Ok(unsafe { NamedPipe::from_raw_handle(pipe.into_raw_handle()) }) + } + + /// Attempts to call `ConnectNamedPipe`, if possible. + /// + /// This function will attempt to connect this pipe to a client in an + /// asynchronous fashion. If the function immediately establishes a + /// connection to a client then `Ok(())` is returned. Otherwise if a + /// connection attempt was issued and is now in progress then a "would + /// block" error is returned. + /// + /// When the connection is finished then this object will be flagged as + /// being ready for a write, or otherwise in the writable state. + /// + /// # Errors + /// + /// This function will return a "would block" error if the pipe has not yet + /// been registered with an event loop, if the connection operation has + /// previously been issued but has not yet completed, or if the connect + /// itself was issued and didn't finish immediately. + /// + /// Normal I/O errors from the call to `ConnectNamedPipe` are returned + /// immediately. + pub fn connect(&self) -> io::Result<()> { + // "Acquire the connecting lock" or otherwise just make sure we're the + // only operation that's using the `connect` overlapped instance. + if self.inner.connecting.swap(true, SeqCst) { + return Err(would_block()); + } + + // Now that we've flagged ourselves in the connecting state, issue the + // connection attempt. Afterwards interpret the return value and set + // internal state accordingly. + let res = unsafe { + let overlapped = self.inner.connect.as_ptr() as *mut _; + self.inner.handle.connect_overlapped(overlapped) + }; + + match res { + // The connection operation finished immediately, so let's schedule + // reads/writes and such. + Ok(true) => { + self.inner.connecting.store(false, SeqCst); + Inner::post_register(&self.inner, None); + Ok(()) + } + + // If the overlapped operation was successful and didn't finish + // immediately then we forget a copy of the arc we hold + // internally. This ensures that when the completion status comes + // in for the I/O operation finishing it'll have a reference + // associated with it and our data will still be valid. The + // `connect_done` function will "reify" this forgotten pointer to + // drop the refcount on the other side. + Ok(false) => { + mem::forget(self.inner.clone()); + Err(would_block()) + } + + Err(e) => { + self.inner.connecting.store(false, SeqCst); + Err(e) + } + } + } + + /// Takes any internal error that has happened after the last I/O operation + /// which hasn't been retrieved yet. + /// + /// This is particularly useful when detecting failed attempts to `connect`. + /// After a completed `connect` flags this pipe as writable then callers + /// must invoke this method to determine whether the connection actually + /// succeeded. If this function returns `None` then a client is connected, + /// otherwise it returns an error of what happened and a client shouldn't be + /// connected. + pub fn take_error(&self) -> io::Result<Option<io::Error>> { + Ok(self.inner.io.lock().unwrap().connect_error.take()) + } + + /// Disconnects this named pipe from a connected client. + /// + /// This function will disconnect the pipe from a connected client, if any, + /// transitively calling the `DisconnectNamedPipe` function. + /// + /// After a `disconnect` is issued, then a `connect` may be called again to + /// connect to another client. + pub fn disconnect(&self) -> io::Result<()> { + self.inner.handle.disconnect() + } +} + +impl FromRawHandle for NamedPipe { + unsafe fn from_raw_handle(handle: RawHandle) -> NamedPipe { + NamedPipe { + inner: Arc::new(Inner { + // Safety: not really unsafe + handle: pipe::NamedPipe::from_raw_handle(handle), + // transmutes to straddle winapi versions (mio 0.6 is on an + // older winapi) + connect: Overlapped::new(connect_done), + connecting: AtomicBool::new(false), + read: Overlapped::new(read_done), + write: Overlapped::new(write_done), + io: Mutex::new(Io { + cp: None, + token: None, + read: State::None, + write: State::None, + connect_error: None, + }), + pool: Mutex::new(BufferPool::with_capacity(2)), + }), + } + } +} + +impl Read for NamedPipe { + fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { + <&NamedPipe as Read>::read(&mut &*self, buf) + } +} + +impl Write for NamedPipe { + fn write(&mut self, buf: &[u8]) -> io::Result<usize> { + <&NamedPipe as Write>::write(&mut &*self, buf) + } + + fn flush(&mut self) -> io::Result<()> { + <&NamedPipe as Write>::flush(&mut &*self) + } +} + +impl<'a> Read for &'a NamedPipe { + fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { + let mut state = self.inner.io.lock().unwrap(); + + if state.token.is_none() { + return Err(would_block()); + } + + match mem::replace(&mut state.read, State::None) { + // In theory not possible with `token` checked above, + // but return would block for now. + State::None => Err(would_block()), + + // A read is in flight, still waiting for it to finish + State::Pending(buf, amt) => { + state.read = State::Pending(buf, amt); + Err(would_block()) + } + + // We previously read something into `data`, try to copy out some + // data. If we copy out all the data schedule a new read and + // otherwise store the buffer to get read later. + State::Ok(data, cur) => { + let n = { + let mut remaining = &data[cur..]; + remaining.read(buf)? + }; + let next = cur + n; + if next != data.len() { + state.read = State::Ok(data, next); + } else { + self.inner.put_buffer(data); + Inner::schedule_read(&self.inner, &mut state, None); + } + Ok(n) + } + + // Looks like an in-flight read hit an error, return that here while + // we schedule a new one. + State::Err(e) => { + Inner::schedule_read(&self.inner, &mut state, None); + if e.raw_os_error() == Some(ERROR_BROKEN_PIPE as i32) { + Ok(0) + } else { + Err(e) + } + } + } + } +} + +impl<'a> Write for &'a NamedPipe { + fn write(&mut self, buf: &[u8]) -> io::Result<usize> { + // Make sure there's no writes pending + let mut io = self.inner.io.lock().unwrap(); + + if io.token.is_none() { + return Err(would_block()); + } + + match io.write { + State::None => {} + State::Err(_) => match mem::replace(&mut io.write, State::None) { + State::Err(e) => return Err(e), + // `io` is locked, so this branch is unreachable + _ => unreachable!(), + }, + // any other state should be handled in `write_done` + _ => { + return Err(would_block()); + } + } + + // Move `buf` onto the heap and fire off the write + let mut owned_buf = self.inner.get_buffer(); + owned_buf.extend(buf); + match Inner::maybe_schedule_write(&self.inner, owned_buf, 0, &mut io)? { + // Some bytes are written immediately + Some(n) => Ok(n), + // Write operation is anqueued for whole buffer + None => Ok(buf.len()), + } + } + + fn flush(&mut self) -> io::Result<()> { + Ok(()) + } +} + +impl Source for NamedPipe { + fn register(&mut self, registry: &Registry, token: Token, _: Interest) -> io::Result<()> { + let mut io = self.inner.io.lock().unwrap(); + + io.check_association(registry, false)?; + + if io.token.is_some() { + return Err(io::Error::new( + io::ErrorKind::AlreadyExists, + "I/O source already registered with a `Registry`", + )); + } + + if io.cp.is_none() { + let selector = registry.selector(); + + io.cp = Some(selector.clone_port()); + + let inner_token = NEXT_TOKEN.fetch_add(2, Relaxed) + 2; + selector + .inner + .cp + .add_handle(inner_token, &self.inner.handle)?; + } + + io.token = Some(token); + drop(io); + + Inner::post_register(&self.inner, None); + + Ok(()) + } + + fn reregister(&mut self, registry: &Registry, token: Token, _: Interest) -> io::Result<()> { + let mut io = self.inner.io.lock().unwrap(); + + io.check_association(registry, true)?; + + io.token = Some(token); + drop(io); + + Inner::post_register(&self.inner, None); + + Ok(()) + } + + fn deregister(&mut self, registry: &Registry) -> io::Result<()> { + let mut io = self.inner.io.lock().unwrap(); + + io.check_association(registry, true)?; + + if io.token.is_none() { + return Err(io::Error::new( + io::ErrorKind::NotFound, + "I/O source not registered with `Registry`", + )); + } + + io.token = None; + Ok(()) + } +} + +impl AsRawHandle for NamedPipe { + fn as_raw_handle(&self) -> RawHandle { + self.inner.handle.as_raw_handle() + } +} + +impl fmt::Debug for NamedPipe { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.inner.handle.fmt(f) + } +} + +impl Drop for NamedPipe { + fn drop(&mut self) { + // Cancel pending reads/connects, but don't cancel writes to ensure that + // everything is flushed out. + unsafe { + if self.inner.connecting.load(SeqCst) { + drop(cancel(&self.inner.handle, &self.inner.connect)); + } + + let io = self.inner.io.lock().unwrap(); + if let State::Pending(..) = io.read { + drop(cancel(&self.inner.handle, &self.inner.read)); + } + } + } +} + +impl Inner { + /// Schedules a read to happen in the background, executing an overlapped + /// operation. + /// + /// This function returns `true` if a normal error happens or if the read + /// is scheduled in the background. If the pipe is no longer connected + /// (ERROR_PIPE_LISTENING) then `false` is returned and no read is + /// scheduled. + fn schedule_read(me: &Arc<Inner>, io: &mut Io, events: Option<&mut Vec<Event>>) -> bool { + // Check to see if a read is already scheduled/completed + match io.read { + State::None => {} + _ => return true, + } + + // Allocate a buffer and schedule the read. + let mut buf = me.get_buffer(); + let e = unsafe { + let overlapped = me.read.as_ptr() as *mut _; + let slice = slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.capacity()); + me.handle.read_overlapped(slice, overlapped) + }; + + match e { + // See `NamedPipe::connect` above for the rationale behind `forget` + Ok(_) => { + io.read = State::Pending(buf, 0); // 0 is ignored on read side + mem::forget(me.clone()); + true + } + + // If ERROR_PIPE_LISTENING happens then it's not a real read error, + // we just need to wait for a connect. + Err(ref e) if e.raw_os_error() == Some(ERROR_PIPE_LISTENING as i32) => false, + + // If some other error happened, though, we're now readable to give + // out the error. + Err(e) => { + io.read = State::Err(e); + io.notify_readable(events); + true + } + } + } + + /// Maybe schedules overlapped write operation. + /// + /// * `None` means that overlapped operation was enqueued + /// * `Some(n)` means that `n` bytes was immediately written. + /// Note, that `write_done` will fire anyway to clean up the state. + fn maybe_schedule_write( + me: &Arc<Inner>, + buf: Vec<u8>, + pos: usize, + io: &mut Io, + ) -> io::Result<Option<usize>> { + // Very similar to `schedule_read` above, just done for the write half. + let e = unsafe { + let overlapped = me.write.as_ptr() as *mut _; + me.handle.write_overlapped(&buf[pos..], overlapped) + }; + + // See `connect` above for the rationale behind `forget` + match e { + // `n` bytes are written immediately + Ok(Some(n)) => { + io.write = State::Ok(buf, pos); + mem::forget(me.clone()); + Ok(Some(n)) + } + // write operation is enqueued + Ok(None) => { + io.write = State::Pending(buf, pos); + mem::forget(me.clone()); + Ok(None) + } + Err(e) => Err(e), + } + } + + fn schedule_write( + me: &Arc<Inner>, + buf: Vec<u8>, + pos: usize, + io: &mut Io, + events: Option<&mut Vec<Event>>, + ) { + match Inner::maybe_schedule_write(me, buf, pos, io) { + Ok(Some(_)) => { + // immediate result will be handled in `write_done`, + // so we'll reinterpret the `Ok` state + let state = mem::replace(&mut io.write, State::None); + io.write = match state { + State::Ok(buf, pos) => State::Pending(buf, pos), + // io is locked, so this branch is unreachable + _ => unreachable!(), + }; + mem::forget(me.clone()); + } + Ok(None) => (), + Err(e) => { + io.write = State::Err(e); + io.notify_writable(events); + } + } + } + + fn post_register(me: &Arc<Inner>, mut events: Option<&mut Vec<Event>>) { + let mut io = me.io.lock().unwrap(); + #[allow(clippy::needless_option_as_deref)] + if Inner::schedule_read(me, &mut io, events.as_deref_mut()) { + if let State::None = io.write { + io.notify_writable(events); + } + } + } + + fn get_buffer(&self) -> Vec<u8> { + self.pool.lock().unwrap().get(4 * 1024) + } + + fn put_buffer(&self, buf: Vec<u8>) { + self.pool.lock().unwrap().put(buf) + } +} + +unsafe fn cancel<T: AsRawHandle>(handle: &T, overlapped: &Overlapped) -> io::Result<()> { + let ret = CancelIoEx(handle.as_raw_handle(), overlapped.as_ptr() as *mut _); + // `CancelIoEx` returns 0 on error: + // https://docs.microsoft.com/en-us/windows/win32/fileio/cancelioex-func + if ret == 0 { + Err(io::Error::last_os_error()) + } else { + Ok(()) + } +} + +fn connect_done(status: &OVERLAPPED_ENTRY, events: Option<&mut Vec<Event>>) { + let status = CompletionStatus::from_entry(status); + + // Acquire the `Arc<Inner>`. Note that we should be guaranteed that + // the refcount is available to us due to the `mem::forget` in + // `connect` above. + let me = unsafe { Arc::from_raw(Inner::ptr_from_conn_overlapped(status.overlapped())) }; + + // Flag ourselves as no longer using the `connect` overlapped instances. + let prev = me.connecting.swap(false, SeqCst); + assert!(prev, "NamedPipe was not previously connecting"); + + // Stash away our connect error if one happened + debug_assert_eq!(status.bytes_transferred(), 0); + unsafe { + match me.handle.result(status.overlapped()) { + Ok(n) => debug_assert_eq!(n, 0), + Err(e) => me.io.lock().unwrap().connect_error = Some(e), + } + } + + // We essentially just finished a registration, so kick off a + // read and register write readiness. + Inner::post_register(&me, events); +} + +fn read_done(status: &OVERLAPPED_ENTRY, events: Option<&mut Vec<Event>>) { + let status = CompletionStatus::from_entry(status); + + // Acquire the `FromRawArc<Inner>`. Note that we should be guaranteed that + // the refcount is available to us due to the `mem::forget` in + // `schedule_read` above. + let me = unsafe { Arc::from_raw(Inner::ptr_from_read_overlapped(status.overlapped())) }; + + // Move from the `Pending` to `Ok` state. + let mut io = me.io.lock().unwrap(); + let mut buf = match mem::replace(&mut io.read, State::None) { + State::Pending(buf, _) => buf, + _ => unreachable!(), + }; + unsafe { + match me.handle.result(status.overlapped()) { + Ok(n) => { + debug_assert_eq!(status.bytes_transferred() as usize, n); + buf.set_len(status.bytes_transferred() as usize); + io.read = State::Ok(buf, 0); + } + Err(e) => { + debug_assert_eq!(status.bytes_transferred(), 0); + io.read = State::Err(e); + } + } + } + + // Flag our readiness that we've got data. + io.notify_readable(events); +} + +fn write_done(status: &OVERLAPPED_ENTRY, events: Option<&mut Vec<Event>>) { + let status = CompletionStatus::from_entry(status); + + // Acquire the `Arc<Inner>`. Note that we should be guaranteed that + // the refcount is available to us due to the `mem::forget` in + // `schedule_write` above. + let me = unsafe { Arc::from_raw(Inner::ptr_from_write_overlapped(status.overlapped())) }; + + // Make the state change out of `Pending`. If we wrote the entire buffer + // then we're writable again and otherwise we schedule another write. + let mut io = me.io.lock().unwrap(); + let (buf, pos) = match mem::replace(&mut io.write, State::None) { + // `Ok` here means, that the operation was completed immediately + // `bytes_transferred` is already reported to a client + State::Ok(..) => { + io.notify_writable(events); + return; + } + State::Pending(buf, pos) => (buf, pos), + _ => unreachable!(), + }; + + unsafe { + match me.handle.result(status.overlapped()) { + Ok(n) => { + debug_assert_eq!(status.bytes_transferred() as usize, n); + let new_pos = pos + (status.bytes_transferred() as usize); + if new_pos == buf.len() { + me.put_buffer(buf); + io.notify_writable(events); + } else { + Inner::schedule_write(&me, buf, new_pos, &mut io, events); + } + } + Err(e) => { + debug_assert_eq!(status.bytes_transferred(), 0); + io.write = State::Err(e); + io.notify_writable(events); + } + } + } +} + +impl Io { + fn check_association(&self, registry: &Registry, required: bool) -> io::Result<()> { + match self.cp { + Some(ref cp) if !registry.selector().same_port(cp) => Err(io::Error::new( + io::ErrorKind::AlreadyExists, + "I/O source already registered with a different `Registry`", + )), + None if required => Err(io::Error::new( + io::ErrorKind::NotFound, + "I/O source not registered with `Registry`", + )), + _ => Ok(()), + } + } + + fn notify_readable(&self, events: Option<&mut Vec<Event>>) { + if let Some(token) = self.token { + let mut ev = Event::new(token); + ev.set_readable(); + + if let Some(events) = events { + events.push(ev); + } else { + let _ = self.cp.as_ref().unwrap().post(ev.to_completion_status()); + } + } + } + + fn notify_writable(&self, events: Option<&mut Vec<Event>>) { + if let Some(token) = self.token { + let mut ev = Event::new(token); + ev.set_writable(); + + if let Some(events) = events { + events.push(ev); + } else { + let _ = self.cp.as_ref().unwrap().post(ev.to_completion_status()); + } + } + } +} + +struct BufferPool { + pool: Vec<Vec<u8>>, +} + +impl BufferPool { + fn with_capacity(cap: usize) -> BufferPool { + BufferPool { + pool: Vec::with_capacity(cap), + } + } + + fn get(&mut self, default_cap: usize) -> Vec<u8> { + self.pool + .pop() + .unwrap_or_else(|| Vec::with_capacity(default_cap)) + } + + fn put(&mut self, mut buf: Vec<u8>) { + if self.pool.len() < self.pool.capacity() { + unsafe { + buf.set_len(0); + } + self.pool.push(buf); + } + } +} diff --git a/third_party/rust/mio/src/sys/windows/net.rs b/third_party/rust/mio/src/sys/windows/net.rs new file mode 100644 index 0000000000..db1896f198 --- /dev/null +++ b/third_party/rust/mio/src/sys/windows/net.rs @@ -0,0 +1,108 @@ +use std::io; +use std::mem; +use std::net::SocketAddr; +use std::sync::Once; + +use winapi::ctypes::c_int; +use winapi::shared::in6addr::{in6_addr_u, IN6_ADDR}; +use winapi::shared::inaddr::{in_addr_S_un, IN_ADDR}; +use winapi::shared::ws2def::{ADDRESS_FAMILY, AF_INET, AF_INET6, SOCKADDR, SOCKADDR_IN}; +use winapi::shared::ws2ipdef::{SOCKADDR_IN6_LH_u, SOCKADDR_IN6_LH}; +use winapi::um::winsock2::{ioctlsocket, socket, FIONBIO, INVALID_SOCKET, SOCKET}; + +/// Initialise the network stack for Windows. +pub(crate) fn init() { + static INIT: Once = Once::new(); + INIT.call_once(|| { + // Let standard library call `WSAStartup` for us, we can't do it + // ourselves because otherwise using any type in `std::net` would panic + // when it tries to call `WSAStartup` a second time. + drop(std::net::UdpSocket::bind("127.0.0.1:0")); + }); +} + +/// Create a new non-blocking socket. +pub(crate) fn new_ip_socket(addr: SocketAddr, socket_type: c_int) -> io::Result<SOCKET> { + use winapi::um::winsock2::{PF_INET, PF_INET6}; + + let domain = match addr { + SocketAddr::V4(..) => PF_INET, + SocketAddr::V6(..) => PF_INET6, + }; + + new_socket(domain, socket_type) +} + +pub(crate) fn new_socket(domain: c_int, socket_type: c_int) -> io::Result<SOCKET> { + syscall!( + socket(domain, socket_type, 0), + PartialEq::eq, + INVALID_SOCKET + ) + .and_then(|socket| { + syscall!(ioctlsocket(socket, FIONBIO, &mut 1), PartialEq::ne, 0).map(|_| socket as SOCKET) + }) +} + +/// A type with the same memory layout as `SOCKADDR`. Used in converting Rust level +/// SocketAddr* types into their system representation. The benefit of this specific +/// type over using `SOCKADDR_STORAGE` is that this type is exactly as large as it +/// needs to be and not a lot larger. And it can be initialized cleaner from Rust. +#[repr(C)] +pub(crate) union SocketAddrCRepr { + v4: SOCKADDR_IN, + v6: SOCKADDR_IN6_LH, +} + +impl SocketAddrCRepr { + pub(crate) fn as_ptr(&self) -> *const SOCKADDR { + self as *const _ as *const SOCKADDR + } +} + +pub(crate) fn socket_addr(addr: &SocketAddr) -> (SocketAddrCRepr, c_int) { + match addr { + SocketAddr::V4(ref addr) => { + // `s_addr` is stored as BE on all machine and the array is in BE order. + // So the native endian conversion method is used so that it's never swapped. + let sin_addr = unsafe { + let mut s_un = mem::zeroed::<in_addr_S_un>(); + *s_un.S_addr_mut() = u32::from_ne_bytes(addr.ip().octets()); + IN_ADDR { S_un: s_un } + }; + + let sockaddr_in = SOCKADDR_IN { + sin_family: AF_INET as ADDRESS_FAMILY, + sin_port: addr.port().to_be(), + sin_addr, + sin_zero: [0; 8], + }; + + let sockaddr = SocketAddrCRepr { v4: sockaddr_in }; + (sockaddr, mem::size_of::<SOCKADDR_IN>() as c_int) + } + SocketAddr::V6(ref addr) => { + let sin6_addr = unsafe { + let mut u = mem::zeroed::<in6_addr_u>(); + *u.Byte_mut() = addr.ip().octets(); + IN6_ADDR { u } + }; + let u = unsafe { + let mut u = mem::zeroed::<SOCKADDR_IN6_LH_u>(); + *u.sin6_scope_id_mut() = addr.scope_id(); + u + }; + + let sockaddr_in6 = SOCKADDR_IN6_LH { + sin6_family: AF_INET6 as ADDRESS_FAMILY, + sin6_port: addr.port().to_be(), + sin6_addr, + sin6_flowinfo: addr.flowinfo(), + u, + }; + + let sockaddr = SocketAddrCRepr { v6: sockaddr_in6 }; + (sockaddr, mem::size_of::<SOCKADDR_IN6_LH>() as c_int) + } + } +} diff --git a/third_party/rust/mio/src/sys/windows/overlapped.rs b/third_party/rust/mio/src/sys/windows/overlapped.rs new file mode 100644 index 0000000000..837b78b60a --- /dev/null +++ b/third_party/rust/mio/src/sys/windows/overlapped.rs @@ -0,0 +1,37 @@ +use crate::sys::windows::Event; + +use std::cell::UnsafeCell; +use std::fmt; + +#[cfg(feature = "os-ext")] +use winapi::um::minwinbase::OVERLAPPED; +use winapi::um::minwinbase::OVERLAPPED_ENTRY; + +#[repr(C)] +pub(crate) struct Overlapped { + inner: UnsafeCell<miow::Overlapped>, + pub(crate) callback: fn(&OVERLAPPED_ENTRY, Option<&mut Vec<Event>>), +} + +#[cfg(feature = "os-ext")] +impl Overlapped { + pub(crate) fn new(cb: fn(&OVERLAPPED_ENTRY, Option<&mut Vec<Event>>)) -> Overlapped { + Overlapped { + inner: UnsafeCell::new(miow::Overlapped::zero()), + callback: cb, + } + } + + pub(crate) fn as_ptr(&self) -> *const OVERLAPPED { + unsafe { (*self.inner.get()).raw() } + } +} + +impl fmt::Debug for Overlapped { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("Overlapped").finish() + } +} + +unsafe impl Send for Overlapped {} +unsafe impl Sync for Overlapped {} diff --git a/third_party/rust/mio/src/sys/windows/selector.rs b/third_party/rust/mio/src/sys/windows/selector.rs new file mode 100644 index 0000000000..133fefe895 --- /dev/null +++ b/third_party/rust/mio/src/sys/windows/selector.rs @@ -0,0 +1,748 @@ +use super::afd::{self, Afd, AfdPollInfo}; +use super::io_status_block::IoStatusBlock; +use super::Event; +use crate::sys::Events; + +cfg_net! { + use crate::sys::event::{ + ERROR_FLAGS, READABLE_FLAGS, READ_CLOSED_FLAGS, WRITABLE_FLAGS, WRITE_CLOSED_FLAGS, + }; + use crate::Interest; +} + +use miow::iocp::{CompletionPort, CompletionStatus}; +use std::collections::VecDeque; +use std::io; +use std::marker::PhantomPinned; +use std::os::windows::io::RawSocket; +use std::pin::Pin; +#[cfg(debug_assertions)] +use std::sync::atomic::AtomicUsize; +use std::sync::atomic::{AtomicBool, Ordering}; +use std::sync::{Arc, Mutex}; +use std::time::Duration; +use winapi::shared::ntdef::NT_SUCCESS; +use winapi::shared::ntdef::{HANDLE, PVOID}; +use winapi::shared::ntstatus::STATUS_CANCELLED; +use winapi::shared::winerror::{ERROR_INVALID_HANDLE, ERROR_IO_PENDING, WAIT_TIMEOUT}; +use winapi::um::minwinbase::OVERLAPPED; + +#[derive(Debug)] +struct AfdGroup { + #[cfg_attr(not(feature = "net"), allow(dead_code))] + cp: Arc<CompletionPort>, + afd_group: Mutex<Vec<Arc<Afd>>>, +} + +impl AfdGroup { + pub fn new(cp: Arc<CompletionPort>) -> AfdGroup { + AfdGroup { + afd_group: Mutex::new(Vec::new()), + cp, + } + } + + pub fn release_unused_afd(&self) { + let mut afd_group = self.afd_group.lock().unwrap(); + afd_group.retain(|g| Arc::strong_count(g) > 1); + } +} + +cfg_io_source! { + const POLL_GROUP__MAX_GROUP_SIZE: usize = 32; + + impl AfdGroup { + pub fn acquire(&self) -> io::Result<Arc<Afd>> { + let mut afd_group = self.afd_group.lock().unwrap(); + if afd_group.len() == 0 { + self._alloc_afd_group(&mut afd_group)?; + } else { + // + 1 reference in Vec + if Arc::strong_count(afd_group.last().unwrap()) > POLL_GROUP__MAX_GROUP_SIZE { + self._alloc_afd_group(&mut afd_group)?; + } + } + + match afd_group.last() { + Some(arc) => Ok(arc.clone()), + None => unreachable!( + "Cannot acquire afd, {:#?}, afd_group: {:#?}", + self, afd_group + ), + } + } + + fn _alloc_afd_group(&self, afd_group: &mut Vec<Arc<Afd>>) -> io::Result<()> { + let afd = Afd::new(&self.cp)?; + let arc = Arc::new(afd); + afd_group.push(arc); + Ok(()) + } + } +} + +#[derive(Debug)] +enum SockPollStatus { + Idle, + Pending, + Cancelled, +} + +#[derive(Debug)] +pub struct SockState { + iosb: IoStatusBlock, + poll_info: AfdPollInfo, + afd: Arc<Afd>, + + base_socket: RawSocket, + + user_evts: u32, + pending_evts: u32, + + user_data: u64, + + poll_status: SockPollStatus, + delete_pending: bool, + + // last raw os error + error: Option<i32>, + + _pinned: PhantomPinned, +} + +impl SockState { + fn update(&mut self, self_arc: &Pin<Arc<Mutex<SockState>>>) -> io::Result<()> { + assert!(!self.delete_pending); + + // make sure to reset previous error before a new update + self.error = None; + + if let SockPollStatus::Pending = self.poll_status { + if (self.user_evts & afd::KNOWN_EVENTS & !self.pending_evts) == 0 { + /* All the events the user is interested in are already being monitored by + * the pending poll operation. It might spuriously complete because of an + * event that we're no longer interested in; when that happens we'll submit + * a new poll operation with the updated event mask. */ + } else { + /* A poll operation is already pending, but it's not monitoring for all the + * events that the user is interested in. Therefore, cancel the pending + * poll operation; when we receive it's completion package, a new poll + * operation will be submitted with the correct event mask. */ + if let Err(e) = self.cancel() { + self.error = e.raw_os_error(); + return Err(e); + } + return Ok(()); + } + } else if let SockPollStatus::Cancelled = self.poll_status { + /* The poll operation has already been cancelled, we're still waiting for + * it to return. For now, there's nothing that needs to be done. */ + } else if let SockPollStatus::Idle = self.poll_status { + /* No poll operation is pending; start one. */ + self.poll_info.exclusive = 0; + self.poll_info.number_of_handles = 1; + *unsafe { self.poll_info.timeout.QuadPart_mut() } = std::i64::MAX; + self.poll_info.handles[0].handle = self.base_socket as HANDLE; + self.poll_info.handles[0].status = 0; + self.poll_info.handles[0].events = self.user_evts | afd::POLL_LOCAL_CLOSE; + + // Increase the ref count as the memory will be used by the kernel. + let overlapped_ptr = into_overlapped(self_arc.clone()); + + let result = unsafe { + self.afd + .poll(&mut self.poll_info, &mut *self.iosb, overlapped_ptr) + }; + if let Err(e) = result { + let code = e.raw_os_error().unwrap(); + if code == ERROR_IO_PENDING as i32 { + /* Overlapped poll operation in progress; this is expected. */ + } else { + // Since the operation failed it means the kernel won't be + // using the memory any more. + drop(from_overlapped(overlapped_ptr as *mut _)); + if code == ERROR_INVALID_HANDLE as i32 { + /* Socket closed; it'll be dropped. */ + self.mark_delete(); + return Ok(()); + } else { + self.error = e.raw_os_error(); + return Err(e); + } + } + } + + self.poll_status = SockPollStatus::Pending; + self.pending_evts = self.user_evts; + } else { + unreachable!("Invalid poll status during update, {:#?}", self) + } + + Ok(()) + } + + fn cancel(&mut self) -> io::Result<()> { + match self.poll_status { + SockPollStatus::Pending => {} + _ => unreachable!("Invalid poll status during cancel, {:#?}", self), + }; + unsafe { + self.afd.cancel(&mut *self.iosb)?; + } + self.poll_status = SockPollStatus::Cancelled; + self.pending_evts = 0; + Ok(()) + } + + // This is the function called from the overlapped using as Arc<Mutex<SockState>>. Watch out for reference counting. + fn feed_event(&mut self) -> Option<Event> { + self.poll_status = SockPollStatus::Idle; + self.pending_evts = 0; + + let mut afd_events = 0; + // We use the status info in IO_STATUS_BLOCK to determine the socket poll status. It is unsafe to use a pointer of IO_STATUS_BLOCK. + unsafe { + if self.delete_pending { + return None; + } else if self.iosb.u.Status == STATUS_CANCELLED { + /* The poll request was cancelled by CancelIoEx. */ + } else if !NT_SUCCESS(self.iosb.u.Status) { + /* The overlapped request itself failed in an unexpected way. */ + afd_events = afd::POLL_CONNECT_FAIL; + } else if self.poll_info.number_of_handles < 1 { + /* This poll operation succeeded but didn't report any socket events. */ + } else if self.poll_info.handles[0].events & afd::POLL_LOCAL_CLOSE != 0 { + /* The poll operation reported that the socket was closed. */ + self.mark_delete(); + return None; + } else { + afd_events = self.poll_info.handles[0].events; + } + } + + afd_events &= self.user_evts; + + if afd_events == 0 { + return None; + } + + // In mio, we have to simulate Edge-triggered behavior to match API usage. + // The strategy here is to intercept all read/write from user that could cause WouldBlock usage, + // then reregister the socket to reset the interests. + self.user_evts &= !afd_events; + + Some(Event { + data: self.user_data, + flags: afd_events, + }) + } + + pub fn is_pending_deletion(&self) -> bool { + self.delete_pending + } + + pub fn mark_delete(&mut self) { + if !self.delete_pending { + if let SockPollStatus::Pending = self.poll_status { + drop(self.cancel()); + } + + self.delete_pending = true; + } + } + + fn has_error(&self) -> bool { + self.error.is_some() + } +} + +cfg_io_source! { + impl SockState { + fn new(raw_socket: RawSocket, afd: Arc<Afd>) -> io::Result<SockState> { + Ok(SockState { + iosb: IoStatusBlock::zeroed(), + poll_info: AfdPollInfo::zeroed(), + afd, + base_socket: get_base_socket(raw_socket)?, + user_evts: 0, + pending_evts: 0, + user_data: 0, + poll_status: SockPollStatus::Idle, + delete_pending: false, + error: None, + _pinned: PhantomPinned, + }) + } + + /// True if need to be added on update queue, false otherwise. + fn set_event(&mut self, ev: Event) -> bool { + /* afd::POLL_CONNECT_FAIL and afd::POLL_ABORT are always reported, even when not requested by the caller. */ + let events = ev.flags | afd::POLL_CONNECT_FAIL | afd::POLL_ABORT; + + self.user_evts = events; + self.user_data = ev.data; + + (events & !self.pending_evts) != 0 + } + } +} + +impl Drop for SockState { + fn drop(&mut self) { + self.mark_delete(); + } +} + +/// Converts the pointer to a `SockState` into a raw pointer. +/// To revert see `from_overlapped`. +fn into_overlapped(sock_state: Pin<Arc<Mutex<SockState>>>) -> PVOID { + let overlapped_ptr: *const Mutex<SockState> = + unsafe { Arc::into_raw(Pin::into_inner_unchecked(sock_state)) }; + overlapped_ptr as *mut _ +} + +/// Convert a raw overlapped pointer into a reference to `SockState`. +/// Reverts `into_overlapped`. +fn from_overlapped(ptr: *mut OVERLAPPED) -> Pin<Arc<Mutex<SockState>>> { + let sock_ptr: *const Mutex<SockState> = ptr as *const _; + unsafe { Pin::new_unchecked(Arc::from_raw(sock_ptr)) } +} + +/// Each Selector has a globally unique(ish) ID associated with it. This ID +/// gets tracked by `TcpStream`, `TcpListener`, etc... when they are first +/// registered with the `Selector`. If a type that is previously associated with +/// a `Selector` attempts to register itself with a different `Selector`, the +/// operation will return with an error. This matches windows behavior. +#[cfg(debug_assertions)] +static NEXT_ID: AtomicUsize = AtomicUsize::new(0); + +/// Windows implementaion of `sys::Selector` +/// +/// Edge-triggered event notification is simulated by resetting internal event flag of each socket state `SockState` +/// and setting all events back by intercepting all requests that could cause `io::ErrorKind::WouldBlock` happening. +/// +/// This selector is currently only support socket due to `Afd` driver is winsock2 specific. +#[derive(Debug)] +pub struct Selector { + #[cfg(debug_assertions)] + id: usize, + pub(super) inner: Arc<SelectorInner>, + #[cfg(debug_assertions)] + has_waker: AtomicBool, +} + +impl Selector { + pub fn new() -> io::Result<Selector> { + SelectorInner::new().map(|inner| { + #[cfg(debug_assertions)] + let id = NEXT_ID.fetch_add(1, Ordering::Relaxed) + 1; + Selector { + #[cfg(debug_assertions)] + id, + inner: Arc::new(inner), + #[cfg(debug_assertions)] + has_waker: AtomicBool::new(false), + } + }) + } + + pub fn try_clone(&self) -> io::Result<Selector> { + Ok(Selector { + #[cfg(debug_assertions)] + id: self.id, + inner: Arc::clone(&self.inner), + #[cfg(debug_assertions)] + has_waker: AtomicBool::new(self.has_waker.load(Ordering::Acquire)), + }) + } + + /// # Safety + /// + /// This requires a mutable reference to self because only a single thread + /// can poll IOCP at a time. + pub fn select(&mut self, events: &mut Events, timeout: Option<Duration>) -> io::Result<()> { + self.inner.select(events, timeout) + } + + #[cfg(debug_assertions)] + pub fn register_waker(&self) -> bool { + self.has_waker.swap(true, Ordering::AcqRel) + } + + pub(super) fn clone_port(&self) -> Arc<CompletionPort> { + self.inner.cp.clone() + } + + #[cfg(feature = "os-ext")] + pub(super) fn same_port(&self, other: &Arc<CompletionPort>) -> bool { + Arc::ptr_eq(&self.inner.cp, other) + } +} + +cfg_io_source! { + use super::InternalState; + use crate::Token; + + impl Selector { + pub(super) fn register( + &self, + socket: RawSocket, + token: Token, + interests: Interest, + ) -> io::Result<InternalState> { + SelectorInner::register(&self.inner, socket, token, interests) + } + + pub(super) fn reregister( + &self, + state: Pin<Arc<Mutex<SockState>>>, + token: Token, + interests: Interest, + ) -> io::Result<()> { + self.inner.reregister(state, token, interests) + } + + #[cfg(debug_assertions)] + pub fn id(&self) -> usize { + self.id + } + } +} + +#[derive(Debug)] +pub struct SelectorInner { + pub(super) cp: Arc<CompletionPort>, + update_queue: Mutex<VecDeque<Pin<Arc<Mutex<SockState>>>>>, + afd_group: AfdGroup, + is_polling: AtomicBool, +} + +// We have ensured thread safety by introducing lock manually. +unsafe impl Sync for SelectorInner {} + +impl SelectorInner { + pub fn new() -> io::Result<SelectorInner> { + CompletionPort::new(0).map(|cp| { + let cp = Arc::new(cp); + let cp_afd = Arc::clone(&cp); + + SelectorInner { + cp, + update_queue: Mutex::new(VecDeque::new()), + afd_group: AfdGroup::new(cp_afd), + is_polling: AtomicBool::new(false), + } + }) + } + + /// # Safety + /// + /// May only be calling via `Selector::select`. + pub fn select(&self, events: &mut Events, timeout: Option<Duration>) -> io::Result<()> { + events.clear(); + + if timeout.is_none() { + loop { + let len = self.select2(&mut events.statuses, &mut events.events, None)?; + if len == 0 { + continue; + } + break Ok(()); + } + } else { + self.select2(&mut events.statuses, &mut events.events, timeout)?; + Ok(()) + } + } + + pub fn select2( + &self, + statuses: &mut [CompletionStatus], + events: &mut Vec<Event>, + timeout: Option<Duration>, + ) -> io::Result<usize> { + assert!(!self.is_polling.swap(true, Ordering::AcqRel)); + + unsafe { self.update_sockets_events() }?; + + let result = self.cp.get_many(statuses, timeout); + + self.is_polling.store(false, Ordering::Relaxed); + + match result { + Ok(iocp_events) => Ok(unsafe { self.feed_events(events, iocp_events) }), + Err(ref e) if e.raw_os_error() == Some(WAIT_TIMEOUT as i32) => Ok(0), + Err(e) => Err(e), + } + } + + unsafe fn update_sockets_events(&self) -> io::Result<()> { + let mut update_queue = self.update_queue.lock().unwrap(); + for sock in update_queue.iter_mut() { + let mut sock_internal = sock.lock().unwrap(); + if !sock_internal.is_pending_deletion() { + sock_internal.update(sock)?; + } + } + + // remove all sock which do not have error, they have afd op pending + update_queue.retain(|sock| sock.lock().unwrap().has_error()); + + self.afd_group.release_unused_afd(); + Ok(()) + } + + // It returns processed count of iocp_events rather than the events itself. + unsafe fn feed_events( + &self, + events: &mut Vec<Event>, + iocp_events: &[CompletionStatus], + ) -> usize { + let mut n = 0; + let mut update_queue = self.update_queue.lock().unwrap(); + for iocp_event in iocp_events.iter() { + if iocp_event.overlapped().is_null() { + events.push(Event::from_completion_status(iocp_event)); + n += 1; + continue; + } else if iocp_event.token() % 2 == 1 { + // Handle is a named pipe. This could be extended to be any non-AFD event. + let callback = (*(iocp_event.overlapped() as *mut super::Overlapped)).callback; + + let len = events.len(); + callback(iocp_event.entry(), Some(events)); + n += events.len() - len; + continue; + } + + let sock_state = from_overlapped(iocp_event.overlapped()); + let mut sock_guard = sock_state.lock().unwrap(); + if let Some(e) = sock_guard.feed_event() { + events.push(e); + n += 1; + } + + if !sock_guard.is_pending_deletion() { + update_queue.push_back(sock_state.clone()); + } + } + self.afd_group.release_unused_afd(); + n + } +} + +cfg_io_source! { + use std::mem::size_of; + use std::ptr::null_mut; + use winapi::um::mswsock; + use winapi::um::winsock2::WSAGetLastError; + use winapi::um::winsock2::{WSAIoctl, SOCKET_ERROR}; + + impl SelectorInner { + fn register( + this: &Arc<Self>, + socket: RawSocket, + token: Token, + interests: Interest, + ) -> io::Result<InternalState> { + let flags = interests_to_afd_flags(interests); + + let sock = { + let sock = this._alloc_sock_for_rawsocket(socket)?; + let event = Event { + flags, + data: token.0 as u64, + }; + sock.lock().unwrap().set_event(event); + sock + }; + + let state = InternalState { + selector: this.clone(), + token, + interests, + sock_state: sock.clone(), + }; + + this.queue_state(sock); + unsafe { this.update_sockets_events_if_polling()? }; + + Ok(state) + } + + // Directly accessed in `IoSourceState::do_io`. + pub(super) fn reregister( + &self, + state: Pin<Arc<Mutex<SockState>>>, + token: Token, + interests: Interest, + ) -> io::Result<()> { + { + let event = Event { + flags: interests_to_afd_flags(interests), + data: token.0 as u64, + }; + + state.lock().unwrap().set_event(event); + } + + // FIXME: a sock which has_error true should not be re-added to + // the update queue because it's already there. + self.queue_state(state); + unsafe { self.update_sockets_events_if_polling() } + } + + /// This function is called by register() and reregister() to start an + /// IOCTL_AFD_POLL operation corresponding to the registered events, but + /// only if necessary. + /// + /// Since it is not possible to modify or synchronously cancel an AFD_POLL + /// operation, and there can be only one active AFD_POLL operation per + /// (socket, completion port) pair at any time, it is expensive to change + /// a socket's event registration after it has been submitted to the kernel. + /// + /// Therefore, if no other threads are polling when interest in a socket + /// event is (re)registered, the socket is added to the 'update queue', but + /// the actual syscall to start the IOCTL_AFD_POLL operation is deferred + /// until just before the GetQueuedCompletionStatusEx() syscall is made. + /// + /// However, when another thread is already blocked on + /// GetQueuedCompletionStatusEx() we tell the kernel about the registered + /// socket event(s) immediately. + unsafe fn update_sockets_events_if_polling(&self) -> io::Result<()> { + if self.is_polling.load(Ordering::Acquire) { + self.update_sockets_events() + } else { + Ok(()) + } + } + + fn queue_state(&self, sock_state: Pin<Arc<Mutex<SockState>>>) { + let mut update_queue = self.update_queue.lock().unwrap(); + update_queue.push_back(sock_state); + } + + fn _alloc_sock_for_rawsocket( + &self, + raw_socket: RawSocket, + ) -> io::Result<Pin<Arc<Mutex<SockState>>>> { + let afd = self.afd_group.acquire()?; + Ok(Arc::pin(Mutex::new(SockState::new(raw_socket, afd)?))) + } + } + + fn try_get_base_socket(raw_socket: RawSocket, ioctl: u32) -> Result<RawSocket, i32> { + let mut base_socket: RawSocket = 0; + let mut bytes: u32 = 0; + unsafe { + if WSAIoctl( + raw_socket as usize, + ioctl, + null_mut(), + 0, + &mut base_socket as *mut _ as PVOID, + size_of::<RawSocket>() as u32, + &mut bytes, + null_mut(), + None, + ) != SOCKET_ERROR + { + Ok(base_socket) + } else { + Err(WSAGetLastError()) + } + } + } + + fn get_base_socket(raw_socket: RawSocket) -> io::Result<RawSocket> { + let res = try_get_base_socket(raw_socket, mswsock::SIO_BASE_HANDLE); + if let Ok(base_socket) = res { + return Ok(base_socket); + } + + // The `SIO_BASE_HANDLE` should not be intercepted by LSPs, therefore + // it should not fail as long as `raw_socket` is a valid socket. See + // https://docs.microsoft.com/en-us/windows/win32/winsock/winsock-ioctls. + // However, at least one known LSP deliberately breaks it, so we try + // some alternative IOCTLs, starting with the most appropriate one. + for &ioctl in &[ + mswsock::SIO_BSP_HANDLE_SELECT, + mswsock::SIO_BSP_HANDLE_POLL, + mswsock::SIO_BSP_HANDLE, + ] { + if let Ok(base_socket) = try_get_base_socket(raw_socket, ioctl) { + // Since we know now that we're dealing with an LSP (otherwise + // SIO_BASE_HANDLE would't have failed), only return any result + // when it is different from the original `raw_socket`. + if base_socket != raw_socket { + return Ok(base_socket); + } + } + } + + // If the alternative IOCTLs also failed, return the original error. + let os_error = res.unwrap_err(); + let err = io::Error::from_raw_os_error(os_error); + Err(err) + } +} + +impl Drop for SelectorInner { + fn drop(&mut self) { + loop { + let events_num: usize; + let mut statuses: [CompletionStatus; 1024] = [CompletionStatus::zero(); 1024]; + + let result = self + .cp + .get_many(&mut statuses, Some(std::time::Duration::from_millis(0))); + match result { + Ok(iocp_events) => { + events_num = iocp_events.iter().len(); + for iocp_event in iocp_events.iter() { + if iocp_event.overlapped().is_null() { + // Custom event + } else if iocp_event.token() % 2 == 1 { + // Named pipe, dispatch the event so it can release resources + let callback = unsafe { + (*(iocp_event.overlapped() as *mut super::Overlapped)).callback + }; + + callback(iocp_event.entry(), None); + } else { + // drain sock state to release memory of Arc reference + let _sock_state = from_overlapped(iocp_event.overlapped()); + } + } + } + + Err(_) => { + break; + } + } + + if events_num == 0 { + // continue looping until all completion statuses have been drained + break; + } + } + + self.afd_group.release_unused_afd(); + } +} + +cfg_net! { + fn interests_to_afd_flags(interests: Interest) -> u32 { + let mut flags = 0; + + if interests.is_readable() { + flags |= READABLE_FLAGS | READ_CLOSED_FLAGS | ERROR_FLAGS; + } + + if interests.is_writable() { + flags |= WRITABLE_FLAGS | WRITE_CLOSED_FLAGS | ERROR_FLAGS; + } + + flags + } +} diff --git a/third_party/rust/mio/src/sys/windows/tcp.rs b/third_party/rust/mio/src/sys/windows/tcp.rs new file mode 100644 index 0000000000..b3f05aec65 --- /dev/null +++ b/third_party/rust/mio/src/sys/windows/tcp.rs @@ -0,0 +1,71 @@ +use std::io; +use std::net::{self, SocketAddr}; +use std::os::windows::io::AsRawSocket; + +use winapi::um::winsock2::{self, PF_INET, PF_INET6, SOCKET, SOCKET_ERROR, SOCK_STREAM}; + +use crate::sys::windows::net::{init, new_socket, socket_addr}; + +pub(crate) fn new_for_addr(address: SocketAddr) -> io::Result<SOCKET> { + init(); + let domain = match address { + SocketAddr::V4(_) => PF_INET, + SocketAddr::V6(_) => PF_INET6, + }; + new_socket(domain, SOCK_STREAM) +} + +pub(crate) fn bind(socket: &net::TcpListener, addr: SocketAddr) -> io::Result<()> { + use winsock2::bind; + + let (raw_addr, raw_addr_length) = socket_addr(&addr); + syscall!( + bind( + socket.as_raw_socket() as _, + raw_addr.as_ptr(), + raw_addr_length + ), + PartialEq::eq, + SOCKET_ERROR + )?; + Ok(()) +} + +pub(crate) fn connect(socket: &net::TcpStream, addr: SocketAddr) -> io::Result<()> { + use winsock2::connect; + + let (raw_addr, raw_addr_length) = socket_addr(&addr); + let res = syscall!( + connect( + socket.as_raw_socket() as _, + raw_addr.as_ptr(), + raw_addr_length + ), + PartialEq::eq, + SOCKET_ERROR + ); + + match res { + Err(err) if err.kind() != io::ErrorKind::WouldBlock => Err(err), + _ => Ok(()), + } +} + +pub(crate) fn listen(socket: &net::TcpListener, backlog: u32) -> io::Result<()> { + use std::convert::TryInto; + use winsock2::listen; + + let backlog = backlog.try_into().unwrap_or(i32::max_value()); + syscall!( + listen(socket.as_raw_socket() as _, backlog), + PartialEq::eq, + SOCKET_ERROR + )?; + Ok(()) +} + +pub(crate) fn accept(listener: &net::TcpListener) -> io::Result<(net::TcpStream, SocketAddr)> { + // The non-blocking state of `listener` is inherited. See + // https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-accept#remarks. + listener.accept() +} diff --git a/third_party/rust/mio/src/sys/windows/udp.rs b/third_party/rust/mio/src/sys/windows/udp.rs new file mode 100644 index 0000000000..825ecccff4 --- /dev/null +++ b/third_party/rust/mio/src/sys/windows/udp.rs @@ -0,0 +1,53 @@ +use std::io; +use std::mem::{self, MaybeUninit}; +use std::net::{self, SocketAddr}; +use std::os::windows::io::{AsRawSocket, FromRawSocket}; +use std::os::windows::raw::SOCKET as StdSocket; // winapi uses usize, stdlib uses u32/u64. + +use winapi::ctypes::c_int; +use winapi::shared::ws2def::IPPROTO_IPV6; +use winapi::shared::ws2ipdef::IPV6_V6ONLY; +use winapi::um::winsock2::{bind as win_bind, closesocket, getsockopt, SOCKET_ERROR, SOCK_DGRAM}; + +use crate::sys::windows::net::{init, new_ip_socket, socket_addr}; + +pub fn bind(addr: SocketAddr) -> io::Result<net::UdpSocket> { + init(); + new_ip_socket(addr, SOCK_DGRAM).and_then(|socket| { + let (raw_addr, raw_addr_length) = socket_addr(&addr); + syscall!( + win_bind(socket, raw_addr.as_ptr(), raw_addr_length,), + PartialEq::eq, + SOCKET_ERROR + ) + .map_err(|err| { + // Close the socket if we hit an error, ignoring the error + // from closing since we can't pass back two errors. + let _ = unsafe { closesocket(socket) }; + err + }) + .map(|_| unsafe { net::UdpSocket::from_raw_socket(socket as StdSocket) }) + }) +} + +pub(crate) fn only_v6(socket: &net::UdpSocket) -> io::Result<bool> { + let mut optval: MaybeUninit<c_int> = MaybeUninit::uninit(); + let mut optlen = mem::size_of::<c_int>() as c_int; + + syscall!( + getsockopt( + socket.as_raw_socket() as usize, + IPPROTO_IPV6 as c_int, + IPV6_V6ONLY as c_int, + optval.as_mut_ptr().cast(), + &mut optlen, + ), + PartialEq::eq, + SOCKET_ERROR + )?; + + debug_assert_eq!(optlen as usize, mem::size_of::<c_int>()); + // Safety: `getsockopt` initialised `optval` for us. + let optval = unsafe { optval.assume_init() }; + Ok(optval != 0) +} diff --git a/third_party/rust/mio/src/sys/windows/waker.rs b/third_party/rust/mio/src/sys/windows/waker.rs new file mode 100644 index 0000000000..ab12c3c689 --- /dev/null +++ b/third_party/rust/mio/src/sys/windows/waker.rs @@ -0,0 +1,29 @@ +use crate::sys::windows::Event; +use crate::sys::windows::Selector; +use crate::Token; + +use miow::iocp::CompletionPort; +use std::io; +use std::sync::Arc; + +#[derive(Debug)] +pub struct Waker { + token: Token, + port: Arc<CompletionPort>, +} + +impl Waker { + pub fn new(selector: &Selector, token: Token) -> io::Result<Waker> { + Ok(Waker { + token, + port: selector.clone_port(), + }) + } + + pub fn wake(&self) -> io::Result<()> { + let mut ev = Event::new(self.token); + ev.set_readable(); + + self.port.post(ev.to_completion_status()) + } +} diff --git a/third_party/rust/mio/src/token.rs b/third_party/rust/mio/src/token.rs new file mode 100644 index 0000000000..91601cde0c --- /dev/null +++ b/third_party/rust/mio/src/token.rs @@ -0,0 +1,138 @@ +/// Associates readiness events with [`event::Source`]s. +/// +/// `Token` is a wrapper around `usize` and is used as an argument to +/// [`Registry::register`] and [`Registry::reregister`]. +/// +/// See [`Poll`] for more documentation on polling. +/// +/// [`event::Source`]: ./event/trait.Source.html +/// [`Poll`]: struct.Poll.html +/// [`Registry::register`]: struct.Registry.html#method.register +/// [`Registry::reregister`]: struct.Registry.html#method.reregister +/// +/// # Example +/// +/// Using `Token` to track which socket generated the event. In this example, +/// `HashMap` is used, but usually something like [`slab`] is better. +/// +/// [`slab`]: https://crates.io/crates/slab +/// +#[cfg_attr(all(feature = "os-poll", feature = "net"), doc = "```")] +#[cfg_attr(not(all(feature = "os-poll", feature = "net")), doc = "```ignore")] +/// # use std::error::Error; +/// # fn main() -> Result<(), Box<dyn Error>> { +/// use mio::{Events, Interest, Poll, Token}; +/// use mio::net::TcpListener; +/// +/// use std::thread; +/// use std::io::{self, Read}; +/// use std::collections::HashMap; +/// +/// // After this number of sockets is accepted, the server will shutdown. +/// const MAX_SOCKETS: usize = 32; +/// +/// // Pick a token that will not be used by any other socket and use that one +/// // for the listener. +/// const LISTENER: Token = Token(1024); +/// +/// // Used to store the sockets. +/// let mut sockets = HashMap::new(); +/// +/// // This is used to generate a unique token for a socket +/// let mut next_socket_index = 0; +/// +/// // The `Poll` instance +/// let mut poll = Poll::new()?; +/// +/// // Tcp listener +/// let mut listener = TcpListener::bind("127.0.0.1:0".parse()?)?; +/// +/// // Register the listener +/// poll.registry().register(&mut listener, LISTENER, Interest::READABLE)?; +/// +/// // Spawn a thread that will connect a bunch of sockets then close them +/// let addr = listener.local_addr()?; +/// thread::spawn(move || { +/// use std::net::TcpStream; +/// +/// // +1 here is to connect an extra socket to signal the socket to close +/// for _ in 0..(MAX_SOCKETS+1) { +/// // Connect then drop the socket +/// let _ = TcpStream::connect(addr).unwrap(); +/// } +/// }); +/// +/// // Event storage +/// let mut events = Events::with_capacity(1024); +/// +/// // Read buffer, this will never actually get filled +/// let mut buf = [0; 256]; +/// +/// // The main event loop +/// loop { +/// // Wait for events +/// poll.poll(&mut events, None)?; +/// +/// for event in &events { +/// match event.token() { +/// LISTENER => { +/// // Perform operations in a loop until `WouldBlock` is +/// // encountered. +/// loop { +/// match listener.accept() { +/// Ok((mut socket, _)) => { +/// // Shutdown the server +/// if next_socket_index == MAX_SOCKETS { +/// return Ok(()); +/// } +/// +/// // Get the token for the socket +/// let token = Token(next_socket_index); +/// next_socket_index += 1; +/// +/// // Register the new socket w/ poll +/// poll.registry().register(&mut socket, token, Interest::READABLE)?; +/// +/// // Store the socket +/// sockets.insert(token, socket); +/// } +/// Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => { +/// // Socket is not ready anymore, stop accepting +/// break; +/// } +/// e => panic!("err={:?}", e), // Unexpected error +/// } +/// } +/// } +/// token => { +/// // Always operate in a loop +/// loop { +/// match sockets.get_mut(&token).unwrap().read(&mut buf) { +/// Ok(0) => { +/// // Socket is closed, remove it from the map +/// sockets.remove(&token); +/// break; +/// } +/// // Data is not actually sent in this example +/// Ok(_) => unreachable!(), +/// Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => { +/// // Socket is not ready anymore, stop reading +/// break; +/// } +/// e => panic!("err={:?}", e), // Unexpected error +/// } +/// } +/// } +/// } +/// } +/// } +/// # } +/// ``` +#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct Token(pub usize); + +impl From<Token> for usize { + fn from(val: Token) -> usize { + val.0 + } +} diff --git a/third_party/rust/mio/src/waker.rs b/third_party/rust/mio/src/waker.rs new file mode 100644 index 0000000000..b0cfe36b65 --- /dev/null +++ b/third_party/rust/mio/src/waker.rs @@ -0,0 +1,96 @@ +use crate::{sys, Registry, Token}; + +use std::io; + +/// Waker allows cross-thread waking of [`Poll`]. +/// +/// When created it will cause events with [`readable`] readiness and the +/// provided `token` if [`wake`] is called, possibly from another thread. +/// +/// [`Poll`]: struct.Poll.html +/// [`readable`]: ./event/struct.Event.html#method.is_readable +/// [`wake`]: struct.Waker.html#method.wake +/// +/// # Notes +/// +/// `Waker` events are only guaranteed to be delivered while the `Waker` value +/// is alive. +/// +/// Only a single `Waker` can be active per [`Poll`], if multiple threads need +/// access to the `Waker` it can be shared via for example an `Arc`. What +/// happens if multiple `Waker`s are registered with the same `Poll` is +/// unspecified. +/// +/// # Implementation notes +/// +/// On platforms that support kqueue this will use the `EVFILT_USER` event +/// filter, see [implementation notes of `Poll`] to see what platforms support +/// kqueue. On Linux it uses [eventfd]. +/// +/// [implementation notes of `Poll`]: struct.Poll.html#implementation-notes +/// [eventfd]: http://man7.org/linux/man-pages/man2/eventfd.2.html +/// +/// # Examples +/// +/// Wake a [`Poll`] instance from another thread. +/// +#[cfg_attr(feature = "os-poll", doc = "```")] +#[cfg_attr(not(feature = "os-poll"), doc = "```ignore")] +/// # fn main() -> Result<(), Box<dyn std::error::Error>> { +/// use std::thread; +/// use std::time::Duration; +/// use std::sync::Arc; +/// +/// use mio::{Events, Token, Poll, Waker}; +/// +/// const WAKE_TOKEN: Token = Token(10); +/// +/// let mut poll = Poll::new()?; +/// let mut events = Events::with_capacity(2); +/// +/// let waker = Arc::new(Waker::new(poll.registry(), WAKE_TOKEN)?); +/// +/// // We need to keep the Waker alive, so we'll create a clone for the +/// // thread we create below. +/// let waker1 = waker.clone(); +/// let handle = thread::spawn(move || { +/// // Working hard, or hardly working? +/// thread::sleep(Duration::from_millis(500)); +/// +/// // Now we'll wake the queue on the other thread. +/// waker1.wake().expect("unable to wake"); +/// }); +/// +/// // On our current thread we'll poll for events, without a timeout. +/// poll.poll(&mut events, None)?; +/// +/// // After about 500 milliseconds we should be awoken by the other thread and +/// // get a single event. +/// assert!(!events.is_empty()); +/// let waker_event = events.iter().next().unwrap(); +/// assert!(waker_event.is_readable()); +/// assert_eq!(waker_event.token(), WAKE_TOKEN); +/// # handle.join().unwrap(); +/// # Ok(()) +/// # } +/// ``` +#[derive(Debug)] +pub struct Waker { + inner: sys::Waker, +} + +impl Waker { + /// Create a new `Waker`. + pub fn new(registry: &Registry, token: Token) -> io::Result<Waker> { + #[cfg(debug_assertions)] + registry.register_waker(); + sys::Waker::new(registry.selector(), token).map(|inner| Waker { inner }) + } + + /// Wake up the [`Poll`] associated with this `Waker`. + /// + /// [`Poll`]: struct.Poll.html + pub fn wake(&self) -> io::Result<()> { + self.inner.wake() + } +} diff --git a/third_party/rust/miow/.cargo-checksum.json b/third_party/rust/miow/.cargo-checksum.json new file mode 100644 index 0000000000..1b3575ee7e --- /dev/null +++ b/third_party/rust/miow/.cargo-checksum.json @@ -0,0 +1 @@ +{"files":{"CHANGELOG.md":"588aa2a1146d5f0a0fe15b633a07b047f0dd333c8beb6fd9eb959a7493f3fdbc","Cargo.toml":"4ef0d55cf903edac87248410e260dfb8fef8fe19322e2917053a1fd757448876","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397","README.md":"3ea75d353de268b9dbec44e2e9f56c12cd391579ec4ac5855a4eb68dea216ef2","appveyor.yml":"ffdfb9572a6362866bea6787a726b0d4e43f6bb6516f3a38ebdd561859531602","src/handle.rs":"683af650dcd2975e066891bcd570454e14958f9fb291e0d6ee1d563d2ac1e4ce","src/iocp.rs":"7d11b2269ec05288f0ad693142186f90da60a11dcda264aca3f4ff2f2f78fc57","src/lib.rs":"816e6b1806daa5bf6c354829b974f3ec8bf021fa82e1dd11ef8a4030d6868163","src/net.rs":"a3477bf3f4da11dd062d2f1a482588c9f85d7c9218554516a6a0d64aba66bc03","src/overlapped.rs":"90c65c36dbeb95fb1b402b06e97f957c01be2ebb9d43b612bd735ca6e60d3c14","src/pipe.rs":"ee1aecf7114919cec801465a9ce355b18a5cfddeb9cde3a7ad3153ebe717675d"},"package":"b9f1c5b025cda876f66ef43a113f91ebc9f4ccef34843000e0adf6ebbab84e21"}
\ No newline at end of file diff --git a/third_party/rust/miow/CHANGELOG.md b/third_party/rust/miow/CHANGELOG.md new file mode 100644 index 0000000000..e16937d5e1 --- /dev/null +++ b/third_party/rust/miow/CHANGELOG.md @@ -0,0 +1,5 @@ + +## [v0.3.7] - 2021-03-22 +### Changed +- Upgrade `rand` dev-dependency from 0.4 -> 0.8 +- Upgrade `socket2` dependency from 0.3 to 0.4 and make it a dev-dependency diff --git a/third_party/rust/miow/Cargo.toml b/third_party/rust/miow/Cargo.toml new file mode 100644 index 0000000000..c32cc3cc40 --- /dev/null +++ b/third_party/rust/miow/Cargo.toml @@ -0,0 +1,35 @@ +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies +# +# If you believe there's an error in this file please file an +# issue against the rust-lang/cargo repository. If you're +# editing this file be aware that the upstream Cargo.toml +# will likely look very different (and much more reasonable) + +[package] +edition = "2018" +name = "miow" +version = "0.3.7" +authors = ["Alex Crichton <alex@alexcrichton.com>"] +description = "A zero overhead I/O library for Windows, focusing on IOCP and Async I/O\nabstractions.\n" +homepage = "https://github.com/yoshuawuyts/miow" +documentation = "https://docs.rs/miow/0.3/x86_64-pc-windows-msvc/miow/" +readme = "README.md" +keywords = ["iocp", "windows", "io", "overlapped"] +license = "MIT/Apache-2.0" +repository = "https://github.com/yoshuawuyts/miow" +[package.metadata.docs.rs] +default-target = "x86_64-pc-windows-msvc" +targets = ["aarch64-pc-windows-msvc", "i686-pc-windows-msvc", "x86_64-pc-windows-msvc"] +[dependencies.winapi] +version = "0.3.3" +features = ["std", "fileapi", "handleapi", "ioapiset", "minwindef", "namedpipeapi", "ntdef", "synchapi", "winerror", "winsock2", "ws2def", "ws2ipdef"] +[dev-dependencies.rand] +version = "0.8.0" + +[dev-dependencies.socket2] +version = "0.4.0" diff --git a/third_party/rust/miow/LICENSE-APACHE b/third_party/rust/miow/LICENSE-APACHE new file mode 100644 index 0000000000..16fe87b06e --- /dev/null +++ b/third_party/rust/miow/LICENSE-APACHE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS + +APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + +Copyright [yyyy] [name of copyright owner] + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. diff --git a/third_party/rust/miow/LICENSE-MIT b/third_party/rust/miow/LICENSE-MIT new file mode 100644 index 0000000000..39e0ed6602 --- /dev/null +++ b/third_party/rust/miow/LICENSE-MIT @@ -0,0 +1,25 @@ +Copyright (c) 2014 Alex Crichton + +Permission is hereby granted, free of charge, to any +person obtaining a copy of this software and associated +documentation files (the "Software"), to deal in the +Software without restriction, including without +limitation the rights to use, copy, modify, merge, +publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software +is furnished to do so, subject to the following +conditions: + +The above copyright notice and this permission notice +shall be included in all copies or substantial portions +of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF +ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED +TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT +SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR +IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. diff --git a/third_party/rust/miow/README.md b/third_party/rust/miow/README.md new file mode 100644 index 0000000000..e6cdddb227 --- /dev/null +++ b/third_party/rust/miow/README.md @@ -0,0 +1,31 @@ +# miow + +[](https://ci.appveyor.com/project/alexcrichton/miow) + +[Documentation](https://docs.rs/miow/0.3/x86_64-pc-windows-msvc/miow/) + +A zero overhead Windows I/O library focusing on IOCP and other async I/O +features. + +```toml +# Cargo.toml +[dependencies] +miow = "0.3.6" +``` + +# License + +This project is licensed under either of + + * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or + http://www.apache.org/licenses/LICENSE-2.0) + * MIT license ([LICENSE-MIT](LICENSE-MIT) or + http://opensource.org/licenses/MIT) + +at your option. + +### Contribution + +Unless you explicitly state otherwise, any contribution intentionally submitted +for inclusion in miow by you, as defined in the Apache-2.0 license, shall be +dual licensed as above, without any additional terms or conditions. diff --git a/third_party/rust/miow/appveyor.yml b/third_party/rust/miow/appveyor.yml new file mode 100644 index 0000000000..2700e425c7 --- /dev/null +++ b/third_party/rust/miow/appveyor.yml @@ -0,0 +1,20 @@ +environment: + matrix: + - TARGET: x86_64-pc-windows-msvc + - TARGET: i686-pc-windows-msvc + - TARGET: i686-pc-windows-gnu + GH_TOKEN: + secure: nHB4fVo+y/Aak+L0nYfrT8Rcs8OfUNm0F2xcIVFVYJ9ehf0CzvCmSMUvWguM0kKp + +install: + - ps: Start-FileDownload "https://static.rust-lang.org/dist/rust-nightly-${env:TARGET}.exe" + - rust-nightly-%TARGET%.exe /VERYSILENT /NORESTART /DIR="C:\Program Files (x86)\Rust" + - SET PATH=%PATH%;C:\Program Files (x86)\Rust\bin + - SET PATH=%PATH%;C:\MinGW\bin + - rustc -V + - cargo -V + +build: false + +test_script: + - cargo test --target %TARGET% diff --git a/third_party/rust/miow/src/handle.rs b/third_party/rust/miow/src/handle.rs new file mode 100644 index 0000000000..a749fb3269 --- /dev/null +++ b/third_party/rust/miow/src/handle.rs @@ -0,0 +1,177 @@ +use std::cmp; +use std::io; +use std::ptr; + +use winapi::shared::minwindef::*; +use winapi::shared::ntdef::{BOOLEAN, FALSE, HANDLE, TRUE}; +use winapi::shared::winerror::*; +use winapi::um::fileapi::*; +use winapi::um::handleapi::*; +use winapi::um::ioapiset::*; +use winapi::um::minwinbase::*; + +#[derive(Debug)] +pub struct Handle(HANDLE); + +unsafe impl Send for Handle {} +unsafe impl Sync for Handle {} + +impl Handle { + pub fn new(handle: HANDLE) -> Handle { + Handle(handle) + } + + pub fn raw(&self) -> HANDLE { + self.0 + } + + pub fn into_raw(self) -> HANDLE { + use std::mem; + + let ret = self.0; + mem::forget(self); + ret + } + + pub fn write(&self, buf: &[u8]) -> io::Result<usize> { + let mut bytes = 0; + let len = cmp::min(buf.len(), <DWORD>::max_value() as usize) as DWORD; + crate::cvt(unsafe { + WriteFile( + self.0, + buf.as_ptr() as *const _, + len, + &mut bytes, + 0 as *mut _, + ) + })?; + Ok(bytes as usize) + } + + pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> { + let mut bytes = 0; + let len = cmp::min(buf.len(), <DWORD>::max_value() as usize) as DWORD; + crate::cvt(unsafe { + ReadFile( + self.0, + buf.as_mut_ptr() as *mut _, + len, + &mut bytes, + 0 as *mut _, + ) + })?; + Ok(bytes as usize) + } + + pub unsafe fn read_overlapped( + &self, + buf: &mut [u8], + overlapped: *mut OVERLAPPED, + ) -> io::Result<Option<usize>> { + self.read_overlapped_helper(buf, overlapped, FALSE) + } + + pub unsafe fn read_overlapped_wait( + &self, + buf: &mut [u8], + overlapped: *mut OVERLAPPED, + ) -> io::Result<usize> { + match self.read_overlapped_helper(buf, overlapped, TRUE) { + Ok(Some(bytes)) => Ok(bytes), + Ok(None) => panic!("logic error"), + Err(e) => Err(e), + } + } + + pub unsafe fn read_overlapped_helper( + &self, + buf: &mut [u8], + overlapped: *mut OVERLAPPED, + wait: BOOLEAN, + ) -> io::Result<Option<usize>> { + let len = cmp::min(buf.len(), <DWORD>::max_value() as usize) as DWORD; + let res = crate::cvt({ + ReadFile( + self.0, + buf.as_mut_ptr() as *mut _, + len, + ptr::null_mut(), + overlapped, + ) + }); + match res { + Ok(_) => (), + Err(ref e) if e.raw_os_error() == Some(ERROR_IO_PENDING as i32) => (), + Err(e) => return Err(e), + } + + let mut bytes = 0; + let res = crate::cvt({ GetOverlappedResult(self.0, overlapped, &mut bytes, wait as BOOL) }); + match res { + Ok(_) => Ok(Some(bytes as usize)), + Err(ref e) if e.raw_os_error() == Some(ERROR_IO_INCOMPLETE as i32) && wait == FALSE => { + Ok(None) + } + Err(e) => Err(e), + } + } + + pub unsafe fn write_overlapped( + &self, + buf: &[u8], + overlapped: *mut OVERLAPPED, + ) -> io::Result<Option<usize>> { + self.write_overlapped_helper(buf, overlapped, FALSE) + } + + pub unsafe fn write_overlapped_wait( + &self, + buf: &[u8], + overlapped: *mut OVERLAPPED, + ) -> io::Result<usize> { + match self.write_overlapped_helper(buf, overlapped, TRUE) { + Ok(Some(bytes)) => Ok(bytes), + Ok(None) => panic!("logic error"), + Err(e) => Err(e), + } + } + + unsafe fn write_overlapped_helper( + &self, + buf: &[u8], + overlapped: *mut OVERLAPPED, + wait: BOOLEAN, + ) -> io::Result<Option<usize>> { + let len = cmp::min(buf.len(), <DWORD>::max_value() as usize) as DWORD; + let res = crate::cvt({ + WriteFile( + self.0, + buf.as_ptr() as *const _, + len, + ptr::null_mut(), + overlapped, + ) + }); + match res { + Ok(_) => (), + Err(ref e) if e.raw_os_error() == Some(ERROR_IO_PENDING as i32) => (), + Err(e) => return Err(e), + } + + let mut bytes = 0; + let res = crate::cvt({ GetOverlappedResult(self.0, overlapped, &mut bytes, wait as BOOL) }); + match res { + Ok(_) => Ok(Some(bytes as usize)), + Err(ref e) if e.raw_os_error() == Some(ERROR_IO_INCOMPLETE as i32) && wait == FALSE => { + Ok(None) + } + Err(e) => Err(e), + } + } +} + +impl Drop for Handle { + fn drop(&mut self) { + unsafe { CloseHandle(self.0) }; + } +} diff --git a/third_party/rust/miow/src/iocp.rs b/third_party/rust/miow/src/iocp.rs new file mode 100644 index 0000000000..d862d6bcfa --- /dev/null +++ b/third_party/rust/miow/src/iocp.rs @@ -0,0 +1,328 @@ +//! Bindings to IOCP, I/O Completion Ports + +use std::cmp; +use std::fmt; +use std::io; +use std::mem; +use std::os::windows::io::*; +use std::time::Duration; + +use crate::handle::Handle; +use crate::Overlapped; +use winapi::shared::basetsd::*; +use winapi::shared::ntdef::*; +use winapi::um::handleapi::*; +use winapi::um::ioapiset::*; +use winapi::um::minwinbase::*; + +/// A handle to an Windows I/O Completion Port. +#[derive(Debug)] +pub struct CompletionPort { + handle: Handle, +} + +/// A status message received from an I/O completion port. +/// +/// These statuses can be created via the `new` or `empty` constructors and then +/// provided to a completion port, or they are read out of a completion port. +/// The fields of each status are read through its accessor methods. +#[derive(Clone, Copy)] +pub struct CompletionStatus(OVERLAPPED_ENTRY); + +impl fmt::Debug for CompletionStatus { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "CompletionStatus(OVERLAPPED_ENTRY)") + } +} + +unsafe impl Send for CompletionStatus {} +unsafe impl Sync for CompletionStatus {} + +impl CompletionPort { + /// Creates a new I/O completion port with the specified concurrency value. + /// + /// The number of threads given corresponds to the level of concurrency + /// allowed for threads associated with this port. Consult the Windows + /// documentation for more information about this value. + pub fn new(threads: u32) -> io::Result<CompletionPort> { + let ret = unsafe { CreateIoCompletionPort(INVALID_HANDLE_VALUE, 0 as *mut _, 0, threads) }; + if ret.is_null() { + Err(io::Error::last_os_error()) + } else { + Ok(CompletionPort { + handle: Handle::new(ret), + }) + } + } + + /// Associates a new `HANDLE` to this I/O completion port. + /// + /// This function will associate the given handle to this port with the + /// given `token` to be returned in status messages whenever it receives a + /// notification. + /// + /// Any object which is convertible to a `HANDLE` via the `AsRawHandle` + /// trait can be provided to this function, such as `std::fs::File` and + /// friends. + pub fn add_handle<T: AsRawHandle + ?Sized>(&self, token: usize, t: &T) -> io::Result<()> { + self._add(token, t.as_raw_handle()) + } + + /// Associates a new `SOCKET` to this I/O completion port. + /// + /// This function will associate the given socket to this port with the + /// given `token` to be returned in status messages whenever it receives a + /// notification. + /// + /// Any object which is convertible to a `SOCKET` via the `AsRawSocket` + /// trait can be provided to this function, such as `std::net::TcpStream` + /// and friends. + pub fn add_socket<T: AsRawSocket + ?Sized>(&self, token: usize, t: &T) -> io::Result<()> { + self._add(token, t.as_raw_socket() as HANDLE) + } + + fn _add(&self, token: usize, handle: HANDLE) -> io::Result<()> { + assert_eq!(mem::size_of_val(&token), mem::size_of::<ULONG_PTR>()); + let ret = + unsafe { CreateIoCompletionPort(handle, self.handle.raw(), token as ULONG_PTR, 0) }; + if ret.is_null() { + Err(io::Error::last_os_error()) + } else { + debug_assert_eq!(ret, self.handle.raw()); + Ok(()) + } + } + + /// Dequeue a completion status from this I/O completion port. + /// + /// This function will associate the calling thread with this completion + /// port and then wait for a status message to become available. The precise + /// semantics on when this function returns depends on the concurrency value + /// specified when the port was created. + /// + /// A timeout can optionally be specified to this function. If `None` is + /// provided this function will not time out, and otherwise it will time out + /// after the specified duration has passed. + /// + /// On success this will return the status message which was dequeued from + /// this completion port. + pub fn get(&self, timeout: Option<Duration>) -> io::Result<CompletionStatus> { + let mut bytes = 0; + let mut token = 0; + let mut overlapped = 0 as *mut _; + let timeout = crate::dur2ms(timeout); + let ret = unsafe { + GetQueuedCompletionStatus( + self.handle.raw(), + &mut bytes, + &mut token, + &mut overlapped, + timeout, + ) + }; + crate::cvt(ret).map(|_| { + CompletionStatus(OVERLAPPED_ENTRY { + dwNumberOfBytesTransferred: bytes, + lpCompletionKey: token, + lpOverlapped: overlapped, + Internal: 0, + }) + }) + } + + /// Dequeues a number of completion statuses from this I/O completion port. + /// + /// This function is the same as `get` except that it may return more than + /// one status. A buffer of "zero" statuses is provided (the contents are + /// not read) and then on success this function will return a sub-slice of + /// statuses which represent those which were dequeued from this port. This + /// function does not wait to fill up the entire list of statuses provided. + /// + /// Like with `get`, a timeout may be specified for this operation. + pub fn get_many<'a>( + &self, + list: &'a mut [CompletionStatus], + timeout: Option<Duration>, + ) -> io::Result<&'a mut [CompletionStatus]> { + debug_assert_eq!( + mem::size_of::<CompletionStatus>(), + mem::size_of::<OVERLAPPED_ENTRY>() + ); + let mut removed = 0; + let timeout = crate::dur2ms(timeout); + let len = cmp::min(list.len(), <ULONG>::max_value() as usize) as ULONG; + let ret = unsafe { + GetQueuedCompletionStatusEx( + self.handle.raw(), + list.as_ptr() as *mut _, + len, + &mut removed, + timeout, + FALSE as i32, + ) + }; + match crate::cvt(ret) { + Ok(_) => Ok(&mut list[..removed as usize]), + Err(e) => Err(e), + } + } + + /// Posts a new completion status onto this I/O completion port. + /// + /// This function will post the given status, with custom parameters, to the + /// port. Threads blocked in `get` or `get_many` will eventually receive + /// this status. + pub fn post(&self, status: CompletionStatus) -> io::Result<()> { + let ret = unsafe { + PostQueuedCompletionStatus( + self.handle.raw(), + status.0.dwNumberOfBytesTransferred, + status.0.lpCompletionKey, + status.0.lpOverlapped, + ) + }; + crate::cvt(ret).map(|_| ()) + } +} + +impl AsRawHandle for CompletionPort { + fn as_raw_handle(&self) -> HANDLE { + self.handle.raw() + } +} + +impl FromRawHandle for CompletionPort { + unsafe fn from_raw_handle(handle: HANDLE) -> CompletionPort { + CompletionPort { + handle: Handle::new(handle), + } + } +} + +impl IntoRawHandle for CompletionPort { + fn into_raw_handle(self) -> HANDLE { + self.handle.into_raw() + } +} + +impl CompletionStatus { + /// Creates a new completion status with the provided parameters. + /// + /// This function is useful when creating a status to send to a port with + /// the `post` method. The parameters are opaquely passed through and not + /// interpreted by the system at all. + pub fn new(bytes: u32, token: usize, overlapped: *mut Overlapped) -> CompletionStatus { + assert_eq!(mem::size_of_val(&token), mem::size_of::<ULONG_PTR>()); + CompletionStatus(OVERLAPPED_ENTRY { + dwNumberOfBytesTransferred: bytes, + lpCompletionKey: token as ULONG_PTR, + lpOverlapped: overlapped as *mut _, + Internal: 0, + }) + } + + /// Creates a new borrowed completion status from the borrowed + /// `OVERLAPPED_ENTRY` argument provided. + /// + /// This method will wrap the `OVERLAPPED_ENTRY` in a `CompletionStatus`, + /// returning the wrapped structure. + pub fn from_entry(entry: &OVERLAPPED_ENTRY) -> &CompletionStatus { + unsafe { &*(entry as *const _ as *const _) } + } + + /// Creates a new "zero" completion status. + /// + /// This function is useful when creating a stack buffer or vector of + /// completion statuses to be passed to the `get_many` function. + pub fn zero() -> CompletionStatus { + CompletionStatus::new(0, 0, 0 as *mut _) + } + + /// Returns the number of bytes that were transferred for the I/O operation + /// associated with this completion status. + pub fn bytes_transferred(&self) -> u32 { + self.0.dwNumberOfBytesTransferred + } + + /// Returns the completion key value associated with the file handle whose + /// I/O operation has completed. + /// + /// A completion key is a per-handle key that is specified when it is added + /// to an I/O completion port via `add_handle` or `add_socket`. + pub fn token(&self) -> usize { + self.0.lpCompletionKey as usize + } + + /// Returns a pointer to the `Overlapped` structure that was specified when + /// the I/O operation was started. + pub fn overlapped(&self) -> *mut OVERLAPPED { + self.0.lpOverlapped + } + + /// Returns a pointer to the internal `OVERLAPPED_ENTRY` object. + pub fn entry(&self) -> &OVERLAPPED_ENTRY { + &self.0 + } +} + +#[cfg(test)] +mod tests { + use std::mem; + use std::time::Duration; + + use winapi::shared::basetsd::*; + use winapi::shared::winerror::*; + + use crate::iocp::{CompletionPort, CompletionStatus}; + + #[test] + fn is_send_sync() { + fn is_send_sync<T: Send + Sync>() {} + is_send_sync::<CompletionPort>(); + } + + #[test] + fn token_right_size() { + assert_eq!(mem::size_of::<usize>(), mem::size_of::<ULONG_PTR>()); + } + + #[test] + fn timeout() { + let c = CompletionPort::new(1).unwrap(); + let err = c.get(Some(Duration::from_millis(1))).unwrap_err(); + assert_eq!(err.raw_os_error(), Some(WAIT_TIMEOUT as i32)); + } + + #[test] + fn get() { + let c = CompletionPort::new(1).unwrap(); + c.post(CompletionStatus::new(1, 2, 3 as *mut _)).unwrap(); + let s = c.get(None).unwrap(); + assert_eq!(s.bytes_transferred(), 1); + assert_eq!(s.token(), 2); + assert_eq!(s.overlapped(), 3 as *mut _); + } + + #[test] + fn get_many() { + let c = CompletionPort::new(1).unwrap(); + + c.post(CompletionStatus::new(1, 2, 3 as *mut _)).unwrap(); + c.post(CompletionStatus::new(4, 5, 6 as *mut _)).unwrap(); + + let mut s = vec![CompletionStatus::zero(); 4]; + { + let s = c.get_many(&mut s, None).unwrap(); + assert_eq!(s.len(), 2); + assert_eq!(s[0].bytes_transferred(), 1); + assert_eq!(s[0].token(), 2); + assert_eq!(s[0].overlapped(), 3 as *mut _); + assert_eq!(s[1].bytes_transferred(), 4); + assert_eq!(s[1].token(), 5); + assert_eq!(s[1].overlapped(), 6 as *mut _); + } + assert_eq!(s[2].bytes_transferred(), 0); + assert_eq!(s[2].token(), 0); + assert_eq!(s[2].overlapped(), 0 as *mut _); + } +} diff --git a/third_party/rust/miow/src/lib.rs b/third_party/rust/miow/src/lib.rs new file mode 100644 index 0000000000..53c01aeeae --- /dev/null +++ b/third_party/rust/miow/src/lib.rs @@ -0,0 +1,52 @@ +//! A zero overhead Windows I/O library + +#![cfg(windows)] +#![deny(missing_docs)] +#![allow(bad_style)] +#![doc(html_root_url = "https://docs.rs/miow/0.3/x86_64-pc-windows-msvc/")] + +use std::cmp; +use std::io; +use std::time::Duration; + +use winapi::shared::minwindef::*; +use winapi::um::winbase::*; + +#[cfg(test)] +macro_rules! t { + ($e:expr) => { + match $e { + Ok(e) => e, + Err(e) => panic!("{} failed with {:?}", stringify!($e), e), + } + }; +} + +mod handle; +mod overlapped; + +pub mod iocp; +pub mod net; +pub mod pipe; + +pub use crate::overlapped::Overlapped; + +fn cvt(i: BOOL) -> io::Result<BOOL> { + if i == 0 { + Err(io::Error::last_os_error()) + } else { + Ok(i) + } +} + +fn dur2ms(dur: Option<Duration>) -> u32 { + let dur = match dur { + Some(dur) => dur, + None => return INFINITE, + }; + let ms = dur.as_secs().checked_mul(1_000); + let ms_extra = dur.subsec_nanos() / 1_000_000; + ms.and_then(|ms| ms.checked_add(ms_extra as u64)) + .map(|ms| cmp::min(u32::max_value() as u64, ms) as u32) + .unwrap_or(INFINITE - 1) +} diff --git a/third_party/rust/miow/src/net.rs b/third_party/rust/miow/src/net.rs new file mode 100644 index 0000000000..e30bc2d2bf --- /dev/null +++ b/third_party/rust/miow/src/net.rs @@ -0,0 +1,1332 @@ +//! Extensions and types for the standard networking primitives. +//! +//! This module contains a number of extension traits for the types in +//! `std::net` for Windows-specific functionality. + +use std::cmp; +use std::io; +use std::mem; +use std::net::{Ipv4Addr, Ipv6Addr, SocketAddrV4, SocketAddrV6}; +use std::net::{SocketAddr, TcpListener, TcpStream, UdpSocket}; +use std::os::windows::prelude::*; +use std::sync::atomic::{AtomicUsize, Ordering}; + +use winapi::ctypes::*; +use winapi::shared::guiddef::*; +use winapi::shared::in6addr::{in6_addr_u, IN6_ADDR}; +use winapi::shared::inaddr::{in_addr_S_un, IN_ADDR}; +use winapi::shared::minwindef::*; +use winapi::shared::minwindef::{FALSE, TRUE}; +use winapi::shared::ntdef::*; +use winapi::shared::ws2def::SOL_SOCKET; +use winapi::shared::ws2def::*; +use winapi::shared::ws2ipdef::*; +use winapi::um::minwinbase::*; +use winapi::um::winsock2::*; + +/// A type to represent a buffer in which a socket address will be stored. +/// +/// This type is used with the `recv_from_overlapped` function on the +/// `UdpSocketExt` trait to provide space for the overlapped I/O operation to +/// fill in the address upon completion. +#[derive(Clone, Copy)] +pub struct SocketAddrBuf { + buf: SOCKADDR_STORAGE, + len: c_int, +} + +/// A type to represent a buffer in which an accepted socket's address will be +/// stored. +/// +/// This type is used with the `accept_overlapped` method on the +/// `TcpListenerExt` trait to provide space for the overlapped I/O operation to +/// fill in the socket addresses upon completion. +#[repr(C)] +pub struct AcceptAddrsBuf { + // For AcceptEx we've got the restriction that the addresses passed in that + // buffer need to be at least 16 bytes more than the maximum address length + // for the protocol in question, so add some extra here and there + local: SOCKADDR_STORAGE, + _pad1: [u8; 16], + remote: SOCKADDR_STORAGE, + _pad2: [u8; 16], +} + +/// The parsed return value of `AcceptAddrsBuf`. +pub struct AcceptAddrs<'a> { + local: LPSOCKADDR, + local_len: c_int, + remote: LPSOCKADDR, + remote_len: c_int, + _data: &'a AcceptAddrsBuf, +} + +struct WsaExtension { + guid: GUID, + val: AtomicUsize, +} + +/// Additional methods for the `TcpStream` type in the standard library. +pub trait TcpStreamExt { + /// Execute an overlapped read I/O operation on this TCP stream. + /// + /// This function will issue an overlapped I/O read (via `WSARecv`) on this + /// socket. The provided buffer will be filled in when the operation + /// completes and the given `OVERLAPPED` instance is used to track the + /// overlapped operation. + /// + /// If the operation succeeds, `Ok(Some(n))` is returned indicating how + /// many bytes were read. If the operation returns an error indicating that + /// the I/O is currently pending, `Ok(None)` is returned. Otherwise, the + /// error associated with the operation is returned and no overlapped + /// operation is enqueued. + /// + /// The number of bytes read will be returned as part of the completion + /// notification when the I/O finishes. + /// + /// # Unsafety + /// + /// This function is unsafe because the kernel requires that the `buf` and + /// `overlapped` pointers are valid until the end of the I/O operation. The + /// kernel also requires that `overlapped` is unique for this I/O operation + /// and is not in use for any other I/O. + /// + /// To safely use this function callers must ensure that these two input + /// pointers are valid until the I/O operation is completed, typically via + /// completion ports and waiting to receive the completion notification on + /// the port. + unsafe fn read_overlapped( + &self, + buf: &mut [u8], + overlapped: *mut OVERLAPPED, + ) -> io::Result<Option<usize>>; + + /// Execute an overlapped write I/O operation on this TCP stream. + /// + /// This function will issue an overlapped I/O write (via `WSASend`) on this + /// socket. The provided buffer will be written when the operation completes + /// and the given `OVERLAPPED` instance is used to track the overlapped + /// operation. + /// + /// If the operation succeeds, `Ok(Some(n))` is returned where `n` is the + /// number of bytes that were written. If the operation returns an error + /// indicating that the I/O is currently pending, `Ok(None)` is returned. + /// Otherwise, the error associated with the operation is returned and no + /// overlapped operation is enqueued. + /// + /// The number of bytes written will be returned as part of the completion + /// notification when the I/O finishes. + /// + /// # Unsafety + /// + /// This function is unsafe because the kernel requires that the `buf` and + /// `overlapped` pointers are valid until the end of the I/O operation. The + /// kernel also requires that `overlapped` is unique for this I/O operation + /// and is not in use for any other I/O. + /// + /// To safely use this function callers must ensure that these two input + /// pointers are valid until the I/O operation is completed, typically via + /// completion ports and waiting to receive the completion notification on + /// the port. + unsafe fn write_overlapped( + &self, + buf: &[u8], + overlapped: *mut OVERLAPPED, + ) -> io::Result<Option<usize>>; + + /// Attempt to consume the internal socket in this builder by executing an + /// overlapped connect operation. + /// + /// This function will issue a connect operation to the address specified on + /// the underlying socket, flagging it as an overlapped operation which will + /// complete asynchronously. If successful this function will return the + /// corresponding TCP stream. + /// + /// The `buf` argument provided is an initial buffer of data that should be + /// sent after the connection is initiated. It's acceptable to + /// pass an empty slice here. + /// + /// This function will also return whether the connect immediately + /// succeeded or not. If `None` is returned then the I/O operation is still + /// pending and will complete at a later date, and if `Some(bytes)` is + /// returned then that many bytes were transferred. + /// + /// Note that to succeed this requires that the underlying socket has + /// previously been bound via a call to `bind` to a local address. + /// + /// # Unsafety + /// + /// This function is unsafe because the kernel requires that the + /// `overlapped` and `buf` pointers to be valid until the end of the I/O + /// operation. The kernel also requires that `overlapped` is unique for + /// this I/O operation and is not in use for any other I/O. + /// + /// To safely use this function callers must ensure that this pointer is + /// valid until the I/O operation is completed, typically via completion + /// ports and waiting to receive the completion notification on the port. + unsafe fn connect_overlapped( + &self, + addr: &SocketAddr, + buf: &[u8], + overlapped: *mut OVERLAPPED, + ) -> io::Result<Option<usize>>; + + /// Once a `connect_overlapped` has finished, this function needs to be + /// called to finish the connect operation. + /// + /// Currently this just calls `setsockopt` with `SO_UPDATE_CONNECT_CONTEXT` + /// to ensure that further functions like `getpeername` and `getsockname` + /// work correctly. + fn connect_complete(&self) -> io::Result<()>; + + /// Calls the `GetOverlappedResult` function to get the result of an + /// overlapped operation for this handle. + /// + /// This function takes the `OVERLAPPED` argument which must have been used + /// to initiate an overlapped I/O operation, and returns either the + /// successful number of bytes transferred during the operation or an error + /// if one occurred, along with the results of the `lpFlags` parameter of + /// the relevant operation, if applicable. + /// + /// # Unsafety + /// + /// This function is unsafe as `overlapped` must have previously been used + /// to execute an operation for this handle, and it must also be a valid + /// pointer to an `OVERLAPPED` instance. + /// + /// # Panics + /// + /// This function will panic + unsafe fn result(&self, overlapped: *mut OVERLAPPED) -> io::Result<(usize, u32)>; +} + +/// Additional methods for the `UdpSocket` type in the standard library. +pub trait UdpSocketExt { + /// Execute an overlapped receive I/O operation on this UDP socket. + /// + /// This function will issue an overlapped I/O read (via `WSARecvFrom`) on + /// this socket. The provided buffer will be filled in when the operation + /// completes, the source from where the data came from will be written to + /// `addr`, and the given `OVERLAPPED` instance is used to track the + /// overlapped operation. + /// + /// If the operation succeeds, `Ok(Some(n))` is returned where `n` is the + /// number of bytes that were read. If the operation returns an error + /// indicating that the I/O is currently pending, `Ok(None)` is returned. + /// Otherwise, the error associated with the operation is returned and no + /// overlapped operation is enqueued. + /// + /// The number of bytes read will be returned as part of the completion + /// notification when the I/O finishes. + /// + /// # Unsafety + /// + /// This function is unsafe because the kernel requires that the `buf`, + /// `addr`, and `overlapped` pointers are valid until the end of the I/O + /// operation. The kernel also requires that `overlapped` is unique for this + /// I/O operation and is not in use for any other I/O. + /// + /// To safely use this function callers must ensure that these two input + /// pointers are valid until the I/O operation is completed, typically via + /// completion ports and waiting to receive the completion notification on + /// the port. + unsafe fn recv_from_overlapped( + &self, + buf: &mut [u8], + addr: *mut SocketAddrBuf, + overlapped: *mut OVERLAPPED, + ) -> io::Result<Option<usize>>; + + /// Execute an overlapped receive I/O operation on this UDP socket. + /// + /// This function will issue an overlapped I/O read (via `WSARecv`) on + /// this socket. The provided buffer will be filled in when the operation + /// completes, the source from where the data came from will be written to + /// `addr`, and the given `OVERLAPPED` instance is used to track the + /// overlapped operation. + /// + /// If the operation succeeds, `Ok(Some(n))` is returned where `n` is the + /// number of bytes that were read. If the operation returns an error + /// indicating that the I/O is currently pending, `Ok(None)` is returned. + /// Otherwise, the error associated with the operation is returned and no + /// overlapped operation is enqueued. + /// + /// The number of bytes read will be returned as part of the completion + /// notification when the I/O finishes. + /// + /// # Unsafety + /// + /// This function is unsafe because the kernel requires that the `buf`, + /// and `overlapped` pointers are valid until the end of the I/O + /// operation. The kernel also requires that `overlapped` is unique for this + /// I/O operation and is not in use for any other I/O. + /// + /// To safely use this function callers must ensure that these two input + /// pointers are valid until the I/O operation is completed, typically via + /// completion ports and waiting to receive the completion notification on + /// the port. + unsafe fn recv_overlapped( + &self, + buf: &mut [u8], + overlapped: *mut OVERLAPPED, + ) -> io::Result<Option<usize>>; + + /// Execute an overlapped send I/O operation on this UDP socket. + /// + /// This function will issue an overlapped I/O write (via `WSASendTo`) on + /// this socket to the address specified by `addr`. The provided buffer will + /// be written when the operation completes and the given `OVERLAPPED` + /// instance is used to track the overlapped operation. + /// + /// If the operation succeeds, `Ok(Some(n0)` is returned where `n` byte + /// were written. If the operation returns an error indicating that the I/O + /// is currently pending, `Ok(None)` is returned. Otherwise, the error + /// associated with the operation is returned and no overlapped operation + /// is enqueued. + /// + /// The number of bytes written will be returned as part of the completion + /// notification when the I/O finishes. + /// + /// # Unsafety + /// + /// This function is unsafe because the kernel requires that the `buf` and + /// `overlapped` pointers are valid until the end of the I/O operation. The + /// kernel also requires that `overlapped` is unique for this I/O operation + /// and is not in use for any other I/O. + /// + /// To safely use this function callers must ensure that these two input + /// pointers are valid until the I/O operation is completed, typically via + /// completion ports and waiting to receive the completion notification on + /// the port. + unsafe fn send_to_overlapped( + &self, + buf: &[u8], + addr: &SocketAddr, + overlapped: *mut OVERLAPPED, + ) -> io::Result<Option<usize>>; + + /// Execute an overlapped send I/O operation on this UDP socket. + /// + /// This function will issue an overlapped I/O write (via `WSASend`) on + /// this socket to the address it was previously connected to. The provided + /// buffer will be written when the operation completes and the given `OVERLAPPED` + /// instance is used to track the overlapped operation. + /// + /// If the operation succeeds, `Ok(Some(n0)` is returned where `n` byte + /// were written. If the operation returns an error indicating that the I/O + /// is currently pending, `Ok(None)` is returned. Otherwise, the error + /// associated with the operation is returned and no overlapped operation + /// is enqueued. + /// + /// The number of bytes written will be returned as part of the completion + /// notification when the I/O finishes. + /// + /// # Unsafety + /// + /// This function is unsafe because the kernel requires that the `buf` and + /// `overlapped` pointers are valid until the end of the I/O operation. The + /// kernel also requires that `overlapped` is unique for this I/O operation + /// and is not in use for any other I/O. + /// + /// To safely use this function callers must ensure that these two input + /// pointers are valid until the I/O operation is completed, typically via + /// completion ports and waiting to receive the completion notification on + /// the port. + unsafe fn send_overlapped( + &self, + buf: &[u8], + overlapped: *mut OVERLAPPED, + ) -> io::Result<Option<usize>>; + + /// Calls the `GetOverlappedResult` function to get the result of an + /// overlapped operation for this handle. + /// + /// This function takes the `OVERLAPPED` argument which must have been used + /// to initiate an overlapped I/O operation, and returns either the + /// successful number of bytes transferred during the operation or an error + /// if one occurred, along with the results of the `lpFlags` parameter of + /// the relevant operation, if applicable. + /// + /// # Unsafety + /// + /// This function is unsafe as `overlapped` must have previously been used + /// to execute an operation for this handle, and it must also be a valid + /// pointer to an `OVERLAPPED` instance. + /// + /// # Panics + /// + /// This function will panic + unsafe fn result(&self, overlapped: *mut OVERLAPPED) -> io::Result<(usize, u32)>; +} + +/// Additional methods for the `TcpListener` type in the standard library. +pub trait TcpListenerExt { + /// Perform an accept operation on this listener, accepting a connection in + /// an overlapped fashion. + /// + /// This function will issue an I/O request to accept an incoming connection + /// with the specified overlapped instance. The `socket` provided must be a + /// configured but not bound or connected socket, and if successful this + /// will consume the internal socket of the builder to return a TCP stream. + /// + /// The `addrs` buffer provided will be filled in with the local and remote + /// addresses of the connection upon completion. + /// + /// If the accept succeeds immediately, `Ok(true)` is returned. If + /// the connect indicates that the I/O is currently pending, `Ok(false)` is + /// returned. Otherwise, the error associated with the operation is + /// returned and no overlapped operation is enqueued. + /// + /// # Unsafety + /// + /// This function is unsafe because the kernel requires that the + /// `addrs` and `overlapped` pointers are valid until the end of the I/O + /// operation. The kernel also requires that `overlapped` is unique for this + /// I/O operation and is not in use for any other I/O. + /// + /// To safely use this function callers must ensure that the pointers are + /// valid until the I/O operation is completed, typically via completion + /// ports and waiting to receive the completion notification on the port. + unsafe fn accept_overlapped( + &self, + socket: &TcpStream, + addrs: &mut AcceptAddrsBuf, + overlapped: *mut OVERLAPPED, + ) -> io::Result<bool>; + + /// Once an `accept_overlapped` has finished, this function needs to be + /// called to finish the accept operation. + /// + /// Currently this just calls `setsockopt` with `SO_UPDATE_ACCEPT_CONTEXT` + /// to ensure that further functions like `getpeername` and `getsockname` + /// work correctly. + fn accept_complete(&self, socket: &TcpStream) -> io::Result<()>; + + /// Calls the `GetOverlappedResult` function to get the result of an + /// overlapped operation for this handle. + /// + /// This function takes the `OVERLAPPED` argument which must have been used + /// to initiate an overlapped I/O operation, and returns either the + /// successful number of bytes transferred during the operation or an error + /// if one occurred, along with the results of the `lpFlags` parameter of + /// the relevant operation, if applicable. + /// + /// # Unsafety + /// + /// This function is unsafe as `overlapped` must have previously been used + /// to execute an operation for this handle, and it must also be a valid + /// pointer to an `OVERLAPPED` instance. + /// + /// # Panics + /// + /// This function will panic + unsafe fn result(&self, overlapped: *mut OVERLAPPED) -> io::Result<(usize, u32)>; +} + +#[doc(hidden)] +trait NetInt { + fn from_be(i: Self) -> Self; + fn to_be(&self) -> Self; +} +macro_rules! doit { + ($($t:ident)*) => ($(impl NetInt for $t { + fn from_be(i: Self) -> Self { <$t>::from_be(i) } + fn to_be(&self) -> Self { <$t>::to_be(*self) } + })*) +} +doit! { i8 i16 i32 i64 isize u8 u16 u32 u64 usize } + +// fn hton<I: NetInt>(i: I) -> I { i.to_be() } +fn ntoh<I: NetInt>(i: I) -> I { + I::from_be(i) +} + +fn last_err() -> io::Result<Option<usize>> { + let err = unsafe { WSAGetLastError() }; + if err == WSA_IO_PENDING as i32 { + Ok(None) + } else { + Err(io::Error::from_raw_os_error(err)) + } +} + +fn cvt(i: c_int, size: DWORD) -> io::Result<Option<usize>> { + if i == SOCKET_ERROR { + last_err() + } else { + Ok(Some(size as usize)) + } +} + +/// A type with the same memory layout as `SOCKADDR`. Used in converting Rust level +/// SocketAddr* types into their system representation. The benefit of this specific +/// type over using `SOCKADDR_STORAGE` is that this type is exactly as large as it +/// needs to be and not a lot larger. And it can be initialized cleaner from Rust. +#[repr(C)] +pub(crate) union SocketAddrCRepr { + v4: SOCKADDR_IN, + v6: SOCKADDR_IN6_LH, +} + +impl SocketAddrCRepr { + pub(crate) fn as_ptr(&self) -> *const SOCKADDR { + self as *const _ as *const SOCKADDR + } +} + +fn socket_addr_to_ptrs(addr: &SocketAddr) -> (SocketAddrCRepr, c_int) { + match *addr { + SocketAddr::V4(ref a) => { + let sin_addr = unsafe { + let mut s_un = mem::zeroed::<in_addr_S_un>(); + *s_un.S_addr_mut() = u32::from_ne_bytes(a.ip().octets()); + IN_ADDR { S_un: s_un } + }; + + let sockaddr_in = SOCKADDR_IN { + sin_family: AF_INET as ADDRESS_FAMILY, + sin_port: a.port().to_be(), + sin_addr, + sin_zero: [0; 8], + }; + + let sockaddr = SocketAddrCRepr { v4: sockaddr_in }; + (sockaddr, mem::size_of::<SOCKADDR_IN>() as c_int) + } + SocketAddr::V6(ref a) => { + let sin6_addr = unsafe { + let mut u = mem::zeroed::<in6_addr_u>(); + *u.Byte_mut() = a.ip().octets(); + IN6_ADDR { u } + }; + let u = unsafe { + let mut u = mem::zeroed::<SOCKADDR_IN6_LH_u>(); + *u.sin6_scope_id_mut() = a.scope_id(); + u + }; + + let sockaddr_in6 = SOCKADDR_IN6_LH { + sin6_family: AF_INET6 as ADDRESS_FAMILY, + sin6_port: a.port().to_be(), + sin6_addr, + sin6_flowinfo: a.flowinfo(), + u, + }; + + let sockaddr = SocketAddrCRepr { v6: sockaddr_in6 }; + (sockaddr, mem::size_of::<SOCKADDR_IN6_LH>() as c_int) + } + } +} + +unsafe fn ptrs_to_socket_addr(ptr: *const SOCKADDR, len: c_int) -> Option<SocketAddr> { + if (len as usize) < mem::size_of::<c_int>() { + return None; + } + match (*ptr).sa_family as i32 { + AF_INET if len as usize >= mem::size_of::<SOCKADDR_IN>() => { + let b = &*(ptr as *const SOCKADDR_IN); + let ip = ntoh(*b.sin_addr.S_un.S_addr()); + let ip = Ipv4Addr::new( + (ip >> 24) as u8, + (ip >> 16) as u8, + (ip >> 8) as u8, + (ip >> 0) as u8, + ); + Some(SocketAddr::V4(SocketAddrV4::new(ip, ntoh(b.sin_port)))) + } + AF_INET6 if len as usize >= mem::size_of::<SOCKADDR_IN6_LH>() => { + let b = &*(ptr as *const SOCKADDR_IN6_LH); + let arr = b.sin6_addr.u.Byte(); + let ip = Ipv6Addr::new( + ((arr[0] as u16) << 8) | (arr[1] as u16), + ((arr[2] as u16) << 8) | (arr[3] as u16), + ((arr[4] as u16) << 8) | (arr[5] as u16), + ((arr[6] as u16) << 8) | (arr[7] as u16), + ((arr[8] as u16) << 8) | (arr[9] as u16), + ((arr[10] as u16) << 8) | (arr[11] as u16), + ((arr[12] as u16) << 8) | (arr[13] as u16), + ((arr[14] as u16) << 8) | (arr[15] as u16), + ); + let addr = SocketAddrV6::new( + ip, + ntoh(b.sin6_port), + ntoh(b.sin6_flowinfo), + ntoh(*b.u.sin6_scope_id()), + ); + Some(SocketAddr::V6(addr)) + } + _ => None, + } +} + +unsafe fn slice2buf(slice: &[u8]) -> WSABUF { + WSABUF { + len: cmp::min(slice.len(), <u_long>::max_value() as usize) as u_long, + buf: slice.as_ptr() as *mut _, + } +} + +unsafe fn result(socket: SOCKET, overlapped: *mut OVERLAPPED) -> io::Result<(usize, u32)> { + let mut transferred = 0; + let mut flags = 0; + let r = WSAGetOverlappedResult(socket, overlapped, &mut transferred, FALSE, &mut flags); + if r == 0 { + Err(io::Error::last_os_error()) + } else { + Ok((transferred as usize, flags)) + } +} + +impl TcpStreamExt for TcpStream { + unsafe fn read_overlapped( + &self, + buf: &mut [u8], + overlapped: *mut OVERLAPPED, + ) -> io::Result<Option<usize>> { + let mut buf = slice2buf(buf); + let mut flags = 0; + let mut bytes_read: DWORD = 0; + let r = WSARecv( + self.as_raw_socket() as SOCKET, + &mut buf, + 1, + &mut bytes_read, + &mut flags, + overlapped, + None, + ); + cvt(r, bytes_read) + } + + unsafe fn write_overlapped( + &self, + buf: &[u8], + overlapped: *mut OVERLAPPED, + ) -> io::Result<Option<usize>> { + let mut buf = slice2buf(buf); + let mut bytes_written = 0; + + // Note here that we capture the number of bytes written. The + // documentation on MSDN, however, states: + // + // > Use NULL for this parameter if the lpOverlapped parameter is not + // > NULL to avoid potentially erroneous results. This parameter can be + // > NULL only if the lpOverlapped parameter is not NULL. + // + // If we're not passing a null overlapped pointer here, then why are we + // then capturing the number of bytes! Well so it turns out that this is + // clearly faster to learn the bytes here rather than later calling + // `WSAGetOverlappedResult`, and in practice almost all implementations + // use this anyway [1]. + // + // As a result we use this to and report back the result. + // + // [1]: https://github.com/carllerche/mio/pull/520#issuecomment-273983823 + let r = WSASend( + self.as_raw_socket() as SOCKET, + &mut buf, + 1, + &mut bytes_written, + 0, + overlapped, + None, + ); + cvt(r, bytes_written) + } + + unsafe fn connect_overlapped( + &self, + addr: &SocketAddr, + buf: &[u8], + overlapped: *mut OVERLAPPED, + ) -> io::Result<Option<usize>> { + connect_overlapped(self.as_raw_socket() as SOCKET, addr, buf, overlapped) + } + + fn connect_complete(&self) -> io::Result<()> { + const SO_UPDATE_CONNECT_CONTEXT: c_int = 0x7010; + let result = unsafe { + setsockopt( + self.as_raw_socket() as SOCKET, + SOL_SOCKET, + SO_UPDATE_CONNECT_CONTEXT, + 0 as *const _, + 0, + ) + }; + if result == 0 { + Ok(()) + } else { + Err(io::Error::last_os_error()) + } + } + + unsafe fn result(&self, overlapped: *mut OVERLAPPED) -> io::Result<(usize, u32)> { + result(self.as_raw_socket() as SOCKET, overlapped) + } +} + +unsafe fn connect_overlapped( + socket: SOCKET, + addr: &SocketAddr, + buf: &[u8], + overlapped: *mut OVERLAPPED, +) -> io::Result<Option<usize>> { + static CONNECTEX: WsaExtension = WsaExtension { + guid: GUID { + Data1: 0x25a207b9, + Data2: 0xddf3, + Data3: 0x4660, + Data4: [0x8e, 0xe9, 0x76, 0xe5, 0x8c, 0x74, 0x06, 0x3e], + }, + val: AtomicUsize::new(0), + }; + type ConnectEx = unsafe extern "system" fn( + SOCKET, + *const SOCKADDR, + c_int, + PVOID, + DWORD, + LPDWORD, + LPOVERLAPPED, + ) -> BOOL; + + let ptr = CONNECTEX.get(socket)?; + assert!(ptr != 0); + let connect_ex = mem::transmute::<_, ConnectEx>(ptr); + + let (addr_buf, addr_len) = socket_addr_to_ptrs(addr); + let mut bytes_sent: DWORD = 0; + let r = connect_ex( + socket, + addr_buf.as_ptr(), + addr_len, + buf.as_ptr() as *mut _, + buf.len() as u32, + &mut bytes_sent, + overlapped, + ); + if r == TRUE { + Ok(Some(bytes_sent as usize)) + } else { + last_err() + } +} + +impl UdpSocketExt for UdpSocket { + unsafe fn recv_from_overlapped( + &self, + buf: &mut [u8], + addr: *mut SocketAddrBuf, + overlapped: *mut OVERLAPPED, + ) -> io::Result<Option<usize>> { + let mut buf = slice2buf(buf); + let mut flags = 0; + let mut received_bytes: DWORD = 0; + let r = WSARecvFrom( + self.as_raw_socket() as SOCKET, + &mut buf, + 1, + &mut received_bytes, + &mut flags, + &mut (*addr).buf as *mut _ as *mut _, + &mut (*addr).len, + overlapped, + None, + ); + cvt(r, received_bytes) + } + + unsafe fn recv_overlapped( + &self, + buf: &mut [u8], + overlapped: *mut OVERLAPPED, + ) -> io::Result<Option<usize>> { + let mut buf = slice2buf(buf); + let mut flags = 0; + let mut received_bytes: DWORD = 0; + let r = WSARecv( + self.as_raw_socket() as SOCKET, + &mut buf, + 1, + &mut received_bytes, + &mut flags, + overlapped, + None, + ); + cvt(r, received_bytes) + } + + unsafe fn send_to_overlapped( + &self, + buf: &[u8], + addr: &SocketAddr, + overlapped: *mut OVERLAPPED, + ) -> io::Result<Option<usize>> { + let (addr_buf, addr_len) = socket_addr_to_ptrs(addr); + let mut buf = slice2buf(buf); + let mut sent_bytes = 0; + let r = WSASendTo( + self.as_raw_socket() as SOCKET, + &mut buf, + 1, + &mut sent_bytes, + 0, + addr_buf.as_ptr() as *const _, + addr_len, + overlapped, + None, + ); + cvt(r, sent_bytes) + } + + unsafe fn send_overlapped( + &self, + buf: &[u8], + overlapped: *mut OVERLAPPED, + ) -> io::Result<Option<usize>> { + let mut buf = slice2buf(buf); + let mut sent_bytes = 0; + let r = WSASend( + self.as_raw_socket() as SOCKET, + &mut buf, + 1, + &mut sent_bytes, + 0, + overlapped, + None, + ); + cvt(r, sent_bytes) + } + + unsafe fn result(&self, overlapped: *mut OVERLAPPED) -> io::Result<(usize, u32)> { + result(self.as_raw_socket() as SOCKET, overlapped) + } +} + +impl TcpListenerExt for TcpListener { + unsafe fn accept_overlapped( + &self, + socket: &TcpStream, + addrs: &mut AcceptAddrsBuf, + overlapped: *mut OVERLAPPED, + ) -> io::Result<bool> { + static ACCEPTEX: WsaExtension = WsaExtension { + guid: GUID { + Data1: 0xb5367df1, + Data2: 0xcbac, + Data3: 0x11cf, + Data4: [0x95, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92], + }, + val: AtomicUsize::new(0), + }; + type AcceptEx = unsafe extern "system" fn( + SOCKET, + SOCKET, + PVOID, + DWORD, + DWORD, + DWORD, + LPDWORD, + LPOVERLAPPED, + ) -> BOOL; + + let ptr = ACCEPTEX.get(self.as_raw_socket() as SOCKET)?; + assert!(ptr != 0); + let accept_ex = mem::transmute::<_, AcceptEx>(ptr); + + let mut bytes = 0; + let (a, b, c, d) = (*addrs).args(); + let r = accept_ex( + self.as_raw_socket() as SOCKET, + socket.as_raw_socket() as SOCKET, + a, + b, + c, + d, + &mut bytes, + overlapped, + ); + let succeeded = if r == TRUE { + true + } else { + last_err()?; + false + }; + Ok(succeeded) + } + + fn accept_complete(&self, socket: &TcpStream) -> io::Result<()> { + const SO_UPDATE_ACCEPT_CONTEXT: c_int = 0x700B; + let me = self.as_raw_socket(); + let result = unsafe { + setsockopt( + socket.as_raw_socket() as SOCKET, + SOL_SOCKET, + SO_UPDATE_ACCEPT_CONTEXT, + &me as *const _ as *const _, + mem::size_of_val(&me) as c_int, + ) + }; + if result == 0 { + Ok(()) + } else { + Err(io::Error::last_os_error()) + } + } + + unsafe fn result(&self, overlapped: *mut OVERLAPPED) -> io::Result<(usize, u32)> { + result(self.as_raw_socket() as SOCKET, overlapped) + } +} + +impl SocketAddrBuf { + /// Creates a new blank socket address buffer. + /// + /// This should be used before a call to `recv_from_overlapped` overlapped + /// to create an instance to pass down. + pub fn new() -> SocketAddrBuf { + SocketAddrBuf { + buf: unsafe { mem::zeroed() }, + len: mem::size_of::<SOCKADDR_STORAGE>() as c_int, + } + } + + /// Parses this buffer to return a standard socket address. + /// + /// This function should be called after the buffer has been filled in with + /// a call to `recv_from_overlapped` being completed. It will interpret the + /// address filled in and return the standard socket address type. + /// + /// If an error is encountered then `None` is returned. + pub fn to_socket_addr(&self) -> Option<SocketAddr> { + unsafe { ptrs_to_socket_addr(&self.buf as *const _ as *const _, self.len) } + } +} + +static GETACCEPTEXSOCKADDRS: WsaExtension = WsaExtension { + guid: GUID { + Data1: 0xb5367df2, + Data2: 0xcbac, + Data3: 0x11cf, + Data4: [0x95, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92], + }, + val: AtomicUsize::new(0), +}; +type GetAcceptExSockaddrs = unsafe extern "system" fn( + PVOID, + DWORD, + DWORD, + DWORD, + *mut LPSOCKADDR, + LPINT, + *mut LPSOCKADDR, + LPINT, +); + +impl AcceptAddrsBuf { + /// Creates a new blank buffer ready to be passed to a call to + /// `accept_overlapped`. + pub fn new() -> AcceptAddrsBuf { + unsafe { mem::zeroed() } + } + + /// Parses the data contained in this address buffer, returning the parsed + /// result if successful. + /// + /// This function can be called after a call to `accept_overlapped` has + /// succeeded to parse out the data that was written in. + pub fn parse(&self, socket: &TcpListener) -> io::Result<AcceptAddrs> { + let mut ret = AcceptAddrs { + local: 0 as *mut _, + local_len: 0, + remote: 0 as *mut _, + remote_len: 0, + _data: self, + }; + let ptr = GETACCEPTEXSOCKADDRS.get(socket.as_raw_socket() as SOCKET)?; + assert!(ptr != 0); + unsafe { + let get_sockaddrs = mem::transmute::<_, GetAcceptExSockaddrs>(ptr); + let (a, b, c, d) = self.args(); + get_sockaddrs( + a, + b, + c, + d, + &mut ret.local, + &mut ret.local_len, + &mut ret.remote, + &mut ret.remote_len, + ); + Ok(ret) + } + } + + fn args(&self) -> (PVOID, DWORD, DWORD, DWORD) { + let remote_offset = unsafe { &(*(0 as *const AcceptAddrsBuf)).remote as *const _ as usize }; + ( + self as *const _ as *mut _, + 0, + remote_offset as DWORD, + (mem::size_of_val(self) - remote_offset) as DWORD, + ) + } +} + +impl<'a> AcceptAddrs<'a> { + /// Returns the local socket address contained in this buffer. + pub fn local(&self) -> Option<SocketAddr> { + unsafe { ptrs_to_socket_addr(self.local, self.local_len) } + } + + /// Returns the remote socket address contained in this buffer. + pub fn remote(&self) -> Option<SocketAddr> { + unsafe { ptrs_to_socket_addr(self.remote, self.remote_len) } + } +} + +impl WsaExtension { + fn get(&self, socket: SOCKET) -> io::Result<usize> { + let prev = self.val.load(Ordering::SeqCst); + if prev != 0 && !cfg!(debug_assertions) { + return Ok(prev); + } + let mut ret = 0 as usize; + let mut bytes = 0; + let r = unsafe { + WSAIoctl( + socket, + SIO_GET_EXTENSION_FUNCTION_POINTER, + &self.guid as *const _ as *mut _, + mem::size_of_val(&self.guid) as DWORD, + &mut ret as *mut _ as *mut _, + mem::size_of_val(&ret) as DWORD, + &mut bytes, + 0 as *mut _, + None, + ) + }; + cvt(r, 0).map(|_| { + debug_assert_eq!(bytes as usize, mem::size_of_val(&ret)); + debug_assert!(prev == 0 || prev == ret); + self.val.store(ret, Ordering::SeqCst); + ret + }) + } +} + +#[cfg(test)] +mod tests { + use std::io::prelude::*; + use std::net::{ + IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV6, TcpListener, TcpStream, UdpSocket, + }; + use std::slice; + use std::thread; + + use socket2::{Domain, Socket, Type}; + + use crate::iocp::CompletionPort; + use crate::net::{AcceptAddrsBuf, TcpListenerExt}; + use crate::net::{SocketAddrBuf, TcpStreamExt, UdpSocketExt}; + use crate::Overlapped; + + fn each_ip(f: &mut dyn FnMut(SocketAddr)) { + f(t!("127.0.0.1:0".parse())); + f(t!("[::1]:0".parse())); + } + + #[test] + fn tcp_read() { + each_ip(&mut |addr| { + let l = t!(TcpListener::bind(addr)); + let addr = t!(l.local_addr()); + let t = thread::spawn(move || { + let mut a = t!(l.accept()).0; + t!(a.write_all(&[1, 2, 3])); + }); + + let cp = t!(CompletionPort::new(1)); + let s = t!(TcpStream::connect(addr)); + t!(cp.add_socket(1, &s)); + + let mut b = [0; 10]; + let a = Overlapped::zero(); + unsafe { + t!(s.read_overlapped(&mut b, a.raw())); + } + let status = t!(cp.get(None)); + assert_eq!(status.bytes_transferred(), 3); + assert_eq!(status.token(), 1); + assert_eq!(status.overlapped(), a.raw()); + assert_eq!(&b[0..3], &[1, 2, 3]); + + t!(t.join()); + }) + } + + #[test] + fn tcp_write() { + each_ip(&mut |addr| { + let l = t!(TcpListener::bind(addr)); + let addr = t!(l.local_addr()); + let t = thread::spawn(move || { + let mut a = t!(l.accept()).0; + let mut b = [0; 10]; + let n = t!(a.read(&mut b)); + assert_eq!(n, 3); + assert_eq!(&b[0..3], &[1, 2, 3]); + }); + + let cp = t!(CompletionPort::new(1)); + let s = t!(TcpStream::connect(addr)); + t!(cp.add_socket(1, &s)); + + let b = [1, 2, 3]; + let a = Overlapped::zero(); + unsafe { + t!(s.write_overlapped(&b, a.raw())); + } + let status = t!(cp.get(None)); + assert_eq!(status.bytes_transferred(), 3); + assert_eq!(status.token(), 1); + assert_eq!(status.overlapped(), a.raw()); + + t!(t.join()); + }) + } + + #[test] + fn tcp_connect() { + each_ip(&mut |addr_template| { + let l = t!(TcpListener::bind(addr_template)); + let addr = t!(l.local_addr()); + let t = thread::spawn(move || { + t!(l.accept()); + }); + + let cp = t!(CompletionPort::new(1)); + let domain = Domain::for_address(addr); + let socket = t!(Socket::new(domain, Type::STREAM, None)); + t!(socket.bind(&addr_template.into())); + let socket = TcpStream::from(socket); + t!(cp.add_socket(1, &socket)); + + let a = Overlapped::zero(); + unsafe { + t!(socket.connect_overlapped(&addr, &[], a.raw())); + } + let status = t!(cp.get(None)); + assert_eq!(status.bytes_transferred(), 0); + assert_eq!(status.token(), 1); + assert_eq!(status.overlapped(), a.raw()); + t!(socket.connect_complete()); + + t!(t.join()); + }) + } + + #[test] + fn udp_recv_from() { + each_ip(&mut |addr| { + let a = t!(UdpSocket::bind(addr)); + let b = t!(UdpSocket::bind(addr)); + let a_addr = t!(a.local_addr()); + let b_addr = t!(b.local_addr()); + let t = thread::spawn(move || { + t!(a.send_to(&[1, 2, 3], b_addr)); + }); + + let cp = t!(CompletionPort::new(1)); + t!(cp.add_socket(1, &b)); + + let mut buf = [0; 10]; + let a = Overlapped::zero(); + let mut addr = SocketAddrBuf::new(); + unsafe { + t!(b.recv_from_overlapped(&mut buf, &mut addr, a.raw())); + } + let status = t!(cp.get(None)); + assert_eq!(status.bytes_transferred(), 3); + assert_eq!(status.token(), 1); + assert_eq!(status.overlapped(), a.raw()); + assert_eq!(&buf[..3], &[1, 2, 3]); + assert_eq!(addr.to_socket_addr(), Some(a_addr)); + + t!(t.join()); + }) + } + + #[test] + fn udp_recv() { + each_ip(&mut |addr| { + let a = t!(UdpSocket::bind(addr)); + let b = t!(UdpSocket::bind(addr)); + let a_addr = t!(a.local_addr()); + let b_addr = t!(b.local_addr()); + assert!(b.connect(a_addr).is_ok()); + assert!(a.connect(b_addr).is_ok()); + let t = thread::spawn(move || { + t!(a.send_to(&[1, 2, 3], b_addr)); + }); + + let cp = t!(CompletionPort::new(1)); + t!(cp.add_socket(1, &b)); + + let mut buf = [0; 10]; + let a = Overlapped::zero(); + unsafe { + t!(b.recv_overlapped(&mut buf, a.raw())); + } + let status = t!(cp.get(None)); + assert_eq!(status.bytes_transferred(), 3); + assert_eq!(status.token(), 1); + assert_eq!(status.overlapped(), a.raw()); + assert_eq!(&buf[..3], &[1, 2, 3]); + + t!(t.join()); + }) + } + + #[test] + fn udp_send_to() { + each_ip(&mut |addr| { + let a = t!(UdpSocket::bind(addr)); + let b = t!(UdpSocket::bind(addr)); + let a_addr = t!(a.local_addr()); + let b_addr = t!(b.local_addr()); + let t = thread::spawn(move || { + let mut b = [0; 100]; + let (n, addr) = t!(a.recv_from(&mut b)); + assert_eq!(n, 3); + assert_eq!(addr, b_addr); + assert_eq!(&b[..3], &[1, 2, 3]); + }); + + let cp = t!(CompletionPort::new(1)); + t!(cp.add_socket(1, &b)); + + let a = Overlapped::zero(); + unsafe { + t!(b.send_to_overlapped(&[1, 2, 3], &a_addr, a.raw())); + } + let status = t!(cp.get(None)); + assert_eq!(status.bytes_transferred(), 3); + assert_eq!(status.token(), 1); + assert_eq!(status.overlapped(), a.raw()); + + t!(t.join()); + }) + } + + #[test] + fn udp_send() { + each_ip(&mut |addr| { + let a = t!(UdpSocket::bind(addr)); + let b = t!(UdpSocket::bind(addr)); + let a_addr = t!(a.local_addr()); + let b_addr = t!(b.local_addr()); + assert!(b.connect(a_addr).is_ok()); + assert!(a.connect(b_addr).is_ok()); + let t = thread::spawn(move || { + let mut b = [0; 100]; + let (n, addr) = t!(a.recv_from(&mut b)); + assert_eq!(n, 3); + assert_eq!(addr, b_addr); + assert_eq!(&b[..3], &[1, 2, 3]); + }); + + let cp = t!(CompletionPort::new(1)); + t!(cp.add_socket(1, &b)); + + let a = Overlapped::zero(); + unsafe { + t!(b.send_overlapped(&[1, 2, 3], a.raw())); + } + let status = t!(cp.get(None)); + assert_eq!(status.bytes_transferred(), 3); + assert_eq!(status.token(), 1); + assert_eq!(status.overlapped(), a.raw()); + + t!(t.join()); + }) + } + + #[test] + fn tcp_accept() { + each_ip(&mut |addr_template| { + let l = t!(TcpListener::bind(addr_template)); + let addr = t!(l.local_addr()); + let t = thread::spawn(move || { + let socket = t!(TcpStream::connect(addr)); + (socket.local_addr().unwrap(), socket.peer_addr().unwrap()) + }); + + let cp = t!(CompletionPort::new(1)); + let domain = Domain::for_address(addr); + let socket = TcpStream::from(t!(Socket::new(domain, Type::STREAM, None))); + t!(cp.add_socket(1, &l)); + + let a = Overlapped::zero(); + let mut addrs = AcceptAddrsBuf::new(); + unsafe { + t!(l.accept_overlapped(&socket, &mut addrs, a.raw())); + } + let status = t!(cp.get(None)); + assert_eq!(status.bytes_transferred(), 0); + assert_eq!(status.token(), 1); + assert_eq!(status.overlapped(), a.raw()); + t!(l.accept_complete(&socket)); + + let (remote, local) = t!(t.join()); + let addrs = addrs.parse(&l).unwrap(); + assert_eq!(addrs.local(), Some(local)); + assert_eq!(addrs.remote(), Some(remote)); + }) + } + + #[test] + fn sockaddr_convert_4() { + let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(3, 4, 5, 6)), 0xabcd); + let (raw_addr, addr_len) = super::socket_addr_to_ptrs(&addr); + assert_eq!(addr_len, 16); + let addr_bytes = + unsafe { slice::from_raw_parts(raw_addr.as_ptr() as *const u8, addr_len as usize) }; + assert_eq!( + addr_bytes, + &[2, 0, 0xab, 0xcd, 3, 4, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0] + ); + } + + #[test] + fn sockaddr_convert_v6() { + let port = 0xabcd; + let flowinfo = 0x12345678; + let scope_id = 0x87654321; + let addr = SocketAddr::V6(SocketAddrV6::new( + Ipv6Addr::new( + 0x0102, 0x0304, 0x0506, 0x0708, 0x090a, 0x0b0c, 0x0d0e, 0x0f10, + ), + port, + flowinfo, + scope_id, + )); + let (raw_addr, addr_len) = super::socket_addr_to_ptrs(&addr); + assert_eq!(addr_len, 28); + let addr_bytes = + unsafe { slice::from_raw_parts(raw_addr.as_ptr() as *const u8, addr_len as usize) }; + assert_eq!( + addr_bytes, + &[ + 23, 0, // AF_INET6 + 0xab, 0xcd, // Port + 0x78, 0x56, 0x34, 0x12, // flowinfo + 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, + 0x0f, 0x10, // IP + 0x21, 0x43, 0x65, 0x87, // scope_id + ] + ); + } +} diff --git a/third_party/rust/miow/src/overlapped.rs b/third_party/rust/miow/src/overlapped.rs new file mode 100644 index 0000000000..abe2d37cbb --- /dev/null +++ b/third_party/rust/miow/src/overlapped.rs @@ -0,0 +1,92 @@ +use std::fmt; +use std::io; +use std::mem; +use std::ptr; + +use winapi::shared::ntdef::{HANDLE, NULL}; +use winapi::um::minwinbase::*; +use winapi::um::synchapi::*; + +/// A wrapper around `OVERLAPPED` to provide "rustic" accessors and +/// initializers. +pub struct Overlapped(OVERLAPPED); + +impl fmt::Debug for Overlapped { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "OVERLAPPED") + } +} + +unsafe impl Send for Overlapped {} +unsafe impl Sync for Overlapped {} + +impl Overlapped { + /// Creates a new zeroed out instance of an overlapped I/O tracking state. + /// + /// This is suitable for passing to methods which will then later get + /// notified via an I/O Completion Port. + pub fn zero() -> Overlapped { + Overlapped(unsafe { mem::zeroed() }) + } + + /// Creates a new `Overlapped` with an initialized non-null `hEvent`. The caller is + /// responsible for calling `CloseHandle` on the `hEvent` field of the returned + /// `Overlapped`. The event is created with `bManualReset` set to `FALSE`, meaning after a + /// single thread waits on the event, it will be reset. + pub fn initialize_with_autoreset_event() -> io::Result<Overlapped> { + let event = unsafe { CreateEventW(ptr::null_mut(), 0i32, 0i32, ptr::null()) }; + if event == NULL { + return Err(io::Error::last_os_error()); + } + let mut overlapped = Self::zero(); + overlapped.set_event(event); + Ok(overlapped) + } + + /// Creates a new `Overlapped` function pointer from the underlying + /// `OVERLAPPED`, wrapping in the "rusty" wrapper for working with + /// accessors. + /// + /// # Unsafety + /// + /// This function doesn't validate `ptr` nor the lifetime of the returned + /// pointer at all, it's recommended to use this method with extreme + /// caution. + pub unsafe fn from_raw<'a>(ptr: *mut OVERLAPPED) -> &'a mut Overlapped { + &mut *(ptr as *mut Overlapped) + } + + /// Gain access to the raw underlying data + pub fn raw(&self) -> *mut OVERLAPPED { + &self.0 as *const _ as *mut _ + } + + /// Sets the offset inside this overlapped structure. + /// + /// Note that for I/O operations in general this only has meaning for I/O + /// handles that are on a seeking device that supports the concept of an + /// offset. + pub fn set_offset(&mut self, offset: u64) { + let s = unsafe { self.0.u.s_mut() }; + s.Offset = offset as u32; + s.OffsetHigh = (offset >> 32) as u32; + } + + /// Reads the offset inside this overlapped structure. + pub fn offset(&self) -> u64 { + let s = unsafe { self.0.u.s() }; + (s.Offset as u64) | ((s.OffsetHigh as u64) << 32) + } + + /// Sets the `hEvent` field of this structure. + /// + /// The event specified can be null. + pub fn set_event(&mut self, event: HANDLE) { + self.0.hEvent = event; + } + + /// Reads the `hEvent` field of this structure, may return null. + pub fn event(&self) -> HANDLE { + self.0.hEvent + } +} diff --git a/third_party/rust/miow/src/pipe.rs b/third_party/rust/miow/src/pipe.rs new file mode 100644 index 0000000000..5088021a86 --- /dev/null +++ b/third_party/rust/miow/src/pipe.rs @@ -0,0 +1,788 @@ +//! Interprocess Communication pipes +//! +//! A pipe is a section of shared memory that processes use for communication. +//! The process that creates a pipe is the _pipe server_. A process that connects +//! to a pipe is a _pipe client_. One process writes information to the pipe, then +//! the other process reads the information from the pipe. This overview +//! describes how to create, manage, and use pipes. +//! +//! There are two types of pipes: [anonymous pipes](#fn.anonymous.html) and +//! [named pipes](#fn.named.html). Anonymous pipes require less overhead than +//! named pipes, but offer limited services. +//! +//! # Anonymous pipes +//! +//! An anonymous pipe is an unnamed, one-way pipe that typically transfers data +//! between a parent process and a child process. Anonymous pipes are always +//! local; they cannot be used for communication over a network. +//! +//! # Named pipes +//! +//! A *named pipe* is a named, one-way or duplex pipe for communication between +//! the pipe server and one or more pipe clients. All instances of a named pipe +//! share the same pipe name, but each instance has its own buffers and handles, +//! and provides a separate conduit for client/server communication. The use of +//! instances enables multiple pipe clients to use the same named pipe +//! simultaneously. +//! +//! Any process can access named pipes, subject to security checks, making named +//! pipes an easy form of communication between related or unrelated processes. +//! +//! Any process can act as both a server and a client, making peer-to-peer +//! communication possible. As used here, the term pipe server refers to a +//! process that creates a named pipe, and the term pipe client refers to a +//! process that connects to an instance of a named pipe. +//! +//! Named pipes can be used to provide communication between processes on the +//! same computer or between processes on different computers across a network. +//! If the server service is running, all named pipes are accessible remotely. If +//! you intend to use a named pipe locally only, deny access to NT +//! AUTHORITY\\NETWORK or switch to local RPC. +//! +//! # References +//! +//! - [win32 pipe docs](https://github.com/MicrosoftDocs/win32/blob/docs/desktop-src/ipc/pipes.md) + +use std::cell::RefCell; +use std::ffi::OsStr; +use std::fs::{File, OpenOptions}; +use std::io; +use std::io::prelude::*; +use std::os::windows::ffi::*; +use std::os::windows::io::*; +use std::time::Duration; + +use crate::handle::Handle; +use crate::overlapped::Overlapped; +use winapi::shared::minwindef::*; +use winapi::shared::ntdef::HANDLE; +use winapi::shared::winerror::*; +use winapi::um::fileapi::*; +use winapi::um::handleapi::*; +use winapi::um::ioapiset::*; +use winapi::um::minwinbase::*; +use winapi::um::namedpipeapi::*; +use winapi::um::winbase::*; + +/// Readable half of an anonymous pipe. +#[derive(Debug)] +pub struct AnonRead(Handle); + +/// Writable half of an anonymous pipe. +#[derive(Debug)] +pub struct AnonWrite(Handle); + +/// A named pipe that can accept connections. +#[derive(Debug)] +pub struct NamedPipe(Handle); + +/// A builder structure for creating a new named pipe. +#[derive(Debug)] +pub struct NamedPipeBuilder { + name: Vec<u16>, + dwOpenMode: DWORD, + dwPipeMode: DWORD, + nMaxInstances: DWORD, + nOutBufferSize: DWORD, + nInBufferSize: DWORD, + nDefaultTimeOut: DWORD, +} + +/// Creates a new anonymous in-memory pipe, returning the read/write ends of the +/// pipe. +/// +/// The buffer size for this pipe may also be specified, but the system will +/// normally use this as a suggestion and it's not guaranteed that the buffer +/// will be precisely this size. +pub fn anonymous(buffer_size: u32) -> io::Result<(AnonRead, AnonWrite)> { + let mut read = 0 as HANDLE; + let mut write = 0 as HANDLE; + crate::cvt(unsafe { CreatePipe(&mut read, &mut write, 0 as *mut _, buffer_size) })?; + Ok((AnonRead(Handle::new(read)), AnonWrite(Handle::new(write)))) +} + +impl Read for AnonRead { + fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { + self.0.read(buf) + } +} +impl<'a> Read for &'a AnonRead { + fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { + self.0.read(buf) + } +} + +impl AsRawHandle for AnonRead { + fn as_raw_handle(&self) -> HANDLE { + self.0.raw() + } +} +impl FromRawHandle for AnonRead { + unsafe fn from_raw_handle(handle: HANDLE) -> AnonRead { + AnonRead(Handle::new(handle)) + } +} +impl IntoRawHandle for AnonRead { + fn into_raw_handle(self) -> HANDLE { + self.0.into_raw() + } +} + +impl Write for AnonWrite { + fn write(&mut self, buf: &[u8]) -> io::Result<usize> { + self.0.write(buf) + } + fn flush(&mut self) -> io::Result<()> { + Ok(()) + } +} +impl<'a> Write for &'a AnonWrite { + fn write(&mut self, buf: &[u8]) -> io::Result<usize> { + self.0.write(buf) + } + fn flush(&mut self) -> io::Result<()> { + Ok(()) + } +} + +impl AsRawHandle for AnonWrite { + fn as_raw_handle(&self) -> HANDLE { + self.0.raw() + } +} +impl FromRawHandle for AnonWrite { + unsafe fn from_raw_handle(handle: HANDLE) -> AnonWrite { + AnonWrite(Handle::new(handle)) + } +} +impl IntoRawHandle for AnonWrite { + fn into_raw_handle(self) -> HANDLE { + self.0.into_raw() + } +} + +/// A convenience function to connect to a named pipe. +/// +/// This function will block the calling process until it can connect to the +/// pipe server specified by `addr`. This will use `NamedPipe::wait` internally +/// to block until it can connect. +pub fn connect<A: AsRef<OsStr>>(addr: A) -> io::Result<File> { + _connect(addr.as_ref()) +} + +fn _connect(addr: &OsStr) -> io::Result<File> { + let mut r = OpenOptions::new(); + let mut w = OpenOptions::new(); + let mut rw = OpenOptions::new(); + r.read(true); + w.write(true); + rw.read(true).write(true); + loop { + let res = rw + .open(addr) + .or_else(|_| r.open(addr)) + .or_else(|_| w.open(addr)); + match res { + Ok(f) => return Ok(f), + Err(ref e) if e.raw_os_error() == Some(ERROR_PIPE_BUSY as i32) => {} + Err(e) => return Err(e), + } + + NamedPipe::wait(addr, Some(Duration::new(20, 0)))?; + } +} + +impl NamedPipe { + /// Creates a new initial named pipe. + /// + /// This function is equivalent to: + /// + /// ``` + /// use miow::pipe::NamedPipeBuilder; + /// + /// # let addr = "foo"; + /// NamedPipeBuilder::new(addr) + /// .first(true) + /// .inbound(true) + /// .outbound(true) + /// .out_buffer_size(65536) + /// .in_buffer_size(65536) + /// .create(); + /// ``` + pub fn new<A: AsRef<OsStr>>(addr: A) -> io::Result<NamedPipe> { + NamedPipeBuilder::new(addr).create() + } + + /// Waits until either a time-out interval elapses or an instance of the + /// specified named pipe is available for connection. + /// + /// If this function succeeds the process can create a `File` to connect to + /// the named pipe. + pub fn wait<A: AsRef<OsStr>>(addr: A, timeout: Option<Duration>) -> io::Result<()> { + NamedPipe::_wait(addr.as_ref(), timeout) + } + + fn _wait(addr: &OsStr, timeout: Option<Duration>) -> io::Result<()> { + let addr = addr.encode_wide().chain(Some(0)).collect::<Vec<_>>(); + let timeout = crate::dur2ms(timeout); + crate::cvt(unsafe { WaitNamedPipeW(addr.as_ptr(), timeout) }).map(|_| ()) + } + + /// Connects this named pipe to a client, blocking until one becomes + /// available. + /// + /// This function will call the `ConnectNamedPipe` function to await for a + /// client to connect. This can be called immediately after the pipe is + /// created, or after it has been disconnected from a previous client. + pub fn connect(&self) -> io::Result<()> { + match crate::cvt(unsafe { ConnectNamedPipe(self.0.raw(), 0 as *mut _) }) { + Ok(_) => Ok(()), + Err(ref e) if e.raw_os_error() == Some(ERROR_PIPE_CONNECTED as i32) => Ok(()), + Err(e) => Err(e), + } + } + + /// Issue a connection request with the specified overlapped operation. + /// + /// This function will issue a request to connect a client to this server, + /// returning immediately after starting the overlapped operation. + /// + /// If this function immediately succeeds then `Ok(true)` is returned. If + /// the overlapped operation is enqueued and pending, then `Ok(false)` is + /// returned. Otherwise an error is returned indicating what went wrong. + /// + /// # Unsafety + /// + /// This function is unsafe because the kernel requires that the + /// `overlapped` pointer is valid until the end of the I/O operation. The + /// kernel also requires that `overlapped` is unique for this I/O operation + /// and is not in use for any other I/O. + /// + /// To safely use this function callers must ensure that this pointer is + /// valid until the I/O operation is completed, typically via completion + /// ports and waiting to receive the completion notification on the port. + pub unsafe fn connect_overlapped(&self, overlapped: *mut OVERLAPPED) -> io::Result<bool> { + match crate::cvt(ConnectNamedPipe(self.0.raw(), overlapped)) { + Ok(_) => Ok(true), + Err(ref e) if e.raw_os_error() == Some(ERROR_PIPE_CONNECTED as i32) => Ok(true), + Err(ref e) if e.raw_os_error() == Some(ERROR_IO_PENDING as i32) => Ok(false), + Err(ref e) if e.raw_os_error() == Some(ERROR_NO_DATA as i32) => Ok(true), + Err(e) => Err(e), + } + } + + /// Disconnects this named pipe from any connected client. + pub fn disconnect(&self) -> io::Result<()> { + crate::cvt(unsafe { DisconnectNamedPipe(self.0.raw()) }).map(|_| ()) + } + + /// Issues an overlapped read operation to occur on this pipe. + /// + /// This function will issue an asynchronous read to occur in an overlapped + /// fashion, returning immediately. The `buf` provided will be filled in + /// with data and the request is tracked by the `overlapped` function + /// provided. + /// + /// If the operation succeeds immediately, `Ok(Some(n))` is returned where + /// `n` is the number of bytes read. If an asynchronous operation is + /// enqueued, then `Ok(None)` is returned. Otherwise if an error occurred + /// it is returned. + /// + /// When this operation completes (or if it completes immediately), another + /// mechanism must be used to learn how many bytes were transferred (such as + /// looking at the filed in the IOCP status message). + /// + /// # Unsafety + /// + /// This function is unsafe because the kernel requires that the `buf` and + /// `overlapped` pointers to be valid until the end of the I/O operation. + /// The kernel also requires that `overlapped` is unique for this I/O + /// operation and is not in use for any other I/O. + /// + /// To safely use this function callers must ensure that the pointers are + /// valid until the I/O operation is completed, typically via completion + /// ports and waiting to receive the completion notification on the port. + pub unsafe fn read_overlapped( + &self, + buf: &mut [u8], + overlapped: *mut OVERLAPPED, + ) -> io::Result<Option<usize>> { + self.0.read_overlapped(buf, overlapped) + } + + /// Issues an overlapped write operation to occur on this pipe. + /// + /// This function will issue an asynchronous write to occur in an overlapped + /// fashion, returning immediately. The `buf` provided will be filled in + /// with data and the request is tracked by the `overlapped` function + /// provided. + /// + /// If the operation succeeds immediately, `Ok(Some(n))` is returned where + /// `n` is the number of bytes written. If an asynchronous operation is + /// enqueued, then `Ok(None)` is returned. Otherwise if an error occurred + /// it is returned. + /// + /// When this operation completes (or if it completes immediately), another + /// mechanism must be used to learn how many bytes were transferred (such as + /// looking at the filed in the IOCP status message). + /// + /// # Unsafety + /// + /// This function is unsafe because the kernel requires that the `buf` and + /// `overlapped` pointers to be valid until the end of the I/O operation. + /// The kernel also requires that `overlapped` is unique for this I/O + /// operation and is not in use for any other I/O. + /// + /// To safely use this function callers must ensure that the pointers are + /// valid until the I/O operation is completed, typically via completion + /// ports and waiting to receive the completion notification on the port. + pub unsafe fn write_overlapped( + &self, + buf: &[u8], + overlapped: *mut OVERLAPPED, + ) -> io::Result<Option<usize>> { + self.0.write_overlapped(buf, overlapped) + } + + /// Calls the `GetOverlappedResult` function to get the result of an + /// overlapped operation for this handle. + /// + /// This function takes the `OVERLAPPED` argument which must have been used + /// to initiate an overlapped I/O operation, and returns either the + /// successful number of bytes transferred during the operation or an error + /// if one occurred. + /// + /// # Unsafety + /// + /// This function is unsafe as `overlapped` must have previously been used + /// to execute an operation for this handle, and it must also be a valid + /// pointer to an `Overlapped` instance. + /// + /// # Panics + /// + /// This function will panic + pub unsafe fn result(&self, overlapped: *mut OVERLAPPED) -> io::Result<usize> { + let mut transferred = 0; + let r = GetOverlappedResult(self.0.raw(), overlapped, &mut transferred, FALSE); + if r == 0 { + Err(io::Error::last_os_error()) + } else { + Ok(transferred as usize) + } + } +} + +thread_local! { + static NAMED_PIPE_OVERLAPPED: RefCell<Option<Overlapped>> = RefCell::new(None); +} + +/// Call a function with a threadlocal `Overlapped`. The function `f` should be +/// sure that the event is reset, either manually or by a thread being released. +fn with_threadlocal_overlapped<F>(f: F) -> io::Result<usize> +where + F: FnOnce(&Overlapped) -> io::Result<usize>, +{ + NAMED_PIPE_OVERLAPPED.with(|overlapped| { + let mut mborrow = overlapped.borrow_mut(); + if let None = *mborrow { + let op = Overlapped::initialize_with_autoreset_event()?; + *mborrow = Some(op); + } + f(mborrow.as_ref().unwrap()) + }) +} + +impl Read for NamedPipe { + fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { + // This is necessary because the pipe is opened with `FILE_FLAG_OVERLAPPED`. + with_threadlocal_overlapped(|overlapped| unsafe { + self.0 + .read_overlapped_wait(buf, overlapped.raw() as *mut OVERLAPPED) + }) + } +} +impl<'a> Read for &'a NamedPipe { + fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { + // This is necessary because the pipe is opened with `FILE_FLAG_OVERLAPPED`. + with_threadlocal_overlapped(|overlapped| unsafe { + self.0 + .read_overlapped_wait(buf, overlapped.raw() as *mut OVERLAPPED) + }) + } +} + +impl Write for NamedPipe { + fn write(&mut self, buf: &[u8]) -> io::Result<usize> { + // This is necessary because the pipe is opened with `FILE_FLAG_OVERLAPPED`. + with_threadlocal_overlapped(|overlapped| unsafe { + self.0 + .write_overlapped_wait(buf, overlapped.raw() as *mut OVERLAPPED) + }) + } + fn flush(&mut self) -> io::Result<()> { + <&NamedPipe as Write>::flush(&mut &*self) + } +} +impl<'a> Write for &'a NamedPipe { + fn write(&mut self, buf: &[u8]) -> io::Result<usize> { + // This is necessary because the pipe is opened with `FILE_FLAG_OVERLAPPED`. + with_threadlocal_overlapped(|overlapped| unsafe { + self.0 + .write_overlapped_wait(buf, overlapped.raw() as *mut OVERLAPPED) + }) + } + fn flush(&mut self) -> io::Result<()> { + crate::cvt(unsafe { FlushFileBuffers(self.0.raw()) }).map(|_| ()) + } +} + +impl AsRawHandle for NamedPipe { + fn as_raw_handle(&self) -> HANDLE { + self.0.raw() + } +} +impl FromRawHandle for NamedPipe { + unsafe fn from_raw_handle(handle: HANDLE) -> NamedPipe { + NamedPipe(Handle::new(handle)) + } +} +impl IntoRawHandle for NamedPipe { + fn into_raw_handle(self) -> HANDLE { + self.0.into_raw() + } +} + +fn flag(slot: &mut DWORD, on: bool, val: DWORD) { + if on { + *slot |= val; + } else { + *slot &= !val; + } +} + +impl NamedPipeBuilder { + /// Creates a new named pipe builder with the default settings. + pub fn new<A: AsRef<OsStr>>(addr: A) -> NamedPipeBuilder { + NamedPipeBuilder { + name: addr.as_ref().encode_wide().chain(Some(0)).collect(), + dwOpenMode: PIPE_ACCESS_DUPLEX | FILE_FLAG_FIRST_PIPE_INSTANCE | FILE_FLAG_OVERLAPPED, + dwPipeMode: PIPE_TYPE_BYTE, + nMaxInstances: PIPE_UNLIMITED_INSTANCES, + nOutBufferSize: 65536, + nInBufferSize: 65536, + nDefaultTimeOut: 0, + } + } + + /// Indicates whether data is allowed to flow from the client to the server. + pub fn inbound(&mut self, allowed: bool) -> &mut Self { + flag(&mut self.dwOpenMode, allowed, PIPE_ACCESS_INBOUND); + self + } + + /// Indicates whether data is allowed to flow from the server to the client. + pub fn outbound(&mut self, allowed: bool) -> &mut Self { + flag(&mut self.dwOpenMode, allowed, PIPE_ACCESS_OUTBOUND); + self + } + + /// Indicates that this pipe must be the first instance. + /// + /// If set to true, then creation will fail if there's already an instance + /// elsewhere. + pub fn first(&mut self, first: bool) -> &mut Self { + flag(&mut self.dwOpenMode, first, FILE_FLAG_FIRST_PIPE_INSTANCE); + self + } + + /// Indicates whether this server can accept remote clients or not. + pub fn accept_remote(&mut self, accept: bool) -> &mut Self { + flag(&mut self.dwPipeMode, !accept, PIPE_REJECT_REMOTE_CLIENTS); + self + } + + /// Specifies the maximum number of instances of the server pipe that are + /// allowed. + /// + /// The first instance of a pipe can specify this value. A value of 255 + /// indicates that there is no limit to the number of instances. + pub fn max_instances(&mut self, instances: u8) -> &mut Self { + self.nMaxInstances = instances as DWORD; + self + } + + /// Specifies the number of bytes to reserver for the output buffer + pub fn out_buffer_size(&mut self, buffer: u32) -> &mut Self { + self.nOutBufferSize = buffer as DWORD; + self + } + + /// Specifies the number of bytes to reserver for the input buffer + pub fn in_buffer_size(&mut self, buffer: u32) -> &mut Self { + self.nInBufferSize = buffer as DWORD; + self + } + + /// Using the options in this builder, attempt to create a new named pipe. + /// + /// This function will call the `CreateNamedPipe` function and return the + /// result. + pub fn create(&mut self) -> io::Result<NamedPipe> { + unsafe { self.with_security_attributes(::std::ptr::null_mut()) } + } + + /// Using the options in the builder and the provided security attributes, attempt to create a + /// new named pipe. This function has to be called with a valid pointer to a + /// `SECURITY_ATTRIBUTES` struct that will stay valid for the lifetime of this function or a + /// null pointer. + /// + /// This function will call the `CreateNamedPipe` function and return the + /// result. + pub unsafe fn with_security_attributes( + &mut self, + attrs: *mut SECURITY_ATTRIBUTES, + ) -> io::Result<NamedPipe> { + let h = CreateNamedPipeW( + self.name.as_ptr(), + self.dwOpenMode, + self.dwPipeMode, + self.nMaxInstances, + self.nOutBufferSize, + self.nInBufferSize, + self.nDefaultTimeOut, + attrs, + ); + + if h == INVALID_HANDLE_VALUE { + Err(io::Error::last_os_error()) + } else { + Ok(NamedPipe(Handle::new(h))) + } + } +} + +#[cfg(test)] +mod tests { + use std::fs::{File, OpenOptions}; + use std::io::prelude::*; + use std::sync::mpsc::channel; + use std::thread; + use std::time::Duration; + + use rand::{distributions::Alphanumeric, thread_rng, Rng}; + + use super::{anonymous, NamedPipe, NamedPipeBuilder}; + use crate::iocp::CompletionPort; + use crate::Overlapped; + + fn name() -> String { + let name = thread_rng() + .sample_iter(Alphanumeric) + .take(30) + .map(char::from) + .collect::<String>(); + format!(r"\\.\pipe\{}", name) + } + + #[test] + fn anon() { + let (mut read, mut write) = t!(anonymous(256)); + assert_eq!(t!(write.write(&[1, 2, 3])), 3); + let mut b = [0; 10]; + assert_eq!(t!(read.read(&mut b)), 3); + assert_eq!(&b[..3], &[1, 2, 3]); + } + + #[test] + fn named_not_first() { + let name = name(); + let _a = t!(NamedPipe::new(&name)); + assert!(NamedPipe::new(&name).is_err()); + + t!(NamedPipeBuilder::new(&name).first(false).create()); + } + + #[test] + fn named_connect() { + let name = name(); + let a = t!(NamedPipe::new(&name)); + + let t = thread::spawn(move || { + t!(File::open(name)); + }); + + t!(a.connect()); + t!(a.disconnect()); + t!(t.join()); + } + + #[test] + fn named_wait() { + let name = name(); + let a = t!(NamedPipe::new(&name)); + + let (tx, rx) = channel(); + let t = thread::spawn(move || { + t!(NamedPipe::wait(&name, None)); + t!(File::open(&name)); + assert!(NamedPipe::wait(&name, Some(Duration::from_millis(1))).is_err()); + t!(tx.send(())); + }); + + t!(a.connect()); + t!(rx.recv()); + t!(a.disconnect()); + t!(t.join()); + } + + #[test] + fn named_connect_overlapped() { + let name = name(); + let a = t!(NamedPipe::new(&name)); + + let t = thread::spawn(move || { + t!(File::open(name)); + }); + + let cp = t!(CompletionPort::new(1)); + t!(cp.add_handle(2, &a)); + + let over = Overlapped::zero(); + unsafe { + t!(a.connect_overlapped(over.raw())); + } + + let status = t!(cp.get(None)); + assert_eq!(status.bytes_transferred(), 0); + assert_eq!(status.token(), 2); + assert_eq!(status.overlapped(), over.raw()); + t!(t.join()); + } + + #[test] + fn named_read_write() { + let name = name(); + let mut a = t!(NamedPipe::new(&name)); + + let t = thread::spawn(move || { + let mut f = t!(OpenOptions::new().read(true).write(true).open(name)); + t!(f.write_all(&[1, 2, 3])); + let mut b = [0; 10]; + assert_eq!(t!(f.read(&mut b)), 3); + assert_eq!(&b[..3], &[1, 2, 3]); + }); + + t!(a.connect()); + let mut b = [0; 10]; + assert_eq!(t!(a.read(&mut b)), 3); + assert_eq!(&b[..3], &[1, 2, 3]); + t!(a.write_all(&[1, 2, 3])); + t!(a.flush()); + t!(a.disconnect()); + t!(t.join()); + } + + #[test] + fn named_read_write_multi() { + for _ in 0..5 { + named_read_write() + } + } + + #[test] + fn named_read_write_multi_same_thread() { + let name1 = name(); + let mut a1 = t!(NamedPipe::new(&name1)); + let name2 = name(); + let mut a2 = t!(NamedPipe::new(&name2)); + + let t = thread::spawn(move || { + let mut f = t!(OpenOptions::new().read(true).write(true).open(name1)); + t!(f.write_all(&[1, 2, 3])); + let mut b = [0; 10]; + assert_eq!(t!(f.read(&mut b)), 3); + assert_eq!(&b[..3], &[1, 2, 3]); + + let mut f = t!(OpenOptions::new().read(true).write(true).open(name2)); + t!(f.write_all(&[1, 2, 3])); + let mut b = [0; 10]; + assert_eq!(t!(f.read(&mut b)), 3); + assert_eq!(&b[..3], &[1, 2, 3]); + }); + + t!(a1.connect()); + let mut b = [0; 10]; + assert_eq!(t!(a1.read(&mut b)), 3); + assert_eq!(&b[..3], &[1, 2, 3]); + t!(a1.write_all(&[1, 2, 3])); + t!(a1.flush()); + t!(a1.disconnect()); + + t!(a2.connect()); + let mut b = [0; 10]; + assert_eq!(t!(a2.read(&mut b)), 3); + assert_eq!(&b[..3], &[1, 2, 3]); + t!(a2.write_all(&[1, 2, 3])); + t!(a2.flush()); + t!(a2.disconnect()); + + t!(t.join()); + } + + #[test] + fn named_read_overlapped() { + let name = name(); + let a = t!(NamedPipe::new(&name)); + + let t = thread::spawn(move || { + let mut f = t!(File::create(name)); + t!(f.write_all(&[1, 2, 3])); + }); + + let cp = t!(CompletionPort::new(1)); + t!(cp.add_handle(3, &a)); + t!(a.connect()); + + let mut b = [0; 10]; + let over = Overlapped::zero(); + unsafe { + t!(a.read_overlapped(&mut b, over.raw())); + } + let status = t!(cp.get(None)); + assert_eq!(status.bytes_transferred(), 3); + assert_eq!(status.token(), 3); + assert_eq!(status.overlapped(), over.raw()); + assert_eq!(&b[..3], &[1, 2, 3]); + + t!(t.join()); + } + + #[test] + fn named_write_overlapped() { + let name = name(); + let a = t!(NamedPipe::new(&name)); + + let t = thread::spawn(move || { + let mut f = t!(super::connect(name)); + let mut b = [0; 10]; + assert_eq!(t!(f.read(&mut b)), 3); + assert_eq!(&b[..3], &[1, 2, 3]) + }); + + let cp = t!(CompletionPort::new(1)); + t!(cp.add_handle(3, &a)); + t!(a.connect()); + + let over = Overlapped::zero(); + unsafe { + t!(a.write_overlapped(&[1, 2, 3], over.raw())); + } + + let status = t!(cp.get(None)); + assert_eq!(status.bytes_transferred(), 3); + assert_eq!(status.token(), 3); + assert_eq!(status.overlapped(), over.raw()); + + t!(t.join()); + } +} |