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
|
use std::os::unix::prelude::*;
use std::fmt::{self, Formatter};
use std::marker::PhantomData;
use msg_socket2::*;
use serde::de::*;
use serde::ser::*;
use sys_util::net::UnixSeqpacket;
#[derive(Debug)]
struct Inner(RawFd, u16);
#[derive(Debug)]
struct Test {
fd: RawFd,
inner: Inner,
}
impl SerializeWithFds for Test {
fn serialize<Ser: SerializerWithFds>(
&self,
mut serializer: Ser,
) -> Result<<Ser::Ser as Serializer>::Ok, <Ser::Ser as Serializer>::Error> {
serializer.fds().push(self.fd);
serializer.fds().push(self.inner.0);
struct SerializableInner<'a>(&'a Inner);
impl<'a> Serialize for SerializableInner<'a> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut state = serializer.serialize_tuple_struct("Inner", 1)?;
state.serialize_field(&(self.0).1)?;
state.end()
}
}
let mut state = serializer.serializer().serialize_struct("Test", 1)?;
state.skip_field("fd")?;
state.serialize_field("inner", &SerializableInner(&self.inner))?;
state.end()
}
}
impl<'de> DeserializeWithFds<'de> for Test {
fn deserialize<I, De>(deserializer: DeserializerWithFds<I, De>) -> Result<Self, De::Error>
where
I: Iterator<Item = RawFd>,
De: Deserializer<'de>,
{
struct Visitor<'iter, 'de, Iter>(&'iter mut Iter, PhantomData<&'de ()>);
impl<'iter, 'de, Iter: Iterator<Item = RawFd>> serde::de::Visitor<'de>
for Visitor<'iter, 'de, Iter>
{
type Value = Test;
fn expecting(&self, f: &mut Formatter) -> fmt::Result {
write!(f, "struct Test")
}
fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error> {
Ok(Test {
fd: self.0.next().unwrap(),
inner: Inner(self.0.next().unwrap(), seq.next_element()?.unwrap()),
})
}
}
let DeserializerWithFds {
mut fds,
deserializer,
} = deserializer;
let visitor = Visitor(&mut fds, PhantomData);
deserializer.deserialize_struct("Test", &["fd", "inner"], visitor)
}
}
#[test]
fn round_trip() {
let (f1, f2) = UnixSeqpacket::pair().unwrap();
let s1: Socket<_, ()> = Socket::new(f1);
let s2: Socket<(), Test> = Socket::new(f2);
s1.send(Test {
fd: 0,
inner: Inner(1, 0xACAB),
})
.unwrap();
let result = s2.recv().unwrap();
assert_eq!(result.inner.1, 0xACAB);
}
|