---

yaml
---
r: 142672
b: refs/heads/try2
c: 794923c
h: refs/heads/master
v: v3

Author: Eric Reed

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 55dda46cf676e5efd713a0c1c8c4c5a297a6db02
+refs/heads/try2: 794923c99511398bc90400e380dd11770ec8e614
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libstd/rt/io/net/udp.rs

@@ -44,7 +44,6 @@ impl UdpSocket {
             Ok((nread, src)) => Some((nread, src)),
             Err(ioerr) => {
                 // EOF is indicated by returning None
-                // XXX do we ever find EOF reading UDP packets?
                 if ioerr.kind != EndOfFile {
                     read_error::cond.raise(ioerr);
                 }
@@ -86,10 +85,12 @@ impl UdpStream {
 
 impl Reader for UdpStream {
     fn read(&mut self, buf: &mut [u8]) -> Option<uint> { 
-        let conn = self.connectedTo;
         do self.as_socket |sock| {
-            sock.recvfrom(buf)
-                .map_consume(|(nread,src)| if src == conn {nread} else {0})
+            match sock.recvfrom(buf) {
+                Some((_nread, src)) if src != self.connectedTo => Some(0),
+                Some((nread, _src)) => Some(nread),
+                None => None,
+            }
         }
     }
 
@@ -105,3 +106,97 @@ impl Writer for UdpStream {
 
     fn flush(&mut self) { fail!() }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use rt::test::*;
+    use rt::io::net::ip::Ipv4;
+    use rt::io::*;
+    use option::{Some, None};
+
+    #[test]  #[ignore]
+    fn bind_error() {
+        do run_in_newsched_task {
+            let mut called = false;
+            do io_error::cond.trap(|e| {
+                assert!(e.kind == PermissionDenied);
+                called = true;
+            }).in {
+                let addr = Ipv4(0, 0, 0, 0, 1);
+                let socket = UdpSocket::bind(addr);
+                assert!(socket.is_none());
+            }
+            assert!(called);
+        }
+    }
+
+    #[test] 
+    fn socket_smoke_test() {
+        do run_in_newsched_task {
+            let server_ip = next_test_ip4();
+            let client_ip = next_test_ip4();
+
+            do spawntask_immediately {
+                match UdpSocket::bind(server_ip) {
+                    Some(server) => {
+                        let mut buf = [0];
+                        match server.recvfrom(buf) {
+                            Some((nread, src)) => {
+                                assert_eq!(nread, 1);
+                                assert_eq!(buf[0], 99);
+                                assert_eq!(src, client_ip);
+                            }
+                            None => fail!()
+                        }
+                    }
+                    None => fail!()
+                }
+            }
+
+            do spawntask_immediately {
+                match UdpSocket::bind(client_ip) {
+                    Some(client) => client.sendto([99], server_ip),
+                    None => fail!()
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn stream_smoke_test() {
+        do run_in_newsched_task {
+            let server_ip = next_test_ip4();
+            let client_ip = next_test_ip4();
+
+            do spawntask_immediately {
+                match UdpSocket::bind(server_ip) {
+                    Some(server) => {
+                        let server = ~server;
+                        let mut stream = server.connect(client_ip);
+                        let mut buf = [0];
+                        match stream.read(buf) {
+                            Some(nread) => {
+                                assert_eq!(nread, 1);
+                                assert_eq!(buf[0], 99);
+                            }
+                            None => fail!()
+                        }
+                    }
+                    None => fail!()
+                }
+            }
+
+            do spawntask_immediately {
+                match UdpSocket::bind(client_ip) {
+                    Some(client) => {
+                        let client = ~client;
+                        let mut stream = client.connect(server_ip);
+                        stream.write([99]);
+                    }
+                    None => fail!()
+                }
+            }
+        }
+    }
+}

branches/try2/src/libstd/rt/uv/mod.rs

@@ -46,6 +46,7 @@ use libc::{c_void, c_int, size_t, malloc, free};
 use cast::transmute;
 use ptr::null;
 use unstable::finally::Finally;
+use rt::io::net::ip::IpAddr;
 
 use rt::io::IoError;
 
@@ -126,7 +127,7 @@ pub type ConnectionCallback = ~fn(StreamWatcher, Option<UvError>);
 pub type FsCallback = ~fn(FsRequest, Option<UvError>);
 pub type TimerCallback = ~fn(TimerWatcher, Option<UvError>);
 pub type AsyncCallback = ~fn(AsyncWatcher, Option<UvError>);
-pub type UdpReceiveCallback = ~fn(UdpWatcher, int, Buf, Ipv4, uint, Option<UvError>);
+pub type UdpReceiveCallback = ~fn(UdpWatcher, int, Buf, IpAddr, uint, Option<UvError>);
 pub type UdpSendCallback = ~fn(UdpWatcher, Option<UvError>);
 
 
@@ -298,9 +299,6 @@ pub fn status_to_maybe_uv_error<T>(handle: *T, status: c_int) -> Option<UvError>
 /// The uv buffer type
 pub type Buf = uvll::uv_buf_t;
 
-/// The uv IPv4 type
-pub type Ipv4 = uvll::sockaddr_in;
-
 /// Borrow a slice to a Buf
 pub fn slice_to_uv_buf(v: &[u8]) -> Buf {
     let data = vec::raw::to_ptr(v);