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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
use std::{
io,
os::raw::{
c_char,
c_void,
},
pin::Pin,
task::{
Context,
Poll,
},
};
use crate::{
cstr,
ffi,
inner,
interface::Interface,
};
type CallbackStream = crate::stream::ServiceStream<inner::OwnedService, EnumerateResult>;
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
pub enum Enumerate {
BrowseDomains,
RegistrationDomains,
}
impl From<Enumerate> for ffi::DNSServiceFlags {
fn from(e: Enumerate) -> Self {
match e {
Enumerate::BrowseDomains => ffi::FLAGS_BROWSE_DOMAINS,
Enumerate::RegistrationDomains => ffi::FLAGS_REGISTRATION_DOMAINS,
}
}
}
bitflags::bitflags! {
#[derive(Default)]
pub struct EnumeratedFlags: ffi::DNSServiceFlags {
const MORE_COMING = ffi::FLAGS_MORE_COMING;
const ADD = ffi::FLAGS_ADD;
const DEFAULT = ffi::FLAGS_DEFAULT;
}
}
#[must_use = "streams do nothing unless polled"]
pub struct EnumerateDomains {
stream: crate::fused_err_stream::FusedErrorStream<CallbackStream>,
}
impl EnumerateDomains {
pin_utils::unsafe_pinned!(stream: crate::fused_err_stream::FusedErrorStream<CallbackStream>);
}
impl futures_core::Stream for EnumerateDomains {
type Item = io::Result<EnumerateResult>;
fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
self.stream().poll_next(cx)
}
}
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
pub struct EnumerateResult {
pub flags: EnumeratedFlags,
pub interface: Interface,
pub domain: String,
}
unsafe extern "C" fn enumerate_callback(
_sd_ref: ffi::DNSServiceRef,
flags: ffi::DNSServiceFlags,
interface_index: u32,
error_code: ffi::DNSServiceErrorType,
reply_domain: *const c_char,
context: *mut c_void,
) {
CallbackStream::run_callback(context, error_code, || {
let reply_domain = cstr::from_cstr(reply_domain)?;
Ok(EnumerateResult {
flags: EnumeratedFlags::from_bits_truncate(flags),
interface: Interface::from_raw(interface_index),
domain: reply_domain.to_string(),
})
});
}
#[doc(alias = "DNSServiceEnumerateDomains")]
pub fn enumerate_domains(enumerate: Enumerate, interface: Interface) -> EnumerateDomains {
crate::init();
let stream = CallbackStream::new(move |sender| {
inner::OwnedService::enumerate_domains(
enumerate.into(),
interface.into_raw(),
Some(enumerate_callback),
sender,
)
})
.into();
EnumerateDomains { stream }
}