read code

Author: ssrlive

Cargo.toml

@@ -5,7 +5,7 @@ edition = '2021'
 repository = 'https://github.com/narrowlink/udp-stream'
 license = 'MIT'
 name = 'udp-stream'
-version = '0.0.12'
+version = '0.1.0'
 keywords = ["stream", "udp", "dtls", "tokio"]
 
 [dependencies]
@@ -14,7 +14,7 @@ log = "0.4"
 tokio = { version = "1", features = ["rt", "sync", "net", "macros", "io-util"] }
 
 [dev-dependencies]
-env_logger = "0.10"
+env_logger = "0.11"
 openssl = { version = "0.10", features = ["vendored"] }
 tokio = { version = "1", features = ["time", "rt-multi-thread"] }
 tokio-openssl = '0.6'

README.md

@@ -16,25 +16,20 @@
 
 To use `udp-stream` in your Rust project, simply add it as a dependency in your `Cargo.toml` file:
 
-toml
-
-```[dependencies]
-udp-stream = "0.0.12"
+```toml
+[dependencies]
+udp-stream = "0.1"
 ``` 
 
 Then, you can import and use the library in your Rust code:
 
-rust
-
-```
+```rust,no_run
 use std::{net::SocketAddr, str::FromStr};
-
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
-
 use udp_stream::UdpStream;
 
 #[tokio::main]
-async fn main() -> Result<(), Box<dyn Error>> {
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut stream = UdpStream::connect(SocketAddr::from_str("127.0.0.1:8080")?).await?;
     println!("Ready to Connected to {}", &stream.peer_addr()?);
     let mut buffer = String::new();

examples/echo-dtls.rs

@@ -33,7 +33,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
     let listener = UdpListener::bind(SocketAddr::from_str("127.0.0.1:8080")?).await?;
     let acceptor = ssl_acceptor(SERVER_CERT, SERVER_KEY)?;
     loop {
-        let (socket, _) = listener.accept().await?;
+        let socket = listener.accept().await?;
         let acceptor = acceptor.clone();
         tokio::spawn(async move {
             let ssl = Ssl::new(&acceptor).unwrap();

examples/echo-udp.rs

@@ -14,7 +14,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
     let listener = udp_stream::UdpListener::bind(SocketAddr::from_str("127.0.0.1:8080")?).await?;
     loop {
-        let (mut stream, _) = listener.accept().await?;
+        let mut stream = listener.accept().await?;
         tokio::spawn(async move {
             let id = std::thread::current().id();
             let block = async move {

rustfmt.toml

@@ -0,0 +1 @@
+max_width = 140

src/lib.rs

@@ -1,8 +1,9 @@
+#![doc = include_str!("../README.md")]
+
 use bytes::{Buf, Bytes, BytesMut};
 use std::{
     collections::HashMap,
     future::Future,
-    io,
     net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr},
     pin::Pin,
     sync::Arc,
@@ -36,14 +37,14 @@ const CHANNEL_LEN: usize = 100;
 ///     let mut listener = UdpListener::bind(SocketAddr::from_str("127.0.0.1:8080")?).await?;
 ///
 ///     loop {
-///         let (socket, _) = listener.accept().await?;
+///         let socket = listener.accept().await?;
 ///         process_socket(socket).await;
 ///     }
 /// }
 /// ```
 pub struct UdpListener {
     handler: tokio::task::JoinHandle<()>,
-    receiver: Arc<Mutex<mpsc::Receiver<(UdpStream, SocketAddr)>>>,
+    receiver: Arc<Mutex<mpsc::Receiver<UdpStream>>>,
     local_addr: SocketAddr,
 }
 
