src/libstd/rt/uv/uvll.rs

   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.
   4 //
   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.
  10
  11 /*!
  12  * Low-level bindings to the libuv library.
  13  *
  14  * This module contains a set of direct, 'bare-metal' wrappers around
  15  * the libuv C-API.
  16  *
  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.
  22  *
  23  * There are also a collection of helper functions to ease interacting
  24  * with the low-level API.
  25  *
  26  * As new functionality, existant in uv.h, is added to the rust stdlib,
  27  * the mappings should be added in this module.
  28  */
  29
  30 #[allow(non_camel_case_types)]; // C types
  31
  32 use libc::{size_t, c_int, c_uint, c_void, c_char, uintptr_t};
  33 use libc::{malloc, free};
  34 use libc;
  35 use prelude::*;
  36 use ptr;
  37 use str;
  38 use vec;
  39
  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;
  48
  49 pub struct uv_err_t {
  50     code: c_int,
  51     sys_errno_: c_int
  52 }
  53
  54 pub struct uv_buf_t {
  55     base: *u8,
  56     len: libc::size_t,
  57 }
  58
  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;
  71
  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;
  76
  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;
  81
  82 #[deriving(Eq)]
  83 pub enum uv_handle_type {
  84     UV_UNKNOWN_HANDLE,
  85     UV_ASYNC,
  86     UV_CHECK,
  87     UV_FS_EVENT,
  88     UV_FS_POLL,
  89     UV_HANDLE,
  90     UV_IDLE,
  91     UV_NAMED_PIPE,
  92     UV_POLL,
  93     UV_PREPARE,
  94     UV_PROCESS,
  95     UV_STREAM,
  96     UV_TCP,
  97     UV_TIMER,
  98     UV_TTY,
  99     UV_UDP,
 100     UV_SIGNAL,
 101     UV_FILE,
 102     UV_HANDLE_TYPE_MAX
 103 }
 104
 105 #[deriving(Eq)]
 106 pub enum uv_req_type {
 107     UV_UNKNOWN_REQ,
 108     UV_REQ,
 109     UV_CONNECT,
 110     UV_WRITE,
 111     UV_SHUTDOWN,
 112     UV_UDP_SEND,
 113     UV_FS,
 114     UV_WORK,
 115     UV_GETADDRINFO,
 116     UV_REQ_TYPE_MAX
 117 }
 118
 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());
 124     return p;
 125 }
 126
 127 pub unsafe fn free_handle(v: *c_void) {
 128     free(v)
 129 }
 130
 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());
 136     return p;
 137 }
 138
 139 pub unsafe fn free_req(v: *c_void) {
 140     free(v)
 141 }
 142
 143 #[test]
 144 fn handle_sanity_check() {
 145     unsafe {
 146         assert_eq!(UV_HANDLE_TYPE_MAX as uint, rust_uv_handle_type_max());
 147     }
 148 }
 149
 150 #[test]
 151 fn request_sanity_check() {
 152     unsafe {
 153         assert_eq!(UV_REQ_TYPE_MAX as uint, rust_uv_req_type_max());
 154     }
 155 }
 156
 157 pub unsafe fn loop_new() -> *c_void {
 158     return rust_uv_loop_new();
 159 }
 160
 161 pub unsafe fn loop_delete(loop_handle: *c_void) {
 162     rust_uv_loop_delete(loop_handle);
 163 }
 164
 165 pub unsafe fn run(loop_handle: *c_void) {
 166     rust_uv_run(loop_handle);
 167 }
 168
 169 pub unsafe fn close<T>(handle: *T, cb: *u8) {
 170     rust_uv_close(handle as *c_void, cb);
 171 }
 172
 173 pub unsafe fn walk(loop_handle: *c_void, cb: *u8, arg: *c_void) {
 174     rust_uv_walk(loop_handle, cb, arg);
 175 }
 176
 177 pub unsafe fn idle_new() -> *uv_idle_t {
 178     rust_uv_idle_new()
 179 }
 180
 181 pub unsafe fn idle_delete(handle: *uv_idle_t) {
 182     rust_uv_idle_delete(handle)
 183 }
 184
 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)
 187 }
 188
 189 pub unsafe fn idle_start(handle: *uv_idle_t, cb: uv_idle_cb) -> c_int {
 190     rust_uv_idle_start(handle, cb)
 191 }
 192
 193 pub unsafe fn idle_stop(handle: *uv_idle_t) -> c_int {
 194     rust_uv_idle_stop(handle)
 195 }
 196
 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);
 199 }
 200
 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);
 203 }
 204
 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);
 207 }
 208
 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);
 214 }
 215
 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);
 221 }
 222
 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);
 226 }
 227
 228 pub unsafe fn udp_recv_stop(server: *uv_udp_t) -> c_int {
 229     return rust_uv_udp_recv_stop(server);
 230 }
 231
 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);
 234 }
 235
 236 pub unsafe fn udp_get_sockname(handle: *uv_udp_t, name: *sockaddr_in) -> c_int {
 237     return rust_uv_udp_getsockname(handle, name);
 238 }
 239
 240 pub unsafe fn udp_get_sockname6(handle: *uv_udp_t, name: *sockaddr_in6) -> c_int {
 241     return rust_uv_udp_getsockname6(handle, name);
 242 }
 243
 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);
 247 }
 248
 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);
 251 }
 252
 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);
 255 }
 256
 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);
 259 }
 260
 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);
 263 }
 264
 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);
 268 }
 269
 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);
 273 }
 274
 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);
 277 }
 278
 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);
 281 }
 282
 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);
 285 }
 286
 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);
 289 }
 290
 291 pub unsafe fn tcp_getsockname(handle: *uv_tcp_t, name: *sockaddr_in) -> c_int {
 292     return rust_uv_tcp_getsockname(handle, name);
 293 }
 294
 295 pub unsafe fn tcp_getsockname6(handle: *uv_tcp_t, name: *sockaddr_in6) -> c_int {
 296     return rust_uv_tcp_getsockname6(handle, name);
 297 }
 298
 299 pub unsafe fn tcp_nodelay(handle: *uv_tcp_t, enable: c_int) -> c_int {
 300     return rust_uv_tcp_nodelay(handle, enable);
 301 }
 302
 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);
 305 }
 306
 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);
 309 }
 310
 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);
 313 }
 314
 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);
 317 }
 318
 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);
 323 }
 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);
 326 }
 327
 328 pub unsafe fn read_stop(stream: *uv_stream_t) -> c_int {
 329     return rust_uv_read_stop(stream as *c_void);
 330 }
 331
 332 pub unsafe fn last_error(loop_handle: *c_void) -> uv_err_t {
 333     return rust_uv_last_error(loop_handle);
 334 }
 335
 336 pub unsafe fn strerror(err: *uv_err_t) -> *c_char {
 337     return rust_uv_strerror(err);
 338 }
 339 pub unsafe fn err_name(err: *uv_err_t) -> *c_char {
 340     return rust_uv_err_name(err);
 341 }
 342
 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);
 345 }
 346
 347 pub unsafe fn async_send(async_handle: *uv_async_t) {
 348     return rust_uv_async_send(async_handle);
 349 }
 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);
 354     return out_buf;
 355 }
 356
 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);
 359 }
 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);
 363 }
 364 pub unsafe fn timer_stop(timer_ptr: *uv_timer_t) -> c_int {
 365     return rust_uv_timer_stop(timer_ptr);
 366 }
 367
 368 pub unsafe fn is_ip4_addr(addr: *sockaddr) -> bool {
 369     match rust_uv_is_ipv4_sockaddr(addr) { 0 => false, _ => true }
 370 }
 371
 372 pub unsafe fn is_ip6_addr(addr: *sockaddr) -> bool {
 373     match rust_uv_is_ipv6_sockaddr(addr) { 0 => false, _ => true }
 374 }
 375
 376 pub unsafe fn as_sockaddr_in(addr: *sockaddr) -> *sockaddr_in {
 377     return rust_uv_sockaddr_as_sockaddr_in(addr);
 378 }
 379
 380 pub unsafe fn as_sockaddr_in6(addr: *sockaddr) -> *sockaddr_in6 {
 381     return rust_uv_sockaddr_as_sockaddr_in6(addr);
 382 }
 383
 384 pub unsafe fn malloc_ip4_addr(ip: &str, port: int) -> *sockaddr_in {
 385     do str::as_c_str(ip) |ip_buf| {
 386         rust_uv_ip4_addrp(ip_buf as *u8, port as libc::c_int)
 387     }
 388 }
 389 pub unsafe fn malloc_ip6_addr(ip: &str, port: int) -> *sockaddr_in6 {
 390     do str::as_c_str(ip) |ip_buf| {
 391         rust_uv_ip6_addrp(ip_buf as *u8, port as libc::c_int)
 392     }
 393 }
 394
 395 pub unsafe fn free_ip4_addr(addr: *sockaddr_in) {
 396     rust_uv_free_ip4_addr(addr);
 397 }
 398
 399 pub unsafe fn free_ip6_addr(addr: *sockaddr_in6) {
 400     rust_uv_free_ip6_addr(addr);
 401 }
 402
 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);
 405 }
 406
 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);
 409 }
 410
 411 pub unsafe fn ip4_port(addr: *sockaddr_in) -> c_uint {
 412    return rust_uv_ip4_port(addr);
 413 }
 414
 415 pub unsafe fn ip6_port(addr: *sockaddr_in6) -> c_uint {
 416     return rust_uv_ip6_port(addr);
 417 }
 418
 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);
 422 }
 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);
 425 }
 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);
 428 }
 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)
 431 }
 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);
 434 }
 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);
 437 }
 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);
 440 }
 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);
 443 }
 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);
 446 }
 447 pub unsafe fn get_base_from_buf(buf: uv_buf_t) -> *u8 {
 448     return rust_uv_get_base_from_buf(buf);
 449 }
 450 pub unsafe fn get_len_from_buf(buf: uv_buf_t) -> size_t {
 451     return rust_uv_get_len_from_buf(buf);
 452 }
 453 pub unsafe fn malloc_buf_base_of(suggested_size: size_t) -> *u8 {
 454     return rust_uv_malloc_buf_base_of(suggested_size);
 455 }
 456 pub unsafe fn free_base_of_buf(buf: uv_buf_t) {
 457     rust_uv_free_base_of_buf(buf);
 458 }
 459
 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",
 466                     err_name, err_msg);
 467 }
 468
 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 }
 475 }
 476
 477 pub struct uv_err_data {
 478     err_name: ~str,
 479     err_msg: ~str,
 480 }
 481
 482 extern {
 483
 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;
 488
 489     // libuv public API
 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);
 495
 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;
 501
 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;
 530
 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;
 548
 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;
 553
 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,
 557                      cb: *u8) -> 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;
 564
 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;
 578 }