---

yaml
---
r: 93597
b: refs/heads/try
c: 8e719bd
h: refs/heads/master
i:
  93595: 5a53493
v: v3

Author: huonw

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 0da105a8b7b6b1e0568e8ff20f6ff4b13cc7ecc2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d3e57dca68fde4effdda3e4ae2887aa535fcd6
-refs/heads/try: b5e602ac563422e13a18be9f79100f96359d582a
+refs/heads/try: 8e719bdfb5e32db67bcd62700bd6f14f597dcb89
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/mk/rt.mk

@@ -207,7 +207,7 @@ LIBUV_MAKEFILE_$(1) := $$(CFG_BUILD_DIR)$$(RT_OUTPUT_DIR_$(1))/libuv/Makefile
 
 $$(LIBUV_MAKEFILE_$(1)): $$(LIBUV_DEPS)
 	(cd $(S)src/libuv/ && \
-	 $$(CFG_PYTHON) ./gyp_uv.py -f make -Dtarget_arch=$$(LIBUV_ARCH_$(1)) \
+	 $$(CFG_PYTHON) ./gyp_uv -f make -Dtarget_arch=$$(LIBUV_ARCH_$(1)) \
 	   -D ninja \
 	   -DOS=$$(LIBUV_OSTYPE_$(1)) \
 	   -Goutput_dir=$$(@D) --generator-output $$(@D))
@@ -218,7 +218,7 @@ $$(LIBUV_MAKEFILE_$(1)): $$(LIBUV_DEPS)
 ifdef CFG_WINDOWSY_$(1)
 $$(LIBUV_LIB_$(1)): $$(LIBUV_DEPS)
 	$$(Q)$$(MAKE) -C $$(S)src/libuv -f Makefile.mingw \
-		CC="$$(CC) $$(CFG_GCCISH_CFLAGS) $$(LIBUV_FLAGS_$$(HOST_$(1))) $$(SNAP_DEFINES)" \
+		CFLAGS="$$(CFG_GCCISH_CFLAGS) $$(LIBUV_FLAGS_$$(HOST_$(1))) $$(SNAP_DEFINES)" \
 		AR="$$(AR_$(1))" \
 		V=$$(VERBOSE)
 	$$(Q)cp $$(S)src/libuv/libuv.a $$@

branches/try/src/libextra/getopts.rs

@@ -142,7 +142,8 @@ pub struct Matches {
 }
 
 /// The type returned when the command line does not conform to the
