(index<- ) ./libstd/rt/uv/addrinfo.rs
1 // Copyright 2013 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
4 //
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
10
11 use cast::transmute;
12 use cell::Cell;
13 use c_str::ToCStr;
14 use libc::{c_int, c_void};
15 use option::{Option, Some, None};
16 use ptr::null;
17 use rt::uv::uvll;
18 use rt::uv::uvll::UV_GETADDRINFO;
19 use rt::uv::{Loop, UvError, NativeHandle};
20 use rt::uv::status_to_maybe_uv_error;
21 use rt::uv::net::UvAddrInfo;
22
23 type GetAddrInfoCallback = ~fn(GetAddrInfoRequest, &UvAddrInfo, Option<UvError>);
24
25 pub struct GetAddrInfoRequest(*uvll::uv_getaddrinfo_t);
26
27 pub struct RequestData {
28 getaddrinfo_cb: Option<GetAddrInfoCallback>,
29 }
30
31 impl GetAddrInfoRequest {
32 pub fn new() -> GetAddrInfoRequest {
33 let req = unsafe { uvll::malloc_req(UV_GETADDRINFO) };
34 assert!(req.is_not_null());
35 let mut req: GetAddrInfoRequest = NativeHandle::from_native_handle(req);
36 req.install_req_data();
37 return req;
38 }
39
40 pub fn getaddrinfo(&mut self, loop_: &Loop, node: Option<&str>,
41 service: Option<&str>, hints: Option<UvAddrInfo>,
42 cb: GetAddrInfoCallback) {
43
44 assert!(node.is_some() || service.is_some());
45
46 let (c_node, c_node_ptr) = match node {
47 Some(n) => {
48 let c_node = n.to_c_str();
49 let c_node_ptr = c_node.with_ref(|r| r);
50 (Some(c_node), c_node_ptr)
51 }
52 None => (None, null())
53 };
54
55 let (c_service, c_service_ptr) = match service {
56 Some(s) => {
57 let c_service = s.to_c_str();
58 let c_service_ptr = c_service.with_ref(|r| r);
59 (Some(c_service), c_service_ptr)
60 }
61 None => (None, null())
62 };
63
64 let cb = Cell::new(cb);
65 let wrapper_cb: GetAddrInfoCallback = |req, addrinfo, err| {
66 // Capture some heap values that need to stay alive for the
67 // getaddrinfo call
68 let _ = &c_node;
69 let _ = &c_service;
70
71 let cb = cb.take();
72 cb(req, addrinfo, err)
73 };
74
75 // XXX: Implement hints
76 assert!(hints.is_none());
77
78 self.get_req_data().getaddrinfo_cb = Some(wrapper_cb);
79
80 unsafe {
81 assert!(0 == uvll::getaddrinfo(loop_.native_handle(),
82 self.native_handle(),
83 getaddrinfo_cb,
84 c_node_ptr,
85 c_service_ptr,
86 null()));
87 }
88
89 extern "C" fn getaddrinfo_cb(req: *uvll::uv_getaddrinfo_t,
90 status: c_int,
91 res: *uvll::addrinfo) {
92 let mut req: GetAddrInfoRequest = NativeHandle::from_native_handle(req);
93 let err = status_to_maybe_uv_error(status);
94 let addrinfo = UvAddrInfo(res);
95 let data = req.get_req_data();
96 (*data.getaddrinfo_cb.get_ref())(req, &addrinfo, err);
97 unsafe {
98 uvll::freeaddrinfo(res);
99 }
100 }
101 }
102
103 fn get_loop(&self) -> Loop {
104 unsafe {
105 Loop {
106 handle: uvll::get_loop_from_fs_req(self.native_handle())
107 }
108 }
109 }
110
111 fn install_req_data(&mut self) {
112 let req = self.native_handle() as *uvll::uv_getaddrinfo_t;
113 let data = ~RequestData {
114 getaddrinfo_cb: None
115 };
116 unsafe {
117 let data = transmute::<~RequestData, *c_void>(data);
118 uvll::set_data_for_req(req, data);
119 }
120 }
121
122 fn get_req_data<'r>(&'r mut self) -> &'r mut RequestData {
123 unsafe {
124 let data = uvll::get_data_for_req(self.native_handle());
125 let data = transmute::<&*c_void, &mut ~RequestData>(&data);
126 return &mut **data;
127 }
128 }
129
130 fn delete(self) {
131 unsafe {
132 let data = uvll::get_data_for_req(self.native_handle());
133 let _data = transmute::<*c_void, ~RequestData>(data);
134 uvll::set_data_for_req(self.native_handle(), null::<()>());
135 uvll::free_req(self.native_handle());
136 }
137 }
138 }
139
140 impl NativeHandle<*uvll::uv_getaddrinfo_t> for GetAddrInfoRequest {
141 fn from_native_handle(handle: *uvll::uv_getaddrinfo_t) -> GetAddrInfoRequest {
142 GetAddrInfoRequest(handle)
143 }
144 fn native_handle(&self) -> *uvll::uv_getaddrinfo_t {
145 match self { &GetAddrInfoRequest(ptr) => ptr }
146 }
147 }
148
149 #[cfg(test)]
150 mod test {
151 use option::{Some, None};
152 use rt::uv::Loop;
153 use rt::uv::net::accum_sockaddrs;
154 use rt::io::net::ip::{SocketAddr, Ipv4Addr};
155 use super::*;
156
157 #[test]
158 fn getaddrinfo_test() {
159 let mut loop_ = Loop::new();
160 let mut req = GetAddrInfoRequest::new();
161 do req.getaddrinfo(&loop_, Some("localhost"), None, None) |_, addrinfo, _| {
162 let sockaddrs = accum_sockaddrs(addrinfo);
163 let mut found_local = false;
164 let local_addr = &SocketAddr {
165 ip: Ipv4Addr(127, 0, 0, 1),
166 port: 0
167 };
168 for addr in sockaddrs.iter() {
169 found_local = found_local || addr == local_addr;
170 }
171 assert!(found_local);
172 }
173 loop_.run();
174 loop_.close();
175 req.delete();
176 }
177 }
libstd/rt/uv/addrinfo.rs:24:1-24:1 -struct- definition:
pub struct GetAddrInfoRequest(*uvll::uv_getaddrinfo_t);
references:-23: type GetAddrInfoCallback = ~fn(GetAddrInfoRequest, &UvAddrInfo, Option<UvError>);
31: impl GetAddrInfoRequest {
140: impl NativeHandle<*uvll::uv_getaddrinfo_t> for GetAddrInfoRequest {
35: let mut req: GetAddrInfoRequest = NativeHandle::from_native_handle(req);
141: fn from_native_handle(handle: *uvll::uv_getaddrinfo_t) -> GetAddrInfoRequest {
32: pub fn new() -> GetAddrInfoRequest {
92: let mut req: GetAddrInfoRequest = NativeHandle::from_native_handle(req);
libstd/rt/uv/addrinfo.rs:26:1-26:1 -struct- definition:
pub struct RequestData {
references:-125: let data = transmute::<&*c_void, &mut ~RequestData>(&data);
122: fn get_req_data<'r>(&'r mut self) -> &'r mut RequestData {
113: let data = ~RequestData {
133: let _data = transmute::<*c_void, ~RequestData>(data);
117: let data = transmute::<~RequestData, *c_void>(data);
libstd/rt/uv/addrinfo.rs:89:8-89:8 -fn- definition:
extern "C" fn getaddrinfo_cb(req: *uvll::uv_getaddrinfo_t,
status: c_int,
references:-83: getaddrinfo_cb,
libstd/rt/uv/addrinfo.rs:22:1-22:1 -ty- definition:
type GetAddrInfoCallback = ~fn(GetAddrInfoRequest, &UvAddrInfo, Option<UvError>);
references:-65: let wrapper_cb: GetAddrInfoCallback = |req, addrinfo, err| {
42: cb: GetAddrInfoCallback) {
28: getaddrinfo_cb: Option<GetAddrInfoCallback>,