Implement clone() for TcpStream and UnixStream

This is part of the overall strategy I would like to take when approaching
issue #11165. The only two I/O objects that reasonably want to be "split" are
the network stream objects. Everything else can be "split" by just creating
another version.

The initial idea I had was the literally split the object into a reader and a
writer half, but that would just introduce lots of clutter with extra interfaces
that were a little unnnecssary, or it would return a ~Reader and a ~Writer which
means you couldn't access things like the remote peer name or local socket name.

The solution I found to be nicer was to just clone the stream itself. The clone
is just a clone of the handle, nothing fancy going on at the kernel level.
Conceptually I found this very easy to wrap my head around (everything else
supports clone()), and it solved the "split" problem at the same time.

The cloning support is pretty specific per platform/lib combination:

* native/win32 - uses some specific WSA apis to clone the SOCKET handle
* native/unix - uses dup() to get another file descriptor
* green/all - This is where things get interesting. When we support full clones
              of a handle, this implies that we're allowing simultaneous writes
              and reads to happen. It turns out that libuv doesn't support two
              simultaneous reads or writes of the same object. It does support
              *one* read and *one* write at the same time, however. Some extra
              infrastructure was added to just block concurrent writers/readers
              until the previous read/write operation was completed.

I've added tests to the tcp/unix modules to make sure that this functionality is
supported everywhere.

Author: alexcrichton

src/libnative/io/file.rs

@@ -294,6 +294,15 @@ impl rtio::RtioPipe for FileDesc {
     fn write(&mut self, buf: &[u8]) -> Result<(), IoError> {
         self.inner_write(buf)
     }
+    fn clone(&self) -> Result<~rtio::RtioPipe, IoError> {
+        match unsafe { libc::dup(self.fd) } {
+            -1 => Err(super::last_error()),
+            fd => Ok(~FileDesc {
+                fd: fd,
+                close_on_drop: true
+            } as ~rtio::RtioPipe)
+        }
+    }
 }
 
 impl rtio::RtioTTY for FileDesc {

src/libnative/io/net.rs

@@ -108,10 +108,27 @@ fn setsockopt<T>(fd: sock_t, opt: libc::c_int, val: libc::c_int,
         let ret = libc::setsockopt(fd, opt, val,
                                    payload,
                                    mem::size_of::<T>() as libc::socklen_t);
-        super::mkerr_libc(ret)
+        if ret != 0 {
+            Err(last_error())
+        } else {
+            Ok(())
+        }
     }
 }
 
+#[cfg(windows)]
+fn last_error() -> io::IoError {
+    extern "system" {
+        fn WSAGetLastError() -> libc::c_int;
+    }
+    super::translate_error(unsafe { WSAGetLastError() }, true)
+}
+
+#[cfg(not(windows))]
+fn last_error() -> io::IoError {
+    super::last_error()
+}
+
 #[cfg(windows)] unsafe fn close(sock: sock_t) { libc::closesocket(sock); }
 #[cfg(unix)]    unsafe fn close(sock: sock_t) { libc::close(sock); }
 
@@ -128,7 +145,7 @@ fn sockname(fd: sock_t,
                     storage as *mut libc::sockaddr,
                     &mut len as *mut libc::socklen_t);
         if ret != 0 {
-            return Err(super::last_error())
+            return Err(last_error())
         }
     }
     return sockaddr_to_addr(&storage, len as uint);
@@ -231,7 +248,7 @@ impl TcpStream {
                     libc::connect(fd, addrp as *libc::sockaddr,
                                   len as libc::socklen_t)
                 }) {
-                    -1 => Err(super::last_error()),
+                    -1 => Err(last_error()),
                     _ => Ok(ret),
                 }
             })
@@ -286,7 +303,7 @@ impl rtio::RtioTcpStream for TcpStream {
         if ret == 0 {
             Err(io::standard_error(io::EndOfFile))
         } else if ret < 0 {
-            Err(super::last_error())
+            Err(last_error())
         } else {
             Ok(ret as uint)
         }
@@ -301,7 +318,7 @@ impl rtio::RtioTcpStream for TcpStream {
             }
         });
         if ret < 0 {
-            Err(super::last_error())
+            Err(last_error())
         } else {
             Ok(())
         }
