Occasionally, it is useful to be able to use UnixSeqpacket as a type that can represent any kind of MsgSocket. For example, to keep some MsgSockets of different types in a Vec. In this case, it may be known what type of messages should be sent over a socket, even though that may not be represantable in the type system. To accomodate this situation, this patch introduces send_msg_on_socket and recv_msg_on_socket methods on UnixSeqpacket, that can be used to send or receive any kind of MsgOnSocket. The caller is obviously responsible for ensuring that the messages being sent are of the type expected by the socket. This lack of type safety for message types is not ideal, and so MsgSender and MsgReceiver should still be preferred wherever possible. --- msg_socket/src/lib.rs | 52 ++++++++++++++++++++++++++----------------- 1 file changed, 32 insertions(+), 20 deletions(-) diff --git a/msg_socket/src/lib.rs b/msg_socket/src/lib.rs index 540d49d7..be860701 100644 --- a/msg_socket/src/lib.rs +++ b/msg_socket/src/lib.rs @@ -123,42 +123,38 @@ impl<M: MsgOnSocket> AsRawFd for Receiver<M> { } } -/// Types that could send a message. -pub trait MsgSender: AsRef<UnixSeqpacket> { - type M: MsgOnSocket; - fn send(&self, msg: &Self::M) -> MsgResult<()> { +pub trait UnixSeqpacketExt { + fn send_msg_on_socket<M: MsgOnSocket>(&self, msg: &M) -> MsgResult<()>; + fn recv_msg_on_socket<M: MsgOnSocket>(&self) -> MsgResult<M>; +} + +impl UnixSeqpacketExt for UnixSeqpacket { + fn send_msg_on_socket<M: MsgOnSocket>(&self, msg: &M) -> MsgResult<()> { let msg_size = msg.msg_size(); let fd_size = msg.fd_count(); let mut msg_buffer: Vec<u8> = vec![0; msg_size]; let mut fd_buffer: Vec<RawFd> = vec![0; fd_size]; let fd_size = msg.write_to_buffer(&mut msg_buffer, &mut fd_buffer)?; - let sock: &UnixSeqpacket = self.as_ref(); if fd_size == 0 { - handle_eintr!(sock.send(&msg_buffer)) + handle_eintr!(self.send(&msg_buffer)) .map_err(|e| MsgError::Send(SysError::new(e.raw_os_error().unwrap_or(0))))?; } else { let ioslice = IoSlice::new(&msg_buffer[..]); - sock.send_with_fds(&[ioslice], &fd_buffer[0..fd_size]) + self.send_with_fds(&[ioslice], &fd_buffer[0..fd_size]) .map_err(MsgError::Send)?; } Ok(()) } -} - -/// Types that could receive a message. -pub trait MsgReceiver: AsRef<UnixSeqpacket> { - type M: MsgOnSocket; - fn recv(&self) -> MsgResult<Self::M> { - let sock: &UnixSeqpacket = self.as_ref(); + fn recv_msg_on_socket<M: MsgOnSocket>(&self) -> MsgResult<M> { let (msg_buffer, fd_buffer) = { - if Self::M::uses_fd() { - sock.recv_as_vec_with_fds() + if M::uses_fd() { + self.recv_as_vec_with_fds() .map_err(|e| MsgError::Recv(SysError::new(e.raw_os_error().unwrap_or(0))))? } else { ( - sock.recv_as_vec().map_err(|e| { + self.recv_as_vec().map_err(|e| { MsgError::Recv(SysError::new(e.raw_os_error().unwrap_or(0))) })?, vec![], @@ -166,11 +162,11 @@ pub trait MsgReceiver: AsRef<UnixSeqpacket> { } }; - if msg_buffer.len() == 0 && Self::M::fixed_size() != Some(0) { + if msg_buffer.len() == 0 && M::fixed_size() != Some(0) { return Err(MsgError::RecvZero); } - if let Some(fixed_size) = Self::M::fixed_size() { + if let Some(fixed_size) = M::fixed_size() { if fixed_size != msg_buffer.len() { return Err(MsgError::BadRecvSize { expected: fixed_size, @@ -180,7 +176,7 @@ pub trait MsgReceiver: AsRef<UnixSeqpacket> { } // Safe because fd buffer is read from socket. - let (v, read_fd_size) = unsafe { Self::M::read_from_buffer(&msg_buffer, &fd_buffer)? }; + let (v, read_fd_size) = unsafe { M::read_from_buffer(&msg_buffer, &fd_buffer)? }; if fd_buffer.len() != read_fd_size { return Err(MsgError::NotExpectFd); } @@ -188,6 +184,22 @@ pub trait MsgReceiver: AsRef<UnixSeqpacket> { } } +/// Types that could send a message. +pub trait MsgSender: AsRef<UnixSeqpacket> { + type M: MsgOnSocket; + fn send(&self, msg: &Self::M) -> MsgResult<()> { + self.as_ref().send_msg_on_socket(msg) + } +} + +/// Types that could receive a message. +pub trait MsgReceiver: AsRef<UnixSeqpacket> { + type M: MsgOnSocket; + fn recv(&self) -> MsgResult<Self::M> { + self.as_ref().recv_msg_on_socket() + } +} + impl<I: MsgOnSocket, O: MsgOnSocket> MsgSender for MsgSocket<I, O> { type M = I; } -- 2.26.2