---

yaml
---
r: 95993
b: refs/heads/dist-snap
c: 584b359
h: refs/heads/master
i:
  95991: 795bf10
v: v3

Author: alexcrichton

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 5842b606a7e11c671d92aac574389e359a8172f6
+refs/heads/dist-snap: 584b3593485ef144de7217de19ac8a98766c0532
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/librustuv/addrinfo.rs

@@ -17,14 +17,9 @@ use std::rt::local::Local;
 use std::rt::sched::Scheduler;
 
 use net;
-use super::{Loop, UvError, NativeHandle};
-use uvll::UV_GETADDRINFO;
+use super::{Loop, UvError, NativeHandle, Request};
 use uvll;
 
-struct GetAddrInfoRequest {
-    handle: *uvll::uv_getaddrinfo_t,
-}
-
 struct Addrinfo {
     handle: *uvll::addrinfo,
 }
@@ -35,13 +30,9 @@ struct Ctx {
     addrinfo: Option<Addrinfo>,
 }
 
-impl GetAddrInfoRequest {
-    pub fn new() -> GetAddrInfoRequest {
-        GetAddrInfoRequest {
-            handle: unsafe { uvll::malloc_req(uvll::UV_GETADDRINFO) },
-        }
-    }
+pub struct GetAddrInfoRequest;
 
+impl GetAddrInfoRequest {
     pub fn run(loop_: &Loop, node: Option<&str>, service: Option<&str>,
                hints: Option<ai::Hint>) -> Result<~[ai::Info], UvError> {
         assert!(node.is_some() || service.is_some());
@@ -85,7 +76,7 @@ impl GetAddrInfoRequest {
             }
         });
         let hint_ptr = hint.as_ref().map_default(null(), |x| x as *uvll::addrinfo);
-        let req = GetAddrInfoRequest::new();
+        let req = Request::new(uvll::UV_GETADDRINFO);
 
         return match unsafe {
             uvll::uv_getaddrinfo(loop_.native_handle(), req.handle,
@@ -94,7 +85,8 @@ impl GetAddrInfoRequest {
         } {
             0 => {
                 let mut cx = Ctx { slot: None, status: 0, addrinfo: None };
-                unsafe { uvll::set_data_for_req(req.handle, &cx) }
+                req.set_data(&cx);
+                req.defuse();
                 let scheduler: ~Scheduler = Local::take();
                 do scheduler.deschedule_running_task_and_then |_, task| {
                     cx.slot = Some(task);
@@ -112,9 +104,9 @@ impl GetAddrInfoRequest {
         extern fn getaddrinfo_cb(req: *uvll::uv_getaddrinfo_t,
                                  status: c_int,
                                  res: *uvll::addrinfo) {
-            let cx: &mut Ctx = unsafe {
-                cast::transmute(uvll::get_data_for_req(req))
-            };
+            let req = Request::wrap(req);
+            if status == uvll::ECANCELED { return }
+            let cx: &mut Ctx = unsafe { cast::transmute(req.get_data()) };
             cx.status = status;
             cx.addrinfo = Some(Addrinfo { handle: res });
 
@@ -124,12 +116,6 @@ impl GetAddrInfoRequest {
     }
 }
 
-impl Drop for GetAddrInfoRequest {
-    fn drop(&mut self) {
-        unsafe { uvll::free_req(self.handle) }
-    }
-}
-
 impl Drop for Addrinfo {
     fn drop(&mut self) {
         unsafe { uvll::uv_freeaddrinfo(self.handle) }

branches/dist-snap/src/librustuv/lib.rs

@@ -54,19 +54,18 @@ use std::libc::{c_void, c_int, size_t, malloc, free};
 use std::cast::transmute;
 use std::ptr::null;
 use std::unstable::finally::Finally;
-use std::rt::io::net::ip::SocketAddr;
 
 use std::rt::io::IoError;
 
 //#[cfg(test)] use unstable::run_in_bare_thread;
 
 pub use self::file::{FsRequest, FileWatcher};
-pub use self::net::{StreamWatcher, TcpWatcher, UdpWatcher};
+pub use self::net::{TcpWatcher, TcpListener, TcpAcceptor, UdpWatcher};
 pub use self::idle::IdleWatcher;
 pub use self::timer::TimerWatcher;
 pub use self::async::AsyncWatcher;
 pub use self::process::Process;
-pub use self::pipe::PipeWatcher;
+pub use self::pipe::{PipeWatcher, PipeListener, PipeAcceptor};
 pub use self::signal::SignalWatcher;
 pub use self::tty::TtyWatcher;
 
@@ -97,24 +96,6 @@ pub struct Loop {
     priv handle: *uvll::uv_loop_t
 }
 
-pub struct Handle(*uvll::uv_handle_t);
-
-impl Watcher for Handle {}
-impl NativeHandle<*uvll::uv_handle_t> for Handle {
-    fn from_native_handle(h: *uvll::uv_handle_t) -> Handle { Handle(h) }
-    fn native_handle(&self) -> *uvll::uv_handle_t { **self }
-}
-
-/// The trait implemented by uv 'watchers' (handles). Watchers are
-/// non-owning wrappers around the uv handles and are not completely
-/// safe - there may be multiple instances for a single underlying
-/// handle.  Watchers are generally created, then `start`ed, `stop`ed
-/// and `close`ed, but due to their complex life cycle may not be
-/// entirely memory safe if used in unanticipated patterns.
-pub trait Watcher { }
-
-pub trait Request { }
-
 /// A type that wraps a native handle
 pub trait NativeHandle<T> {
     fn from_native_handle(T) -> Self;
@@ -160,32 +141,47 @@ pub trait UvHandle<T> {
     }
 }
 
-pub trait UvRequest<T> {
-    fn uv_request(&self) -> *T;
+pub struct Request {
+    handle: *uvll::uv_req_t,
+}
 
-    // FIXME(#8888) dummy self
-    fn alloc(_: Option<Self>, ty: uvll::uv_req_type) -> *T {
-        unsafe {
-            let handle = uvll::malloc_req(ty);
-            assert!(!handle.is_null());
-            handle as *T
-        }
+impl Request {
+    pub fn new(ty: uvll::uv_req_type) -> Request {
+        Request::wrap(unsafe { uvll::malloc_req(ty) })
     }
 
-    unsafe fn from_uv_request<'a>(h: &'a *T) -> &'a mut Self {
-        cast::transmute(uvll::get_data_for_req(*h))
+    pub fn wrap(handle: *uvll::uv_req_t) -> Request {
+        Request { handle: handle }
     }
 
-    fn install(~self) -> ~Self {
-        unsafe {
-            let myptr = cast::transmute::<&~Self, &*u8>(&self);
-            uvll::set_data_for_req(self.uv_request(), *myptr);
-        }
-        self
+    pub fn set_data<T>(&self, t: *T) {
+        unsafe { uvll::set_data_for_req(self.handle, t) }
     }
 
-    fn delete(&mut self) {
-        unsafe { uvll::free_req(self.uv_request() as *c_void) }
+    pub fn get_data(&self) -> *c_void {
+        unsafe { uvll::get_data_for_req(self.handle) }
+    }
+
+    // This function should be used when the request handle has been given to an
+    // underlying uv function, and the uv function has succeeded. This means
+    // that uv will at some point invoke the callback, and in the meantime we
+    // can't deallocate the handle because libuv could be using it.
+    //
+    // This is still a problem in blocking situations due to linked failure. In
+    // the connection callback the handle should be re-wrapped with the `wrap`
+    // function to ensure its destruction.
+    pub fn defuse(mut self) {
+        self.handle = ptr::null();
+    }
+}
+
+impl Drop for Request {
+    fn drop(&mut self) {
+        unsafe {
+            if self.handle != ptr::null() {
+                uvll::free_req(self.handle)
+            }
+        }
     }
 }
 
@@ -214,110 +210,6 @@ impl NativeHandle<*uvll::uv_loop_t> for Loop {
     }
 }
 
-// XXX: The uv alloc callback also has a *uv_handle_t arg
-pub type AllocCallback = ~fn(uint) -> Buf;
-pub type ReadCallback = ~fn(StreamWatcher, int, Buf, Option<UvError>);
-pub type NullCallback = ~fn();
-pub type ConnectionCallback = ~fn(StreamWatcher, Option<UvError>);
-pub type UdpReceiveCallback = ~fn(UdpWatcher, int, Buf, SocketAddr, uint, Option<UvError>);
-pub type UdpSendCallback = ~fn(UdpWatcher, Option<UvError>);
-
-
-/// Callbacks used by StreamWatchers, set as custom data on the foreign handle.
-/// XXX: Would be better not to have all watchers allocate room for all callback types.
-struct WatcherData {
-    read_cb: Option<ReadCallback>,
-    write_cb: Option<ConnectionCallback>,
-    connect_cb: Option<ConnectionCallback>,
-    close_cb: Option<NullCallback>,
-    alloc_cb: Option<AllocCallback>,
-    udp_recv_cb: Option<UdpReceiveCallback>,
-    udp_send_cb: Option<UdpSendCallback>,
-}
-
-pub trait WatcherInterop {
-    fn event_loop(&self) -> Loop;
-    fn install_watcher_data(&mut self);
-    fn get_watcher_data<'r>(&'r mut self) -> &'r mut WatcherData;
-    fn drop_watcher_data(&mut self);
-    fn close(self, cb: NullCallback);
-    fn close_async(self);
-}
-
-impl<H, W: Watcher + NativeHandle<*H>> WatcherInterop for W {
-    /// Get the uv event loop from a Watcher
-    fn event_loop(&self) -> Loop {
-        unsafe {
-            let handle = self.native_handle();
-            let loop_ = uvll::get_loop_for_uv_handle(handle);
-            NativeHandle::from_native_handle(loop_)
-        }
-    }
-
-    fn install_watcher_data(&mut self) {
-        unsafe {
-            let data = ~WatcherData {
-                read_cb: None,
-                write_cb: None,
-                connect_cb: None,
-                close_cb: None,
-                alloc_cb: None,
-                udp_recv_cb: None,
-                udp_send_cb: None,
-            };
-            let data = transmute::<~WatcherData, *c_void>(data);
-            uvll::set_data_for_uv_handle(self.native_handle(), data);
-        }
-    }
-
-    fn get_watcher_data<'r>(&'r mut self) -> &'r mut WatcherData {
-        unsafe {
-            let data = uvll::get_data_for_uv_handle(self.native_handle());
-            let data = transmute::<&*c_void, &mut ~WatcherData>(&data);
-            return &mut **data;
-        }
-    }
-
-    fn drop_watcher_data(&mut self) {
-        unsafe {
-            let data = uvll::get_data_for_uv_handle(self.native_handle());
-            let _data = transmute::<*c_void, ~WatcherData>(data);
-            uvll::set_data_for_uv_handle(self.native_handle(), null::<()>());
-        }
-    }
-
-    fn close(mut self, cb: NullCallback) {
-        {
-            let data = self.get_watcher_data();
-            assert!(data.close_cb.is_none());
-            data.close_cb = Some(cb);
-        }
-
-        unsafe {
-            uvll::uv_close(self.native_handle() as *uvll::uv_handle_t, close_cb);
-        }
-
-        extern fn close_cb(handle: *uvll::uv_handle_t) {
-            let mut h: Handle = NativeHandle::from_native_handle(handle);
-            h.get_watcher_data().close_cb.take_unwrap()();
-            h.drop_watcher_data();
-            unsafe { uvll::free_handle(handle as *c_void) }
-        }
-    }
-
-    fn close_async(self) {
-        unsafe {
-            uvll::uv_close(self.native_handle() as *uvll::uv_handle_t, close_cb);
-        }
-
-        extern fn close_cb(handle: *uvll::uv_handle_t) {
-            let mut h: Handle = NativeHandle::from_native_handle(handle);
-            h.drop_watcher_data();
-            unsafe { uvll::free_handle(handle as *c_void) }
-        }
-    }
-}
-
 // XXX: Need to define the error constants like EOF so they can be
 // compared to the UvError type