@@ -321,6 +338,47 @@ impl rtio::RtioTcpStream for TcpStream {
     fn letdie(&mut self) -> IoResult<()> {
         self.set_keepalive(None)
     }
+
+    #[cfg(not(windows))]
+    fn clone(&self) -> IoResult<~rtio::RtioTcpStream> {
+        match unsafe { libc::dup(self.fd) } {
+            -1 => Err(last_error()),
+            fd => Ok(~TcpStream { fd: fd } as ~rtio::RtioTcpStream)
+        }
+    }
+
+    #[cfg(windows)]
+    fn clone(&self) -> IoResult<~rtio::RtioTcpStream> {
+        extern "system" {
+            fn WSADuplicateSocketA(s: libc::SOCKET,
+                                   dwProcessId: libc::DWORD,
+                                   lpProtocolInfo: libc::LPWSAPROTOCOL_INFO)
+                                        -> libc::c_int;
+            fn WSASocketA(af: libc::c_int,
+                          type_: libc::c_int,
+                          protocol: libc::c_int,
+                          lpProtocolInfo: libc::LPWSAPROTOCOL_INFO,
+                          g: libc::GROUP,
+                          dwFlags: libc::DWORD) -> libc::SOCKET;
+        }
+        let mut info: libc::WSAPROTOCOL_INFO = unsafe { intrinsics::init() };
+        match unsafe {
+            WSADuplicateSocketA(self.fd,
+                                libc::GetCurrentProcessId(),
+                                &mut info)
+        } {
+            0 => {}
+            _ => return Err(last_error())
+        }
+
+        match unsafe {
+            WSASocketA(info.iAddressFamily, info.iSocketType,
+                       info.iProtocol, &mut info, 0, 0)
+        } {
+            libc::INVALID_SOCKET => Err(last_error()),
+            fd => Ok(~TcpStream { fd: fd } as ~rtio::RtioTcpStream)
+        }
+    }
 }
 
 impl rtio::RtioSocket for TcpStream {
@@ -350,7 +408,7 @@ impl TcpListener {
                 let ret = TcpListener { fd: fd };
                 match libc::bind(fd, addrp as *libc::sockaddr,
                                  len as libc::socklen_t) {
-                    -1 => Err(super::last_error()),
+                    -1 => Err(last_error()),
                     _ => Ok(ret),
                 }
             })
@@ -361,7 +419,7 @@ impl TcpListener {
 
     pub fn native_listen(self, backlog: int) -> IoResult<TcpAcceptor> {
         match unsafe { libc::listen(self.fd, backlog as libc::c_int) } {
-            -1 => Err(super::last_error()),
+            -1 => Err(last_error()),
             _ => Ok(TcpAcceptor { listener: self })
         }
     }
@@ -401,7 +459,7 @@ impl TcpAcceptor {
                              storagep as *mut libc::sockaddr,
                              &mut size as *mut libc::socklen_t) as libc::c_int
             }) as sock_t {
-                -1 => Err(super::last_error()),
+                -1 => Err(last_error()),
                 fd => Ok(TcpStream { fd: fd })
             }
         }
@@ -440,7 +498,7 @@ impl UdpSocket {
                 let ret = UdpSocket { fd: fd };
                 match libc::bind(fd, addrp as *libc::sockaddr,
                                  len as libc::socklen_t) {
-                    -1 => Err(super::last_error()),
+                    -1 => Err(last_error()),
                     _ => Ok(ret),
                 }
             })
@@ -505,7 +563,7 @@ impl rtio::RtioUdpSocket for UdpSocket {
                                storagep as *mut libc::sockaddr,
                                &mut addrlen) as libc::c_int
             });
-            if ret < 0 { return Err(super::last_error()) }
+            if ret < 0 { return Err(last_error()) }
             sockaddr_to_addr(&storage, addrlen as uint).and_then(|addr| {
                 Ok((ret as uint, addr))
             })
