listenfd 0.3.5

A simple library to work with listenfds passed from the outside (systemd/catflap socket activation)
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

use std::env;
use std::io::{self, Read, Write};
use std::mem;
use std::net::{Shutdown, SocketAddr, TcpListener, TcpStream, UdpSocket};

use uuid::Uuid;

pub use std::os::windows::io::{FromRawSocket, RawSocket};
use winapi::ctypes::{c_uint, c_ulong, c_void};
use winapi::shared::ntdef::{HANDLE, NTSTATUS};
use winapi::um::processthreadsapi::GetCurrentProcessId;
use winapi::um::winsock2::{
    WSASocketW, FROM_PROTOCOL_INFO, WSAPROTOCOL_INFOW, WSA_FLAG_OVERLAPPED,
};

pub use self::RawSocket as FdType;

pub fn make_tcp_listener(fd: FdType) -> io::Result<TcpListener> {
    Ok(unsafe { FromRawSocket::from_raw_socket(fd) })
}

pub fn make_udp_socket(fd: FdType) -> io::Result<UdpSocket> {
    Ok(unsafe { FromRawSocket::from_raw_socket(fd) })
}

#[repr(C)]
pub struct IO_STATUS_BLOCK {
    status: *const c_void,
    information: *const c_ulong,
}

#[repr(C)]
pub struct FILE_INFORMATION {
    port: HANDLE,
    key: *const c_void,
}

#[link(name = "ntdll")]
extern "system" {
    #[link_name = "NtSetInformationFile"]
    fn NtSetInformationFile(
        file_handle: HANDLE,
        block: *mut IO_STATUS_BLOCK,
        file_info: *mut FILE_INFORMATION,
        len: c_ulong,
        cls: c_uint,
    ) -> NTSTATUS;
}

/// This detaches a socket from IOCP.
///
/// This only works on windows 8.1 and later.  In ealier windows
/// versions it's not possible to detach the socket until shutdown
/// which means that stuff that uses IOCP (like tokio) cannot be
/// used for reloading type scenarios.
unsafe fn detach_from_iocp(sock: FdType) {
    let mut status_block: IO_STATUS_BLOCK = mem::zeroed();
    let mut file_info: FILE_INFORMATION = mem::zeroed();

    // FileReplaceCompletionInformation
    NtSetInformationFile(
        sock as HANDLE,
        &mut status_block,
        &mut file_info,
        mem::size_of::<FILE_INFORMATION>() as c_ulong,
        61,
    );
}

pub fn get_fds() -> Option<Vec<FdType>> {
    let addr: SocketAddr = env::var("SYSTEMFD_SOCKET_SERVER")
        .ok()
        .and_then(|x| x.parse().ok())?;
    let secret: Uuid = env::var("SYSTEMFD_SOCKET_SECRET")
        .ok()
        .and_then(|x| x.parse().ok())?;

    env::remove_var("SYSTEMFD_SOCKET_SERVER");
    env::remove_var("SYSTEMFD_SOCKET_SECRET");

    let mut data = Vec::new();
    let proto_len = mem::size_of::<WSAPROTOCOL_INFOW>();

    let mut listener = TcpStream::connect(addr).ok()?;
    let pid = unsafe { GetCurrentProcessId() };
    listener
        .write_all(format!("{}|{}", secret, pid).as_bytes())
        .ok()?;
    listener.shutdown(Shutdown::Write).ok()?;
    listener.read_to_end(&mut data).ok()?;

    let items = data.len() / proto_len;
    let mut rv = Vec::new();

    for idx in 0..items {
        let offset = idx * proto_len;
        let proto_info: &mut WSAPROTOCOL_INFOW =
            unsafe { mem::transmute(data[offset..offset + proto_len].as_ptr()) };
        unsafe {
            let sock = WSASocketW(
                FROM_PROTOCOL_INFO,
                FROM_PROTOCOL_INFO,
                FROM_PROTOCOL_INFO,
                proto_info,
                0,
                WSA_FLAG_OVERLAPPED,
            ) as FdType;
            if sock == 0 {
                return None;
            }
            detach_from_iocp(sock);
            rv.push(sock);
        }
    }

    Some(rv)
}