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
|
// SPDX-License-Identifier: MIT OR Apache-2.0
// Copyright 2020, Alyssa Ross
use bincode::{DefaultOptions, Deserializer, Serializer};
use std::io::IoSlice;
use std::marker::PhantomData;
use std::os::unix::prelude::*;
use sys_util::{net::UnixSeqpacket, ScmSocket};
use crate::{de, DeserializeWithFds, Error, Fd, FdSerializerImpl, SerializeWithFds};
/// A Unix **SOCK_SEQPACKET** socket that can send and receive values
/// consisting of binary data and file descriptors.
#[derive(Debug)]
pub struct Socket<Send, Recv> {
sock: UnixSeqpacket,
__: PhantomData<(Send, Recv)>,
}
impl<Send, Recv> Socket<Send, Recv> {
pub fn new(sock: UnixSeqpacket) -> Self {
Self {
sock,
__: PhantomData,
}
}
}
impl<Send: SerializeWithFds, Recv> Socket<Send, Recv> {
pub fn send(&self, value: Send) -> Result<(), Error> {
let mut bytes: Vec<u8> = vec![];
let mut fds: Vec<RawFd> = vec![];
value.serialize(&mut Serializer::new(&mut bytes, DefaultOptions::new()))?;
value
.serialize_fds(&mut FdSerializerImpl { fds: &mut fds })
.unwrap();
self.sock.send_with_fds(&[IoSlice::new(&bytes)], &fds)?;
Ok(())
}
}
impl<Send, Recv: for<'de> DeserializeWithFds<'de>> Socket<Send, Recv> {
pub fn recv(&self) -> Result<Recv, Error> {
let (bytes, raw_fds) = self.sock.recv_as_vec_with_fds()?;
// Safe because we just received ownership of the fds.
let mut fds = raw_fds.into_iter().map(|fd| unsafe { Fd::new(fd) });
let mut deserializer = Deserializer::from_slice(&bytes, DefaultOptions::new());
let deserializer_with_fds = de::WithFds {
inner: &mut deserializer,
fds: &mut fds,
};
Ok(Recv::deserialize(deserializer_with_fds)?)
}
}
impl<Send, Recv> AsRawFd for Socket<Send, Recv> {
fn as_raw_fd(&self) -> RawFd {
self.sock.as_raw_fd()
}
}
|