use libc::c_int;
use libc;
use std::mem;
-use std::ptr::null;
+use std::ptr::{null, null_mut};
use std::rt::task::BlockedTask;
use std::rt::rtio;
use uvll;
struct Addrinfo {
- handle: *libc::addrinfo,
+ handle: *const libc::addrinfo,
}
struct Ctx {
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);
+ let c_node_ptr = c_node.as_ptr();
(Some(c_node), c_node_ptr)
}
None => (None, null())
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);
+ let c_service_ptr = c_service.as_ptr();
(Some(c_service), c_service_ptr)
}
None => (None, null())
ai_socktype: 0,
ai_protocol: 0,
ai_addrlen: 0,
- ai_canonname: null(),
- ai_addr: null(),
- ai_next: null(),
+ ai_canonname: null_mut(),
+ ai_addr: null_mut(),
+ ai_next: null_mut(),
}
});
- let hint_ptr = hint.as_ref().map_or(null(), |x| x as *libc::addrinfo);
+ let hint_ptr = hint.as_ref().map_or(null(), |x| {
+ x as *const libc::addrinfo
+ });
let mut req = Request::new(uvll::UV_GETADDRINFO);
return match unsafe {
let mut cx = Ctx { slot: None, status: 0, addrinfo: None };
wait_until_woken_after(&mut cx.slot, loop_, || {
- req.set_data(&cx);
+ req.set_data(&mut cx);
});
match cx.status {
- 0 => Ok(accum_addrinfo(cx.addrinfo.get_ref())),
+ 0 => Ok(accum_addrinfo(cx.addrinfo.as_ref().unwrap())),
n => Err(UvError(n))
}
}
};
- extern fn getaddrinfo_cb(req: *uvll::uv_getaddrinfo_t,
+ extern fn getaddrinfo_cb(req: *mut uvll::uv_getaddrinfo_t,
status: c_int,
- res: *libc::addrinfo) {
+ res: *const libc::addrinfo) {
let req = Request::wrap(req);
assert!(status != uvll::ECANCELED);
let cx: &mut Ctx = unsafe { req.get_data() };
impl Drop for Addrinfo {
fn drop(&mut self) {
- unsafe { uvll::uv_freeaddrinfo(self.handle) }
+ unsafe { uvll::uv_freeaddrinfo(self.handle as *mut _) }
}
}
flags: 0,
});
if (*addr).ai_next.is_not_null() {
- addr = (*addr).ai_next;
+ addr = (*addr).ai_next as *const _;
} else {
break;
}