libuv 2.13.1

A safe rust wrapper for libuv
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

use crate::{FromInner, IntoInner};
use std::net::SocketAddr;
use uv::addrinfo;

pub struct AddrInfo {
    /// Bitwise OR of uv::AI_* flags
    pub flags: u32,

    /// One of the uv::AF_* constants
    pub family: u32,

    /// One of the uv::SOCK_* constants
    pub socktype: u32,

    /// One of the uv::IPPROTO_* constants
    pub protocol: u32,

    /// The canonical name of the host
    pub canonical_name: Option<String>,

    /// The address info, filled in by getaddrinfo()
    pub addr: Option<SocketAddr>,
}

impl FromInner<*mut addrinfo> for AddrInfo {
    fn from_inner(info: *mut addrinfo) -> AddrInfo {
        unsafe {
            let canonical_name = if (*info).ai_canonname.is_null() {
                None
            } else {
                Some(
                    std::ffi::CStr::from_ptr((*info).ai_canonname as _)
                        .to_string_lossy()
                        .into_owned(),
                )
            };
            let addr = if (*info).ai_addr.is_null() {
                None
            } else {
                crate::build_socketaddr((*info).ai_addr).ok()
            };
            AddrInfo {
                flags: (*info).ai_flags as _,
                family: (*info).ai_family as _,
                socktype: (*info).ai_socktype as _,
                protocol: (*info).ai_protocol as _,
                canonical_name,
                addr,
            }
        }
    }
}

impl IntoInner<addrinfo> for AddrInfo {
    fn into_inner(self) -> addrinfo {
        let mut ai: addrinfo = unsafe { std::mem::zeroed() };
        ai.ai_flags = self.flags as _;
        ai.ai_family = self.family as _;
        ai.ai_socktype = self.socktype as _;
        ai.ai_protocol = self.protocol as _;
        ai
    }
}

impl FromInner<*mut addrinfo> for Vec<AddrInfo> {
    fn from_inner(info: *mut addrinfo) -> Vec<AddrInfo> {
        let mut v = Vec::new();
        let mut current = info;
        while !current.is_null() {
            v.push(current.into_inner());
            unsafe { current = (*current).ai_next };
        }
        return v;
    }
}