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
|
use std::os::unix::prelude::*;
use std::fmt::{self, Formatter};
use std::marker::PhantomData;
use msg_socket2::{
ser::{
SerializeAdapter, SerializeRawFd, SerializeStruct, SerializeStructFds,
SerializeTupleStruct, SerializeTupleStructFds,
},
DeserializeWithFds, DeserializerWithFds, FdSerializer, SerializeWithFds, Serializer, Socket,
};
use serde::de::{Deserializer, SeqAccess};
use sys_util::net::UnixSeqpacket;
#[derive(Debug)]
struct Inner(RawFd, u16);
impl SerializeWithFds for Inner {
fn serialize<Ser: Serializer>(&self, serializer: Ser) -> Result<Ser::Ok, Ser::Error> {
let mut state = serializer.serialize_tuple_struct("Inner", 1)?;
state.serialize_field(&self.1)?;
state.end()
}
fn serialize_fds<Ser: FdSerializer>(&self, serializer: Ser) -> Result<Ser::Ok, Ser::Error> {
let mut state = serializer.serialize_tuple_struct("Inner", 1)?;
state.serialize_field(&SerializeRawFd::new(&self.0))?;
state.end()
}
}
#[derive(Debug)]
struct Test {
fd: RawFd,
inner: Inner,
}
impl SerializeWithFds for Test {
fn serialize<Ser: Serializer>(&self, serializer: Ser) -> Result<Ser::Ok, Ser::Error> {
let mut state = serializer.serialize_struct("Test", 1)?;
state.skip_field("fd")?;
state.serialize_field("inner", &SerializeAdapter::new(&self.inner))?;
state.end()
}
fn serialize_fds<Ser: FdSerializer>(&self, serializer: Ser) -> Result<Ser::Ok, Ser::Error> {
let mut state = serializer.serialize_struct("Test", 2)?;
state.serialize_field("fd", &SerializeRawFd::new(&self.fd))?;
state.serialize_field("inner", &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);
}
|