---

yaml
---
r: 152348
b: refs/heads/try2
c: 550c347
h: refs/heads/master
v: v3

Author: alexcrichton

[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: 51348b068b88d71426d9de93762575cd2bb9a5f5
+refs/heads/try2: 550c347d7b9fbeb10dcf039f0e7e0c16de83dc4a
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/librustuv/addrinfo.rs

@@ -8,12 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use ai = std::io::net::addrinfo;
 use libc::c_int;
 use libc;
 use std::mem;
 use std::ptr::null;
 use std::rt::task::BlockedTask;
+use std::rt::rtio;
 
 use net;
 use super::{Loop, UvError, Request, wait_until_woken_after, wakeup};
@@ -33,7 +33,9 @@ pub struct GetAddrInfoRequest;
 
 impl GetAddrInfoRequest {
     pub fn run(loop_: &Loop, node: Option<&str>, service: Option<&str>,
-               hints: Option<ai::Hint>) -> Result<Vec<ai::Info>, UvError> {
+               hints: Option<rtio::AddrinfoHint>)
+        -> Result<Vec<rtio::AddrinfoInfo>, UvError>
+    {
         assert!(node.is_some() || service.is_some());
         let (_c_node, c_node_ptr) = match node {
             Some(n) => {
@@ -54,20 +56,11 @@ impl GetAddrInfoRequest {
         };
 
         let hint = hints.map(|hint| {
-            let mut flags = 0;
-            each_ai_flag(|cval, aival| {
-                if hint.flags & (aival as uint) != 0 {
-                    flags |= cval as i32;
-                }
-            });
-            let socktype = 0;
-            let protocol = 0;
-
             libc::addrinfo {
-                ai_flags: flags,
+                ai_flags: 0,
                 ai_family: hint.family as c_int,
-                ai_socktype: socktype,
-                ai_protocol: protocol,
+                ai_socktype: 0,
+                ai_protocol: 0,
                 ai_addrlen: 0,
                 ai_canonname: null(),
                 ai_addr: null(),
@@ -119,22 +112,8 @@ impl Drop for Addrinfo {
     }
 }
 
-fn each_ai_flag(_f: |c_int, ai::Flag|) {
-    /* FIXME: do we really want to support these?
-    unsafe {
-        f(uvll::rust_AI_ADDRCONFIG(), ai::AddrConfig);
-        f(uvll::rust_AI_ALL(), ai::All);
-        f(uvll::rust_AI_CANONNAME(), ai::CanonName);
-        f(uvll::rust_AI_NUMERICHOST(), ai::NumericHost);
-        f(uvll::rust_AI_NUMERICSERV(), ai::NumericServ);
-        f(uvll::rust_AI_PASSIVE(), ai::Passive);
-        f(uvll::rust_AI_V4MAPPED(), ai::V4Mapped);
-    }
-    */
-}
-
 // Traverse the addrinfo linked list, producing a vector of Rust socket addresses
-pub fn accum_addrinfo(addr: &Addrinfo) -> Vec<ai::Info> {
+pub fn accum_addrinfo(addr: &Addrinfo) -> Vec<rtio::AddrinfoInfo> {
     unsafe {
         let mut addr = addr.handle;
 
@@ -143,35 +122,12 @@ pub fn accum_addrinfo(addr: &Addrinfo) -> Vec<ai::Info> {
             let rustaddr = net::sockaddr_to_addr(mem::transmute((*addr).ai_addr),
                                                  (*addr).ai_addrlen as uint);
 
-            let mut flags = 0;
-            each_ai_flag(|cval, aival| {
-                if (*addr).ai_flags & cval != 0 {
-                    flags |= aival as uint;
-                }
-            });
-
-            /* FIXME: do we really want to support these
-            let protocol = match (*addr).ai_protocol {
-                p if p == uvll::rust_IPPROTO_UDP() => Some(ai::UDP),
-                p if p == uvll::rust_IPPROTO_TCP() => Some(ai::TCP),
-                _ => None,
-            };
-            let socktype = match (*addr).ai_socktype {
-                p if p == uvll::rust_SOCK_STREAM() => Some(ai::Stream),
-                p if p == uvll::rust_SOCK_DGRAM() => Some(ai::Datagram),
-                p if p == uvll::rust_SOCK_RAW() => Some(ai::Raw),
-                _ => None,
-            };
-            */
-            let protocol = None;
-            let socktype = None;
-
-            addrs.push(ai::Info {
+            addrs.push(rtio::AddrinfoInfo {
                 address: rustaddr,
                 family: (*addr).ai_family as uint,
-                socktype: socktype,
-                protocol: protocol,
-                flags: flags,
+                socktype: 0,
+                protocol: 0,
+                flags: 0,
             });
             if (*addr).ai_next.is_not_null() {
                 addr = (*addr).ai_next;

branches/try2/src/librustuv/async.rs

@@ -8,9 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use alloc::arc::Arc;
 use std::mem;
+use std::rt::exclusive::Exclusive;
 use std::rt::rtio::{Callback, RemoteCallback};
-use std::unstable::sync::Exclusive;
 
 use uvll;
 use super::{Loop, UvHandle};
@@ -22,12 +23,12 @@ pub struct AsyncWatcher {
 
     // A flag to tell the callback to exit, set from the dtor. This is
     // almost never contested - only in rare races with the dtor.
-    exit_flag: Exclusive<bool>
+    exit_flag: Arc<Exclusive<bool>>,
 }
 
 struct Payload {
     callback: Box<Callback:Send>,
-    exit_flag: Exclusive<bool>,
+    exit_flag: Arc<Exclusive<bool>>,
 }
 
 impl AsyncWatcher {
@@ -36,7 +37,7 @@ impl AsyncWatcher {
         assert_eq!(unsafe {
             uvll::uv_async_init(loop_.handle, handle, async_cb)
         }, 0);
-        let flag = Exclusive::new(false);
+        let flag = Arc::new(Exclusive::new(false));
         let payload = box Payload { callback: cb, exit_flag: flag.clone() };
         unsafe {
             let payload: *u8 = mem::transmute(payload);
@@ -80,9 +81,7 @@ extern fn async_cb(handle: *uvll::uv_async_t) {
     // could be called in the other thread, missing the final
     // callback while still destroying the handle.
 
-    let should_exit = unsafe {
-        payload.exit_flag.with_imm(|&should_exit| should_exit)
-    };
+    let should_exit = unsafe { *payload.exit_flag.lock() };
 
     payload.callback.call();
 
@@ -108,16 +107,13 @@ impl RemoteCallback for AsyncWatcher {
 
 impl Drop for AsyncWatcher {
     fn drop(&mut self) {
-        unsafe {
-            self.exit_flag.with(|should_exit| {
-                // NB: These two things need to happen atomically. Otherwise
-                // the event handler could wake up due to a *previous*
-                // signal and see the exit flag, destroying the handle
-                // before the final send.
-                *should_exit = true;
-                uvll::uv_async_send(self.handle)
-            })
-        }
+        let mut should_exit = unsafe { self.exit_flag.lock() };
+        // NB: These two things need to happen atomically. Otherwise
+        // the event handler could wake up due to a *previous*
+        // signal and see the exit flag, destroying the handle
+        // before the final send.
+        *should_exit = true;
+        unsafe { uvll::uv_async_send(self.handle) }
     }
 }