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

use byteorder::{BigEndian, ByteOrder};
use fd;
use std::io;
use std::os::raw::c_int;
use Argdata;
use ReadError;
use Value;

/// Create an argdata value representing a file descriptor of this process.
pub fn process_fd(fd: c_int) -> fd::Fd {
	fd::Fd(fd)
}

/// Create an argdata value representing a file descriptor attached to the data.
pub fn encoded_fd<T: fd::ConvertFd>(raw: u32, convert_fd: T) -> fd::EncodedFd<T> {
	fd::EncodedFd::new(raw, convert_fd)
}

/// Create an argdata value representing an invalid file descriptor.
pub fn invalid_fd() -> fd::InvalidFd {
	fd::InvalidFd
}

impl<'d> Argdata<'d> for fd::Fd {
	fn read<'a>(&'a self) -> Result<Value<'a, 'd>, ReadError>
	where
		'd: 'a,
	{
		Ok(Value::Fd(encoded_fd(self.0 as u32, &fd::Identity)))
	}

	fn serialized_length(&self) -> usize {
		5
	}

	fn serialize(
		&self,
		writer: &mut io::Write,
		fd_map: Option<&mut fd::FdMapping>,
	) -> io::Result<()> {
		encoded_fd(self.0 as u32, fd::Identity).serialize(writer, fd_map)
	}
}

impl<'d, T: fd::ConvertFd> Argdata<'d> for fd::EncodedFd<T> {
	fn read<'a>(&'a self) -> Result<Value<'a, 'd>, ReadError>
	where
		'd: 'a,
	{
		Ok(Value::Fd(encoded_fd(self.raw, &self.convert_fd)))
	}

	fn serialized_length(&self) -> usize {
		5
	}

	fn serialize(
		&self,
		writer: &mut io::Write,
		fd_map: Option<&mut fd::FdMapping>,
	) -> io::Result<()> {
		let raw: u32 = if let Some(fd_map) = fd_map {
			self.convert_fd
				.convert_fd(self.raw)
				.ok()
				.map_or(!0, |fd| fd_map.map(fd))
		} else {
			self.raw
		};
		let mut buf = [3, 0, 0, 0, 0];
		BigEndian::write_u32(&mut buf[1..], raw);
		writer.write_all(&buf)
	}
}

impl<'d> Argdata<'d> for fd::InvalidFd {
	fn read<'a>(&'a self) -> Result<Value<'a, 'd>, ReadError>
	where
		'd: 'a,
	{
		Ok(Value::Fd(encoded_fd(!0, &fd::NoConvert)))
	}

	fn serialized_length(&self) -> usize {
		5
	}

	fn serialize(&self, writer: &mut io::Write, _: Option<&mut fd::FdMapping>) -> io::Result<()> {
		writer.write_all(&[5, 0xFF, 0xFF, 0xFF, 0xFF])
	}
}