From 7c0fed469f70fffc7164539ba9e6e28bf84371a3 Mon Sep 17 00:00:00 2001 From: Jeff Olson Date: Mon, 2 Apr 2012 09:12:43 -0700 Subject: [PATCH] rename uv::direct:: to uv::ll:: and put into its own crate --- src/libstd/std.rc | 3 + src/libstd/uv.rs | 737 +++++++++----------------------------------- src/libstd/uv_ll.rs | 526 +++++++++++++++++++++++++++++++ 3 files changed, 669 insertions(+), 597 deletions(-) create mode 100644 src/libstd/uv_ll.rs diff --git a/src/libstd/std.rc b/src/libstd/std.rc index 072ad5e25ac0..7469e3183228 100644 --- a/src/libstd/std.rc +++ b/src/libstd/std.rc @@ -23,7 +23,10 @@ export test, tempfile, serialization; // General io and system-services modules mod net; + +// libuv modules mod uv; +mod uv_ll; // Utility modules diff --git a/src/libstd/uv.rs b/src/libstd/uv.rs index 6f89f607bc07..f5ee758a368b 100644 --- a/src/libstd/uv.rs +++ b/src/libstd/uv.rs @@ -24,321 +24,9 @@ import map::hashmap; export loop_new, loop_delete, run, close, run_in_bg; export async_init, async_send; export timer_init, timer_start, timer_stop; -export uv_ip4_addr, uv_ip6_addr; -export direct; -// these are processed solely in the -// process_operation() crust fn below -enum uv_operation { - op_async_init([u8]), - op_close(uv_handle, *libc::c_void), - op_timer_init([u8]), - op_timer_start([u8], *libc::c_void, u32, u32), - op_timer_stop([u8], *libc::c_void, fn~(uv_handle)), - op_teardown(*libc::c_void) -} - -enum uv_handle { - uv_async([u8], uv_loop), - uv_timer([u8], uv_loop), -} - -enum uv_msg { - // requests from library users - msg_run(comm::chan), - msg_run_in_bg(), - msg_async_init(fn~(uv_handle), fn~(uv_handle)), - msg_async_send([u8]), - msg_close(uv_handle, fn~()), - msg_timer_init(fn~(uv_handle)), - msg_timer_start([u8], u32, u32, fn~(uv_handle)), - msg_timer_stop([u8], fn~(uv_handle)), - - // dispatches from libuv - uv_async_init([u8], *libc::c_void), - uv_async_send([u8]), - uv_close([u8]), - uv_timer_init([u8], *libc::c_void), - uv_timer_call([u8]), - uv_timer_stop([u8], fn~(uv_handle)), - uv_end(), - uv_teardown_check() -} - -type uv_loop_data = { - operation_port: comm::port, - rust_loop_chan: comm::chan -}; - -enum uv_loop { - uv_loop_new(comm::chan, *libc::c_void) -} - -// libuv struct mappings -type uv_ip4_addr = { - ip: [u8], - port: int -}; -type uv_ip6_addr = uv_ip4_addr; - -enum uv_handle_type { - UNKNOWN_HANDLE = 0, - UV_TCP, - UV_UDP, - UV_NAMED_PIPE, - UV_TTY, - UV_FILE, - UV_TIMER, - UV_PREPARE, - UV_CHECK, - UV_IDLE, - UV_ASYNC, - UV_ARES_TASK, - UV_ARES_EVENT, - UV_PROCESS, - UV_FS_EVENT -} - -type handle_type = libc::c_uint; - -type uv_handle_fields = { - loop_handle: *libc::c_void, - type_: handle_type, - close_cb: *u8, - mut data: *libc::c_void, -}; - -// unix size: 8 -type uv_err_t = { - code: libc::c_int, - sys_errno_: libc::c_int -}; - -// don't create one of these directly. instead, -// count on it appearing in libuv callbacks or embedded -// in other types as a pointer to be used in other -// operations (so mostly treat it as opaque, once you -// have it in this form..) -#[cfg(target_os = "linux")] -#[cfg(target_os = "macos")] -#[cfg(target_os = "freebsd")] -#[cfg(target_os = "win32")] -type uv_stream_t = { - fields: uv_handle_fields -}; - -// unix size: 272 -#[cfg(target_os = "linux")] -#[cfg(target_os = "macos")] -#[cfg(target_os = "freebsd")] -type uv_tcp_t = { - fields: uv_handle_fields, - a00: *u8, a01: *u8, a02: *u8, a03: *u8, - a04: *u8, a05: *u8, a06: *u8, a07: *u8, - a08: *u8, a09: *u8, a10: *u8, a11: *u8, - a12: *u8, a13: *u8, a14: *u8, a15: *u8, - a16: *u8, a17: *u8, a18: *u8, a19: *u8, - a20: *u8, a21: *u8, a22: *u8, a23: *u8, - a24: *u8, a25: *u8, a26: *u8, a27: *u8, - a28: *u8, a29: *u8 -}; -// win32 size: 240 (120) -#[cfg(target_os = "win32")] -type uv_tcp_t = { - fields: uv_handle_fields, - a00: *u8, a01: *u8, a02: *u8, a03: *u8, - a04: *u8, a05: *u8, a06: *u8, a07: *u8, - a08: *u8, a09: *u8, a10: *u8, a11: *u8, - a12: *u8, a13: *u8, a14: *u8, a15: *u8, - a16: *u8, a17: *u8, a18: *u8, a19: *u8, - a20: *u8, a21: *u8, a22: *u8, a23: *u8, - a24: *u8, a25: *u8 -}; -#[cfg(target_os = "linux")] -#[cfg(target_os = "macos")] -#[cfg(target_os = "freebsd")] -fn gen_stub_uv_tcp_t() -> uv_tcp_t { - ret { fields: { loop_handle: ptr::null(), type_: 0u32, - close_cb: ptr::null(), - mut data: ptr::null() }, - a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8, a03: 0 as *u8, - a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8, a07: 0 as *u8, - a08: 0 as *u8, a09: 0 as *u8, a10: 0 as *u8, a11: 0 as *u8, - a12: 0 as *u8, a13: 0 as *u8, a14: 0 as *u8, a15: 0 as *u8, - a16: 0 as *u8, a17: 0 as *u8, a18: 0 as *u8, a19: 0 as *u8, - a20: 0 as *u8, a21: 0 as *u8, a22: 0 as *u8, a23: 0 as *u8, - a24: 0 as *u8, a25: 0 as *u8, a26: 0 as *u8, a27: 0 as *u8, - a28: 0 as *u8, a29: 0 as *u8 - }; -} -#[cfg(target_os = "win32")] -fn gen_stub_uv_tcp_t() -> uv_tcp_t { - ret { fields: { loop_handle: ptr::null(), type_: 0u32, - close_cb: ptr::null(), - mut data: ptr::null() }, - a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8, a03: 0 as *u8, - a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8, a07: 0 as *u8, - a08: 0 as *u8, a09: 0 as *u8, a10: 0 as *u8, a11: 0 as *u8, - a12: 0 as *u8, a13: 0 as *u8, a14: 0 as *u8, a15: 0 as *u8, - a16: 0 as *u8, a17: 0 as *u8, a18: 0 as *u8, a19: 0 as *u8, - a20: 0 as *u8, a21: 0 as *u8, a22: 0 as *u8, a23: 0 as *u8, - a24: 0 as *u8, a25: 0 as *u8 - }; -} - -// unix size: 48 -#[cfg(target_os = "linux")] -#[cfg(target_os = "macos")] -#[cfg(target_os = "freebsd")] -type uv_connect_t = { - a00: *u8, a01: *u8, a02: *u8, a03: *u8, - a04: *u8, a05: *u8 -}; -// win32 size: 88 (44) -#[cfg(target_os = "win32")] -type uv_connect_t = { - a00: *u8, a01: *u8, a02: *u8, a03: *u8, - a04: *u8, a05: *u8, a06: *u8, a07: *u8, - a08: *u8, a09: *u8, a10: *u8 -}; -#[cfg(target_os = "linux")] -#[cfg(target_os = "macos")] -#[cfg(target_os = "freebsd")] -fn gen_stub_uv_connect_t() -> uv_connect_t { - ret { - a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8, a03: 0 as *u8, - a04: 0 as *u8, a05: 0 as *u8 - }; -} -#[cfg(target_os = "win32")] -fn gen_stub_uv_connect_t() -> uv_connect_t { - ret { - a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8, a03: 0 as *u8, - a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8, a07: 0 as *u8, - a08: 0 as *u8, a09: 0 as *u8, a10: 0 as *u8 - }; -} - -// unix size: 16 -#[cfg(target_os = "linux")] -#[cfg(target_os = "macos")] -#[cfg(target_os = "freebsd")] -#[cfg(target_os = "win32")] -type uv_buf_t = { - base: *u8, - len: libc::size_t -}; -// no gen stub method.. should create -// it via uv::direct::buf_init() - -// unix size: 144 -#[cfg(target_os = "linux")] -#[cfg(target_os = "macos")] -#[cfg(target_os = "freebsd")] -type uv_write_t = { - fields: uv_handle_fields, - a00: *u8, a01: *u8, a02: *u8, a03: *u8, - a04: *u8, a05: *u8, a06: *u8, a07: *u8, - a08: *u8, a09: *u8, a10: *u8, a11: *u8, - a12: *u8, a13: *u8 -}; -// win32 size: 136 (68) -#[cfg(target_os = "win32")] -type uv_write_t = { - fields: uv_handle_fields, - a00: *u8, a01: *u8, a02: *u8, a03: *u8, - a04: *u8, a05: *u8, a06: *u8, a07: *u8, - a08: *u8, a09: *u8, a10: *u8, a11: *u8, - a12: *u8 -}; -#[cfg(target_os = "linux")] -#[cfg(target_os = "macos")] -#[cfg(target_os = "freebsd")] -fn gen_stub_uv_write_t() -> uv_write_t { - ret { fields: { loop_handle: ptr::null(), type_: 0u32, - close_cb: ptr::null(), - mut data: ptr::null() }, - a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8, a03: 0 as *u8, - a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8, a07: 0 as *u8, - a08: 0 as *u8, a09: 0 as *u8, a10: 0 as *u8, a11: 0 as *u8, - a12: 0 as *u8, a13: 0 as *u8 - }; -} -#[cfg(target_os = "win32")] -fn gen_stub_uv_write_t() -> uv_write_t { - ret { fields: { loop_handle: ptr::null(), type_: 0u32, - close_cb: ptr::null(), - mut data: ptr::null() }, - a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8, a03: 0 as *u8, - a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8, a07: 0 as *u8, - a08: 0 as *u8, a09: 0 as *u8, a10: 0 as *u8, a11: 0 as *u8, - a12: 0 as *u8 - }; -} -// unix size: 120 -#[cfg(target_os = "linux")] -#[cfg(target_os = "macos")] -#[cfg(target_os = "freebsd")] -type uv_async_t = { - fields: uv_handle_fields, - a00: *u8, a01: *u8, a02: *u8, a03: *u8, - a04: *u8, a05: *u8, a06: *u8, a07: *u8, - a08: *u8, a09: *u8, a10: *u8 -}; -// win32 size 132 (68) -#[cfg(target_os = "win32")] -type uv_async_t = { - fields: uv_handle_fields, - a00: *u8, a01: *u8, a02: *u8, a03: *u8, - a04: *u8, a05: *u8, a06: *u8, a07: *u8, - a08: *u8, a09: *u8, a10: *u8, a11: *u8, - a12: *u8 -}; -#[cfg(target_os = "linux")] -#[cfg(target_os = "macos")] -#[cfg(target_os = "freebsd")] -fn gen_stub_uv_async_t() -> uv_async_t { - ret { fields: { loop_handle: ptr::null(), type_: 0u32, - close_cb: ptr::null(), - mut data: ptr::null() }, - a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8, a03: 0 as *u8, - a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8, a07: 0 as *u8, - a08: 0 as *u8, a09: 0 as *u8, a10: 0 as *u8 - }; -} -#[cfg(target_os = "win32")] -fn gen_stub_uv_async_t() -> uv_async_t { - ret { fields: { loop_handle: ptr::null(), type_: 0u32, - close_cb: ptr::null(), - mut data: ptr::null() }, - a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8, a03: 0 as *u8, - a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8, a07: 0 as *u8, - a08: 0 as *u8, a09: 0 as *u8, a10: 0 as *u8, a11: 0 as *u8, - a12: 0 as *u8 - }; -} - -// unix size: 16 -#[cfg(target_os = "linux")] -#[cfg(target_os = "macos")] -#[cfg(target_os = "freebsd")] -#[cfg(target_os = "win32")] -type sockaddr_in = { - mut sin_family: u16, - mut sin_port: u16, - mut sin_addr: u32, // in_addr: this is an opaque, per-platform struct - mut sin_zero: (u8, u8, u8, u8, u8, u8, u8, u8) -}; - -// unix size: 28 .. make due w/ 32 -#[cfg(target_os = "linux")] -#[cfg(target_os = "macos")] -#[cfg(target_os = "freebsd")] -#[cfg(target_os = "win32")] -type sockaddr_in6 = { - a0: *u8, a1: *u8, - a2: *u8, a3: *u8 -}; +import ll = uv_ll; +export ll; #[nolink] native mod rustrt { @@ -351,14 +39,10 @@ native mod rustrt { -> *libc::c_void; fn rust_uv_stop_op_cb(handle: *libc::c_void); fn rust_uv_run(loop_handle: *libc::c_void); - fn rust_uv_close(handle: *libc::c_void, cb: *u8); fn rust_uv_hilvl_close(handle: *libc::c_void, cb: *u8); fn rust_uv_hilvl_close_async(handle: *libc::c_void); fn rust_uv_hilvl_close_timer(handle: *libc::c_void); - fn rust_uv_async_send(handle: *uv_async_t); - fn rust_uv_async_init(loop_handle: *libc::c_void, - async_handle: *uv_async_t, - cb: *u8) -> libc::c_int; + fn rust_uv_async_send(handle: *ll::uv_async_t); fn rust_uv_hilvl_async_init( loop_handle: *libc::c_void, cb: *u8, @@ -414,198 +98,54 @@ native mod rustrt { fn rust_uv_helper_uv_err_t_size() -> libc::c_uint; fn rust_uv_helper_sockaddr_in_size() -> libc::c_uint; fn rust_uv_helper_uv_async_t_size() -> libc::c_uint; - - // data accessors for rust-mapped uv structs - fn rust_uv_get_stream_handle_from_connect_req( - connect_req: *uv_connect_t) - -> *uv_stream_t; - fn rust_uv_get_stream_handle_from_write_req( - write_req: *uv_write_t) - -> *uv_stream_t; - fn rust_uv_get_loop_for_uv_handle(handle: *libc::c_void) - -> *libc::c_void; - fn rust_uv_get_data_for_uv_handle(handle: *libc::c_void) - -> *libc::c_void; - fn rust_uv_set_data_for_uv_handle(handle: *libc::c_void, - data: *libc::c_void); - fn rust_uv_get_data_for_req(req: *libc::c_void) -> *libc::c_void; - fn rust_uv_set_data_for_req(req: *libc::c_void, - data: *libc::c_void); - fn rust_uv_get_base_from_buf(++buf: uv_buf_t) -> *u8; - fn rust_uv_get_len_from_buf(++buf: uv_buf_t) -> libc::size_t; } -// this module is structured around functions that directly -// expose libuv functionality and data structures. for use -// in higher level mappings -mod direct { - unsafe fn loop_new() -> *libc::c_void { - ret rustrt::rust_uv_loop_new(); - } - unsafe fn loop_delete(loop_handle: *libc::c_void) { - rustrt::rust_uv_loop_delete(loop_handle); - } +// these are processed solely in the +// process_operation() crust fn below +enum uv_operation { + op_async_init([u8]), + op_close(uv_handle, *libc::c_void), + op_timer_init([u8]), + op_timer_start([u8], *libc::c_void, u32, u32), + op_timer_stop([u8], *libc::c_void, fn~(uv_handle)), + op_teardown(*libc::c_void) +} - unsafe fn run(loop_handle: *libc::c_void) { - rustrt::rust_uv_run(loop_handle); - } +enum uv_handle { + uv_async([u8], uv_loop), + uv_timer([u8], uv_loop), +} - unsafe fn close(handle: *libc::c_void, cb: *u8) { - rustrt::rust_uv_close(handle, cb); - } +enum uv_msg { + // requests from library users + msg_run(comm::chan), + msg_run_in_bg(), + msg_async_init(fn~(uv_handle), fn~(uv_handle)), + msg_async_send([u8]), + msg_close(uv_handle, fn~()), + msg_timer_init(fn~(uv_handle)), + msg_timer_start([u8], u32, u32, fn~(uv_handle)), + msg_timer_stop([u8], fn~(uv_handle)), - unsafe fn tcp_init(loop_handle: *libc::c_void, handle: *uv_tcp_t) - -> libc::c_int { - ret rustrt::rust_uv_tcp_init(loop_handle, handle); - } - // FIXME ref #2064 - unsafe fn tcp_connect(connect_ptr: *uv_connect_t, - tcp_handle_ptr: *uv_tcp_t, - addr_ptr: *sockaddr_in, - ++after_connect_cb: *u8) - -> libc::c_int { - let address = *addr_ptr; - io::println(#fmt("b4 native tcp_connect--addr port: %u cb: %u", - address.sin_port as uint, after_connect_cb as uint)); - ret rustrt::rust_uv_tcp_connect(connect_ptr, tcp_handle_ptr, - after_connect_cb, addr_ptr); - } - // FIXME ref #2064 - unsafe fn tcp_bind(tcp_server_ptr: *uv_tcp_t, - addr_ptr: *sockaddr_in) -> libc::c_int { - ret rustrt::rust_uv_tcp_bind(tcp_server_ptr, - addr_ptr); - } + // dispatches from libuv + uv_async_init([u8], *libc::c_void), + uv_async_send([u8]), + uv_close([u8]), + uv_timer_init([u8], *libc::c_void), + uv_timer_call([u8]), + uv_timer_stop([u8], fn~(uv_handle)), + uv_end(), + uv_teardown_check() +} - unsafe fn listen(stream: *libc::c_void, backlog: libc::c_int, - cb: *u8) -> libc::c_int { - ret rustrt::rust_uv_listen(stream, backlog, cb); - } +type uv_loop_data = { + operation_port: comm::port, + rust_loop_chan: comm::chan +}; - unsafe fn accept(server: *libc::c_void, client: *libc::c_void) - -> libc::c_int { - ret rustrt::rust_uv_accept(server, client); - } - - unsafe fn write(req: *libc::c_void, stream: *libc::c_void, - buf_in: *[uv_buf_t], cb: *u8) -> libc::c_int { - let buf_ptr = vec::unsafe::to_ptr(*buf_in); - let buf_cnt = vec::len(*buf_in) as i32; - ret rustrt::rust_uv_write(req, stream, buf_ptr, buf_cnt, cb); - } - unsafe fn read_start(stream: *uv_stream_t, on_alloc: *u8, - on_read: *u8) -> libc::c_int { - ret rustrt::rust_uv_read_start(stream as *libc::c_void, - on_alloc, on_read); - } - - unsafe fn read_stop(stream: *uv_stream_t) -> libc::c_int { - ret rustrt::rust_uv_read_stop(stream as *libc::c_void); - } - - unsafe fn last_error(loop_handle: *libc::c_void) -> uv_err_t { - ret rustrt::rust_uv_last_error(loop_handle); - } - - unsafe fn strerror(err: *uv_err_t) -> *libc::c_char { - ret rustrt::rust_uv_strerror(err); - } - unsafe fn err_name(err: *uv_err_t) -> *libc::c_char { - ret rustrt::rust_uv_err_name(err); - } - - unsafe fn async_init(loop_handle: *libc::c_void, - async_handle: *uv_async_t, - cb: *u8) -> libc::c_int { - ret rustrt::rust_uv_async_init(loop_handle, - async_handle, - cb); - } - - unsafe fn async_send(async_handle: *uv_async_t) { - ret rustrt::rust_uv_async_send(async_handle); - } - - // libuv struct initializers - unsafe fn tcp_t() -> uv_tcp_t { - ret gen_stub_uv_tcp_t(); - } - unsafe fn connect_t() -> uv_connect_t { - ret gen_stub_uv_connect_t(); - } - unsafe fn write_t() -> uv_write_t { - ret gen_stub_uv_write_t(); - } - unsafe fn async_t() -> uv_async_t { - ret gen_stub_uv_async_t(); - } - unsafe fn get_loop_for_uv_handle(handle: *libc::c_void) - -> *libc::c_void { - ret rustrt::rust_uv_get_loop_for_uv_handle(handle); - } - unsafe fn get_stream_handle_from_connect_req(connect: *uv_connect_t) - -> *uv_stream_t { - ret rustrt::rust_uv_get_stream_handle_from_connect_req( - connect); - } - unsafe fn get_stream_handle_from_write_req( - write_req: *uv_write_t) - -> *uv_stream_t { - ret rustrt::rust_uv_get_stream_handle_from_write_req( - write_req); - } - - unsafe fn get_data_for_uv_handle(handle: *libc::c_void) -> *libc::c_void { - ret rustrt::rust_uv_get_data_for_uv_handle(handle); - } - unsafe fn set_data_for_uv_handle(handle: *libc::c_void, - data: *libc::c_void) { - rustrt::rust_uv_set_data_for_uv_handle(handle, data); - } - unsafe fn get_data_for_req(req: *libc::c_void) -> *libc::c_void { - ret rustrt::rust_uv_get_data_for_req(req); - } - unsafe fn set_data_for_req(req: *libc::c_void, - data: *libc::c_void) { - rustrt::rust_uv_set_data_for_req(req, data); - } - unsafe fn get_base_from_buf(buf: uv_buf_t) -> *u8 { - ret rustrt::rust_uv_get_base_from_buf(buf); - } - unsafe fn get_len_from_buf(buf: uv_buf_t) -> libc::size_t { - ret rustrt::rust_uv_get_len_from_buf(buf); - } - unsafe fn buf_init(input: *u8, len: uint) -> uv_buf_t { - ret rustrt::rust_uv_buf_init(input, len); - } - unsafe fn ip4_addr(ip: str, port: int) - -> sockaddr_in { - let mut addr_vec = str::bytes(ip); - addr_vec += [0u8]; // add null terminator - let addr_vec_ptr = vec::unsafe::to_ptr(addr_vec); - let ip_back = str::from_bytes(addr_vec); - io::println(#fmt("vec val: '%s' length: %u", - ip_back, vec::len(addr_vec))); - ret rustrt::rust_uv_ip4_addr(addr_vec_ptr, - port as libc::c_int); - } - unsafe fn malloc_buf_base_of(suggested_size: libc::size_t) - -> *u8 { - ret rustrt::rust_uv_malloc_buf_base_of(suggested_size); - } - unsafe fn free_base_of_buf(buf: uv_buf_t) { - rustrt::rust_uv_free_base_of_buf(buf); - } - - unsafe fn print_last_err_info(uv_loop: *libc::c_void) { - let err = direct::last_error(uv_loop); - let err_ptr = ptr::addr_of(err); - let err_name = str::unsafe::from_c_str(direct::err_name(err_ptr)); - let err_msg = str::unsafe::from_c_str(direct::strerror(err_ptr)); - io::println(#fmt("LIBUV ERROR: name: %s msg: %s", - err_name, err_msg)); - } +enum uv_loop { + uv_loop_new(comm::chan, *libc::c_void) } // public functions @@ -934,7 +474,7 @@ fn pass_to_libuv( do_send(op_handle); } fn do_send(h: *libc::c_void) { - rustrt::rust_uv_async_send(h as *uv_async_t); + rustrt::rust_uv_async_send(h as *ll::uv_async_t); } fn gen_handle_id() -> [u8] { ret rand::rng().gen_bytes(16u); @@ -1162,8 +702,8 @@ enum tcp_read_data { } type request_wrapper = { - write_req: *uv_write_t, - req_buf: *[uv_buf_t], + write_req: *ll::uv_write_t, + req_buf: *[ll::uv_buf_t], read_chan: *comm::chan }; @@ -1172,30 +712,31 @@ crust fn after_close_cb(handle: *libc::c_void) { } crust fn on_alloc_cb(handle: *libc::c_void, - suggested_size: libc::size_t) -> uv_buf_t - unsafe { + suggested_size: libc::size_t) + -> ll::uv_buf_t unsafe { io::println("on_alloc_cb!"); - let char_ptr = direct::malloc_buf_base_of(suggested_size); - ret direct::buf_init(char_ptr, suggested_size); + let char_ptr = ll::malloc_buf_base_of(suggested_size); + ret ll::buf_init(char_ptr, suggested_size); } -crust fn on_read_cb(stream: *uv_stream_t, nread: libc::ssize_t, - ++buf: uv_buf_t) unsafe { +crust fn on_read_cb(stream: *ll::uv_stream_t, + nread: libc::ssize_t, + ++buf: ll::uv_buf_t) unsafe { io::println(#fmt("CLIENT entering on_read_cb nred: %d", nread)); if (nread > 0) { // we have data io::println(#fmt("CLIENT read: data! nread: %d", nread)); - direct::read_stop(stream); - let client_data = direct:: + ll::read_stop(stream); + let client_data = ll:: get_data_for_uv_handle(stream as *libc::c_void) as *request_wrapper; - let buf_base = direct::get_base_from_buf(buf); - let buf_len = direct::get_len_from_buf(buf); + let buf_base = ll::get_base_from_buf(buf); + let buf_len = ll::get_len_from_buf(buf); let bytes = vec::unsafe::from_buf(buf_base, buf_len); let read_chan = *((*client_data).read_chan); let msg_from_server = str::from_bytes(bytes); comm::send(read_chan, msg_from_server); - direct::close(stream as *libc::c_void, after_close_cb) + ll::close(stream as *libc::c_void, after_close_cb) } else if (nread == -1) { // err .. possibly EOF @@ -1206,47 +747,48 @@ crust fn on_read_cb(stream: *uv_stream_t, nread: libc::ssize_t, io::println("read: do nothing!"); } // when we're done - direct::free_base_of_buf(buf); + ll::free_base_of_buf(buf); io::println("CLIENT exiting on_read_cb"); } -crust fn on_write_complete_cb(write_req: *uv_write_t, +crust fn on_write_complete_cb(write_req: *ll::uv_write_t, status: libc::c_int) unsafe { io::println(#fmt("CLIENT beginning on_write_complete_cb status: %d", status as int)); - let stream = direct::get_stream_handle_from_write_req(write_req); + let stream = ll::get_stream_handle_from_write_req(write_req); io::println(#fmt("CLIENT on_write_complete_cb: tcp:%d write_handle:%d", stream as int, write_req as int)); - let result = direct::read_start(stream, on_alloc_cb, on_read_cb); + let result = ll::read_start(stream, on_alloc_cb, on_read_cb); io::println(#fmt("CLIENT ending on_write_complete_cb .. status: %d", result as int)); } -crust fn on_connect_cb(connect_req_ptr: *uv_connect_t, +crust fn on_connect_cb(connect_req_ptr: *ll::uv_connect_t, status: libc::c_int) unsafe { io::println(#fmt("beginning on_connect_cb .. status: %d", status as int)); let stream = - direct::get_stream_handle_from_connect_req(connect_req_ptr); + ll::get_stream_handle_from_connect_req(connect_req_ptr); if (status == 0i32) { io::println("on_connect_cb: in status=0 if.."); - let client_data = direct::get_data_for_req( + let client_data = ll::get_data_for_req( connect_req_ptr as *libc::c_void) as *request_wrapper; let write_handle = (*client_data).write_req as *libc::c_void; io::println(#fmt("on_connect_cb: tcp stream: %d write_handle addr %d", stream as int, write_handle as int)); - let write_result = direct::write(write_handle, + let write_result = ll::write(write_handle, stream as *libc::c_void, (*client_data).req_buf, on_write_complete_cb); - io::println(#fmt("on_connect_cb: direct::write() status: %d", + io::println(#fmt("on_connect_cb: ll::write() status: %d", write_result as int)); } else { - let test_loop = direct::get_loop_for_uv_handle( + let test_loop = ll::get_loop_for_uv_handle( stream as *libc::c_void); - direct::print_last_err_info(test_loop); + let err_msg = ll::get_last_err_info(test_loop); + io::println(err_msg); assert false; } io::println("finishing on_connect_cb"); @@ -1254,10 +796,10 @@ crust fn on_connect_cb(connect_req_ptr: *uv_connect_t, fn impl_uv_tcp_request(ip: str, port: int, req_str: str, client_chan: *comm::chan) unsafe { - let test_loop = direct::loop_new(); - let tcp_handle = direct::tcp_t(); + let test_loop = ll::loop_new(); + let tcp_handle = ll::tcp_t(); let tcp_handle_ptr = ptr::addr_of(tcp_handle); - let connect_handle = direct::connect_t(); + let connect_handle = ll::connect_t(); let connect_req_ptr = ptr::addr_of(connect_handle); // this is the persistent payload of data that we @@ -1268,11 +810,11 @@ fn impl_uv_tcp_request(ip: str, port: int, req_str: str, let req_str_bytes = str::bytes(req_str); let req_msg_ptr: *u8 = vec::unsafe::to_ptr(req_str_bytes); let req_msg = [ - direct::buf_init(req_msg_ptr, vec::len(req_str_bytes)) + ll::buf_init(req_msg_ptr, vec::len(req_str_bytes)) ]; // this is the enclosing record, we'll pass a ptr to // this to C.. - let write_handle = direct::write_t(); + let write_handle = ll::write_t(); let write_handle_ptr = ptr::addr_of(write_handle); io::println(#fmt("tcp req: tcp stream: %d write_handle: %d", tcp_handle_ptr as int, @@ -1281,13 +823,13 @@ fn impl_uv_tcp_request(ip: str, port: int, req_str: str, req_buf: ptr::addr_of(req_msg), read_chan: client_chan }; - let tcp_init_result = direct::tcp_init( + let tcp_init_result = ll::tcp_init( test_loop as *libc::c_void, tcp_handle_ptr); if (tcp_init_result == 0i32) { io::println("sucessful tcp_init_result"); io::println("building addr..."); - let addr = direct::ip4_addr(ip, port); + let addr = ll::ip4_addr(ip, port); // FIXME ref #2064 let addr_ptr = ptr::addr_of(addr); io::println(#fmt("after build addr in rust. port: %u", @@ -1296,32 +838,32 @@ fn impl_uv_tcp_request(ip: str, port: int, req_str: str, // this should set up the connection request.. io::println(#fmt("before calling tcp_connect .. connect cb ptr: %u ", on_connect_cb as uint)); - let tcp_connect_result = direct::tcp_connect( + let tcp_connect_result = ll::tcp_connect( connect_req_ptr, tcp_handle_ptr, addr_ptr, on_connect_cb); if (tcp_connect_result == 0i32) { // not set the data on the connect_req // until its initialized - direct::set_data_for_req( + ll::set_data_for_req( connect_req_ptr as *libc::c_void, ptr::addr_of(client_data) as *libc::c_void); - direct::set_data_for_uv_handle( + ll::set_data_for_uv_handle( tcp_handle_ptr as *libc::c_void, ptr::addr_of(client_data) as *libc::c_void); io::println("before run tcp req loop"); - direct::run(test_loop); + ll::run(test_loop); io::println("after run tcp req loop"); } else { - io::println("direct::tcp_connect() failure"); + io::println("ll::tcp_connect() failure"); assert false; } } else { - io::println("direct::tcp_init() failure"); + io::println("ll::tcp_init() failure"); assert false; } - direct::loop_delete(test_loop); + ll::loop_delete(test_loop); } @@ -1332,38 +874,38 @@ crust fn server_after_close_cb(handle: *libc::c_void) unsafe { crust fn client_stream_after_close_cb(handle: *libc::c_void) unsafe { io::println("SERVER: closed client stream, now closing server stream"); - let client_data = direct::get_data_for_uv_handle( + let client_data = ll::get_data_for_uv_handle( handle) as *tcp_server_data; - direct::close((*client_data).server as *libc::c_void, + ll::close((*client_data).server as *libc::c_void, server_after_close_cb); } -crust fn after_server_resp_write(req: *uv_write_t) unsafe { +crust fn after_server_resp_write(req: *ll::uv_write_t) unsafe { let client_stream_ptr = - direct::get_stream_handle_from_write_req(req); - let client_data = direct::get_data_for_uv_handle( + ll::get_stream_handle_from_write_req(req); + let client_data = ll::get_data_for_uv_handle( client_stream_ptr as *libc::c_void) as *tcp_server_data; io::println("SERVER: resp sent... closing client stream"); - direct::close(client_stream_ptr as *libc::c_void, + ll::close(client_stream_ptr as *libc::c_void, client_stream_after_close_cb) } -crust fn on_server_read_cb(client_stream_ptr: *uv_stream_t, +crust fn on_server_read_cb(client_stream_ptr: *ll::uv_stream_t, nread: libc::ssize_t, - ++buf: uv_buf_t) unsafe { + ++buf: ll::uv_buf_t) unsafe { if (nread > 0) { // we have data io::println(#fmt("SERVER read: data! nread: %d", nread)); // pull out the contents of the write from the client - let buf_base = direct::get_base_from_buf(buf); - let buf_len = direct::get_len_from_buf(buf); + let buf_base = ll::get_base_from_buf(buf); + let buf_len = ll::get_len_from_buf(buf); let bytes = vec::unsafe::from_buf(buf_base, buf_len); let request_str = str::from_bytes(bytes); - let client_data = direct::get_data_for_uv_handle( + let client_data = ll::get_data_for_uv_handle( client_stream_ptr as *libc::c_void) as *tcp_server_data; let server_kill_msg = (*client_data).server_kill_msg; @@ -1371,10 +913,10 @@ crust fn on_server_read_cb(client_stream_ptr: *uv_stream_t, if (str::contains(request_str, server_kill_msg)) { io::println("SERVER: client request contains server_kill_msg!"); io::println("SERVER: sending response to client"); - direct::read_stop(client_stream_ptr); + ll::read_stop(client_stream_ptr); let server_chan = *((*client_data).server_chan); comm::send(server_chan, request_str); - let write_result = direct::write( + let write_result = ll::write( write_req as *libc::c_void, client_stream_ptr as *libc::c_void, (*client_data).server_resp_buf, @@ -1382,10 +924,10 @@ crust fn on_server_read_cb(client_stream_ptr: *uv_stream_t, io::println(#fmt("SERVER: resp write result: %d", write_result as int)); if (write_result != 0i32) { - io::println("bad result for server resp direct::write()"); - direct::print_last_err_info( - direct::get_loop_for_uv_handle(client_stream_ptr - as *libc::c_void)); + io::println("bad result for server resp ll::write()"); + io::println(ll::get_last_err_info( + ll::get_loop_for_uv_handle(client_stream_ptr + as *libc::c_void))); assert false; } } @@ -1402,33 +944,34 @@ crust fn on_server_read_cb(client_stream_ptr: *uv_stream_t, io::println("read: do nothing!"); } // when we're done - direct::free_base_of_buf(buf); + ll::free_base_of_buf(buf); io::println("SERVER exiting on_read_cb"); } -crust fn server_connection_cb(server_stream_ptr: *uv_stream_t, +crust fn server_connection_cb(server_stream_ptr: + *ll::uv_stream_t, status: libc::c_int) unsafe { io::println("client connecting!"); - let test_loop = direct::get_loop_for_uv_handle( + let test_loop = ll::get_loop_for_uv_handle( server_stream_ptr as *libc::c_void); - let server_data = direct::get_data_for_uv_handle( + let server_data = ll::get_data_for_uv_handle( server_stream_ptr as *libc::c_void) as *tcp_server_data; let client_stream_ptr = (*server_data).client; - let client_init_result = direct::tcp_init(test_loop, + let client_init_result = ll::tcp_init(test_loop, client_stream_ptr); - direct::set_data_for_uv_handle( + ll::set_data_for_uv_handle( client_stream_ptr as *libc::c_void, server_data as *libc::c_void); if (client_init_result == 0i32) { io::println("successfully initialized client stream"); - let accept_result = direct::accept(server_stream_ptr as + let accept_result = ll::accept(server_stream_ptr as *libc::c_void, client_stream_ptr as *libc::c_void); if (accept_result == 0i32) { // start reading - let read_result = direct::read_start(client_stream_ptr - as *uv_stream_t, + let read_result = ll::read_start( + client_stream_ptr as *ll::uv_stream_t, on_alloc_cb, on_server_read_cb); if (read_result == 0i32) { @@ -1454,12 +997,12 @@ crust fn server_connection_cb(server_stream_ptr: *uv_stream_t, } type tcp_server_data = { - client: *uv_tcp_t, - server: *uv_tcp_t, + client: *ll::uv_tcp_t, + server: *ll::uv_tcp_t, server_kill_msg: str, - server_resp_buf: *[uv_buf_t], + server_resp_buf: *[ll::uv_buf_t], server_chan: *comm::chan, - server_write_req: *uv_write_t + server_write_req: *ll::uv_write_t }; type async_handle_data = { @@ -1470,17 +1013,17 @@ crust fn async_close_cb(handle: *libc::c_void) { io::println("SERVER: closing async cb..."); } -crust fn continue_async_cb(async_handle: *uv_async_t, +crust fn continue_async_cb(async_handle: *ll::uv_async_t, status: libc::c_int) unsafe { // once we're in the body of this callback, // the tcp server's loop is set up, so we // can continue on to let the tcp client // do its thang - let data = direct::get_data_for_uv_handle( + let data = ll::get_data_for_uv_handle( async_handle as *libc::c_void) as *async_handle_data; let continue_chan = *((*data).continue_chan); comm::send(continue_chan, true); - direct::close(async_handle as *libc::c_void, async_close_cb); + ll::close(async_handle as *libc::c_void, async_close_cb); } fn impl_uv_tcp_server(server_ip: str, @@ -1489,23 +1032,23 @@ fn impl_uv_tcp_server(server_ip: str, server_resp_msg: str, server_chan: *comm::chan, continue_chan: *comm::chan) unsafe { - let test_loop = direct::loop_new(); - let tcp_server = direct::tcp_t(); + let test_loop = ll::loop_new(); + let tcp_server = ll::tcp_t(); let tcp_server_ptr = ptr::addr_of(tcp_server); - let tcp_client = direct::tcp_t(); + let tcp_client = ll::tcp_t(); let tcp_client_ptr = ptr::addr_of(tcp_client); - let server_write_req = direct::write_t(); + let server_write_req = ll::write_t(); let server_write_req_ptr = ptr::addr_of(server_write_req); let resp_str_bytes = str::bytes(server_resp_msg); let resp_msg_ptr: *u8 = vec::unsafe::to_ptr(resp_str_bytes); let resp_msg = [ - direct::buf_init(resp_msg_ptr, vec::len(resp_str_bytes)) + ll::buf_init(resp_msg_ptr, vec::len(resp_str_bytes)) ]; - let continue_async_handle = direct::async_t(); + let continue_async_handle = ll::async_t(); let continue_async_handle_ptr = ptr::addr_of(continue_async_handle); let async_data = @@ -1521,41 +1064,41 @@ fn impl_uv_tcp_server(server_ip: str, server_write_req: server_write_req_ptr }; let server_data_ptr = ptr::addr_of(server_data); - direct::set_data_for_uv_handle(tcp_server_ptr as *libc::c_void, + ll::set_data_for_uv_handle(tcp_server_ptr as *libc::c_void, server_data_ptr as *libc::c_void); // uv_tcp_init() - let tcp_init_result = direct::tcp_init( + let tcp_init_result = ll::tcp_init( test_loop as *libc::c_void, tcp_server_ptr); if (tcp_init_result == 0i32) { - let server_addr = direct::ip4_addr(server_ip, server_port); + let server_addr = ll::ip4_addr(server_ip, server_port); // FIXME ref #2064 let server_addr_ptr = ptr::addr_of(server_addr); // uv_tcp_bind() - let bind_result = direct::tcp_bind(tcp_server_ptr, + let bind_result = ll::tcp_bind(tcp_server_ptr, server_addr_ptr); if (bind_result == 0i32) { io::println("successful uv_tcp_bind, listening"); // uv_listen() - let listen_result = direct::listen(tcp_server_ptr as + let listen_result = ll::listen(tcp_server_ptr as *libc::c_void, 128i32, server_connection_cb); if (listen_result == 0i32) { // let the test know it can set up the tcp server, // now.. this may still present a race, not sure.. - let async_result = direct::async_init(test_loop, + let async_result = ll::async_init(test_loop, continue_async_handle_ptr, continue_async_cb); if (async_result == 0i32) { - direct::set_data_for_uv_handle( + ll::set_data_for_uv_handle( continue_async_handle_ptr as *libc::c_void, async_data_ptr as *libc::c_void); - direct::async_send(continue_async_handle_ptr); + ll::async_send(continue_async_handle_ptr); // uv_run() - direct::run(test_loop); + ll::run(test_loop); io::println("server uv::run() has returned"); } else { @@ -1581,7 +1124,7 @@ fn impl_uv_tcp_server(server_ip: str, tcp_init_result as int)); assert false; } - direct::loop_delete(test_loop); + ll::loop_delete(test_loop); } #[test] @@ -1632,7 +1175,7 @@ fn test_uv_tcp_server_and_request() unsafe { #[ignore(cfg(target_os = "freebsd"))] fn test_uv_struct_size_uv_tcp_t() { let native_handle_size = rustrt::rust_uv_helper_uv_tcp_t_size(); - let rust_handle_size = sys::size_of::(); + let rust_handle_size = sys::size_of::(); let output = #fmt("uv_tcp_t -- native: %u rust: %u", native_handle_size as uint, rust_handle_size); io::println(output); @@ -1643,7 +1186,7 @@ fn test_uv_struct_size_uv_tcp_t() { fn test_uv_struct_size_uv_connect_t() { let native_handle_size = rustrt::rust_uv_helper_uv_connect_t_size(); - let rust_handle_size = sys::size_of::(); + let rust_handle_size = sys::size_of::(); let output = #fmt("uv_connect_t -- native: %u rust: %u", native_handle_size as uint, rust_handle_size); io::println(output); @@ -1654,7 +1197,7 @@ fn test_uv_struct_size_uv_connect_t() { fn test_uv_struct_size_uv_buf_t() { let native_handle_size = rustrt::rust_uv_helper_uv_buf_t_size(); - let rust_handle_size = sys::size_of::(); + let rust_handle_size = sys::size_of::(); let output = #fmt("uv_buf_t -- native: %u rust: %u", native_handle_size as uint, rust_handle_size); io::println(output); @@ -1665,7 +1208,7 @@ fn test_uv_struct_size_uv_buf_t() { fn test_uv_struct_size_uv_write_t() { let native_handle_size = rustrt::rust_uv_helper_uv_write_t_size(); - let rust_handle_size = sys::size_of::(); + let rust_handle_size = sys::size_of::(); let output = #fmt("uv_write_t -- native: %u rust: %u", native_handle_size as uint, rust_handle_size); io::println(output); @@ -1677,7 +1220,7 @@ fn test_uv_struct_size_uv_write_t() { fn test_uv_struct_size_sockaddr_in() { let native_handle_size = rustrt::rust_uv_helper_sockaddr_in_size(); - let rust_handle_size = sys::size_of::(); + let rust_handle_size = sys::size_of::(); let output = #fmt("sockaddr_in -- native: %u rust: %u", native_handle_size as uint, rust_handle_size); io::println(output); @@ -1689,7 +1232,7 @@ fn test_uv_struct_size_sockaddr_in() { fn test_uv_struct_size_uv_async_t() { let native_handle_size = rustrt::rust_uv_helper_uv_async_t_size(); - let rust_handle_size = sys::size_of::(); + let rust_handle_size = sys::size_of::(); let output = #fmt("uv_async_t -- native: %u rust: %u", native_handle_size as uint, rust_handle_size); io::println(output); diff --git a/src/libstd/uv_ll.rs b/src/libstd/uv_ll.rs new file mode 100644 index 000000000000..520298ca5c0d --- /dev/null +++ b/src/libstd/uv_ll.rs @@ -0,0 +1,526 @@ +// libuv struct mappings +type uv_ip4_addr = { + ip: [u8], + port: int +}; +type uv_ip6_addr = uv_ip4_addr; + +enum uv_handle_type { + UNKNOWN_HANDLE = 0, + UV_TCP, + UV_UDP, + UV_NAMED_PIPE, + UV_TTY, + UV_FILE, + UV_TIMER, + UV_PREPARE, + UV_CHECK, + UV_IDLE, + UV_ASYNC, + UV_ARES_TASK, + UV_ARES_EVENT, + UV_PROCESS, + UV_FS_EVENT +} + +type handle_type = libc::c_uint; + +type uv_handle_fields = { + loop_handle: *libc::c_void, + type_: handle_type, + close_cb: *u8, + mut data: *libc::c_void, +}; + +// unix size: 8 +type uv_err_t = { + code: libc::c_int, + sys_errno_: libc::c_int +}; + +// don't create one of these directly. instead, +// count on it appearing in libuv callbacks or embedded +// in other types as a pointer to be used in other +// operations (so mostly treat it as opaque, once you +// have it in this form..) +#[cfg(target_os = "linux")] +#[cfg(target_os = "macos")] +#[cfg(target_os = "freebsd")] +#[cfg(target_os = "win32")] +type uv_stream_t = { + fields: uv_handle_fields +}; + +// unix size: 272 +#[cfg(target_os = "linux")] +#[cfg(target_os = "macos")] +#[cfg(target_os = "freebsd")] +type uv_tcp_t = { + fields: uv_handle_fields, + a00: *u8, a01: *u8, a02: *u8, a03: *u8, + a04: *u8, a05: *u8, a06: *u8, a07: *u8, + a08: *u8, a09: *u8, a10: *u8, a11: *u8, + a12: *u8, a13: *u8, a14: *u8, a15: *u8, + a16: *u8, a17: *u8, a18: *u8, a19: *u8, + a20: *u8, a21: *u8, a22: *u8, a23: *u8, + a24: *u8, a25: *u8, a26: *u8, a27: *u8, + a28: *u8, a29: *u8 +}; +// win32 size: 240 (120) +#[cfg(target_os = "win32")] +type uv_tcp_t = { + fields: uv_handle_fields, + a00: *u8, a01: *u8, a02: *u8, a03: *u8, + a04: *u8, a05: *u8, a06: *u8, a07: *u8, + a08: *u8, a09: *u8, a10: *u8, a11: *u8, + a12: *u8, a13: *u8, a14: *u8, a15: *u8, + a16: *u8, a17: *u8, a18: *u8, a19: *u8, + a20: *u8, a21: *u8, a22: *u8, a23: *u8, + a24: *u8, a25: *u8 +}; + +// unix size: 48 +#[cfg(target_os = "linux")] +#[cfg(target_os = "macos")] +#[cfg(target_os = "freebsd")] +type uv_connect_t = { + a00: *u8, a01: *u8, a02: *u8, a03: *u8, + a04: *u8, a05: *u8 +}; +// win32 size: 88 (44) +#[cfg(target_os = "win32")] +type uv_connect_t = { + a00: *u8, a01: *u8, a02: *u8, a03: *u8, + a04: *u8, a05: *u8, a06: *u8, a07: *u8, + a08: *u8, a09: *u8, a10: *u8 +}; + +// unix size: 16 +#[cfg(target_os = "linux")] +#[cfg(target_os = "macos")] +#[cfg(target_os = "freebsd")] +#[cfg(target_os = "win32")] +type uv_buf_t = { + base: *u8, + len: libc::size_t +}; +// no gen stub method.. should create +// it via uv::direct::buf_init() + +// unix size: 144 +#[cfg(target_os = "linux")] +#[cfg(target_os = "macos")] +#[cfg(target_os = "freebsd")] +type uv_write_t = { + fields: uv_handle_fields, + a00: *u8, a01: *u8, a02: *u8, a03: *u8, + a04: *u8, a05: *u8, a06: *u8, a07: *u8, + a08: *u8, a09: *u8, a10: *u8, a11: *u8, + a12: *u8, a13: *u8 +}; +// win32 size: 136 (68) +#[cfg(target_os = "win32")] +type uv_write_t = { + fields: uv_handle_fields, + a00: *u8, a01: *u8, a02: *u8, a03: *u8, + a04: *u8, a05: *u8, a06: *u8, a07: *u8, + a08: *u8, a09: *u8, a10: *u8, a11: *u8, + a12: *u8 +}; +// unix size: 120 +#[cfg(target_os = "linux")] +#[cfg(target_os = "macos")] +#[cfg(target_os = "freebsd")] +type uv_async_t = { + fields: uv_handle_fields, + a00: *u8, a01: *u8, a02: *u8, a03: *u8, + a04: *u8, a05: *u8, a06: *u8, a07: *u8, + a08: *u8, a09: *u8, a10: *u8 +}; +// win32 size 132 (68) +#[cfg(target_os = "win32")] +type uv_async_t = { + fields: uv_handle_fields, + a00: *u8, a01: *u8, a02: *u8, a03: *u8, + a04: *u8, a05: *u8, a06: *u8, a07: *u8, + a08: *u8, a09: *u8, a10: *u8, a11: *u8, + a12: *u8 +}; + +// unix size: 16 +#[cfg(target_os = "linux")] +#[cfg(target_os = "macos")] +#[cfg(target_os = "freebsd")] +#[cfg(target_os = "win32")] +type sockaddr_in = { + mut sin_family: u16, + mut sin_port: u16, + mut sin_addr: u32, // in_addr: this is an opaque, per-platform struct + mut sin_zero: (u8, u8, u8, u8, u8, u8, u8, u8) +}; + +// unix size: 28 .. make due w/ 32 +#[cfg(target_os = "linux")] +#[cfg(target_os = "macos")] +#[cfg(target_os = "freebsd")] +#[cfg(target_os = "win32")] +type sockaddr_in6 = { + a0: *u8, a1: *u8, + a2: *u8, a3: *u8 +}; + +mod uv_ll_struct_stubgen { + #[cfg(target_os = "linux")] + #[cfg(target_os = "macos")] + #[cfg(target_os = "freebsd")] + fn gen_stub_uv_tcp_t() -> uv_tcp_t { + ret { fields: { loop_handle: ptr::null(), type_: 0u32, + close_cb: ptr::null(), + mut data: ptr::null() }, + a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8, + a03: 0 as *u8, + a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8, + a07: 0 as *u8, + a08: 0 as *u8, a09: 0 as *u8, a10: 0 as *u8, + a11: 0 as *u8, + a12: 0 as *u8, a13: 0 as *u8, a14: 0 as *u8, + a15: 0 as *u8, + a16: 0 as *u8, a17: 0 as *u8, a18: 0 as *u8, + a19: 0 as *u8, + a20: 0 as *u8, a21: 0 as *u8, a22: 0 as *u8, + a23: 0 as *u8, + a24: 0 as *u8, a25: 0 as *u8, a26: 0 as *u8, + a27: 0 as *u8, + a28: 0 as *u8, a29: 0 as *u8 + }; + } + #[cfg(target_os = "win32")] + fn gen_stub_uv_tcp_t() -> uv_tcp_t { + ret { fields: { loop_handle: ptr::null(), type_: 0u32, + close_cb: ptr::null(), + mut data: ptr::null() }, + a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8, + a03: 0 as *u8, + a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8, + a07: 0 as *u8, + a08: 0 as *u8, a09: 0 as *u8, a10: 0 as *u8, + a11: 0 as *u8, + a12: 0 as *u8, a13: 0 as *u8, a14: 0 as *u8, + a15: 0 as *u8, + a16: 0 as *u8, a17: 0 as *u8, a18: 0 as *u8, + a19: 0 as *u8, + a20: 0 as *u8, a21: 0 as *u8, a22: 0 as *u8, + a23: 0 as *u8, + a24: 0 as *u8, a25: 0 as *u8 + }; + } + #[cfg(target_os = "linux")] + #[cfg(target_os = "macos")] + #[cfg(target_os = "freebsd")] + fn gen_stub_uv_connect_t() -> uv_connect_t { + ret { + a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8, + a03: 0 as *u8, + a04: 0 as *u8, a05: 0 as *u8 + }; + } + #[cfg(target_os = "win32")] + fn gen_stub_uv_connect_t() -> uv_connect_t { + ret { + a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8, + a03: 0 as *u8, + a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8, + a07: 0 as *u8, + a08: 0 as *u8, a09: 0 as *u8, a10: 0 as *u8 + }; + } + #[cfg(target_os = "linux")] + #[cfg(target_os = "macos")] + #[cfg(target_os = "freebsd")] + fn gen_stub_uv_async_t() -> uv_async_t { + ret { fields: { loop_handle: ptr::null(), type_: 0u32, + close_cb: ptr::null(), + mut data: ptr::null() }, + a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8, + a03: 0 as *u8, + a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8, + a07: 0 as *u8, + a08: 0 as *u8, a09: 0 as *u8, a10: 0 as *u8 + }; + } + #[cfg(target_os = "win32")] + fn gen_stub_uv_async_t() -> uv_async_t { + ret { fields: { loop_handle: ptr::null(), type_: 0u32, + close_cb: ptr::null(), + mut data: ptr::null() }, + a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8, + a03: 0 as *u8, + a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8, + a07: 0 as *u8, + a08: 0 as *u8, a09: 0 as *u8, a10: 0 as *u8, + a11: 0 as *u8, + a12: 0 as *u8 + }; + } + #[cfg(target_os = "linux")] + #[cfg(target_os = "macos")] + #[cfg(target_os = "freebsd")] + fn gen_stub_uv_write_t() -> uv_write_t { + ret { fields: { loop_handle: ptr::null(), type_: 0u32, + close_cb: ptr::null(), + mut data: ptr::null() }, + a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8, + a03: 0 as *u8, + a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8, + a07: 0 as *u8, + a08: 0 as *u8, a09: 0 as *u8, a10: 0 as *u8, + a11: 0 as *u8, + a12: 0 as *u8, a13: 0 as *u8 + }; + } + #[cfg(target_os = "win32")] + fn gen_stub_uv_write_t() -> uv_write_t { + ret { fields: { loop_handle: ptr::null(), type_: 0u32, + close_cb: ptr::null(), + mut data: ptr::null() }, + a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8, + a03: 0 as *u8, + a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8, + a07: 0 as *u8, + a08: 0 as *u8, a09: 0 as *u8, a10: 0 as *u8, + a11: 0 as *u8, + a12: 0 as *u8 + }; + } +} + +#[nolink] +native mod rustrt { + fn rust_uv_loop_new() -> *libc::c_void; + fn rust_uv_loop_delete(lp: *libc::c_void); + fn rust_uv_run(loop_handle: *libc::c_void); + fn rust_uv_close(handle: *libc::c_void, cb: *u8); + fn rust_uv_async_send(handle: *uv_async_t); + fn rust_uv_async_init(loop_handle: *libc::c_void, + async_handle: *uv_async_t, + cb: *u8) -> libc::c_int; + fn rust_uv_tcp_init( + loop_handle: *libc::c_void, + handle_ptr: *uv_tcp_t) -> libc::c_int; + fn rust_uv_buf_init(base: *u8, len: libc::size_t) + -> uv_buf_t; + fn rust_uv_last_error(loop_handle: *libc::c_void) -> uv_err_t; + // FIXME ref #2064 + fn rust_uv_strerror(err: *uv_err_t) -> *libc::c_char; + // FIXME ref #2064 + fn rust_uv_err_name(err: *uv_err_t) -> *libc::c_char; + fn rust_uv_ip4_addr(ip: *u8, port: libc::c_int) + -> sockaddr_in; + // FIXME ref #2064 + fn rust_uv_tcp_connect(connect_ptr: *uv_connect_t, + tcp_handle_ptr: *uv_tcp_t, + ++after_cb: *u8, + ++addr: *sockaddr_in) -> libc::c_int; + // FIXME ref 2064 + fn rust_uv_tcp_bind(tcp_server: *uv_tcp_t, + ++addr: *sockaddr_in) -> libc::c_int; + fn rust_uv_listen(stream: *libc::c_void, backlog: libc::c_int, + cb: *u8) -> libc::c_int; + fn rust_uv_accept(server: *libc::c_void, client: *libc::c_void) + -> libc::c_int; + fn rust_uv_write(req: *libc::c_void, stream: *libc::c_void, + ++buf_in: *uv_buf_t, buf_cnt: libc::c_int, + cb: *u8) -> libc::c_int; + fn rust_uv_read_start(stream: *libc::c_void, on_alloc: *u8, + on_read: *u8) -> libc::c_int; + fn rust_uv_read_stop(stream: *libc::c_void) -> libc::c_int; + fn rust_uv_malloc_buf_base_of(sug_size: libc::size_t) -> *u8; + fn rust_uv_free_base_of_buf(++buf: uv_buf_t); + + // data accessors for rust-mapped uv structs + fn rust_uv_get_stream_handle_from_connect_req( + connect_req: *uv_connect_t) + -> *uv_stream_t; + fn rust_uv_get_stream_handle_from_write_req( + write_req: *uv_write_t) + -> *uv_stream_t; + fn rust_uv_get_loop_for_uv_handle(handle: *libc::c_void) + -> *libc::c_void; + fn rust_uv_get_data_for_uv_handle(handle: *libc::c_void) + -> *libc::c_void; + fn rust_uv_set_data_for_uv_handle(handle: *libc::c_void, + data: *libc::c_void); + fn rust_uv_get_data_for_req(req: *libc::c_void) -> *libc::c_void; + fn rust_uv_set_data_for_req(req: *libc::c_void, + data: *libc::c_void); + fn rust_uv_get_base_from_buf(++buf: uv_buf_t) -> *u8; + fn rust_uv_get_len_from_buf(++buf: uv_buf_t) -> libc::size_t; +} + +unsafe fn loop_new() -> *libc::c_void { + ret rustrt::rust_uv_loop_new(); +} + +unsafe fn loop_delete(loop_handle: *libc::c_void) { + rustrt::rust_uv_loop_delete(loop_handle); +} + +unsafe fn run(loop_handle: *libc::c_void) { + rustrt::rust_uv_run(loop_handle); +} + +unsafe fn close(handle: *libc::c_void, cb: *u8) { + rustrt::rust_uv_close(handle, cb); +} + +unsafe fn tcp_init(loop_handle: *libc::c_void, handle: *uv_tcp_t) + -> libc::c_int { + ret rustrt::rust_uv_tcp_init(loop_handle, handle); +} +// FIXME ref #2064 +unsafe fn tcp_connect(connect_ptr: *uv_connect_t, + tcp_handle_ptr: *uv_tcp_t, + addr_ptr: *sockaddr_in, + ++after_connect_cb: *u8) +-> libc::c_int { + let address = *addr_ptr; + io::println(#fmt("b4 native tcp_connect--addr port: %u cb: %u", + address.sin_port as uint, after_connect_cb as uint)); + ret rustrt::rust_uv_tcp_connect(connect_ptr, tcp_handle_ptr, + after_connect_cb, addr_ptr); +} +// FIXME ref #2064 +unsafe fn tcp_bind(tcp_server_ptr: *uv_tcp_t, + addr_ptr: *sockaddr_in) -> libc::c_int { + ret rustrt::rust_uv_tcp_bind(tcp_server_ptr, + addr_ptr); +} + +unsafe fn listen(stream: *libc::c_void, backlog: libc::c_int, + cb: *u8) -> libc::c_int { + ret rustrt::rust_uv_listen(stream, backlog, cb); +} + +unsafe fn accept(server: *libc::c_void, client: *libc::c_void) + -> libc::c_int { + ret rustrt::rust_uv_accept(server, client); +} + +unsafe fn write(req: *libc::c_void, stream: *libc::c_void, + buf_in: *[uv_buf_t], cb: *u8) -> libc::c_int { + let buf_ptr = vec::unsafe::to_ptr(*buf_in); + let buf_cnt = vec::len(*buf_in) as i32; + ret rustrt::rust_uv_write(req, stream, buf_ptr, buf_cnt, cb); +} +unsafe fn read_start(stream: *uv_stream_t, on_alloc: *u8, + on_read: *u8) -> libc::c_int { + ret rustrt::rust_uv_read_start(stream as *libc::c_void, + on_alloc, on_read); +} + +unsafe fn read_stop(stream: *uv_stream_t) -> libc::c_int { + ret rustrt::rust_uv_read_stop(stream as *libc::c_void); +} + +unsafe fn last_error(loop_handle: *libc::c_void) -> uv_err_t { + ret rustrt::rust_uv_last_error(loop_handle); +} + +unsafe fn strerror(err: *uv_err_t) -> *libc::c_char { + ret rustrt::rust_uv_strerror(err); +} +unsafe fn err_name(err: *uv_err_t) -> *libc::c_char { + ret rustrt::rust_uv_err_name(err); +} + +unsafe fn async_init(loop_handle: *libc::c_void, + async_handle: *uv_async_t, + cb: *u8) -> libc::c_int { + ret rustrt::rust_uv_async_init(loop_handle, + async_handle, + cb); +} + +unsafe fn async_send(async_handle: *uv_async_t) { + ret rustrt::rust_uv_async_send(async_handle); +} + +// libuv struct initializers +unsafe fn tcp_t() -> uv_tcp_t { + ret uv_ll_struct_stubgen::gen_stub_uv_tcp_t(); +} +unsafe fn connect_t() -> uv_connect_t { + ret uv_ll_struct_stubgen::gen_stub_uv_connect_t(); +} +unsafe fn write_t() -> uv_write_t { + ret uv_ll_struct_stubgen::gen_stub_uv_write_t(); +} +unsafe fn async_t() -> uv_async_t { + ret uv_ll_struct_stubgen::gen_stub_uv_async_t(); +} +unsafe fn get_loop_for_uv_handle(handle: *libc::c_void) + -> *libc::c_void { + ret rustrt::rust_uv_get_loop_for_uv_handle(handle); +} +unsafe fn get_stream_handle_from_connect_req(connect: *uv_connect_t) + -> *uv_stream_t { + ret rustrt::rust_uv_get_stream_handle_from_connect_req( + connect); +} +unsafe fn get_stream_handle_from_write_req( + write_req: *uv_write_t) + -> *uv_stream_t { + ret rustrt::rust_uv_get_stream_handle_from_write_req( + write_req); +} + +unsafe fn get_data_for_uv_handle(handle: *libc::c_void) -> *libc::c_void { + ret rustrt::rust_uv_get_data_for_uv_handle(handle); +} +unsafe fn set_data_for_uv_handle(handle: *libc::c_void, + data: *libc::c_void) { + rustrt::rust_uv_set_data_for_uv_handle(handle, data); +} +unsafe fn get_data_for_req(req: *libc::c_void) -> *libc::c_void { + ret rustrt::rust_uv_get_data_for_req(req); +} +unsafe fn set_data_for_req(req: *libc::c_void, + data: *libc::c_void) { + rustrt::rust_uv_set_data_for_req(req, data); +} +unsafe fn get_base_from_buf(buf: uv_buf_t) -> *u8 { + ret rustrt::rust_uv_get_base_from_buf(buf); +} +unsafe fn get_len_from_buf(buf: uv_buf_t) -> libc::size_t { + ret rustrt::rust_uv_get_len_from_buf(buf); +} +unsafe fn buf_init(input: *u8, len: uint) -> uv_buf_t { + ret rustrt::rust_uv_buf_init(input, len); +} +unsafe fn ip4_addr(ip: str, port: int) +-> sockaddr_in { + let mut addr_vec = str::bytes(ip); + addr_vec += [0u8]; // add null terminator + let addr_vec_ptr = vec::unsafe::to_ptr(addr_vec); + let ip_back = str::from_bytes(addr_vec); + io::println(#fmt("vec val: '%s' length: %u", + ip_back, vec::len(addr_vec))); + ret rustrt::rust_uv_ip4_addr(addr_vec_ptr, + port as libc::c_int); +} +unsafe fn malloc_buf_base_of(suggested_size: libc::size_t) + -> *u8 { + ret rustrt::rust_uv_malloc_buf_base_of(suggested_size); +} +unsafe fn free_base_of_buf(buf: uv_buf_t) { + rustrt::rust_uv_free_base_of_buf(buf); +} + +unsafe fn get_last_err_info(uv_loop: *libc::c_void) -> str { + let err = last_error(uv_loop); + let err_ptr = ptr::addr_of(err); + let err_name = str::unsafe::from_c_str(err_name(err_ptr)); + let err_msg = str::unsafe::from_c_str(strerror(err_ptr)); + ret #fmt("LIBUV ERROR: name: %s msg: %s", + err_name, err_msg); +} \ No newline at end of file