@@ -524,7 +582,7 @@ impl rtio::RtioUdpSocket for UdpSocket {
                              len as libc::socklen_t) as libc::c_int
             });
             match ret {
-                -1 => Err(super::last_error()),
+                -1 => Err(last_error()),
                 n if n as uint != buf.len() => {
                     Err(io::IoError {
                         kind: io::OtherIoError,

src/librustuv/access.rs

@@ -0,0 +1,109 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// 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.
+
+/// An exclusive access primitive
+///
+/// This primitive is used to gain exclusive access to read() and write() in uv.
+/// It is assumed that all invocations of this struct happen on the same thread
+/// (the uv event loop).
+
+use std::cast;
+use std::sync::arc::UnsafeArc;
+use std::rt::task::{BlockedTask, Task};
+use std::rt::local::Local;
+
+use homing::HomingMissile;
+
+pub struct Access {
+    priv inner: UnsafeArc<Inner>,
+}
+
+pub struct Guard<'a> {
+    priv access: &'a mut Access,
+    priv missile: Option<HomingMissile>,
+}
+
+struct Inner {
+    queue: ~[BlockedTask],
+    held: bool,
+}
+
+impl Access {
+    pub fn new() -> Access {
+        Access {
+            inner: UnsafeArc::new(Inner {
+                queue: ~[],
+                held: false,
+            })
+        }
+    }
+
+    pub fn grant<'a>(&'a mut self, missile: HomingMissile) -> Guard<'a> {
+        // This unsafety is actually OK because the homing missile argument
+        // guarantees that we're on the same event loop as all the other objects
+        // attempting to get access granted.
+        let inner: &mut Inner = unsafe { cast::transmute(self.inner.get()) };
+
+        if inner.held {
+            let t: ~Task = Local::take();
+            t.deschedule(1, |task| {
+                inner.queue.push(task);
+                Ok(())
+            });
+            assert!(inner.held);
+        } else {
+            inner.held = true;
+        }
+
+        Guard { access: self, missile: Some(missile) }
+    }
+}
+
+impl Clone for Access {
+    fn clone(&self) -> Access {
+        Access { inner: self.inner.clone() }
+    }
+}
+
+#[unsafe_destructor]
+impl<'a> Drop for Guard<'a> {
+    fn drop(&mut self) {
+        // This guard's homing missile is still armed, so we're guaranteed to be
+        // on the same I/O event loop, so this unsafety should be ok.
+        assert!(self.missile.is_some());
+        let inner: &mut Inner = unsafe {
+            cast::transmute(self.access.inner.get())
+        };
+
+        match inner.queue.shift() {
+            // Here we have found a task that was waiting for access, and we
+            // current have the "access lock" we need to relinquish access to
+            // this sleeping task.
+            //
+            // To do so, we first drop out homing missile and we then reawaken
+            // the task. In reawakening the task, it will be immediately
+            // scheduled on this scheduler. Because we might be woken up on some
+            // other scheduler, we drop our homing missile before we reawaken
+            // the task.
+            Some(task) => {
+                drop(self.missile.take());
+                task.wake().map(|t| t.reawaken(true));
+            }
+            None => { inner.held = false; }
+        }
+    }
+}
+
+impl Drop for Inner {
+    fn drop(&mut self) {
+        assert!(!self.held);
+        assert_eq!(self.queue.len(), 0);
+    }
+}

src/librustuv/homing.rs

@@ -125,7 +125,7 @@ pub trait HomingIO {
 /// After a homing operation has been completed, this will return the current
 /// task back to its appropriate home (if applicable). The field is used to
 /// assert that we are where we think we are.
-struct HomingMissile {
+pub struct HomingMissile {
     priv io_home: uint,
 }
 

src/librustuv/lib.rs

@@ -67,8 +67,10 @@ pub use self::tty::TtyWatcher;
 
 mod macros;
 
-mod queue;
+mod access;
 mod homing;
+mod queue;
+mod rc;
 
 /// The implementation of `rtio` for libuv
 pub mod uvio;

src/librustuv/net.rs

@@ -19,7 +19,9 @@ use std::rt::rtio;
 use std::rt::task::BlockedTask;
 use std::unstable::intrinsics;
 
+use access::Access;
 use homing::{HomingIO, HomeHandle};
+use rc::Refcount;
 use stream::StreamWatcher;
 use super::{Loop, Request, UvError, Buf, status_to_io_result,
             uv_error_to_io_error, UvHandle, slice_to_uv_buf,
@@ -152,6 +154,14 @@ pub struct TcpWatcher {
     handle: *uvll::uv_tcp_t,
     stream: StreamWatcher,
     home: HomeHandle,
+    priv refcount: Refcount,
+
+    // libuv can't support concurrent reads and concurrent writes of the same
+    // stream object, so we use these access guards in order to arbitrate among
+    // multiple concurrent reads and writes. Note that libuv *can* read and
+    // write simultaneously, it just can't read and read simultaneously.
+    priv read_access: Access,
+    priv write_access: Access,
 }
 
 pub struct TcpListener {
@@ -183,6 +193,9 @@ impl TcpWatcher {
             home: home,
             handle: handle,
             stream: StreamWatcher::new(handle),
+            refcount: Refcount::new(),
+            read_access: Access::new(),
+            write_access: Access::new(),
         }
     }
 
@@ -238,12 +251,14 @@ impl rtio::RtioSocket for TcpWatcher {
 
 impl rtio::RtioTcpStream for TcpWatcher {
     fn read(&mut self, buf: &mut [u8]) -> Result<uint, IoError> {
-        let _m = self.fire_homing_missile();
+        let m = self.fire_homing_missile();
+        let _g = self.read_access.grant(m);
         self.stream.read(buf).map_err(uv_error_to_io_error)
     }
 
     fn write(&mut self, buf: &[u8]) -> Result<(), IoError> {
-        let _m = self.fire_homing_missile();
+        let m = self.fire_homing_missile();
+        let _g = self.write_access.grant(m);
         self.stream.write(buf).map_err(uv_error_to_io_error)
     }
 
@@ -280,6 +295,17 @@ impl rtio::RtioTcpStream for TcpWatcher {
             uvll::uv_tcp_keepalive(self.handle, 0 as c_int, 0 as c_uint)
         })
     }
+
+    fn clone(&self) -> Result<~rtio::RtioTcpStream, IoError> {
+        Ok(~TcpWatcher {
+            handle: self.handle,
+            stream: StreamWatcher::new(self.handle),
+            home: self.home.clone(),
+            refcount: self.refcount.clone(),
+            write_access: self.write_access.clone(),
+            read_access: self.read_access.clone(),
+        } as ~rtio::RtioTcpStream)
+    }
 }
 
 impl UvHandle<uvll::uv_tcp_t> for TcpWatcher {
@@ -289,7 +315,9 @@ impl UvHandle<uvll::uv_tcp_t> for TcpWatcher {
 impl Drop for TcpWatcher {
     fn drop(&mut self) {
         let _m = self.fire_homing_missile();
-        self.close();
+        if self.refcount.decrement() {
+            self.close();
+        }
     }
 }