From 3a3eefc5c3ce95de3001d8ee830296345c2f6bc9 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Thu, 7 Nov 2013 15:26:47 -0800 Subject: [PATCH] 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 --- .gitmodules | 2 +- mk/rt.mk | 2 +- src/librustuv/addrinfo.rs | 3 +- src/librustuv/lib.rs | 2 +- src/librustuv/net.rs | 221 +++++++++++++++----------------------- src/librustuv/process.rs | 4 +- src/librustuv/stream.rs | 13 +-- src/librustuv/uvll.rs | 216 ++++++++----------------------------- src/libuv | 2 +- src/rt/rust_uv.cpp | 177 +++++------------------------- 10 files changed, 172 insertions(+), 470 deletions(-) diff --git a/.gitmodules b/.gitmodules index 7e997334cec..a861cf79978 100644 --- a/.gitmodules +++ b/.gitmodules @@ -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 diff --git a/mk/rt.mk b/mk/rt.mk index 3d5e9cbcb82..55187fad49d 100644 --- a/mk/rt.mk +++ b/mk/rt.mk @@ -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)) diff --git a/src/librustuv/addrinfo.rs b/src/librustuv/addrinfo.rs index 56f6eda5357..601cc9f84ad 100644 --- a/src/librustuv/addrinfo.rs +++ b/src/librustuv/addrinfo.rs @@ -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| { diff --git a/src/librustuv/lib.rs b/src/librustuv/lib.rs index 4da5ad4275f..7c84ccb8f2c 100644 --- a/src/librustuv/lib.rs +++ b/src/librustuv/lib.rs @@ -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; diff --git a/src/librustuv/net.rs b/src/librustuv/net.rs index bf5f6c88527..10b8f50e387 100644 --- a/src/librustuv/net.rs +++ b/src/librustuv/net.rs @@ -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(addr: SocketAddr, f: &fn(UvSocketAddr) -> T) -> T { +#[fixed_stack_segment] +fn socket_addr_as_sockaddr(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(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 { - 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, buf: Option, - result: Option<(ssize_t, SocketAddr)>, + result: Option<(ssize_t, Option)>, } 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 { diff --git a/src/librustuv/process.rs b/src/librustuv/process.rs index 17a7510aa19..d0b0d6429b8 100644 --- a/src/librustuv/process.rs +++ b/src/librustuv/process.rs @@ -78,7 +78,7 @@ impl Process { let handle = UvHandle::alloc(None::, 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) }; diff --git a/src/librustuv/stream.rs b/src/librustuv/stream.rs index b9ccacf4df7..08b307700c7 100644 --- a/src/librustuv/stream.rs +++ b/src/librustuv/stream.rs @@ -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 { diff --git a/src/librustuv/uvll.rs b/src/librustuv/uvll.rs index 58d182a22c3..4183ce4309e 100644 --- a/src/librustuv/uvll.rs +++ b/src/librustuv/uvll.rs @@ -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(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(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 diff --git a/src/libuv b/src/libuv index d88cf5652a1..c6ecf97aafc 160000 --- a/src/libuv +++ b/src/libuv @@ -1 +1 @@ -Subproject commit d88cf5652a1afb23939da0bae86c70ec521b9921 +Subproject commit c6ecf97aafc858c2ad1089fb78da6c586d61d8b6 diff --git a/src/rt/rust_uv.cpp b/src/rt/rust_uv.cpp index 6f619431ad7..280b016af10 100644 --- a/src/rt/rust_uv.cpp +++ b/src/rt/rust_uv.cpp @@ -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;