Vendor dependencies for 0.3.0 release

vendor/polling/examples/tcp_client.rs

@@ -0,0 +1,36 @@
+use std::{io, net};
+
+use polling::Event;
+use socket2::Type;
+
+fn main() -> io::Result<()> {
+    let socket = socket2::Socket::new(socket2::Domain::IPV4, Type::STREAM, None)?;
+    let poller = polling::Poller::new()?;
+    unsafe {
+        poller.add(&socket, Event::new(0, true, true))?;
+    }
+    let addr = net::SocketAddr::new(net::Ipv4Addr::LOCALHOST.into(), 8080);
+    socket.set_nonblocking(true)?;
+    let _ = socket.connect(&addr.into());
+
+    let mut events = polling::Events::new();
+
+    events.clear();
+    poller.wait(&mut events, None)?;
+
+    let event = events.iter().next();
+    let event = match event {
+        Some(event) => event,
+        None => {
+            println!("no event");
+            return Ok(());
+        }
+    };
+
+    println!("event: {event:?}");
+    if event.is_err().unwrap_or(false) {
+        println!("connect failed");
+    }
+
+    Ok(())
+}

vendor/polling/examples/two-listeners.rs

@@ -0,0 +1,43 @@
+use std::io;
+use std::net::TcpListener;
+
+use polling::{Event, Events, Poller};
+
+fn main() -> io::Result<()> {
+    let l1 = TcpListener::bind("127.0.0.1:8001")?;
+    let l2 = TcpListener::bind("127.0.0.1:8002")?;
+    l1.set_nonblocking(true)?;
+    l2.set_nonblocking(true)?;
+
+    let poller = Poller::new()?;
+    unsafe {
+        poller.add(&l1, Event::readable(1))?;
+        poller.add(&l2, Event::readable(2))?;
+    }
+
+    println!("You can connect to the server using `nc`:");
+    println!(" $ nc 127.0.0.1 8001");
+    println!(" $ nc 127.0.0.1 8002");
+
+    let mut events = Events::new();
+    loop {
+        events.clear();
+        poller.wait(&mut events, None)?;
+
+        for ev in events.iter() {
+            match ev.key {
+                1 => {
+                    println!("Accept on l1");
+                    l1.accept()?;
+                    poller.modify(&l1, Event::readable(1))?;
+                }
+                2 => {
+                    println!("Accept on l2");
+                    l2.accept()?;
+                    poller.modify(&l2, Event::readable(2))?;
+                }
+                _ => unreachable!(),
+            }
+        }
+    }
+}

vendor/polling/examples/wait-signal.rs

@@ -0,0 +1,67 @@
+#[cfg(all(
+    any(
+        target_vendor = "apple",
+        target_os = "freebsd",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "dragonfly",
+    ),
+    not(polling_test_poll_backend),
+))]
+mod example {
+    use polling::os::kqueue::{PollerKqueueExt, Signal};
+    use polling::{Events, PollMode, Poller};
+
+    pub(super) fn main2() {
+        // Create a poller.
+        let poller = Poller::new().unwrap();
+
+        // Register SIGINT in the poller.
+        let sigint = Signal(rustix::process::Signal::INT.as_raw());
+        poller.add_filter(sigint, 1, PollMode::Oneshot).unwrap();
+
+        let mut events = Events::new();
+
+        println!("Press Ctrl+C to exit...");
+
+        // Wait for events.
+        poller.wait(&mut events, None).unwrap();
+
+        // Process events.
+        let ev = events.iter().next().unwrap();
+        match ev.key {
+            1 => {
+                println!("SIGINT received");
+            }
+            _ => unreachable!(),
+        }
+    }
+}
+
+#[cfg(all(
+    any(
+        target_vendor = "apple",
+        target_os = "freebsd",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "dragonfly",
+    ),
+    not(polling_test_poll_backend),
+))]
+fn main() {
+    example::main2();
+}
+
+#[cfg(not(all(
+    any(
+        target_vendor = "apple",
+        target_os = "freebsd",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "dragonfly",
+    ),
+    not(polling_test_poll_backend),
+)))]
+fn main() {
+    eprintln!("This example is only supported on kqueue-based platforms.");
+}