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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
// Copyright (C) 2020 - Will Glozer. All rights reserved.

use std::io::{Error, ErrorKind, IoSlice, IoSliceMut, Result};
use std::mem::{size_of, transmute, zeroed};
use std::net::{SocketAddr, ToSocketAddrs};
use std::os::unix::io::{AsRawFd, RawFd};
use libc::{AF_INET, AF_INET6, c_int, msghdr, sockaddr_storage, socklen_t};
use socket2::{Socket, SockAddr};
use crate::{Domain, Type, Protocol};
use crate::option::{Level, Name, Opt};

pub struct RawSocket {
    sys: Socket,
}

impl RawSocket {
    pub fn new(domain: Domain, kind: Type, protocol: Option<Protocol>) -> Result<Self> {
        let sys = Socket::new(domain, kind, protocol)?;
        Ok(Self { sys })
    }

    pub fn bind<A: ToSocketAddrs>(&self, addr: A) -> Result<()> {
        self.sys.bind(&sockaddr(addr)?)
    }

    pub fn local_addr(&self) -> Result<SocketAddr> {
        socketaddr(&self.sys.local_addr()?)
    }

    pub fn recv_from(&self, buf: &mut [u8]) -> Result<(usize, SocketAddr)> {
        let (n, addr) = self.sys.recv_from(buf)?;
        Ok((n, socketaddr(&addr)?))
    }

    pub fn recv_msg(
        &self,
        data: &[IoSliceMut<'_>],
        ctrl: &mut [u8]
    ) -> Result<(usize, SocketAddr)> {
        let fd = self.as_raw_fd();
        unsafe {
            let mut addr: sockaddr_storage = zeroed();
            let addr    = &mut addr as *mut _;
            let addrlen = size_of::<sockaddr_storage>();

            let mut msg: msghdr = zeroed();
            msg.msg_name    = addr          as *mut _;
            msg.msg_namelen = addrlen       as      _;
            msg.msg_iov     = data.as_ptr() as *mut _;
            msg.msg_iovlen  = data.len()    as      _;

            if !ctrl.is_empty() {
                msg.msg_control    = ctrl.as_ptr() as *mut _;
                msg.msg_controllen = ctrl.len()    as      _;
            }

            let n = match libc::recvmsg(fd, &mut msg, 0) {
                n if n >= 0 => n as usize,
                _           => Err(Error::last_os_error())?,
            };

            let addr = msg.msg_name as *const _;
            let len  = msg.msg_namelen;
            let addr = socketaddr(&SockAddr::from_raw_parts(addr, len))?;

            Ok((n, addr))
        }
    }

    pub fn send_to<A: ToSocketAddrs>(&self, buf: &[u8], addr: A) -> Result<usize> {
        self.sys.send_to(buf, &sockaddr(addr)?)
    }

    pub fn send_msg<A: ToSocketAddrs>(
        &self,
        addr: A,
        data: &[IoSlice<'_>],
        ctrl: &[u8],
    ) -> Result<usize> {
        let fd   = self.as_raw_fd();
        let addr = sockaddr(addr)?;

        unsafe {
            let mut msg: msghdr = zeroed();
            msg.msg_name    = addr.as_ptr() as      _;
            msg.msg_namelen = addr.len()    as      _;
            msg.msg_iov     = data.as_ptr() as *mut _;
            msg.msg_iovlen  = data.len()    as      _;

            if !ctrl.is_empty() {
                msg.msg_control    = ctrl.as_ptr() as *mut _;
                msg.msg_controllen = ctrl.len()    as      _;
            }

            match libc::sendmsg(fd, &msg, 0) {
                n if n >= 0 => Ok(n as usize),
                _           => Err(Error::last_os_error()),
            }
        }
    }

    pub fn get_sockopt<O: Opt>(&self, level: Level, name: Name) -> Result<O> {
        let fd = self.as_raw_fd();

        let mut val = O::default();
        let mut len = size_of::<O>() as socklen_t;

        let ptr = &mut val as *mut _ as *mut _;
        let len = &mut len as *mut _;

        unsafe {
            let level = transmute(level);
            let name  = transmute(name);
            match libc::getsockopt(fd, level, name, ptr, len) {
                0 => Ok(val),
                _ => Err(Error::last_os_error()),
            }
        }
    }

    pub fn set_sockopt<O: Opt>(&self, level: Level, name: Name, value: &O) -> Result<()> {
        let fd  = self.as_raw_fd();
        let ptr = value as *const _ as *const _;
        let len = size_of::<O>() as socklen_t;

        unsafe {
            let level = transmute(level);
            let name  = transmute(name);
            match libc::setsockopt(fd, level, name, ptr, len) {
                0 => Ok(()),
                _ => Err(Error::last_os_error()),
            }
        }
    }

    pub fn set_nonblocking(&self, nonblocking: bool) -> Result<()> {
        self.sys.set_nonblocking(nonblocking)
    }
}

impl AsRawFd for RawSocket {
    fn as_raw_fd(&self) -> RawFd {
        self.sys.as_raw_fd()
    }
}

fn sockaddr<A: ToSocketAddrs>(addr: A) -> Result<SockAddr> {
    match addr.to_socket_addrs()?.next() {
        Some(addr) => Ok(SockAddr::from(addr)),
        None       => Err(Error::new(ErrorKind::InvalidInput, "invalid socket address")),
    }
}

fn socketaddr(addr: &SockAddr) -> Result<SocketAddr> {
    match addr.family() as c_int {
        AF_INET  => Ok(addr.as_inet().expect("AF_INET addr").into()),
        AF_INET6 => Ok(addr.as_inet6().expect("AF_INET6 addr").into()),
        _        => Err(Error::new(ErrorKind::Other, "unknown address type")),
    }
}