about summary refs log tree commit diff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/libstd/rt/io/net/udp.rs17
-rw-r--r--src/libstd/rt/rtio.rs40
-rw-r--r--src/libstd/rt/uv/net.rs30
-rw-r--r--src/libstd/rt/uv/uvio.rs76
4 files changed, 81 insertions, 82 deletions
diff --git a/src/libstd/rt/io/net/udp.rs b/src/libstd/rt/io/net/udp.rs
index f3b52783573..59649dee5b9 100644
--- a/src/libstd/rt/io/net/udp.rs
+++ b/src/libstd/rt/io/net/udp.rs
@@ -30,7 +30,7 @@ impl UdpSocket {
         }
     }
 
-    pub fn recvfrom(&self, buf: &mut [u8]) -> Option<(uint, IpAddr)> {
+    pub fn recvfrom(&mut self, buf: &mut [u8]) -> Option<(uint, IpAddr)> {
         match (**self).recvfrom(buf) {
             Ok((nread, src)) => Some((nread, src)),
             Err(ioerr) => {
@@ -43,7 +43,7 @@ impl UdpSocket {
         }
     }
 
-    pub fn sendto(&self, buf: &[u8], dst: IpAddr) {
+    pub fn sendto(&mut self, buf: &[u8], dst: IpAddr) {
         match (**self).sendto(buf, dst) {
             Ok(_) => (),
             Err(ioerr) => io_error::cond.raise(ioerr),
@@ -61,16 +61,17 @@ pub struct UdpStream {
 }
 
 impl UdpStream {
-    pub fn as_socket<T>(&self, f: &fn(&UdpSocket) -> T) -> T { f(&self.socket) }
+    pub fn as_socket<T>(&mut self, f: &fn(&mut UdpSocket) -> T) -> T { f(&mut self.socket) }
 
     pub fn disconnect(self) -> UdpSocket { self.socket }
 }
 
 impl Reader for UdpStream {
     fn read(&mut self, buf: &mut [u8]) -> Option<uint> {
+        let peer = self.connectedTo;
         do self.as_socket |sock| {
             match sock.recvfrom(buf) {
-                Some((_nread, src)) if src != self.connectedTo => Some(0),
+                Some((_nread, src)) if src != peer => Some(0),
                 Some((nread, _src)) => Some(nread),
                 None => None,
             }
@@ -122,7 +123,7 @@ mod test {
 
             do spawntask_immediately {
                 match UdpSocket::bind(server_ip) {
-                    Some(server) => {
+                    Some(ref mut server) => {
                         let mut buf = [0];
                         match server.recvfrom(buf) {
                             Some((nread, src)) => {
@@ -139,7 +140,7 @@ mod test {
 
             do spawntask_immediately {
                 match UdpSocket::bind(client_ip) {
-                    Some(client) => client.sendto([99], server_ip),
+                    Some(ref mut client) => client.sendto([99], server_ip),
                     None => fail!()
                 }
             }
@@ -154,7 +155,7 @@ mod test {
 
             do spawntask_immediately {
                 match UdpSocket::bind(server_ip) {
-                    Some(server) => {
+                    Some(ref mut server) => {
                         let mut buf = [0];
                         match server.recvfrom(buf) {
                             Some((nread, src)) => {
@@ -171,7 +172,7 @@ mod test {
 
             do spawntask_immediately {
                 match UdpSocket::bind(client_ip) {
-                    Some(client) => client.sendto([99], server_ip),
+                    Some(ref mut client) => client.sendto([99], server_ip),
                     None => fail!()
                 }
             }
diff --git a/src/libstd/rt/rtio.rs b/src/libstd/rt/rtio.rs
index 6bf352ee144..10eba85188e 100644
--- a/src/libstd/rt/rtio.rs
+++ b/src/libstd/rt/rtio.rs
@@ -50,37 +50,37 @@ pub trait IoFactory {
 
 pub trait RtioTcpListener : RtioSocket {
     fn accept(&mut self) -> Result<~RtioTcpStreamObject, IoError>;
-    fn accept_simultaneously(&self);
-    fn dont_accept_simultaneously(&self);
+    fn accept_simultaneously(&mut self);
+    fn dont_accept_simultaneously(&mut self);
 }
 
 pub trait RtioTcpStream : RtioSocket {
-    fn read(&self, buf: &mut [u8]) -> Result<uint, IoError>;
-    fn write(&self, buf: &[u8]) -> Result<(), IoError>;
-    fn peer_name(&self) -> IpAddr;
-    fn control_congestion(&self);
-    fn nodelay(&self);
-    fn keepalive(&self, delay_in_seconds: uint);
-    fn letdie(&self);
+    fn read(&mut self, buf: &mut [u8]) -> Result<uint, IoError>;
+    fn write(&mut self, buf: &[u8]) -> Result<(), IoError>;
+    fn peer_name(&mut self) -> IpAddr;
+    fn control_congestion(&mut self);
+    fn nodelay(&mut self);
+    fn keepalive(&mut self, delay_in_seconds: uint);
+    fn letdie(&mut self);
 }
 
 pub trait RtioSocket {
-    fn socket_name(&self) -> IpAddr;
+    fn socket_name(&mut self) -> IpAddr;
 }
 
 pub trait RtioUdpSocket : RtioSocket {
-    fn recvfrom(&self, buf: &mut [u8]) -> Result<(uint, IpAddr), IoError>;
-    fn sendto(&self, buf: &[u8], dst: IpAddr) -> Result<(), IoError>;
+    fn recvfrom(&mut self, buf: &mut [u8]) -> Result<(uint, IpAddr), IoError>;
+    fn sendto(&mut self, buf: &[u8], dst: IpAddr) -> Result<(), IoError>;
 
-    fn join_multicast(&self, multi: IpAddr);
-    fn leave_multicast(&self, multi: IpAddr);
+    fn join_multicast(&mut self, multi: IpAddr);
+    fn leave_multicast(&mut self, multi: IpAddr);
 
-    fn loop_multicast_locally(&self);
-    fn dont_loop_multicast_locally(&self);
+    fn loop_multicast_locally(&mut self);
+    fn dont_loop_multicast_locally(&mut self);
 
-    fn multicast_time_to_live(&self, ttl: int);
-    fn time_to_live(&self, ttl: int);
+    fn multicast_time_to_live(&mut self, ttl: int);
+    fn time_to_live(&mut self, ttl: int);
 
-    fn hear_broadcasts(&self);
-    fn ignore_broadcasts(&self);
+    fn hear_broadcasts(&mut self);
+    fn ignore_broadcasts(&mut self);
 }
diff --git a/src/libstd/rt/uv/net.rs b/src/libstd/rt/uv/net.rs
index b9713fffb65..86891a9df8a 100644
--- a/src/libstd/rt/uv/net.rs
+++ b/src/libstd/rt/uv/net.rs
@@ -359,7 +359,7 @@ impl UdpWatcher {
         }
     }
 
-    pub fn bind(&self, address: IpAddr) -> Result<(), UvError> {
+    pub fn bind(&mut self, address: IpAddr) -> Result<(), UvError> {
         do ip_as_uv_ip(address) |addr| {
             let result = unsafe {
                 match addr {
@@ -374,10 +374,9 @@ impl UdpWatcher {
         }
     }
 
-    pub fn recv_start(&self, alloc: AllocCallback, cb: UdpReceiveCallback) {
+    pub fn recv_start(&mut self, alloc: AllocCallback, cb: UdpReceiveCallback) {
         {
-            let mut this = *self;
-            let data = this.get_watcher_data();
+            let data = self.get_watcher_data();
             data.alloc_cb = Some(alloc);
             data.udp_recv_cb = Some(cb);
         }
@@ -409,14 +408,13 @@ impl UdpWatcher {
         }
     }
 
-    pub fn recv_stop(&self) {
+    pub fn recv_stop(&mut self) {
         unsafe { uvll::udp_recv_stop(self.native_handle()); }
     }
 
-    pub fn send(&self, buf: Buf, address: IpAddr, cb: UdpSendCallback) {
+    pub fn send(&mut self, buf: Buf, address: IpAddr, cb: UdpSendCallback) {
         {
-            let mut this = *self;
-            let data = this.get_watcher_data();
+            let data = self.get_watcher_data();
             assert!(data.udp_send_cb.is_none());
             data.udp_send_cb = Some(cb);
         }
@@ -620,7 +618,7 @@ mod test {
     fn udp_bind_close_ip4() {
         do run_in_bare_thread() {
             let mut loop_ = Loop::new();
-            let udp_watcher = { UdpWatcher::new(&mut loop_) };
+            let mut udp_watcher = { UdpWatcher::new(&mut loop_) };
             let addr = next_test_ip4();
             udp_watcher.bind(addr);
             udp_watcher.close(||());
@@ -633,7 +631,7 @@ mod test {
     fn udp_bind_close_ip6() {
         do run_in_bare_thread() {
             let mut loop_ = Loop::new();
-            let udp_watcher = { UdpWatcher::new(&mut loop_) };
+            let mut udp_watcher = { UdpWatcher::new(&mut loop_) };
             let addr = next_test_ip6();
             udp_watcher.bind(addr);
             udp_watcher.close(||());
@@ -798,7 +796,7 @@ mod test {
             let server_addr = next_test_ip4();
             let client_addr = next_test_ip4();
 
-            let server = UdpWatcher::new(&loop_);
+            let mut server = UdpWatcher::new(&loop_);
             assert!(server.bind(server_addr).is_ok());
 
             rtdebug!("starting read");
@@ -806,7 +804,7 @@ mod test {
                 vec_to_uv_buf(vec::from_elem(size, 0u8))
             };
 
-            do server.recv_start(alloc) |server, nread, buf, src, flags, status| {
+            do server.recv_start(alloc) |mut server, nread, buf, src, flags, status| {
                 server.recv_stop();
                 rtdebug!("i'm reading!");
                 assert!(status.is_none());
@@ -830,7 +828,7 @@ mod test {
 
             do Thread::start {
                 let mut loop_ = Loop::new();
-                let client = UdpWatcher::new(&loop_);
+                let mut client = UdpWatcher::new(&loop_);
                 assert!(client.bind(client_addr).is_ok());
                 let msg = ~[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
                 let buf = slice_to_uv_buf(msg);
@@ -857,7 +855,7 @@ mod test {
             let server_addr = next_test_ip6();
             let client_addr = next_test_ip6();
 
-            let server = UdpWatcher::new(&loop_);
+            let mut server = UdpWatcher::new(&loop_);
             assert!(server.bind(server_addr).is_ok());
 
             rtdebug!("starting read");
@@ -865,7 +863,7 @@ mod test {
                 vec_to_uv_buf(vec::from_elem(size, 0u8))
             };
 
-            do server.recv_start(alloc) |server, nread, buf, src, flags, status| {
+            do server.recv_start(alloc) |mut server, nread, buf, src, flags, status| {
                 server.recv_stop();
                 rtdebug!("i'm reading!");
                 assert!(status.is_none());
@@ -889,7 +887,7 @@ mod test {
 
             do Thread::start {
                 let mut loop_ = Loop::new();
-                let client = UdpWatcher::new(&loop_);
+                let mut client = UdpWatcher::new(&loop_);
                 assert!(client.bind(client_addr).is_ok());
                 let msg = ~[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
                 let buf = slice_to_uv_buf(msg);
diff --git a/src/libstd/rt/uv/uvio.rs b/src/libstd/rt/uv/uvio.rs
index 7046afe8551..9b96c871734 100644
--- a/src/libstd/rt/uv/uvio.rs
+++ b/src/libstd/rt/uv/uvio.rs
@@ -264,7 +264,7 @@ impl IoFactory for UvIoFactory {
     }
 
     fn udp_bind(&mut self, addr: IpAddr) -> Result<~RtioUdpSocketObject, IoError> {
-        let /*mut*/ watcher = UdpWatcher::new(self.uv_loop());
+        let mut watcher = UdpWatcher::new(self.uv_loop());
         match watcher.bind(addr) {
             Ok(_) => Ok(~UvUdpSocket(watcher)),
             Err(uverr) => {
@@ -317,7 +317,7 @@ impl Drop for UvTcpListener {
 
 impl RtioSocket for UvTcpListener {
     // XXX implement
-    fn socket_name(&self) -> IpAddr { fail!(); }
+    fn socket_name(&mut self) -> IpAddr { fail!(); }
 }
 
 impl RtioTcpListener for UvTcpListener {
@@ -357,8 +357,8 @@ impl RtioTcpListener for UvTcpListener {
     }
 
     // XXX implement
-    fn accept_simultaneously(&self) { fail!(); }
-    fn dont_accept_simultaneously(&self) { fail!(); }
+    fn accept_simultaneously(&mut self) { fail!(); }
+    fn dont_accept_simultaneously(&mut self) { fail!(); }
 }
 
 // FIXME #6090: Prefer newtype structs but Drop doesn't work
@@ -380,11 +380,11 @@ impl Drop for UvTcpStream {
 
 impl RtioSocket for UvTcpStream {
     // XXX implement
-    fn socket_name(&self) -> IpAddr { fail!(); }
+    fn socket_name(&mut self) -> IpAddr { fail!(); }
 }
 
 impl RtioTcpStream for UvTcpStream {
-    fn read(&self, buf: &mut [u8]) -> Result<uint, IoError> {
+    fn read(&mut self, buf: &mut [u8]) -> Result<uint, IoError> {
         let result_cell = Cell::new_empty();
         let result_cell_ptr: *Cell<Result<uint, IoError>> = &result_cell;
 
@@ -427,7 +427,7 @@ impl RtioTcpStream for UvTcpStream {
         return result_cell.take();
     }
 
-    fn write(&self, buf: &[u8]) -> Result<(), IoError> {
+    fn write(&mut self, buf: &[u8]) -> Result<(), IoError> {
         let result_cell = Cell::new_empty();
         let result_cell_ptr: *Cell<Result<(), IoError>> = &result_cell;
         let scheduler = Local::take::<Scheduler>();
@@ -456,11 +456,11 @@ impl RtioTcpStream for UvTcpStream {
     }
 
     // XXX implement
-    fn peer_name(&self) -> IpAddr { fail!(); }
-    fn control_congestion(&self) { fail!(); }
-    fn nodelay(&self) { fail!(); }
-    fn keepalive(&self, _delay_in_seconds: uint) { fail!(); }
-    fn letdie(&self) { fail!(); }
+    fn peer_name(&mut self) -> IpAddr { fail!(); }
+    fn control_congestion(&mut self) { fail!(); }
+    fn nodelay(&mut self) { fail!(); }
+    fn keepalive(&mut self, _delay_in_seconds: uint) { fail!(); }
+    fn letdie(&mut self) { fail!(); }
 }
 
 pub struct UvUdpSocket(UdpWatcher);
@@ -481,11 +481,11 @@ impl Drop for UvUdpSocket {
 
 impl RtioSocket for UvUdpSocket {
     // XXX implement
-    fn socket_name(&self) -> IpAddr { fail!(); }
+    fn socket_name(&mut self) -> IpAddr { fail!(); }
 }
 
 impl RtioUdpSocket for UvUdpSocket {
-    fn recvfrom(&self, buf: &mut [u8]) -> Result<(uint, IpAddr), IoError> {
+    fn recvfrom(&mut self, buf: &mut [u8]) -> Result<(uint, IpAddr), IoError> {
         let result_cell = Cell::new_empty();
         let result_cell_ptr: *Cell<Result<(uint, IpAddr), IoError>> = &result_cell;
 
@@ -497,7 +497,7 @@ impl RtioUdpSocket for UvUdpSocket {
             assert!(!sched.in_task_context());
             let task_cell = Cell::new(task);
             let alloc: AllocCallback = |_| unsafe { slice_to_uv_buf(*buf_ptr) };
-            do self.recv_start(alloc) |watcher, nread, _buf, addr, flags, status| {
+            do self.recv_start(alloc) |mut watcher, nread, _buf, addr, flags, status| {
                 let _ = flags; // XXX add handling for partials?
 
                 watcher.recv_stop();
@@ -521,7 +521,7 @@ impl RtioUdpSocket for UvUdpSocket {
         return result_cell.take();
     }
 
-    fn sendto(&self, buf: &[u8], dst: IpAddr) -> Result<(), IoError> {
+    fn sendto(&mut self, buf: &[u8], dst: IpAddr) -> Result<(), IoError> {
         let result_cell = Cell::new_empty();
         let result_cell_ptr: *Cell<Result<(), IoError>> = &result_cell;
         let scheduler = Local::take::<Scheduler>();
@@ -549,17 +549,17 @@ impl RtioUdpSocket for UvUdpSocket {
     }
 
     // XXX implement
-    fn join_multicast(&self, _multi: IpAddr) { fail!(); }
-    fn leave_multicast(&self, _multi: IpAddr) { fail!(); }
+    fn join_multicast(&mut self, _multi: IpAddr) { fail!(); }
+    fn leave_multicast(&mut self, _multi: IpAddr) { fail!(); }
 
-    fn loop_multicast_locally(&self) { fail!(); }
-    fn dont_loop_multicast_locally(&self) { fail!(); }
+    fn loop_multicast_locally(&mut self) { fail!(); }
+    fn dont_loop_multicast_locally(&mut self) { fail!(); }
 
-    fn multicast_time_to_live(&self, _ttl: int) { fail!(); }
-    fn time_to_live(&self, _ttl: int) { fail!(); }
+    fn multicast_time_to_live(&mut self, _ttl: int) { fail!(); }
+    fn time_to_live(&mut self, _ttl: int) { fail!(); }
 
-    fn hear_broadcasts(&self) { fail!(); }
-    fn ignore_broadcasts(&self) { fail!(); }
+    fn hear_broadcasts(&mut self) { fail!(); }
+    fn ignore_broadcasts(&mut self) { fail!(); }
 }
 
 #[test]
@@ -596,7 +596,7 @@ fn test_simple_tcp_server_and_client() {
             unsafe {
                 let io = Local::unsafe_borrow::<IoFactoryObject>();
                 let mut listener = (*io).tcp_bind(addr).unwrap();
-                let stream = listener.accept().unwrap();
+                let mut stream = listener.accept().unwrap();
                 let mut buf = [0, .. 2048];
                 let nread = stream.read(buf).unwrap();
                 assert_eq!(nread, 8);
@@ -610,7 +610,7 @@ fn test_simple_tcp_server_and_client() {
         do spawntask_immediately {
             unsafe {
                 let io = Local::unsafe_borrow::<IoFactoryObject>();
-                let stream = (*io).tcp_connect(addr).unwrap();
+                let mut stream = (*io).tcp_connect(addr).unwrap();
                 stream.write([0, 1, 2, 3, 4, 5, 6, 7]);
             }
         }
@@ -626,7 +626,7 @@ fn test_simple_udp_server_and_client() {
         do spawntask_immediately {
             unsafe {
                 let io = Local::unsafe_borrow::<IoFactoryObject>();
-                let server_socket = (*io).udp_bind(server_addr).unwrap();
+                let mut server_socket = (*io).udp_bind(server_addr).unwrap();
                 let mut buf = [0, .. 2048];
                 let (nread,src) = server_socket.recvfrom(buf).unwrap();
                 assert_eq!(nread, 8);
@@ -641,7 +641,7 @@ fn test_simple_udp_server_and_client() {
         do spawntask_immediately {
             unsafe {
                 let io = Local::unsafe_borrow::<IoFactoryObject>();
-                let client_socket = (*io).udp_bind(client_addr).unwrap();
+                let mut client_socket = (*io).udp_bind(client_addr).unwrap();
                 client_socket.sendto([0, 1, 2, 3, 4, 5, 6, 7], server_addr);
             }
         }
@@ -656,7 +656,7 @@ fn test_read_and_block() {
         do spawntask_immediately {
             let io = unsafe { Local::unsafe_borrow::<IoFactoryObject>() };
             let mut listener = unsafe { (*io).tcp_bind(addr).unwrap() };
-            let stream = listener.accept().unwrap();
+            let mut stream = listener.accept().unwrap();
             let mut buf = [0, .. 2048];
 
             let expected = 32;
@@ -689,7 +689,7 @@ fn test_read_and_block() {
         do spawntask_immediately {
             unsafe {
                 let io = Local::unsafe_borrow::<IoFactoryObject>();
-                let stream = (*io).tcp_connect(addr).unwrap();
+                let mut stream = (*io).tcp_connect(addr).unwrap();
                 stream.write([0, 1, 2, 3, 4, 5, 6, 7]);
                 stream.write([0, 1, 2, 3, 4, 5, 6, 7]);
                 stream.write([0, 1, 2, 3, 4, 5, 6, 7]);
@@ -710,7 +710,7 @@ fn test_read_read_read() {
             unsafe {
                 let io = Local::unsafe_borrow::<IoFactoryObject>();
                 let mut listener = (*io).tcp_bind(addr).unwrap();
-                let stream = listener.accept().unwrap();
+                let mut stream = listener.accept().unwrap();
                 let buf = [1, .. 2048];
                 let mut total_bytes_written = 0;
                 while total_bytes_written < MAX {
@@ -723,7 +723,7 @@ fn test_read_read_read() {
         do spawntask_immediately {
             unsafe {
                 let io = Local::unsafe_borrow::<IoFactoryObject>();
-                let stream = (*io).tcp_connect(addr).unwrap();
+                let mut stream = (*io).tcp_connect(addr).unwrap();
                 let mut buf = [0, .. 2048];
                 let mut total_bytes_read = 0;
                 while total_bytes_read < MAX {
@@ -749,7 +749,7 @@ fn test_udp_twice() {
         do spawntask_immediately {
             unsafe {
                 let io = Local::unsafe_borrow::<IoFactoryObject>();
-                let client = (*io).udp_bind(client_addr).unwrap();
+                let mut client = (*io).udp_bind(client_addr).unwrap();
                 assert!(client.sendto([1], server_addr).is_ok());
                 assert!(client.sendto([2], server_addr).is_ok());
             }
@@ -758,7 +758,7 @@ fn test_udp_twice() {
         do spawntask_immediately {
             unsafe {
                 let io = Local::unsafe_borrow::<IoFactoryObject>();
-                let server = (*io).udp_bind(server_addr).unwrap();
+                let mut server = (*io).udp_bind(server_addr).unwrap();
                 let mut buf1 = [0];
                 let mut buf2 = [0];
                 let (nread1, src1) = server.recvfrom(buf1).unwrap();
@@ -786,8 +786,8 @@ fn test_udp_many_read() {
         do spawntask_immediately {
             unsafe {
                 let io = Local::unsafe_borrow::<IoFactoryObject>();
-                let server_out = (*io).udp_bind(server_out_addr).unwrap();
-                let server_in = (*io).udp_bind(server_in_addr).unwrap();
+                let mut server_out = (*io).udp_bind(server_out_addr).unwrap();
+                let mut server_in = (*io).udp_bind(server_in_addr).unwrap();
                 let msg = [1, .. 2048];
                 let mut total_bytes_sent = 0;
                 let mut buf = [1];
@@ -809,8 +809,8 @@ fn test_udp_many_read() {
         do spawntask_immediately {
             unsafe {
                 let io = Local::unsafe_borrow::<IoFactoryObject>();
-                let client_out = (*io).udp_bind(client_out_addr).unwrap();
-                let client_in = (*io).udp_bind(client_in_addr).unwrap();
+                let mut client_out = (*io).udp_bind(client_out_addr).unwrap();
+                let mut client_in = (*io).udp_bind(client_in_addr).unwrap();
                 let mut total_bytes_recv = 0;
                 let mut buf = [0, .. 2048];
                 while total_bytes_recv < MAX {
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2025-11-04 01:55:50 +0000