-/// expected format. Pass this value to <fail_str> to get an error message.
+/// expected format. Call the `to_err_msg` method to retrieve the
+/// error as a string.
 #[deriving(Clone, Eq, ToStr)]
 #[allow(missing_doc)]
 pub enum Fail_ {

branches/try/src/librustuv/addrinfo.rs

@@ -8,34 +8,41 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use ai = std::rt::io::net::addrinfo;
-use std::libc::c_int;
+use std::cast::transmute;
+use std::cell::Cell;
+use std::libc::{c_int, c_void};
 use std::ptr::null;
-use std::rt::BlockedTask;
-use std::rt::local::Local;
-use std::rt::sched::Scheduler;
+use ai = std::rt::io::net::addrinfo;
 
-use net;
-use super::{Loop, UvError, Request, wait_until_woken_after};
 use uvll;
+use uvll::UV_GETADDRINFO;
+use super::{Loop, UvError, NativeHandle, status_to_maybe_uv_error};
+use net;
 
-struct Addrinfo {
-    handle: *uvll::addrinfo,
-}
+type GetAddrInfoCallback = ~fn(GetAddrInfoRequest, &net::UvAddrInfo, Option<UvError>);
 
-struct Ctx {
-    slot: Option<BlockedTask>,
-    status: c_int,
-    addrinfo: Option<Addrinfo>,
-}
+pub struct GetAddrInfoRequest(*uvll::uv_getaddrinfo_t);
 
-pub struct GetAddrInfoRequest;
+pub struct RequestData {
+    priv getaddrinfo_cb: Option<GetAddrInfoCallback>,
+}
 
 impl GetAddrInfoRequest {
-    pub fn run(loop_: &Loop, node: Option<&str>, service: Option<&str>,
-               hints: Option<ai::Hint>) -> Result<~[ai::Info], UvError> {
+    pub fn new() -> GetAddrInfoRequest {
+        let req = unsafe { uvll::malloc_req(UV_GETADDRINFO) };
+        assert!(req.is_not_null());
+        let mut req: GetAddrInfoRequest = NativeHandle::from_native_handle(req);
+        req.install_req_data();
+        return req;
+    }
+
+    pub fn getaddrinfo(&mut self, loop_: &Loop, node: Option<&str>,
+                       service: Option<&str>, hints: Option<ai::Hint>,
+                       cb: GetAddrInfoCallback) {
+
         assert!(node.is_some() || service.is_some());
-        let (_c_node, c_node_ptr) = match node {
+
+        let (c_node, c_node_ptr) = match node {
             Some(n) => {
                 let c_node = n.to_c_str();
                 let c_node_ptr = c_node.with_ref(|r| r);
@@ -44,7 +51,7 @@ impl GetAddrInfoRequest {
             None => (None, null())
         };
 
-        let (_c_service, c_service_ptr) = match service {
+        let (c_service, c_service_ptr) = match service {
             Some(s) => {
                 let c_service = s.to_c_str();
                 let c_service_ptr = c_service.with_ref(|r| r);
@@ -53,13 +60,37 @@ impl GetAddrInfoRequest {
             None => (None, null())
         };
 
+        let cb = Cell::new(cb);
+        let wrapper_cb: GetAddrInfoCallback = |req, addrinfo, err| {
+            // Capture some heap values that need to stay alive for the
+            // getaddrinfo call
+            let _ = &c_node;
+            let _ = &c_service;
+
+            let cb = cb.take();
+            cb(req, addrinfo, err)
+        };
+
         let hint = hints.map(|hint| {
             let mut flags = 0;
             do each_ai_flag |cval, aival| {
                 if hint.flags & (aival as uint) != 0 {
                     flags |= cval as i32;
                 }
             }
+            /* XXX: do we really want to support these?
+            let socktype = match hint.socktype {
+                Some(ai::Stream) => uvll::rust_SOCK_STREAM(),
+                Some(ai::Datagram) => uvll::rust_SOCK_DGRAM(),
+                Some(ai::Raw) => uvll::rust_SOCK_RAW(),
+                None => 0,
+            };
+            let protocol = match hint.protocol {
+                Some(ai::UDP) => uvll::rust_IPPROTO_UDP(),
+                Some(ai::TCP) => uvll::rust_IPPROTO_TCP(),
+                _ => 0,
+            };
+            */
             let socktype = 0;
             let protocol = 0;
 
@@ -75,48 +106,66 @@ impl GetAddrInfoRequest {
             }
         });
         let hint_ptr = hint.as_ref().map_default(null(), |x| x as *uvll::addrinfo);
-        let mut req = Request::new(uvll::UV_GETADDRINFO);
-
-        return match unsafe {
-            uvll::uv_getaddrinfo(loop_.handle, req.handle,
-                                 getaddrinfo_cb, c_node_ptr, c_service_ptr,
-                                 hint_ptr)
-        } {
-            0 => {
-                req.defuse(); // uv callback now owns this request
-                let mut cx = Ctx { slot: None, status: 0, addrinfo: None };
-
-                do wait_until_woken_after(&mut cx.slot) {
-                    req.set_data(&cx);
-                }
 
-                match cx.status {
-                    0 => Ok(accum_addrinfo(cx.addrinfo.get_ref())),
-                    n => Err(UvError(n))
-                }
+        self.get_req_data().getaddrinfo_cb = Some(wrapper_cb);
+
+        unsafe {
+            assert!(0 == uvll::getaddrinfo(loop_.native_handle(),
+                                           self.native_handle(),
+                                           getaddrinfo_cb,
+                                           c_node_ptr,
+                                           c_service_ptr,
+                                           hint_ptr));
+        }
+
+        extern "C" fn getaddrinfo_cb(req: *uvll::uv_getaddrinfo_t,
+                                     status: c_int,
+                                     res: *uvll::addrinfo) {
+            let mut req: GetAddrInfoRequest = NativeHandle::from_native_handle(req);
+            let err = status_to_maybe_uv_error(status);
+            let addrinfo = net::UvAddrInfo(res);
+            let data = req.get_req_data();
+            (*data.getaddrinfo_cb.get_ref())(req, &addrinfo, err);
+            unsafe {
+                uvll::freeaddrinfo(res);
             }
-            n => Err(UvError(n))
-        };
+        }
+    }
 
+    fn get_loop(&self) -> Loop {
+        unsafe {
+            Loop {
+                handle: uvll::get_loop_from_fs_req(self.native_handle())
+            }
+        }
+    }
 
-        extern fn getaddrinfo_cb(req: *uvll::uv_getaddrinfo_t,
-                                 status: c_int,
-                                 res: *uvll::addrinfo) {
-            let req = Request::wrap(req);
-            assert!(status != uvll::ECANCELED);
-            let cx: &mut Ctx = unsafe { req.get_data() };
-            cx.status = status;
-            cx.addrinfo = Some(Addrinfo { handle: res });
+    fn install_req_data(&mut self) {
+        let req = self.native_handle() as *uvll::uv_getaddrinfo_t;
+        let data = ~RequestData {
+            getaddrinfo_cb: None
+        };
+        unsafe {
+            let data = transmute::<~RequestData, *c_void>(data);
+            uvll::set_data_for_req(req, data);
+        }
+    }
 
-            let sched: ~Scheduler = Local::take();
-            sched.resume_blocked_task_immediately(cx.slot.take_unwrap());
+    fn get_req_data<'r>(&'r mut self) -> &'r mut RequestData {
+        unsafe {
+            let data = uvll::get_data_for_req(self.native_handle());
+            let data = transmute::<&*c_void, &mut ~RequestData>(&data);
+            return &mut **data;
         }
     }
-}
 
-impl Drop for Addrinfo {
-    fn drop(&mut self) {
-        unsafe { uvll::uv_freeaddrinfo(self.handle) }
+    fn delete(self) {
+        unsafe {
+            let data = uvll::get_data_for_req(self.native_handle());
+            let _data = transmute::<*c_void, ~RequestData>(data);
+            uvll::set_data_for_req(self.native_handle(), null::<()>());
+            uvll::free_req(self.native_handle());
+        }
     }
 }
 
@@ -135,13 +184,15 @@ fn each_ai_flag(_f: &fn(c_int, ai::Flag)) {
 }
 
 // Traverse the addrinfo linked list, producing a vector of Rust socket addresses
-pub fn accum_addrinfo(addr: &Addrinfo) -> ~[ai::Info] {
+pub fn accum_addrinfo(addr: &net::UvAddrInfo) -> ~[ai::Info] {
     unsafe {
-        let mut addr = addr.handle;
+        let &net::UvAddrInfo(addr) = addr;
+        let mut addr = addr;
 
         let mut addrs = ~[];
         loop {
-            let rustaddr = net::sockaddr_to_socket_addr((*addr).ai_addr);
+            let uvaddr = net::sockaddr_to_UvSocketAddr((*addr).ai_addr);
+            let rustaddr = net::uv_socket_addr_to_socket_addr(uvaddr);
 
             let mut flags = 0;
             do each_ai_flag |cval, aival| {
@@ -184,27 +235,39 @@ pub fn accum_addrinfo(addr: &Addrinfo) -> ~[ai::Info] {
     }
 }
 
+impl NativeHandle<*uvll::uv_getaddrinfo_t> for GetAddrInfoRequest {
+    fn from_native_handle(handle: *uvll::uv_getaddrinfo_t) -> GetAddrInfoRequest {
+        GetAddrInfoRequest(handle)
+    }
+    fn native_handle(&self) -> *uvll::uv_getaddrinfo_t {
+        match self { &GetAddrInfoRequest(ptr) => ptr }
+    }
+}
+
 #[cfg(test)]
 mod test {
+    use Loop;
     use std::rt::io::net::ip::{SocketAddr, Ipv4Addr};
     use super::*;
-    use super::super::local_loop;
 
     #[test]
     fn getaddrinfo_test() {
-        match GetAddrInfoRequest::run(local_loop(), Some("localhost"), None, None) {
-            Ok(infos) => {
-                let mut found_local = false;
-                let local_addr = &SocketAddr {
-                    ip: Ipv4Addr(127, 0, 0, 1),
-                    port: 0
-                };
-                for addr in infos.iter() {
-                    found_local = found_local || addr.address == *local_addr;
-                }
-                assert!(found_local);
+        let mut loop_ = Loop::new();
+        let mut req = GetAddrInfoRequest::new();
+        do req.getaddrinfo(&loop_, Some("localhost"), None, None) |_, addrinfo, _| {
+            let sockaddrs = accum_addrinfo(addrinfo);
+            let mut found_local = false;
+            let local_addr = &SocketAddr {
+                ip: Ipv4Addr(127, 0, 0, 1),
+                port: 0
+            };
+            for addr in sockaddrs.iter() {
+                found_local = found_local || addr.address == *local_addr;
             }
-            Err(e) => fail!("{:?}", e),
+            assert!(found_local);
         }
+        loop_.run();
+        loop_.close();
+        req.delete();
     }
 }