Skip to content

Commit 3a3eefc

Browse files
alexcrichtonalexcrichton
committed
Update to the latest libuv
At this time, also point the libuv submodule to the official repo instead of my own off to the side. cc #10246 Closes #10329
1 parent b652bbc commit 3a3eefc

File tree

10 files changed

+172
-470
lines changed

10 files changed

+172
-470
lines changed

‎.gitmodules

+1-1
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@
44
branch = master
55
[submodule "src/libuv"]
66
path = src/libuv
7-
url = https://github.com/alexcrichton/libuv.git
7+
url = https://github.com/joyent/libuv.git
88
branch = master
99
[submodule "src/gyp"]
1010
path = src/gyp

‎mk/rt.mk

+1-1
Original file line numberDiff line numberDiff line change
@@ -207,7 +207,7 @@ LIBUV_MAKEFILE_$(1) := $$(CFG_BUILD_DIR)$$(RT_OUTPUT_DIR_$(1))/libuv/Makefile
207207

208208
$$(LIBUV_MAKEFILE_$(1)): $$(LIBUV_DEPS)
209209
(cd $(S)src/libuv/ && \
210-
$$(CFG_PYTHON) ./gyp_uv -f make -Dtarget_arch=$$(LIBUV_ARCH_$(1)) \
210+
$$(CFG_PYTHON) ./gyp_uv.py -f make -Dtarget_arch=$$(LIBUV_ARCH_$(1)) \
211211
-D ninja \
212212
-DOS=$$(LIBUV_OSTYPE_$(1)) \
213213
-Goutput_dir=$$(@D) --generator-output $$(@D))

‎src/librustuv/addrinfo.rs

