mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update to the latest libuv

Browse Source 
At this time, also point the libuv submodule to the official repo instead of my
own off to the side.

cc #10246
Closes #10329
This commit is contained in:
Alex Crichton 2013-11-07 15:26:47 -08:00
parent b652bbc670
commit 3a3eefc5c3
10 changed files with 172 additions and 470 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitmodules vendored
View File

@ -4,7 +4,7 @@
branch = master
[submodule "src/libuv"]
path = src/libuv
url = https://github.com/alexcrichton/libuv.git
url = https://github.com/joyent/libuv.git
branch = master
[submodule "src/gyp"]
path = src/gyp

2
mk/rt.mk
View File

@ -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 -f make -Dtarget_arch=$$(LIBUV_ARCH_$(1)) \
$$(CFG_PYTHON) ./gyp_uv.py -f make -Dtarget_arch=$$(LIBUV_ARCH_$(1)) \
-D ninja \
-DOS=$$(LIBUV_OSTYPE_$(1)) \
-Goutput_dir=$$(@D) --generator-output $$(@D))

3
src/librustuv/addrinfo.rs
View File

@ -141,8 +141,7 @@ pub fn accum_addrinfo(addr: &Addrinfo) -> ~[ai::Info] {
let mut addrs = ~[];
loop {
let uvaddr = net::sockaddr_to_UvSocketAddr((*addr).ai_addr);
let rustaddr = net::uv_socket_addr_to_socket_addr(uvaddr);
let rustaddr = net::sockaddr_to_socket_addr((*addr).ai_addr);
let mut flags = 0;
do each_ai_flag |cval, aival| {

2
src/librustuv/lib.rs
View File

@ -47,7 +47,7 @@ via `close` and `delete` methods.
use std::cast::transmute;
use std::cast;
use std::libc::{c_int, malloc, free};
use std::libc::{c_int, malloc};
use std::ptr::null;
use std::ptr;
use std::rt::BlockedTask;

221
src/librustuv/net.rs
View File

@ -9,6 +9,7 @@
// except according to those terms.
use std::cast;
use std::libc;
use std::libc::{size_t, ssize_t, c_int, c_void, c_uint, c_char};
use std::ptr;
use std::rt::BlockedTask;
@ -28,87 +29,61 @@ use super::{Loop, Request, UvError, Buf, status_to_io_result,
wait_until_woken_after};
use uvio::HomingIO;
use uvll;
use uvll::sockaddr;
////////////////////////////////////////////////////////////////////////////////
/// Generic functions related to dealing with sockaddr things
////////////////////////////////////////////////////////////////////////////////
pub enum UvSocketAddr {
UvIpv4SocketAddr(*uvll::sockaddr_in),
UvIpv6SocketAddr(*uvll::sockaddr_in6),
}
pub fn sockaddr_to_UvSocketAddr(addr: *uvll::sockaddr) -> UvSocketAddr {
unsafe {
assert!((uvll::is_ip4_addr(addr) || uvll::is_ip6_addr(addr)));
assert!(!(uvll::is_ip4_addr(addr) && uvll::is_ip6_addr(addr)));
match addr {
_ if uvll::is_ip4_addr(addr) =>
UvIpv4SocketAddr(addr as *uvll::sockaddr_in),
_ if uvll::is_ip6_addr(addr) =>
UvIpv6SocketAddr(addr as *uvll::sockaddr_in6),
_ => fail!(),
}
}
}
fn socket_addr_as_uv_socket_addr<T>(addr: SocketAddr, f: &fn(UvSocketAddr) -> T) -> T {
#[fixed_stack_segment]
fn socket_addr_as_sockaddr<T>(addr: SocketAddr, f: &fn(*sockaddr) -> T) -> T {
let malloc = match addr.ip {
Ipv4Addr(*) => uvll::malloc_ip4_addr,
Ipv6Addr(*) => uvll::malloc_ip6_addr,
};
let wrap = match addr.ip {
Ipv4Addr(*) => UvIpv4SocketAddr,
Ipv6Addr(*) => UvIpv6SocketAddr,
};
let free = match addr.ip {
Ipv4Addr(*) => uvll::free_ip4_addr,
Ipv6Addr(*) => uvll::free_ip6_addr,
Ipv4Addr(*) => uvll::rust_malloc_ip4_addr,
Ipv6Addr(*) => uvll::rust_malloc_ip6_addr,
};
let addr = unsafe { malloc(addr.ip.to_str(), addr.port as int) };
let ip = addr.ip.to_str();
let addr = ip.with_c_str(|p| unsafe { malloc(p, addr.port as c_int) });
do (|| {
f(wrap(addr))
f(addr)
}).finally {
unsafe { free(addr) };
unsafe { libc::free(addr) };
}
}
fn uv_socket_addr_as_socket_addr<T>(addr: UvSocketAddr, f: &fn(SocketAddr) -> T) -> T {
let ip_size = match addr {
UvIpv4SocketAddr(*) => 4/*groups of*/ * 3/*digits separated by*/ + 3/*periods*/,
UvIpv6SocketAddr(*) => 8/*groups of*/ * 4/*hex digits separated by*/ + 7 /*colons*/,
};
let ip_name = {
let buf = vec::from_elem(ip_size + 1 /*null terminated*/, 0u8);
unsafe {
#[fixed_stack_segment]
pub fn sockaddr_to_socket_addr(addr: *sockaddr) -> SocketAddr {
unsafe {
let ip_size = if uvll::rust_is_ipv4_sockaddr(addr) == 1 {
4/*groups of*/ * 3/*digits separated by*/ + 3/*periods*/
} else if uvll::rust_is_ipv6_sockaddr(addr) == 1 {
8/*groups of*/ * 4/*hex digits separated by*/ + 7 /*colons*/
} else {
fail!("unknown address?");
};
let ip_name = {
let buf = vec::from_elem(ip_size + 1 /*null terminated*/, 0u8);
let buf_ptr = vec::raw::to_ptr(buf);
match addr {
UvIpv4SocketAddr(addr) =>
uvll::uv_ip4_name(addr, buf_ptr as *c_char, ip_size as size_t),
UvIpv6SocketAddr(addr) =>
uvll::uv_ip6_name(addr, buf_ptr as *c_char, ip_size as size_t),
if uvll::rust_is_ipv4_sockaddr(addr) == 1 {
uvll::uv_ip4_name(addr, buf_ptr as *c_char, ip_size as size_t);
} else {
uvll::uv_ip6_name(addr, buf_ptr as *c_char, ip_size as size_t);
}
buf
};
buf
};
let ip_port = unsafe {
let port = match addr {
UvIpv4SocketAddr(addr) => uvll::ip4_port(addr),
UvIpv6SocketAddr(addr) => uvll::ip6_port(addr),
let ip_port = {
let port = if uvll::rust_is_ipv4_sockaddr(addr) == 1 {
uvll::rust_ip4_port(addr)
} else {
uvll::rust_ip6_port(addr)
};
port as u16
};
port as u16
};
let ip_str = str::from_utf8_slice(ip_name).trim_right_chars(&'\x00');
let ip_addr = FromStr::from_str(ip_str).unwrap();
let ip_str = str::from_utf8_slice(ip_name).trim_right_chars(&'\x00');
let ip_addr = FromStr::from_str(ip_str).unwrap();
// finally run the closure
f(SocketAddr { ip: ip_addr, port: ip_port })
}
pub fn uv_socket_addr_to_socket_addr(addr: UvSocketAddr) -> SocketAddr {
use std::util;
uv_socket_addr_as_socket_addr(addr, util::id)
SocketAddr { ip: ip_addr, port: ip_port }
}
}
#[cfg(test)]
@ -116,7 +91,9 @@ pub fn uv_socket_addr_to_socket_addr(addr: UvSocketAddr) -> SocketAddr {
fn test_ip4_conversion() {
use std::rt;
let ip4 = rt::test::next_test_ip4();
assert_eq!(ip4, socket_addr_as_uv_socket_addr(ip4, uv_socket_addr_to_socket_addr));
do socket_addr_as_sockaddr(ip4) |addr| {
assert_eq!(ip4, sockaddr_to_socket_addr(addr));
}
}
#[cfg(test)]
@ -124,7 +101,9 @@ fn test_ip4_conversion() {
fn test_ip6_conversion() {
use std::rt;
let ip6 = rt::test::next_test_ip6();
assert_eq!(ip6, socket_addr_as_uv_socket_addr(ip6, uv_socket_addr_to_socket_addr));
do socket_addr_as_sockaddr(ip6) |addr| {
assert_eq!(ip6, sockaddr_to_socket_addr(addr));
}
}
enum SocketNameKind {
@ -133,37 +112,29 @@ enum SocketNameKind {
Udp
}
#[fixed_stack_segment]
fn socket_name(sk: SocketNameKind, handle: *c_void) -> Result<SocketAddr, IoError> {
let getsockname = match sk {
TcpPeer => uvll::tcp_getpeername,
Tcp => uvll::tcp_getsockname,
Udp => uvll::udp_getsockname,
};
unsafe {
let getsockname = match sk {
TcpPeer => uvll::uv_tcp_getpeername,
Tcp => uvll::uv_tcp_getsockname,
Udp => uvll::uv_udp_getsockname,
};
// Allocate a sockaddr_storage
// since we don't know if it's ipv4 or ipv6
let r_addr = unsafe { uvll::malloc_sockaddr_storage() };
// Allocate a sockaddr_storage
// since we don't know if it's ipv4 or ipv6
let size = uvll::rust_sockaddr_size();
let name = libc::malloc(size as size_t);
assert!(!name.is_null());
let mut namelen = size;
let r = unsafe {
getsockname(handle, r_addr as *uvll::sockaddr_storage)
};
if r != 0 {
return Err(uv_error_to_io_error(UvError(r)));
let ret = match getsockname(handle, name, &mut namelen) {
0 => Ok(sockaddr_to_socket_addr(name)),
n => Err(uv_error_to_io_error(UvError(n)))
};
libc::free(name);
ret
}
let addr = unsafe {
if uvll::is_ip6_addr(r_addr as *uvll::sockaddr) {
uv_socket_addr_to_socket_addr(UvIpv6SocketAddr(r_addr as *uvll::sockaddr_in6))
} else {
uv_socket_addr_to_socket_addr(UvIpv4SocketAddr(r_addr as *uvll::sockaddr_in))
}
};
unsafe { uvll::free_sockaddr_storage(r_addr); }
Ok(addr)
}
////////////////////////////////////////////////////////////////////////////////
@ -210,17 +181,11 @@ impl TcpWatcher {
return do task::unkillable {
let tcp = TcpWatcher::new(loop_);
let ret = do socket_addr_as_uv_socket_addr(address) |addr| {
let ret = do socket_addr_as_sockaddr(address) |addr| {
let mut req = Request::new(uvll::UV_CONNECT);
let result = match addr {
UvIpv4SocketAddr(addr) => unsafe {
uvll::tcp_connect(req.handle, tcp.handle, addr,
connect_cb)
},
UvIpv6SocketAddr(addr) => unsafe {
uvll::tcp_connect6(req.handle, tcp.handle, addr,
connect_cb)
},
let result = unsafe {
uvll::uv_tcp_connect(req.handle, tcp.handle, addr,
connect_cb)
};
match result {
0 => {
@ -340,11 +305,8 @@ impl TcpListener {
closing_task: None,
outgoing: Tube::new(),
};
let res = socket_addr_as_uv_socket_addr(address, |addr| unsafe {
match addr {
UvIpv4SocketAddr(addr) => uvll::tcp_bind(l.handle, addr),
UvIpv6SocketAddr(addr) => uvll::tcp_bind6(l.handle, addr),
}
let res = socket_addr_as_sockaddr(address, |addr| unsafe {
uvll::uv_tcp_bind(l.handle, addr)
});
match res {
0 => Ok(l.install()),
@ -475,13 +437,8 @@ impl UdpWatcher {
assert_eq!(unsafe {
uvll::uv_udp_init(loop_.handle, udp.handle)
}, 0);
let result = socket_addr_as_uv_socket_addr(address, |addr| unsafe {
match addr {
UvIpv4SocketAddr(addr) =>
uvll::udp_bind(udp.handle, addr, 0u32),
UvIpv6SocketAddr(addr) =>
uvll::udp_bind6(udp.handle, addr, 0u32),
}
let result = socket_addr_as_sockaddr(address, |addr| unsafe {
uvll::uv_udp_bind(udp.handle, addr, 0u32)
});
match result {
0 => Ok(udp),
@ -513,7 +470,7 @@ impl rtio::RtioUdpSocket for UdpWatcher {
struct Ctx {
task: Option<BlockedTask>,
buf: Option<Buf>,
result: Option<(ssize_t, SocketAddr)>,
result: Option<(ssize_t, Option<SocketAddr>)>,
}
let _m = self.fire_homing_missile();
@ -532,7 +489,7 @@ impl rtio::RtioUdpSocket for UdpWatcher {
match cx.result.take_unwrap() {
(n, _) if n < 0 =>
Err(uv_error_to_io_error(UvError(n as c_int))),
(n, addr) => Ok((n as uint, addr))
(n, addr) => Ok((n as uint, addr.unwrap()))
}
}
n => Err(uv_error_to_io_error(UvError(n)))
@ -540,14 +497,16 @@ impl rtio::RtioUdpSocket for UdpWatcher {
return a;
extern fn alloc_cb(handle: *uvll::uv_udp_t,
_suggested_size: size_t) -> Buf {
let cx: &mut Ctx = unsafe {
cast::transmute(uvll::get_data_for_uv_handle(handle))
};
cx.buf.take().expect("recv alloc_cb called more than once")
_suggested_size: size_t,
buf: *mut Buf) {
unsafe {
let cx: &mut Ctx =
cast::transmute(uvll::get_data_for_uv_handle(handle));
*buf = cx.buf.take().expect("recv alloc_cb called more than once")
}
}
extern fn recv_cb(handle: *uvll::uv_udp_t, nread: ssize_t, buf: Buf,
extern fn recv_cb(handle: *uvll::uv_udp_t, nread: ssize_t, buf: *Buf,
addr: *uvll::sockaddr, _flags: c_uint) {
assert!(nread != uvll::ECANCELED as ssize_t);
let cx: &mut Ctx = unsafe {
@ -558,7 +517,7 @@ impl rtio::RtioUdpSocket for UdpWatcher {
// This can happen if read returns EAGAIN/EWOULDBLOCK. By ignoring
// this we just drop back to kqueue and wait for the next callback.
if nread == 0 {
cx.buf = Some(buf);
cx.buf = Some(unsafe { *buf });
return
}
@ -569,8 +528,11 @@ impl rtio::RtioUdpSocket for UdpWatcher {
let cx: &mut Ctx = unsafe {
cast::transmute(uvll::get_data_for_uv_handle(handle))
};
let addr = sockaddr_to_UvSocketAddr(addr);
let addr = uv_socket_addr_to_socket_addr(addr);
let addr = if addr == ptr::null() {
None
} else {
Some(sockaddr_to_socket_addr(addr))
};
cx.result = Some((nread, addr));
let sched: ~Scheduler = Local::take();
@ -585,13 +547,8 @@ impl rtio::RtioUdpSocket for UdpWatcher {
let mut req = Request::new(uvll::UV_UDP_SEND);
let buf = slice_to_uv_buf(buf);
let result = socket_addr_as_uv_socket_addr(dst, |dst| unsafe {
match dst {
UvIpv4SocketAddr(dst) =>
uvll::udp_send(req.handle, self.handle, [buf], dst, send_cb),
UvIpv6SocketAddr(dst) =>
uvll::udp_send6(req.handle, self.handle, [buf], dst, send_cb),
}
let result = socket_addr_as_sockaddr(dst, |dst| unsafe {
uvll::uv_udp_send(req.handle, self.handle, [buf], dst, send_cb)
});
return match result {

4
src/librustuv/process.rs
View File

@ -78,7 +78,7 @@ impl Process {
let handle = UvHandle::alloc(None::<Process>, uvll::UV_PROCESS);
match unsafe {
uvll::uv_spawn(loop_.handle, handle, options)
uvll::uv_spawn(loop_.handle, handle, &options)
} {
0 => {
let process = ~Process {
@ -106,7 +106,7 @@ impl Process {
}
extern fn on_exit(handle: *uvll::uv_process_t,
exit_status: libc::c_int,
exit_status: i64,
term_signal: libc::c_int) {
let p: &mut Process = unsafe { UvHandle::from_uv_handle(&handle) };

13
src/librustuv/stream.rs
View File

@ -135,17 +135,18 @@ impl StreamWatcher {
// This allocation callback expects to be invoked once and only once. It will
// unwrap the buffer in the ReadContext stored in the stream and return it. This
// will fail if it is called more than once.
extern fn alloc_cb(stream: *uvll::uv_stream_t, _hint: size_t) -> Buf {
extern fn alloc_cb(stream: *uvll::uv_stream_t, _hint: size_t, buf: *mut Buf) {
uvdebug!("alloc_cb");
let rcx: &mut ReadContext = unsafe {
cast::transmute(uvll::get_data_for_uv_handle(stream))
};
rcx.buf.take().expect("stream alloc_cb called more than once")
unsafe {
let rcx: &mut ReadContext =
cast::transmute(uvll::get_data_for_uv_handle(stream));
*buf = rcx.buf.take().expect("stream alloc_cb called more than once");
}
}
// When a stream has read some data, we will always forcibly stop reading and
// return all the data read (even if it didn't fill the whole buffer).
extern fn read_cb(handle: *uvll::uv_stream_t, nread: ssize_t, _buf: Buf) {
extern fn read_cb(handle: *uvll::uv_stream_t, nread: ssize_t, _buf: *Buf) {
uvdebug!("read_cb {}", nread);
assert!(nread != uvll::ECANCELED as ssize_t);
let rcx: &mut ReadContext = unsafe {

216
src/librustuv/uvll.rs
View File

@ -206,15 +206,16 @@ impl uv_stat_t {
pub type uv_idle_cb = extern "C" fn(handle: *uv_idle_t,
status: c_int);
pub type uv_alloc_cb = extern "C" fn(stream: *uv_stream_t,
suggested_size: size_t) -> uv_buf_t;
suggested_size: size_t,
buf: *mut uv_buf_t);
pub type uv_read_cb = extern "C" fn(stream: *uv_stream_t,
nread: ssize_t,
buf: uv_buf_t);
buf: *uv_buf_t);
pub type uv_udp_send_cb = extern "C" fn(req: *uv_udp_send_t,
status: c_int);
pub type uv_udp_recv_cb = extern "C" fn(handle: *uv_udp_t,
nread: ssize_t,
buf: uv_buf_t,
buf: *uv_buf_t,
addr: *sockaddr,
flags: c_uint);
pub type uv_close_cb = extern "C" fn(handle: *uv_handle_t);
@ -234,16 +235,13 @@ pub type uv_getaddrinfo_cb = extern "C" fn(req: *uv_getaddrinfo_t,
status: c_int,
res: *addrinfo);
pub type uv_exit_cb = extern "C" fn(handle: *uv_process_t,
exit_status: c_int,
exit_status: i64,
term_signal: c_int);
pub type uv_signal_cb = extern "C" fn(handle: *uv_signal_t,
signum: c_int);
pub type uv_fs_cb = extern "C" fn(req: *uv_fs_t);
pub type sockaddr = c_void;
pub type sockaddr_in = c_void;
pub type sockaddr_in6 = c_void;
pub type sockaddr_storage = c_void;
#[cfg(unix)]
pub type socklen_t = c_int;
@ -420,86 +418,12 @@ pub unsafe fn loop_new() -> *c_void {
return rust_uv_loop_new();
}
pub unsafe fn udp_bind(server: *uv_udp_t, addr: *sockaddr_in, flags: c_uint) -> c_int {
#[fixed_stack_segment]; #[inline(never)];
return rust_uv_udp_bind(server, addr, flags);
}
pub unsafe fn udp_bind6(server: *uv_udp_t, addr: *sockaddr_in6, flags: c_uint) -> c_int {
#[fixed_stack_segment]; #[inline(never)];
return rust_uv_udp_bind6(server, addr, flags);
}
pub unsafe fn udp_send<T>(req: *uv_udp_send_t, handle: *T, buf_in: &[uv_buf_t],
addr: *sockaddr_in, cb: uv_udp_send_cb) -> c_int {
#[fixed_stack_segment]; #[inline(never)];
let buf_ptr = vec::raw::to_ptr(buf_in);
let buf_cnt = buf_in.len() as i32;
return rust_uv_udp_send(req, handle as *c_void, buf_ptr, buf_cnt, addr, cb);
}
pub unsafe fn udp_send6<T>(req: *uv_udp_send_t, handle: *T, buf_in: &[uv_buf_t],
addr: *sockaddr_in6, cb: uv_udp_send_cb) -> c_int {
#[fixed_stack_segment]; #[inline(never)];
let buf_ptr = vec::raw::to_ptr(buf_in);
let buf_cnt = buf_in.len() as i32;
return rust_uv_udp_send6(req, handle as *c_void, buf_ptr, buf_cnt, addr, cb);
}
pub unsafe fn get_udp_handle_from_send_req(send_req: *uv_udp_send_t) -> *uv_udp_t {
#[fixed_stack_segment]; #[inline(never)];
return rust_uv_get_udp_handle_from_send_req(send_req);
}
pub unsafe fn udp_getsockname(handle: *uv_udp_t, name: *sockaddr_storage) -> c_int {
#[fixed_stack_segment]; #[inline(never)];
return rust_uv_udp_getsockname(handle, name);
}
pub unsafe fn tcp_connect(connect_ptr: *uv_connect_t, tcp_handle_ptr: *uv_tcp_t,
addr_ptr: *sockaddr_in, after_connect_cb: uv_connect_cb) -> c_int {
#[fixed_stack_segment]; #[inline(never)];
return rust_uv_tcp_connect(connect_ptr, tcp_handle_ptr, after_connect_cb, addr_ptr);
}
pub unsafe fn tcp_connect6(connect_ptr: *uv_connect_t, tcp_handle_ptr: *uv_tcp_t,
addr_ptr: *sockaddr_in6, after_connect_cb: uv_connect_cb) -> c_int {
#[fixed_stack_segment]; #[inline(never)];
return rust_uv_tcp_connect6(connect_ptr, tcp_handle_ptr, after_connect_cb, addr_ptr);
}
pub unsafe fn tcp_bind(tcp_server_ptr: *uv_tcp_t, addr_ptr: *sockaddr_in) -> c_int {
#[fixed_stack_segment]; #[inline(never)];
return rust_uv_tcp_bind(tcp_server_ptr, addr_ptr);
}
pub unsafe fn tcp_bind6(tcp_server_ptr: *uv_tcp_t, addr_ptr: *sockaddr_in6) -> c_int {
#[fixed_stack_segment]; #[inline(never)];
return rust_uv_tcp_bind6(tcp_server_ptr, addr_ptr);
}
pub unsafe fn tcp_getpeername(tcp_handle_ptr: *uv_tcp_t, name: *sockaddr_storage) -> c_int {
#[fixed_stack_segment]; #[inline(never)];
return rust_uv_tcp_getpeername(tcp_handle_ptr, name);
}
pub unsafe fn tcp_getsockname(handle: *uv_tcp_t, name: *sockaddr_storage) -> c_int {
#[fixed_stack_segment]; #[inline(never)];
return rust_uv_tcp_getsockname(handle, name);
}
pub unsafe fn uv_write(req: *uv_write_t,
stream: *uv_stream_t,
buf_in: &[uv_buf_t],
@ -513,67 +437,6 @@ pub unsafe fn uv_write(req: *uv_write_t,
return uv_write(req, stream, buf_ptr, buf_cnt, cb);
}
pub unsafe fn is_ip4_addr(addr: *sockaddr) -> bool {
#[fixed_stack_segment]; #[inline(never)];
match rust_uv_is_ipv4_sockaddr(addr) { 0 => false, _ => true }
}
pub unsafe fn is_ip6_addr(addr: *sockaddr) -> bool {
#[fixed_stack_segment]; #[inline(never)];
match rust_uv_is_ipv6_sockaddr(addr) { 0 => false, _ => true }
}
pub unsafe fn malloc_ip4_addr(ip: &str, port: int) -> *sockaddr_in {
#[fixed_stack_segment]; #[inline(never)];
do ip.with_c_str |ip_buf| {
rust_uv_ip4_addrp(ip_buf as *u8, port as libc::c_int)
}
}
pub unsafe fn malloc_ip6_addr(ip: &str, port: int) -> *sockaddr_in6 {
#[fixed_stack_segment]; #[inline(never)];
do ip.with_c_str |ip_buf| {
rust_uv_ip6_addrp(ip_buf as *u8, port as libc::c_int)
}
}
pub unsafe fn malloc_sockaddr_storage() -> *sockaddr_storage {
#[fixed_stack_segment]; #[inline(never)];
rust_uv_malloc_sockaddr_storage()
}
pub unsafe fn free_sockaddr_storage(ss: *sockaddr_storage) {
#[fixed_stack_segment]; #[inline(never)];
rust_uv_free_sockaddr_storage(ss);
}
pub unsafe fn free_ip4_addr(addr: *sockaddr_in) {
#[fixed_stack_segment]; #[inline(never)];
rust_uv_free_ip4_addr(addr);
}
pub unsafe fn free_ip6_addr(addr: *sockaddr_in6) {
#[fixed_stack_segment]; #[inline(never)];
rust_uv_free_ip6_addr(addr);
}
pub unsafe fn ip4_port(addr: *sockaddr_in) -> c_uint {
#[fixed_stack_segment]; #[inline(never)];
return rust_uv_ip4_port(addr);
}
pub unsafe fn ip6_port(addr: *sockaddr_in6) -> c_uint {
#[fixed_stack_segment]; #[inline(never)];
return rust_uv_ip6_port(addr);
}
pub unsafe fn process_pid(p: *uv_process_t) -> c_int {
#[fixed_stack_segment]; #[inline(never)];
return rust_uv_process_pid(p);
@ -685,36 +548,19 @@ pub unsafe fn guess_handle(handle: c_int) -> c_int {
extern {
fn rust_uv_loop_new() -> *c_void;
// dealing with sockaddr things
pub fn rust_sockaddr_size() -> c_int;
pub fn rust_malloc_ip4_addr(s: *c_char, port: c_int) -> *sockaddr;
pub fn rust_malloc_ip6_addr(s: *c_char, port: c_int) -> *sockaddr;
pub fn rust_ip4_port(src: *sockaddr) -> c_uint;
pub fn rust_ip6_port(src: *sockaddr) -> c_uint;
pub fn rust_is_ipv4_sockaddr(addr: *sockaddr) -> c_int;
pub fn rust_is_ipv6_sockaddr(addr: *sockaddr) -> c_int;
fn rust_uv_handle_type_max() -> uintptr_t;
fn rust_uv_req_type_max() -> uintptr_t;
fn rust_uv_ip4_addrp(ip: *u8, port: c_int) -> *sockaddr_in;
fn rust_uv_ip6_addrp(ip: *u8, port: c_int) -> *sockaddr_in6;
fn rust_uv_free_ip4_addr(addr: *sockaddr_in);
fn rust_uv_free_ip6_addr(addr: *sockaddr_in6);
fn rust_uv_ip4_port(src: *sockaddr_in) -> c_uint;
fn rust_uv_ip6_port(src: *sockaddr_in6) -> c_uint;
fn rust_uv_tcp_connect(req: *uv_connect_t, handle: *uv_tcp_t,
cb: uv_connect_cb,
addr: *sockaddr_in) -> c_int;
fn rust_uv_tcp_bind(tcp_server: *uv_tcp_t, addr: *sockaddr_in) -> c_int;
fn rust_uv_tcp_connect6(req: *uv_connect_t, handle: *uv_tcp_t,
cb: uv_connect_cb,
addr: *sockaddr_in6) -> c_int;
fn rust_uv_tcp_bind6(tcp_server: *uv_tcp_t, addr: *sockaddr_in6) -> c_int;
fn rust_uv_tcp_getpeername(tcp_handle_ptr: *uv_tcp_t, name: *sockaddr_storage) -> c_int;
fn rust_uv_tcp_getsockname(handle: *uv_tcp_t, name: *sockaddr_storage) -> c_int;
fn rust_uv_udp_bind(server: *uv_udp_t, addr: *sockaddr_in, flags: c_uint) -> c_int;
fn rust_uv_udp_bind6(server: *uv_udp_t, addr: *sockaddr_in6, flags: c_uint) -> c_int;
fn rust_uv_udp_send(req: *uv_udp_send_t, handle: *uv_udp_t, buf_in: *uv_buf_t,
buf_cnt: c_int, addr: *sockaddr_in, cb: uv_udp_send_cb) -> c_int;
fn rust_uv_udp_send6(req: *uv_udp_send_t, handle: *uv_udp_t, buf_in: *uv_buf_t,
buf_cnt: c_int, addr: *sockaddr_in6, cb: uv_udp_send_cb) -> c_int;
fn rust_uv_get_udp_handle_from_send_req(req: *uv_udp_send_t) -> *uv_udp_t;
fn rust_uv_udp_getsockname(handle: *uv_udp_t, name: *sockaddr_storage) -> c_int;
fn rust_uv_is_ipv4_sockaddr(addr: *sockaddr) -> c_int;
fn rust_uv_is_ipv6_sockaddr(addr: *sockaddr) -> c_int;
fn rust_uv_malloc_sockaddr_storage() -> *sockaddr_storage;
fn rust_uv_free_sockaddr_storage(ss: *sockaddr_storage);
fn rust_uv_populate_uv_stat(req_in: *uv_fs_t, stat_out: *uv_stat_t);
fn rust_uv_get_result_from_fs_req(req: *uv_fs_t) -> c_int;
fn rust_uv_get_ptr_from_fs_req(req: *uv_fs_t) -> *libc::c_void;
@ -768,17 +614,27 @@ externfn!(fn uv_async_send(a: *uv_async_t))
// tcp bindings
externfn!(fn uv_tcp_init(l: *uv_loop_t, h: *uv_tcp_t) -> c_int)
externfn!(fn uv_ip4_name(src: *sockaddr_in, dst: *c_char,
externfn!(fn uv_tcp_connect(c: *uv_connect_t, h: *uv_tcp_t,
addr: *sockaddr, cb: uv_connect_cb) -> c_int)
externfn!(fn uv_tcp_bind(t: *uv_tcp_t, addr: *sockaddr) -> c_int)
externfn!(fn uv_ip4_name(src: *sockaddr, dst: *c_char,
size: size_t) -> c_int)
externfn!(fn uv_ip6_name(src: *sockaddr_in6, dst: *c_char,
externfn!(fn uv_ip6_name(src: *sockaddr, dst: *c_char,
size: size_t) -> c_int)
externfn!(fn uv_tcp_nodelay(h: *uv_tcp_t, enable: c_int) -> c_int)
externfn!(fn uv_tcp_keepalive(h: *uv_tcp_t, enable: c_int,
delay: c_uint) -> c_int)
externfn!(fn uv_tcp_simultaneous_accepts(h: *uv_tcp_t, enable: c_int) -> c_int)
externfn!(fn uv_tcp_getsockname(h: *uv_tcp_t, name: *sockaddr,
len: *mut c_int) -> c_int)
externfn!(fn uv_tcp_getpeername(h: *uv_tcp_t, name: *sockaddr,
len: *mut c_int) -> c_int)
externfn!(fn uv_ip4_addr(ip: *c_char, port: c_int, addr: *sockaddr) -> c_int)
externfn!(fn uv_ip6_addr(ip: *c_char, port: c_int, addr: *sockaddr) -> c_int)
// udp bindings
externfn!(fn uv_udp_init(l: *uv_loop_t, h: *uv_udp_t) -> c_int)
externfn!(fn uv_udp_bind(h: *uv_udp_t, addr: *sockaddr, flags: c_uint) -> c_int)
externfn!(fn uv_udp_recv_start(server: *uv_udp_t,
on_alloc: uv_alloc_cb,
on_recv: uv_udp_recv_cb) -> c_int)
@ -790,6 +646,22 @@ externfn!(fn uv_udp_set_multicast_loop(handle: *uv_udp_t, on: c_int) -> c_int)
externfn!(fn uv_udp_set_multicast_ttl(handle: *uv_udp_t, ttl: c_int) -> c_int)
externfn!(fn uv_udp_set_ttl(handle: *uv_udp_t, ttl: c_int) -> c_int)
externfn!(fn uv_udp_set_broadcast(handle: *uv_udp_t, on: c_int) -> c_int)
externfn!(fn uv_udp_getsockname(h: *uv_udp_t, name: *sockaddr,
len: *mut c_int) -> c_int)
pub unsafe fn uv_udp_send(req: *uv_udp_send_t,
handle: *uv_udp_t,
buf_in: &[uv_buf_t],
addr: *sockaddr,
cb: uv_udp_send_cb) -> c_int {
externfn!(fn uv_udp_send(req: *uv_write_t, stream: *uv_stream_t,
buf_in: *uv_buf_t, buf_cnt: c_int, addr: *sockaddr,
cb: uv_udp_send_cb) -> c_int)
let buf_ptr = vec::raw::to_ptr(buf_in);
let buf_cnt = buf_in.len() as i32;
return uv_udp_send(req, handle, buf_ptr, buf_cnt, addr, cb);
}
// timer bindings
externfn!(fn uv_timer_init(l: *uv_loop_t, t: *uv_timer_t) -> c_int)
@ -853,7 +725,7 @@ externfn!(fn uv_freeaddrinfo(ai: *addrinfo))
// process spawning
externfn!(fn uv_spawn(loop_ptr: *uv_loop_t, outptr: *uv_process_t,
options: uv_process_options_t) -> c_int)
options: *uv_process_options_t) -> c_int)
externfn!(fn uv_process_kill(p: *uv_process_t, signum: c_int) -> c_int)
// pipes

2
src/libuv

@ -1 +1 @@
Subproject commit d88cf5652a1afb23939da0bae86c70ec521b9921
Subproject commit c6ecf97aafc858c2ad1089fb78da6c586d61d8b6

177
src/rt/rust_uv.cpp
View File

@ -36,96 +36,11 @@ rust_uv_loop_set_data(uv_loop_t* loop, void* data) {
loop->data = data;
}
extern "C" int
rust_uv_tcp_connect(uv_connect_t* connect_ptr,
uv_tcp_t* tcp_ptr,
uv_connect_cb cb,
sockaddr_in* addr_ptr) {
// FIXME ref #2064
sockaddr_in addr = *addr_ptr;
int result = uv_tcp_connect(connect_ptr, tcp_ptr, addr, cb);
return result;
}
extern "C" int
rust_uv_tcp_bind(uv_tcp_t* tcp_server, sockaddr_in* addr_ptr) {
// FIXME ref #2064
sockaddr_in addr = *addr_ptr;
return uv_tcp_bind(tcp_server, addr);
}
extern "C" int
rust_uv_tcp_connect6(uv_connect_t* connect_ptr,
uv_tcp_t* tcp_ptr,
uv_connect_cb cb,
sockaddr_in6* addr_ptr) {
// FIXME ref #2064
sockaddr_in6 addr = *addr_ptr;
int result = uv_tcp_connect6(connect_ptr, tcp_ptr, addr, cb);
return result;
}
extern "C" int
rust_uv_tcp_bind6
(uv_tcp_t* tcp_server, sockaddr_in6* addr_ptr) {
// FIXME ref #2064
sockaddr_in6 addr = *addr_ptr;
return uv_tcp_bind6(tcp_server, addr);
}
extern "C" int
rust_uv_tcp_getpeername
(uv_tcp_t* handle, sockaddr_storage* name) {
// sockaddr_storage is big enough to hold either
// sockaddr_in or sockaddr_in6
int namelen = sizeof(sockaddr_in);
return uv_tcp_getpeername(handle, (sockaddr*)name, &namelen);
}
extern "C" int
rust_uv_tcp_getsockname
(uv_tcp_t* handle, sockaddr_storage* name) {
// sockaddr_storage is big enough to hold either
// sockaddr_in or sockaddr_in6
int namelen = sizeof(sockaddr_storage);
return uv_tcp_getsockname(handle, (sockaddr*)name, &namelen);
}
extern "C" int
rust_uv_udp_bind(uv_udp_t* server, sockaddr_in* addr_ptr, unsigned flags) {
return uv_udp_bind(server, *addr_ptr, flags);
}
extern "C" int
rust_uv_udp_bind6(uv_udp_t* server, sockaddr_in6* addr_ptr, unsigned flags) {
return uv_udp_bind6(server, *addr_ptr, flags);
}
extern "C" int
rust_uv_udp_send(uv_udp_send_t* req, uv_udp_t* handle, uv_buf_t* buf_in,
int buf_cnt, sockaddr_in* addr_ptr, uv_udp_send_cb cb) {
return uv_udp_send(req, handle, buf_in, buf_cnt, *addr_ptr, cb);
}
extern "C" int
rust_uv_udp_send6(uv_udp_send_t* req, uv_udp_t* handle, uv_buf_t* buf_in,
int buf_cnt, sockaddr_in6* addr_ptr, uv_udp_send_cb cb) {
return uv_udp_send6(req, handle, buf_in, buf_cnt, *addr_ptr, cb);
}
extern "C" uv_udp_t*
rust_uv_get_udp_handle_from_send_req(uv_udp_send_t* send_req) {
return send_req->handle;
}
extern "C" int
rust_uv_udp_getsockname
(uv_udp_t* handle, sockaddr_storage* name) {
// sockaddr_storage is big enough to hold either
// sockaddr_in or sockaddr_in6
int namelen = sizeof(sockaddr_storage);
return uv_udp_getsockname(handle, (sockaddr*)name, &namelen);
}
extern "C" uv_stream_t*
rust_uv_get_stream_handle_from_connect_req(uv_connect_t* connect) {
return connect->handle;
@ -171,94 +86,52 @@ rust_uv_set_data_for_req(uv_req_t* req, void* data) {
req->data = data;
}
extern "C" struct sockaddr_in
rust_uv_ip4_addr(const char* ip, int port) {
struct sockaddr_in addr = uv_ip4_addr(ip, port);
return addr;
}
extern "C" struct sockaddr_in6
rust_uv_ip6_addr(const char* ip, int port) {
return uv_ip6_addr(ip, port);
extern "C" int
rust_sockaddr_size() {
return sizeof(struct sockaddr_storage);
}
extern "C" struct sockaddr_in*
rust_uv_ip4_addrp(const char* ip, int port) {
struct sockaddr_in addr = uv_ip4_addr(ip, port);
struct sockaddr_in *addrp = (sockaddr_in*)malloc(sizeof(struct sockaddr_in));
assert(addrp);
memcpy(addrp, &addr, sizeof(struct sockaddr_in));
return addrp;
}
extern "C" struct sockaddr_in6*
rust_uv_ip6_addrp(const char* ip, int port) {
struct sockaddr_in6 addr = uv_ip6_addr(ip, port);
struct sockaddr_in6 *addrp = (sockaddr_in6*)malloc(sizeof(struct sockaddr_in6));
assert(addrp);
memcpy(addrp, &addr, sizeof(struct sockaddr_in6));
return addrp;
extern "C" struct sockaddr*
rust_malloc_ip4_addr(char *name, int port) {
struct sockaddr_in *addr = (struct sockaddr_in*) malloc(sizeof(struct sockaddr_in));
memset(addr, 0, sizeof(struct sockaddr_in));
assert(addr != NULL);
addr->sin_port = htons(port);
assert(uv_inet_pton(AF_INET, name, &addr->sin_addr) == 0);
addr->sin_family = AF_INET;
return (struct sockaddr*) addr;
}
extern "C" struct sockaddr_storage *
rust_uv_malloc_sockaddr_storage() {
struct sockaddr_storage *ss = (sockaddr_storage *)malloc(sizeof(struct sockaddr_storage));
return ss;
extern "C" struct sockaddr*
rust_malloc_ip6_addr(char *name, int port) {
struct sockaddr_in6 *addr = (struct sockaddr_in6*) malloc(sizeof(struct sockaddr_in6));
memset(addr, 0, sizeof(struct sockaddr));
assert(addr != NULL);
addr->sin6_port = htons(port);
assert(uv_inet_pton(AF_INET6, name, &addr->sin6_addr) == 0);
addr->sin6_family = AF_INET6;
return (struct sockaddr*) addr;
}
extern "C" void
rust_uv_free_sockaddr_storage(struct sockaddr_storage *ss) {
free(ss);
}
extern "C" void
rust_uv_free_ip4_addr(sockaddr_in *addrp) {
free(addrp);
}
extern "C" void
rust_uv_free_ip6_addr(sockaddr_in6 *addrp) {
free(addrp);
}
extern "C" unsigned int
rust_uv_ip4_port(struct sockaddr_in* src) {
rust_ip4_port(struct sockaddr_in* src) {
return ntohs(src->sin_port);
}
extern "C" unsigned int
rust_uv_ip6_port(struct sockaddr_in6* src) {
rust_ip6_port(struct sockaddr_in6* src) {
return ntohs(src->sin6_port);
}
extern "C" int
rust_uv_is_ipv4_sockaddr(sockaddr* addr) {
rust_is_ipv4_sockaddr(sockaddr* addr) {
return addr->sa_family == AF_INET;
}
extern "C" int
rust_uv_is_ipv6_sockaddr(sockaddr* addr) {
rust_is_ipv6_sockaddr(sockaddr* addr) {
return addr->sa_family == AF_INET6;
}
extern "C" bool
rust_uv_is_ipv4_addrinfo(addrinfo* input) {
return input->ai_family == AF_INET;
}
extern "C" bool
rust_uv_is_ipv6_addrinfo(addrinfo* input) {
return input->ai_family == AF_INET6;
}
extern "C" addrinfo*
rust_uv_get_next_addrinfo(addrinfo* input) {
return input->ai_next;
}
extern "C" sockaddr_in*
rust_uv_addrinfo_as_sockaddr_in(addrinfo* input) {
return (sockaddr_in*)input->ai_addr;
}
extern "C" sockaddr_in6*
rust_uv_addrinfo_as_sockaddr_in6(addrinfo* input) {
return (sockaddr_in6*)input->ai_addr;
}
extern "C" uintptr_t
rust_uv_handle_type_max() {
return UV_HANDLE_TYPE_MAX;