@@ -55,12 +56,13 @@ impl Drop for UdpListener {
 
 impl UdpListener {
     /// Binds the `UdpListener` to the given local address.
-    pub async fn bind(local_addr: SocketAddr) -> io::Result<Self> {
+    pub async fn bind(local_addr: SocketAddr) -> std::io::Result<Self> {
         let udp_socket = UdpSocket::bind(local_addr).await?;
         Self::from_tokio(udp_socket).await
     }
+
     /// Creates a `UdpListener` from an existing `tokio::net::UdpSocket`.
-    pub async fn from_tokio(udp_socket: UdpSocket) -> io::Result<Self> {
+    pub async fn from_tokio(udp_socket: UdpSocket) -> std::io::Result<Self> {
         let (tx, rx) = mpsc::channel(CHANNEL_LEN);
         let local_addr = udp_socket.local_addr()?;
 
@@ -103,7 +105,7 @@ impl UdpListener {
                                     drop: Some(drop_tx.clone()),
                                     remaining: None,
                                 };
-                                if let Err(err) = tx.send((udp_stream, peer_addr)).await {
+                                if let Err(err) = tx.send(udp_stream).await {
                                     log::error!("tx.send {:?}", err);
                                     continue;
                                 }
@@ -122,18 +124,18 @@ impl UdpListener {
     }
 
     ///Returns the local address that this socket is bound to.
-    pub fn local_addr(&self) -> io::Result<SocketAddr> {
+    pub fn local_addr(&self) -> std::io::Result<SocketAddr> {
         Ok(self.local_addr)
     }
 
     /// Accepts a new incoming UDP connection.
-    pub async fn accept(&self) -> io::Result<(UdpStream, SocketAddr)> {
+    pub async fn accept(&self) -> std::io::Result<UdpStream> {
         self.receiver
             .lock()
             .await
             .recv()
             .await
-            .ok_or(io::Error::from(io::ErrorKind::BrokenPipe))
+            .ok_or(std::io::Error::from(std::io::ErrorKind::BrokenPipe))
     }
 }
 
@@ -187,10 +189,7 @@ impl UdpStream {
     /// Creates a new UdpStream from a tokio::net::UdpSocket.
     /// This function is intended to be used to wrap a UDP socket from the tokio library.
     /// Note: The UdpSocket must have the UdpSocket::connect method called before invoking this function.
-    pub async fn from_tokio(
-        socket: UdpSocket,
-        peer_addr: SocketAddr,
-    ) -> Result<Self, tokio::io::Error> {
+    pub async fn from_tokio(socket: UdpSocket, peer_addr: SocketAddr) -> Result<Self, tokio::io::Error> {
         let socket = Arc::new(socket);
 
         let local_addr = socket.local_addr()?;
@@ -201,8 +200,7 @@ impl UdpStream {
 
         let handler = tokio::spawn(async move {
             let mut buf = BytesMut::with_capacity(UDP_BUFFER_SIZE);
-            while let Ok((len, received_addr)) = socket_inner.clone().recv_buf_from(&mut buf).await
-            {
+            while let Ok((len, received_addr)) = socket_inner.clone().recv_buf_from(&mut buf).await {
                 if received_addr != peer_addr {
                     continue;
                 }
@@ -242,11 +240,7 @@ impl UdpStream {
 }
 
 impl AsyncRead for UdpStream {
-    fn poll_read(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context,
-        buf: &mut ReadBuf,
-    ) -> Poll<io::Result<()>> {
+    fn poll_read(mut self: Pin<&mut Self>, cx: &mut Context, buf: &mut ReadBuf) -> Poll<std::io::Result<()>> {
         if let Some(remaining) = self.remaining.as_mut() {
             if buf.remaining() < remaining.len() {
                 buf.put_slice(&remaining.split_to(buf.remaining())[..]);
@@ -271,14 +265,14 @@ impl AsyncRead for UdpStream {
                 buf.put_slice(&inner_buf[..]);
                 Poll::Ready(Ok(()))
             }
-            Poll::Ready(None) => Poll::Ready(Err(io::Error::from(io::ErrorKind::BrokenPipe))),
+            Poll::Ready(None) => Poll::Ready(Err(std::io::Error::from(std::io::ErrorKind::BrokenPipe))),
             Poll::Pending => Poll::Pending,
         }
     }
 }
 
 impl AsyncWrite for UdpStream {
-    fn poll_write(self: Pin<&mut Self>, cx: &mut Context, buf: &[u8]) -> Poll<io::Result<usize>> {
+    fn poll_write(self: Pin<&mut Self>, cx: &mut Context, buf: &[u8]) -> Poll<std::io::Result<usize>> {
         match self.socket.poll_send_to(cx, buf, self.peer_addr) {
             Poll::Ready(Ok(r)) => Poll::Ready(Ok(r)),
             Poll::Ready(Err(e)) => {
@@ -290,10 +284,10 @@ impl AsyncWrite for UdpStream {
             Poll::Pending => Poll::Pending,
         }
     }
-    fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context) -> Poll<io::Result<()>> {
+    fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context) -> Poll<std::io::Result<()>> {
         Poll::Ready(Ok(()))
     }
-    fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context) -> Poll<io::Result<()>> {
+    fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context) -> Poll<std::io::Result<()>> {
         Poll::Ready(Ok(()))
     }
 }