1 // Copyright 2012 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
12 * Low-level bindings to the libuv library.
14 * This module contains a set of direct, 'bare-metal' wrappers around
17 * We're not bothering yet to redefine uv's structs as Rust structs
18 * because they are quite large and change often between versions.
19 * The maintenance burden is just too high. Instead we use the uv's
20 * `uv_handle_size` and `uv_req_size` to find the correct size of the
21 * structs and allocate them on the heap. This can be revisited later.
23 * There are also a collection of helper functions to ease interacting
24 * with the low-level API.
26 * As new functionality, existant in uv.h, is added to the rust stdlib,
27 * the mappings should be added in this module.
30 #[allow(non_camel_case_types)]; // C types
32 use libc::{size_t, c_int, c_uint, c_void, c_char, uintptr_t};
33 use libc::{malloc, free};
40 pub static UNKNOWN: c_int = -1;
41 pub static OK: c_int = 0;
42 pub static EOF: c_int = 1;
43 pub static EADDRINFO: c_int = 2;
44 pub static EACCES: c_int = 3;
45 pub static ECONNREFUSED: c_int = 12;
46 pub static ECONNRESET: c_int = 13;
47 pub static EPIPE: c_int = 36;
59 pub type uv_handle_t = c_void;
60 pub type uv_loop_t = c_void;
61 pub type uv_idle_t = c_void;
62 pub type uv_tcp_t = c_void;
63 pub type uv_udp_t = c_void;
64 pub type uv_connect_t = c_void;
65 pub type uv_write_t = c_void;
66 pub type uv_async_t = c_void;
67 pub type uv_timer_t = c_void;
68 pub type uv_stream_t = c_void;
69 pub type uv_fs_t = c_void;
70 pub type uv_udp_send_t = c_void;
72 pub type uv_idle_cb = *u8;
73 pub type uv_alloc_cb = *u8;
74 pub type uv_udp_send_cb = *u8;
75 pub type uv_udp_recv_cb = *u8;
77 pub type sockaddr = c_void;
78 pub type sockaddr_in = c_void;
79 pub type sockaddr_in6 = c_void;
80 pub type uv_membership = c_void;
83 pub enum uv_handle_type {
106 pub enum uv_req_type {
119 pub unsafe fn malloc_handle(handle: uv_handle_type) -> *c_void {
120 assert!(handle != UV_UNKNOWN_HANDLE && handle != UV_HANDLE_TYPE_MAX);
121 let size = rust_uv_handle_size(handle as uint);
122 let p = malloc(size);
123 assert!(p.is_not_null());
127 pub unsafe fn free_handle(v: *c_void) {
131 pub unsafe fn malloc_req(req: uv_req_type) -> *c_void {
132 assert!(req != UV_UNKNOWN_REQ && req != UV_REQ_TYPE_MAX);
133 let size = rust_uv_req_size(req as uint);
134 let p = malloc(size);
135 assert!(p.is_not_null());
139 pub unsafe fn free_req(v: *c_void) {
144 fn handle_sanity_check() {
146 assert_eq!(UV_HANDLE_TYPE_MAX as uint, rust_uv_handle_type_max());
151 fn request_sanity_check() {
153 assert_eq!(UV_REQ_TYPE_MAX as uint, rust_uv_req_type_max());
157 pub unsafe fn loop_new() -> *c_void {
158 return rust_uv_loop_new();
161 pub unsafe fn loop_delete(loop_handle: *c_void) {
162 rust_uv_loop_delete(loop_handle);
165 pub unsafe fn run(loop_handle: *c_void) {
166 rust_uv_run(loop_handle);
169 pub unsafe fn close<T>(handle: *T, cb: *u8) {
170 rust_uv_close(handle as *c_void, cb);
173 pub unsafe fn walk(loop_handle: *c_void, cb: *u8, arg: *c_void) {
174 rust_uv_walk(loop_handle, cb, arg);
177 pub unsafe fn idle_new() -> *uv_idle_t {
181 pub unsafe fn idle_delete(handle: *uv_idle_t) {
182 rust_uv_idle_delete(handle)
185 pub unsafe fn idle_init(loop_handle: *uv_loop_t, handle: *uv_idle_t) -> c_int {
186 rust_uv_idle_init(loop_handle, handle)
189 pub unsafe fn idle_start(handle: *uv_idle_t, cb: uv_idle_cb) -> c_int {
190 rust_uv_idle_start(handle, cb)
193 pub unsafe fn idle_stop(handle: *uv_idle_t) -> c_int {
194 rust_uv_idle_stop(handle)
197 pub unsafe fn udp_init(loop_handle: *uv_loop_t, handle: *uv_udp_t) -> c_int {
198 return rust_uv_udp_init(loop_handle, handle);
201 pub unsafe fn udp_bind(server: *uv_udp_t, addr: *sockaddr_in, flags: c_uint) -> c_int {
202 return rust_uv_udp_bind(server, addr, flags);
205 pub unsafe fn udp_bind6(server: *uv_udp_t, addr: *sockaddr_in6, flags: c_uint) -> c_int {
206 return rust_uv_udp_bind6(server, addr, flags);
209 pub unsafe fn udp_send<T>(req: *uv_udp_send_t, handle: *T, buf_in: &[uv_buf_t],
210 addr: *sockaddr_in, cb: uv_udp_send_cb) -> c_int {
211 let buf_ptr = vec::raw::to_ptr(buf_in);
212 let buf_cnt = buf_in.len() as i32;
213 return rust_uv_udp_send(req, handle as *c_void, buf_ptr, buf_cnt, addr, cb);
216 pub unsafe fn udp_send6<T>(req: *uv_udp_send_t, handle: *T, buf_in: &[uv_buf_t],
217 addr: *sockaddr_in6, cb: uv_udp_send_cb) -> c_int {
218 let buf_ptr = vec::raw::to_ptr(buf_in);
219 let buf_cnt = buf_in.len() as i32;
220 return rust_uv_udp_send6(req, handle as *c_void, buf_ptr, buf_cnt, addr, cb);
223 pub unsafe fn udp_recv_start(server: *uv_udp_t, on_alloc: uv_alloc_cb,
224 on_recv: uv_udp_recv_cb) -> c_int {
225 return rust_uv_udp_recv_start(server, on_alloc, on_recv);
228 pub unsafe fn udp_recv_stop(server: *uv_udp_t) -> c_int {
229 return rust_uv_udp_recv_stop(server);
232 pub unsafe fn get_udp_handle_from_send_req(send_req: *uv_udp_send_t) -> *uv_udp_t {
233 return rust_uv_get_udp_handle_from_send_req(send_req);
236 pub unsafe fn udp_get_sockname(handle: *uv_udp_t, name: *sockaddr_in) -> c_int {
237 return rust_uv_udp_getsockname(handle, name);
240 pub unsafe fn udp_get_sockname6(handle: *uv_udp_t, name: *sockaddr_in6) -> c_int {
241 return rust_uv_udp_getsockname6(handle, name);
244 pub unsafe fn udp_set_membership(handle: *uv_udp_t, multicast_addr: *c_char,
245 interface_addr: *c_char, membership: uv_membership) -> c_int {
246 return rust_uv_udp_set_membership(handle, multicast_addr, interface_addr, membership);
249 pub unsafe fn udp_set_multicast_loop(handle: *uv_udp_t, on: c_int) -> c_int {
250 return rust_uv_udp_set_multicast_loop(handle, on);
253 pub unsafe fn udp_set_multicast_ttl(handle: *uv_udp_t, ttl: c_int) -> c_int {
254 return rust_uv_udp_set_multicast_ttl(handle, ttl);
257 pub unsafe fn udp_set_broadcast(handle: *uv_udp_t, on: c_int) -> c_int {
258 return rust_uv_udp_set_broadcast(handle, on);
261 pub unsafe fn tcp_init(loop_handle: *c_void, handle: *uv_tcp_t) -> c_int {
262 return rust_uv_tcp_init(loop_handle, handle);
265 pub unsafe fn tcp_connect(connect_ptr: *uv_connect_t, tcp_handle_ptr: *uv_tcp_t,
266 addr_ptr: *sockaddr_in, after_connect_cb: *u8) -> c_int {
267 return rust_uv_tcp_connect(connect_ptr, tcp_handle_ptr, after_connect_cb, addr_ptr);
270 pub unsafe fn tcp_connect6(connect_ptr: *uv_connect_t, tcp_handle_ptr: *uv_tcp_t,
271 addr_ptr: *sockaddr_in6, after_connect_cb: *u8) -> c_int {
272 return rust_uv_tcp_connect6(connect_ptr, tcp_handle_ptr, after_connect_cb, addr_ptr);
275 pub unsafe fn tcp_bind(tcp_server_ptr: *uv_tcp_t, addr_ptr: *sockaddr_in) -> c_int {
276 return rust_uv_tcp_bind(tcp_server_ptr, addr_ptr);
279 pub unsafe fn tcp_bind6(tcp_server_ptr: *uv_tcp_t, addr_ptr: *sockaddr_in6) -> c_int {
280 return rust_uv_tcp_bind6(tcp_server_ptr, addr_ptr);
283 pub unsafe fn tcp_getpeername(tcp_handle_ptr: *uv_tcp_t, name: *sockaddr_in) -> c_int {
284 return rust_uv_tcp_getpeername(tcp_handle_ptr, name);
287 pub unsafe fn tcp_getpeername6(tcp_handle_ptr: *uv_tcp_t, name: *sockaddr_in6) ->c_int {
288 return rust_uv_tcp_getpeername6(tcp_handle_ptr, name);
291 pub unsafe fn tcp_getsockname(handle: *uv_tcp_t, name: *sockaddr_in) -> c_int {
292 return rust_uv_tcp_getsockname(handle, name);
295 pub unsafe fn tcp_getsockname6(handle: *uv_tcp_t, name: *sockaddr_in6) -> c_int {
296 return rust_uv_tcp_getsockname6(handle, name);
299 pub unsafe fn tcp_nodelay(handle: *uv_tcp_t, enable: c_int) -> c_int {
300 return rust_uv_tcp_nodelay(handle, enable);
303 pub unsafe fn tcp_keepalive(handle: *uv_tcp_t, enable: c_int, delay: c_uint) -> c_int {
304 return rust_uv_tcp_keepalive(handle, enable, delay);
307 pub unsafe fn tcp_simultaneous_accepts(handle: *uv_tcp_t, enable: c_int) -> c_int {
308 return rust_uv_tcp_simultaneous_accepts(handle, enable);
311 pub unsafe fn listen<T>(stream: *T, backlog: c_int, cb: *u8) -> c_int {
312 return rust_uv_listen(stream as *c_void, backlog, cb);
315 pub unsafe fn accept(server: *c_void, client: *c_void) -> c_int {
316 return rust_uv_accept(server as *c_void, client as *c_void);
319 pub unsafe fn write<T>(req: *uv_write_t, stream: *T, buf_in: &[uv_buf_t], cb: *u8) -> c_int {
320 let buf_ptr = vec::raw::to_ptr(buf_in);
321 let buf_cnt = buf_in.len() as i32;
322 return rust_uv_write(req as *c_void, stream as *c_void, buf_ptr, buf_cnt, cb);
324 pub unsafe fn read_start(stream: *uv_stream_t, on_alloc: uv_alloc_cb, on_read: *u8) -> c_int {
325 return rust_uv_read_start(stream as *c_void, on_alloc, on_read);
328 pub unsafe fn read_stop(stream: *uv_stream_t) -> c_int {
329 return rust_uv_read_stop(stream as *c_void);
332 pub unsafe fn last_error(loop_handle: *c_void) -> uv_err_t {
333 return rust_uv_last_error(loop_handle);
336 pub unsafe fn strerror(err: *uv_err_t) -> *c_char {
337 return rust_uv_strerror(err);
339 pub unsafe fn err_name(err: *uv_err_t) -> *c_char {
340 return rust_uv_err_name(err);
343 pub unsafe fn async_init(loop_handle: *c_void, async_handle: *uv_async_t, cb: *u8) -> c_int {
344 return rust_uv_async_init(loop_handle, async_handle, cb);
347 pub unsafe fn async_send(async_handle: *uv_async_t) {
348 return rust_uv_async_send(async_handle);
350 pub unsafe fn buf_init(input: *u8, len: uint) -> uv_buf_t {
351 let out_buf = uv_buf_t { base: ptr::null(), len: 0 as size_t };
352 let out_buf_ptr = ptr::to_unsafe_ptr(&out_buf);
353 rust_uv_buf_init(out_buf_ptr, input, len as size_t);
357 pub unsafe fn timer_init(loop_ptr: *c_void, timer_ptr: *uv_timer_t) -> c_int {
358 return rust_uv_timer_init(loop_ptr, timer_ptr);
360 pub unsafe fn timer_start(timer_ptr: *uv_timer_t, cb: *u8, timeout: u64,
361 repeat: u64) -> c_int {
362 return rust_uv_timer_start(timer_ptr, cb, timeout, repeat);
364 pub unsafe fn timer_stop(timer_ptr: *uv_timer_t) -> c_int {
365 return rust_uv_timer_stop(timer_ptr);
368 pub unsafe fn is_ip4_addr(addr: *sockaddr) -> bool {
369 match rust_uv_is_ipv4_sockaddr(addr) { 0 => false, _ => true }
372 pub unsafe fn is_ip6_addr(addr: *sockaddr) -> bool {
373 match rust_uv_is_ipv6_sockaddr(addr) { 0 => false, _ => true }
376 pub unsafe fn as_sockaddr_in(addr: *sockaddr) -> *sockaddr_in {
377 return rust_uv_sockaddr_as_sockaddr_in(addr);
380 pub unsafe fn as_sockaddr_in6(addr: *sockaddr) -> *sockaddr_in6 {
381 return rust_uv_sockaddr_as_sockaddr_in6(addr);
384 pub unsafe fn malloc_ip4_addr(ip: &str, port: int) -> *sockaddr_in {
385 do ip.as_c_str |ip_buf| {
386 rust_uv_ip4_addrp(ip_buf as *u8, port as libc::c_int)
389 pub unsafe fn malloc_ip6_addr(ip: &str, port: int) -> *sockaddr_in6 {
390 do ip.as_c_str |ip_buf| {
391 rust_uv_ip6_addrp(ip_buf as *u8, port as libc::c_int)
395 pub unsafe fn free_ip4_addr(addr: *sockaddr_in) {
396 rust_uv_free_ip4_addr(addr);
399 pub unsafe fn free_ip6_addr(addr: *sockaddr_in6) {
400 rust_uv_free_ip6_addr(addr);
403 pub unsafe fn ip4_name(addr: *sockaddr_in, dst: *u8, size: size_t) -> c_int {
404 return rust_uv_ip4_name(addr, dst, size);
407 pub unsafe fn ip6_name(addr: *sockaddr_in6, dst: *u8, size: size_t) -> c_int {
408 return rust_uv_ip6_name(addr, dst, size);
411 pub unsafe fn ip4_port(addr: *sockaddr_in) -> c_uint {
412 return rust_uv_ip4_port(addr);
415 pub unsafe fn ip6_port(addr: *sockaddr_in6) -> c_uint {
416 return rust_uv_ip6_port(addr);
419 // data access helpers
420 pub unsafe fn get_loop_for_uv_handle<T>(handle: *T) -> *c_void {
421 return rust_uv_get_loop_for_uv_handle(handle as *c_void);
423 pub unsafe fn get_stream_handle_from_connect_req(connect: *uv_connect_t) -> *uv_stream_t {
424 return rust_uv_get_stream_handle_from_connect_req(connect);
426 pub unsafe fn get_stream_handle_from_write_req(write_req: *uv_write_t) -> *uv_stream_t {
427 return rust_uv_get_stream_handle_from_write_req(write_req);
429 pub unsafe fn get_data_for_uv_loop(loop_ptr: *c_void) -> *c_void {
430 rust_uv_get_data_for_uv_loop(loop_ptr)
432 pub unsafe fn set_data_for_uv_loop(loop_ptr: *c_void, data: *c_void) {
433 rust_uv_set_data_for_uv_loop(loop_ptr, data);
435 pub unsafe fn get_data_for_uv_handle<T>(handle: *T) -> *c_void {
436 return rust_uv_get_data_for_uv_handle(handle as *c_void);
438 pub unsafe fn set_data_for_uv_handle<T, U>(handle: *T, data: *U) {
439 rust_uv_set_data_for_uv_handle(handle as *c_void, data as *c_void);
441 pub unsafe fn get_data_for_req<T>(req: *T) -> *c_void {
442 return rust_uv_get_data_for_req(req as *c_void);
444 pub unsafe fn set_data_for_req<T, U>(req: *T, data: *U) {
445 rust_uv_set_data_for_req(req as *c_void, data as *c_void);
447 pub unsafe fn get_base_from_buf(buf: uv_buf_t) -> *u8 {
448 return rust_uv_get_base_from_buf(buf);
450 pub unsafe fn get_len_from_buf(buf: uv_buf_t) -> size_t {
451 return rust_uv_get_len_from_buf(buf);
453 pub unsafe fn malloc_buf_base_of(suggested_size: size_t) -> *u8 {
454 return rust_uv_malloc_buf_base_of(suggested_size);
456 pub unsafe fn free_base_of_buf(buf: uv_buf_t) {
457 rust_uv_free_base_of_buf(buf);
460 pub unsafe fn get_last_err_info(uv_loop: *c_void) -> ~str {
461 let err = last_error(uv_loop);
462 let err_ptr = ptr::to_unsafe_ptr(&err);
463 let err_name = str::raw::from_c_str(err_name(err_ptr));
464 let err_msg = str::raw::from_c_str(strerror(err_ptr));
465 return fmt!("LIBUV ERROR: name: %s msg: %s",
469 pub unsafe fn get_last_err_data(uv_loop: *c_void) -> uv_err_data {
470 let err = last_error(uv_loop);
471 let err_ptr = ptr::to_unsafe_ptr(&err);
472 let err_name = str::raw::from_c_str(err_name(err_ptr));
473 let err_msg = str::raw::from_c_str(strerror(err_ptr));
474 uv_err_data { err_name: err_name, err_msg: err_msg }
477 pub struct uv_err_data {
484 fn rust_uv_handle_size(type_: uintptr_t) -> size_t;
485 fn rust_uv_req_size(type_: uintptr_t) -> size_t;
486 fn rust_uv_handle_type_max() -> uintptr_t;
487 fn rust_uv_req_type_max() -> uintptr_t;
490 fn rust_uv_loop_new() -> *c_void;
491 fn rust_uv_loop_delete(lp: *c_void);
492 fn rust_uv_run(loop_handle: *c_void);
493 fn rust_uv_close(handle: *c_void, cb: *u8);
494 fn rust_uv_walk(loop_handle: *c_void, cb: *u8, arg: *c_void);
496 fn rust_uv_idle_new() -> *uv_idle_t;
497 fn rust_uv_idle_delete(handle: *uv_idle_t);
498 fn rust_uv_idle_init(loop_handle: *uv_loop_t, handle: *uv_idle_t) -> c_int;
499 fn rust_uv_idle_start(handle: *uv_idle_t, cb: uv_idle_cb) -> c_int;
500 fn rust_uv_idle_stop(handle: *uv_idle_t) -> c_int;
502 fn rust_uv_async_send(handle: *uv_async_t);
503 fn rust_uv_async_init(loop_handle: *c_void, async_handle: *uv_async_t, cb: *u8) -> c_int;
504 fn rust_uv_tcp_init(loop_handle: *c_void, handle_ptr: *uv_tcp_t) -> c_int;
505 fn rust_uv_buf_init(out_buf: *uv_buf_t, base: *u8, len: size_t);
506 fn rust_uv_last_error(loop_handle: *c_void) -> uv_err_t;
507 fn rust_uv_strerror(err: *uv_err_t) -> *c_char;
508 fn rust_uv_err_name(err: *uv_err_t) -> *c_char;
509 fn rust_uv_ip4_addrp(ip: *u8, port: c_int) -> *sockaddr_in;
510 fn rust_uv_ip6_addrp(ip: *u8, port: c_int) -> *sockaddr_in6;
511 fn rust_uv_free_ip4_addr(addr: *sockaddr_in);
512 fn rust_uv_free_ip6_addr(addr: *sockaddr_in6);
513 fn rust_uv_ip4_name(src: *sockaddr_in, dst: *u8, size: size_t) -> c_int;
514 fn rust_uv_ip6_name(src: *sockaddr_in6, dst: *u8, size: size_t) -> c_int;
515 fn rust_uv_ip4_port(src: *sockaddr_in) -> c_uint;
516 fn rust_uv_ip6_port(src: *sockaddr_in6) -> c_uint;
517 fn rust_uv_tcp_connect(req: *uv_connect_t, handle: *uv_tcp_t, cb: *u8,
518 addr: *sockaddr_in) -> c_int;
519 fn rust_uv_tcp_bind(tcp_server: *uv_tcp_t, addr: *sockaddr_in) -> c_int;
520 fn rust_uv_tcp_connect6(req: *uv_connect_t, handle: *uv_tcp_t, cb: *u8,
521 addr: *sockaddr_in6) -> c_int;
522 fn rust_uv_tcp_bind6(tcp_server: *uv_tcp_t, addr: *sockaddr_in6) -> c_int;
523 fn rust_uv_tcp_getpeername(tcp_handle_ptr: *uv_tcp_t, name: *sockaddr_in) -> c_int;
524 fn rust_uv_tcp_getpeername6(tcp_handle_ptr: *uv_tcp_t, name: *sockaddr_in6) ->c_int;
525 fn rust_uv_tcp_getsockname(handle: *uv_tcp_t, name: *sockaddr_in) -> c_int;
526 fn rust_uv_tcp_getsockname6(handle: *uv_tcp_t, name: *sockaddr_in6) -> c_int;
527 fn rust_uv_tcp_nodelay(handle: *uv_tcp_t, enable: c_int) -> c_int;
528 fn rust_uv_tcp_keepalive(handle: *uv_tcp_t, enable: c_int, delay: c_uint) -> c_int;
529 fn rust_uv_tcp_simultaneous_accepts(handle: *uv_tcp_t, enable: c_int) -> c_int;
531 fn rust_uv_udp_init(loop_handle: *uv_loop_t, handle_ptr: *uv_udp_t) -> c_int;
532 fn rust_uv_udp_bind(server: *uv_udp_t, addr: *sockaddr_in, flags: c_uint) -> c_int;
533 fn rust_uv_udp_bind6(server: *uv_udp_t, addr: *sockaddr_in6, flags: c_uint) -> c_int;
534 fn rust_uv_udp_send(req: *uv_udp_send_t, handle: *uv_udp_t, buf_in: *uv_buf_t,
535 buf_cnt: c_int, addr: *sockaddr_in, cb: *u8) -> c_int;
536 fn rust_uv_udp_send6(req: *uv_udp_send_t, handle: *uv_udp_t, buf_in: *uv_buf_t,
537 buf_cnt: c_int, addr: *sockaddr_in6, cb: *u8) -> c_int;
538 fn rust_uv_udp_recv_start(server: *uv_udp_t, on_alloc: *u8, on_recv: *u8) -> c_int;
539 fn rust_uv_udp_recv_stop(server: *uv_udp_t) -> c_int;
540 fn rust_uv_get_udp_handle_from_send_req(req: *uv_udp_send_t) -> *uv_udp_t;
541 fn rust_uv_udp_getsockname(handle: *uv_udp_t, name: *sockaddr_in) -> c_int;
542 fn rust_uv_udp_getsockname6(handle: *uv_udp_t, name: *sockaddr_in6) -> c_int;
543 fn rust_uv_udp_set_membership(handle: *uv_udp_t, multicast_addr: *c_char,
544 interface_addr: *c_char, membership: uv_membership) -> c_int;
545 fn rust_uv_udp_set_multicast_loop(handle: *uv_udp_t, on: c_int) -> c_int;
546 fn rust_uv_udp_set_multicast_ttl(handle: *uv_udp_t, ttl: c_int) -> c_int;
547 fn rust_uv_udp_set_broadcast(handle: *uv_udp_t, on: c_int) -> c_int;
549 fn rust_uv_is_ipv4_sockaddr(addr: *sockaddr) -> c_int;
550 fn rust_uv_is_ipv6_sockaddr(addr: *sockaddr) -> c_int;
551 fn rust_uv_sockaddr_as_sockaddr_in(addr: *sockaddr) -> *sockaddr_in;
552 fn rust_uv_sockaddr_as_sockaddr_in6(addr: *sockaddr) -> *sockaddr_in6;
554 fn rust_uv_listen(stream: *c_void, backlog: c_int, cb: *u8) -> c_int;
555 fn rust_uv_accept(server: *c_void, client: *c_void) -> c_int;
556 fn rust_uv_write(req: *c_void, stream: *c_void, buf_in: *uv_buf_t, buf_cnt: c_int,
558 fn rust_uv_read_start(stream: *c_void, on_alloc: *u8, on_read: *u8) -> c_int;
559 fn rust_uv_read_stop(stream: *c_void) -> c_int;
560 fn rust_uv_timer_init(loop_handle: *c_void, timer_handle: *uv_timer_t) -> c_int;
561 fn rust_uv_timer_start(timer_handle: *uv_timer_t, cb: *u8, timeout: libc::uint64_t,
562 repeat: libc::uint64_t) -> c_int;
563 fn rust_uv_timer_stop(handle: *uv_timer_t) -> c_int;
565 fn rust_uv_malloc_buf_base_of(sug_size: size_t) -> *u8;
566 fn rust_uv_free_base_of_buf(buf: uv_buf_t);
567 fn rust_uv_get_stream_handle_from_connect_req(connect_req: *uv_connect_t) -> *uv_stream_t;
568 fn rust_uv_get_stream_handle_from_write_req(write_req: *uv_write_t) -> *uv_stream_t;
569 fn rust_uv_get_loop_for_uv_handle(handle: *c_void) -> *c_void;
570 fn rust_uv_get_data_for_uv_loop(loop_ptr: *c_void) -> *c_void;
571 fn rust_uv_set_data_for_uv_loop(loop_ptr: *c_void, data: *c_void);
572 fn rust_uv_get_data_for_uv_handle(handle: *c_void) -> *c_void;
573 fn rust_uv_set_data_for_uv_handle(handle: *c_void, data: *c_void);
574 fn rust_uv_get_data_for_req(req: *c_void) -> *c_void;
575 fn rust_uv_set_data_for_req(req: *c_void, data: *c_void);
576 fn rust_uv_get_base_from_buf(buf: uv_buf_t) -> *u8;
577 fn rust_uv_get_len_from_buf(buf: uv_buf_t) -> size_t;