+1-2
Original file line numberDiff line numberDiff line change
@@ -141,8 +141,7 @@ pub fn accum_addrinfo(addr: &Addrinfo) -> ~[ai::Info] {
141141

142142
let mut addrs = ~[];
143143
loop {
144-
let uvaddr = net::sockaddr_to_UvSocketAddr((*addr).ai_addr);
145-
let rustaddr = net::uv_socket_addr_to_socket_addr(uvaddr);
144+
let rustaddr = net::sockaddr_to_socket_addr((*addr).ai_addr);
146145

147146
let mut flags = 0;
148147
do each_ai_flag |cval, aival| {

‎src/librustuv/lib.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -47,7 +47,7 @@ via `close` and `delete` methods.
4747

4848
use std::cast::transmute;
4949
use std::cast;
50-
use std::libc::{c_int, malloc, free};
50+
use std::libc::{c_int, malloc};
5151
use std::ptr::null;
5252
use std::ptr;
5353
use std::rt::BlockedTask;

‎src/librustuv/net.rs

+89-132
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,7 @@
99
// except according to those terms.
1010

1111
use std::cast;
12+
use std::libc;
1213
use std::libc::{size_t, ssize_t, c_int, c_void, c_uint, c_char};
1314
use std::ptr;
1415
use std::rt::BlockedTask;
@@ -28,103 +29,81 @@ use super::{Loop, Request, UvError, Buf, status_to_io_result,
2829
wait_until_woken_after};
2930
use uvio::HomingIO;
3031
use uvll;
32+
use uvll::sockaddr;
3133

3234
////////////////////////////////////////////////////////////////////////////////
3335
/// Generic functions related to dealing with sockaddr things
3436
////////////////////////////////////////////////////////////////////////////////
3537

36-
pub enum UvSocketAddr {
37-
UvIpv4SocketAddr(*uvll::sockaddr_in),
38-
UvIpv6SocketAddr(*uvll::sockaddr_in6),
39-
}
40-
41-
pub fn sockaddr_to_UvSocketAddr(addr: *uvll::sockaddr) -> UvSocketAddr {
42-
unsafe {
43-
assert!((uvll::is_ip4_addr(addr) || uvll::is_ip6_addr(addr)));
44-
assert!(!(uvll::is_ip4_addr(addr) && uvll::is_ip6_addr(addr)));
45-
match addr {
46-
_ if uvll::is_ip4_addr(addr) =>
47-
UvIpv4SocketAddr(addr as *uvll::sockaddr_in),
48-
_ if uvll::is_ip6_addr(addr) =>
49-
UvIpv6SocketAddr(addr as *uvll::sockaddr_in6),
50-
_ => fail!(),
51-
}
52-
}
53-
}
54-
55-
fn socket_addr_as_uv_socket_addr<T>(addr: SocketAddr, f: &fn(UvSocketAddr) -> T) -> T {
38+
#[fixed_stack_segment]
39+
fn socket_addr_as_sockaddr<T>(addr: SocketAddr, f: &fn(*sockaddr) -> T) -> T {
5640
let malloc = match addr.ip {
57-
Ipv4Addr(*) => uvll::malloc_ip4_addr,
58-
Ipv6Addr(*) => uvll::malloc_ip6_addr,
59-
};
60-
let wrap = match addr.ip {
61-
Ipv4Addr(*) => UvIpv4SocketAddr,
62-
Ipv6Addr(*) => UvIpv6SocketAddr,
63-
};
64-
let free = match addr.ip {
65-
Ipv4Addr(*) => uvll::free_ip4_addr,
66-
Ipv6Addr(*) => uvll::free_ip6_addr,
41+
Ipv4Addr(*) => uvll::rust_malloc_ip4_addr,
42+
Ipv6Addr(*) => uvll::rust_malloc_ip6_addr,
6743
};
6844

69-
let addr = unsafe { malloc(addr.ip.to_str(), addr.port as int) };
45+
let ip = addr.ip.to_str();
46+
let addr = ip.with_c_str(|p| unsafe { malloc(p, addr.port as c_int) });
7047
do (|| {
71-
f(wrap(addr))
48+
f(addr)
7249
}).finally {
73-
unsafe { free(addr) };
50+
unsafe { libc::free(addr) };
7451
}
7552
}
7653

77-
fn uv_socket_addr_as_socket_addr<T>(addr: UvSocketAddr, f: &fn(SocketAddr) -> T) -> T {
78-
let ip_size = match addr {
79-
UvIpv4SocketAddr(*) => 4/*groups of*/ * 3/*digits separated by*/ + 3/*periods*/,
80-
UvIpv6SocketAddr(*) => 8/*groups of*/ * 4/*hex digits separated by*/ + 7 /*colons*/,
81-
};
82-
let ip_name = {
83-
let buf = vec::from_elem(ip_size + 1 /*null terminated*/, 0u8);
84-
unsafe {
54+
#[fixed_stack_segment]
55+
pub fn sockaddr_to_socket_addr(addr: *sockaddr) -> SocketAddr {
56+
unsafe {
57+
let ip_size = if uvll::rust_is_ipv4_sockaddr(addr) == 1 {
58+
4/*groups of*/ * 3/*digits separated by*/ + 3/*periods*/
59+
} else if uvll::rust_is_ipv6_sockaddr(addr) == 1 {
60+
8/*groups of*/ * 4/*hex digits separated by*/ + 7 /*colons*/
61+
} else {
62+
fail!("unknown address?");
63+
};
64+
let ip_name = {
65+
let buf = vec::from_elem(ip_size + 1 /*null terminated*/, 0u8);
8566
let buf_ptr = vec::raw::to_ptr(buf);
86-
match addr {
87-
UvIpv4SocketAddr(addr) =>
88-
uvll::uv_ip4_name(addr, buf_ptr as *c_char, ip_size as size_t),
89-
UvIpv6SocketAddr(addr) =>
90-
uvll::uv_ip6_name(addr, buf_ptr as *c_char, ip_size as size_t),
67+
if uvll::rust_is_ipv4_sockaddr(addr) == 1 {
68+
uvll::uv_ip4_name(addr, buf_ptr as *c_char, ip_size as size_t);
69+
} else {
70+
uvll::uv_ip6_name(addr, buf_ptr as *c_char, ip_size as size_t);
9171
}
72+
buf
9273
};
93-
buf
94-
};
95-
let ip_port = unsafe {
96-
let port = match addr {
97-
UvIpv4SocketAddr(addr) => uvll::ip4_port(addr),
98-
UvIpv6SocketAddr(addr) => uvll::ip6_port(addr),
74+
let ip_port = {
75+
let port = if uvll::rust_is_ipv4_sockaddr(addr) == 1 {
76+
uvll::rust_ip4_port(addr)
77+
} else {
78+
uvll::rust_ip6_port(addr)
79+
};
80+
port as u16
9981
};
100-
port as u16
101-
};
102-
let ip_str = str::from_utf8_slice(ip_name).trim_right_chars(&'\x00');
103-
let ip_addr = FromStr::from_str(ip_str).unwrap();
82+
let ip_str = str::from_utf8_slice(ip_name).trim_right_chars(&'\x00');
83+
let ip_addr = FromStr::from_str(ip_str).unwrap();
10484

105-
// finally run the closure
106-
f(SocketAddr { ip: ip_addr, port: ip_port })
107-
}
108-
109-
pub fn uv_socket_addr_to_socket_addr(addr: UvSocketAddr) -> SocketAddr {
110-
use std::util;
111-
uv_socket_addr_as_socket_addr(addr, util::id)
85+
SocketAddr { ip: ip_addr, port: ip_port }
86+
}
11287
}
11388

11489
#[cfg(test)]
11590
#[test]
11691
fn test_ip4_conversion() {
11792
use std::rt;
11893
let ip4 = rt::test::next_test_ip4();
119-
assert_eq!(ip4, socket_addr_as_uv_socket_addr(ip4, uv_socket_addr_to_socket_addr));
94+
do socket_addr_as_sockaddr(ip4) |addr| {
95+
assert_eq!(ip4, sockaddr_to_socket_addr(addr));
96+
}
12097
}
12198

12299
#[cfg(test)]
123100
#[test]
124101
fn test_ip6_conversion() {
125102
use std::rt;
126103
let ip6 = rt::test::next_test_ip6();
127-
assert_eq!(ip6, socket_addr_as_uv_socket_addr(ip6, uv_socket_addr_to_socket_addr));
104+
do socket_addr_as_sockaddr(ip6) |addr| {
105+
assert_eq!(ip6, sockaddr_to_socket_addr(addr));
106+
}
128107
}
129108

130109
enum SocketNameKind {
@@ -133,37 +112,29 @@ enum SocketNameKind {
133112
Udp
134113
}
135114

115+
#[fixed_stack_segment]
136116
fn socket_name(sk: SocketNameKind, handle: *c_void) -> Result<SocketAddr, IoError> {
137-
let getsockname = match sk {
138-
TcpPeer => uvll::tcp_getpeername,
139-
Tcp => uvll::tcp_getsockname,
140-
Udp => uvll::udp_getsockname,
141-
};
142-
143-
// Allocate a sockaddr_storage
144-
// since we don't know if it's ipv4 or ipv6
145-
let r_addr = unsafe { uvll::malloc_sockaddr_storage() };
117+
unsafe {
118+
let getsockname = match sk {
119+
TcpPeer => uvll::uv_tcp_getpeername,
120+
Tcp => uvll::uv_tcp_getsockname,
121+
Udp => uvll::uv_udp_getsockname,
122+
};
146123

147-
let r = unsafe {
148-
getsockname(handle, r_addr as *uvll::sockaddr_storage)
149-
};
124+
// Allocate a sockaddr_storage
125+
// since we don't know if it's ipv4 or ipv6
126+
let size = uvll::rust_sockaddr_size();
127+
let name = libc::malloc(size as size_t);
128+
assert!(!name.is_null());
129+
let mut namelen = size;
150130

151-
if r != 0 {
152-
return Err(uv_error_to_io_error(UvError(r)));
131+
let ret = match getsockname(handle, name, &mut namelen) {
132+
0 => Ok(sockaddr_to_socket_addr(name)),
133+
n => Err(uv_error_to_io_error(UvError(n)))
134+
};
135+
libc::free(name);
136+
ret
153137
}
154-
155-
let addr = unsafe {
156-
if uvll::is_ip6_addr(r_addr as *uvll::sockaddr) {
157-
uv_socket_addr_to_socket_addr(UvIpv6SocketAddr(r_addr as *uvll::sockaddr_in6))
158-
} else {
159-
uv_socket_addr_to_socket_addr(UvIpv4SocketAddr(r_addr as *uvll::sockaddr_in))
160-
}
161-
};
162-
163-
unsafe { uvll::free_sockaddr_storage(r_addr); }
164-
165-
Ok(addr)
166-
167138
}
168139

169140
////////////////////////////////////////////////////////////////////////////////
@@ -210,17 +181,11 @@ impl TcpWatcher {
210181

211182
return do task::unkillable {
212183
let tcp = TcpWatcher::new(loop_);
213-
let ret = do socket_addr_as_uv_socket_addr(address) |addr| {
184+
let ret = do socket_addr_as_sockaddr(address) |addr| {
214185
let mut req = Request::new(uvll::UV_CONNECT);
215-
let result = match addr {
216-
UvIpv4SocketAddr(addr) => unsafe {
217-
uvll::tcp_connect(req.handle, tcp.handle, addr,
218-
connect_cb)
219-
},
220-
UvIpv6SocketAddr(addr) => unsafe {
221-
uvll::tcp_connect6(req.handle, tcp.handle, addr,
222-
connect_cb)
223-
},
186+
let result = unsafe {
187+
uvll::uv_tcp_connect(req.handle, tcp.handle, addr,
188+
connect_cb)
224189
};
225190
match result {
226191
0 => {
@@ -340,11 +305,8 @@ impl TcpListener {
340305
closing_task: None,
341306
outgoing: Tube::new(),
342307
};
343-
let res = socket_addr_as_uv_socket_addr(address, |addr| unsafe {
344-
match addr {
345-
UvIpv4SocketAddr(addr) => uvll::tcp_bind(l.handle, addr),
346-
UvIpv6SocketAddr(addr) => uvll::tcp_bind6(l.handle, addr),
347-
}
308+
let res = socket_addr_as_sockaddr(address, |addr| unsafe {
309+
uvll::uv_tcp_bind(l.handle, addr)
348310
});
349311
match res {
350312
0 => Ok(l.install()),
@@ -475,13 +437,8 @@ impl UdpWatcher {
475437
assert_eq!(unsafe {
476438
uvll::uv_udp_init(loop_.handle, udp.handle)
477439
}, 0);
478-
let result = socket_addr_as_uv_socket_addr(address, |addr| unsafe {
479-
match addr {
480-
UvIpv4SocketAddr(addr) =>
481-
uvll::udp_bind(udp.handle, addr, 0u32),
482-
UvIpv6SocketAddr(addr) =>
483-
uvll::udp_bind6(udp.handle, addr, 0u32),
484-
}
440+
let result = socket_addr_as_sockaddr(address, |addr| unsafe {
441+
uvll::uv_udp_bind(udp.handle, addr, 0u32)
485442
});
486443
match result {
487444
0 => Ok(udp),
@@ -513,7 +470,7 @@ impl rtio::RtioUdpSocket for UdpWatcher {
513470
struct Ctx {
514471
task: Option<BlockedTask>,
515472
buf: Option<Buf>,
516-
result: Option<(ssize_t, SocketAddr)>,
473+
result: Option<(ssize_t, Option<SocketAddr>)>,
517474
}
518475
let _m = self.fire_homing_missile();
519476

@@ -532,22 +489,24 @@ impl rtio::RtioUdpSocket for UdpWatcher {
532489
match cx.result.take_unwrap() {
533490
(n, _) if n < 0 =>
534491
Err(uv_error_to_io_error(UvError(n as c_int))),
535-
(n, addr) => Ok((n as uint, addr))
492+
(n, addr) => Ok((n as uint, addr.unwrap()))
536493
}
537494
}
538495
n => Err(uv_error_to_io_error(UvError(n)))
539496
};
540497
return a;
541498

542499
extern fn alloc_cb(handle: *uvll::uv_udp_t,
543-
_suggested_size: size_t) -> Buf {
544-
let cx: &mut Ctx = unsafe {
545-
cast::transmute(uvll::get_data_for_uv_handle(handle))
546-
};
547-
cx.buf.take().expect("recv alloc_cb called more than once")
500+
_suggested_size: size_t,
501+
buf: *mut Buf) {
502+
unsafe {
503+
let cx: &mut Ctx =
504+
cast::transmute(uvll::get_data_for_uv_handle(handle));
505+
*buf = cx.buf.take().expect("recv alloc_cb called more than once")
506+
}
548507
}
549508

550-
extern fn recv_cb(handle: *uvll::uv_udp_t, nread: ssize_t, buf: Buf,
509+
extern fn recv_cb(handle: *uvll::uv_udp_t, nread: ssize_t, buf: *Buf,
551510
addr: *uvll::sockaddr, _flags: c_uint) {
552511
assert!(nread != uvll::ECANCELED as ssize_t);
553512
let cx: &mut Ctx = unsafe {
@@ -558,7 +517,7 @@ impl rtio::RtioUdpSocket for UdpWatcher {
558517
// This can happen if read returns EAGAIN/EWOULDBLOCK. By ignoring
559518
// this we just drop back to kqueue and wait for the next callback.
560519
if nread == 0 {
561-
cx.buf = Some(buf);
520+
cx.buf = Some(unsafe { *buf });
562521
return
563522
}
564523

@@ -569,8 +528,11 @@ impl rtio::RtioUdpSocket for UdpWatcher {
569528
let cx: &mut Ctx = unsafe {
570529
cast::transmute(uvll::get_data_for_uv_handle(handle))
571530
};
572-
let addr = sockaddr_to_UvSocketAddr(addr);
573-
let addr = uv_socket_addr_to_socket_addr(addr);
531+
let addr = if addr == ptr::null() {
532+
None
533+
} else {
534+
Some(sockaddr_to_socket_addr(addr))
535+
};
574536
cx.result = Some((nread, addr));
575537

576538
let sched: ~Scheduler = Local::take();
@@ -585,13 +547,8 @@ impl rtio::RtioUdpSocket for UdpWatcher {
585547

586548
let mut req = Request::new(uvll::UV_UDP_SEND);
587549
let buf = slice_to_uv_buf(buf);
588-
let result = socket_addr_as_uv_socket_addr(dst, |dst| unsafe {
589-
match dst {
590-
UvIpv4SocketAddr(dst) =>
591-
uvll::udp_send(req.handle, self.handle, [buf], dst, send_cb),
592-
UvIpv6SocketAddr(dst) =>
593-
uvll::udp_send6(req.handle, self.handle, [buf], dst, send_cb),
594-
}
550+
let result = socket_addr_as_sockaddr(dst, |dst| unsafe {
551+
uvll::uv_udp_send(req.handle, self.handle, [buf], dst, send_cb)
595552
});
596553

597554
return match result {

‎src/librustuv/process.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -78,7 +78,7 @@ impl Process {
7878

7979
let handle = UvHandle::alloc(None::<Process>, uvll::UV_PROCESS);
8080
match unsafe {
81-
uvll::uv_spawn(loop_.handle, handle, options)
81+
uvll::uv_spawn(loop_.handle, handle, &options)
8282
} {
8383
0 => {
8484
let process = ~Process {
@@ -106,7 +106,7 @@ impl Process {
106106
}
107107

108108
extern fn on_exit(handle: *uvll::uv_process_t,
109-
exit_status: libc::c_int,
109+
exit_status: i64,
110110
term_signal: libc::c_int) {
111111
let p: &mut Process = unsafe { UvHandle::from_uv_handle(&handle) };
112112

0 commit comments

Comments
 (0)