src/libstd/sys/redox/net/udp.rs

   1 // Copyright 2016 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 use cell::UnsafeCell;
  12 use cmp;
  13 use io::{self, Error, ErrorKind, Result};
  14 use mem;
  15 use net::{SocketAddr, Ipv4Addr, Ipv6Addr};
  16 use path::Path;
  17 use sys::fs::{File, OpenOptions};
  18 use sys::syscall::TimeSpec;
  19 use sys_common::{AsInner, FromInner, IntoInner};
  20 use time::Duration;
  21
  22 use super::{path_to_peer_addr, path_to_local_addr};
  23
  24 #[derive(Debug)]
  25 pub struct UdpSocket(File, UnsafeCell<Option<SocketAddr>>);
  26
  27 impl UdpSocket {
  28     pub fn bind(addr: Result<&SocketAddr>) -> Result<UdpSocket> {
  29         let path = format!("udp:/{}", addr?);
  30         let mut options = OpenOptions::new();
  31         options.read(true);
  32         options.write(true);
  33         Ok(UdpSocket(File::open(Path::new(path.as_str()), &options)?, UnsafeCell::new(None)))
  34     }
  35
  36     fn get_conn(&self) -> &mut Option<SocketAddr> {
  37         unsafe { &mut *(self.1.get()) }
  38     }
  39
  40     pub fn connect(&self, addr: Result<&SocketAddr>) -> Result<()> {
  41         unsafe { *self.1.get() = Some(*addr?) };
  42         Ok(())
  43     }
  44
  45     pub fn duplicate(&self) -> Result<UdpSocket> {
  46         let new_bind = self.0.dup(&[])?;
  47         let new_conn = *self.get_conn();
  48         Ok(UdpSocket(new_bind, UnsafeCell::new(new_conn)))
  49     }
  50
  51     pub fn recv_from(&self, buf: &mut [u8]) -> Result<(usize, SocketAddr)> {
  52         let from = self.0.dup(b"listen")?;
  53         let path = from.path()?;
  54         let peer_addr = path_to_peer_addr(path.to_str().unwrap_or(""));
  55         let count = from.read(buf)?;
  56         Ok((count, peer_addr))
  57     }
  58
  59     pub fn recv(&self, buf: &mut [u8]) -> Result<usize> {
  60         if let Some(addr) = *self.get_conn() {
  61             let from = self.0.dup(addr.to_string().as_bytes())?;
  62             from.read(buf)
  63         } else {
  64             Err(Error::new(ErrorKind::Other, "UdpSocket::recv not connected"))
  65         }
  66     }
  67
  68     pub fn send_to(&self, buf: &[u8], addr: &SocketAddr) -> Result<usize> {
  69         let to = self.0.dup(format!("{}", addr).as_bytes())?;
  70         to.write(buf)
  71     }
  72
  73     pub fn send(&self, buf: &[u8]) -> Result<usize> {
  74         if let Some(addr) = *self.get_conn() {
  75             self.send_to(buf, &addr)
  76         } else {
  77             Err(Error::new(ErrorKind::Other, "UdpSocket::send not connected"))
  78         }
  79     }
  80
  81     pub fn take_error(&self) -> Result<Option<Error>> {
  82         Ok(None)
  83     }
  84
  85     pub fn socket_addr(&self) -> Result<SocketAddr> {
  86         let path = self.0.path()?;
  87         Ok(path_to_local_addr(path.to_str().unwrap_or("")))
  88     }
  89
  90     pub fn peek(&self, _buf: &mut [u8]) -> Result<usize> {
  91         Err(Error::new(ErrorKind::Other, "UdpSocket::peek not implemented"))
  92     }
  93
  94     pub fn peek_from(&self, _buf: &mut [u8]) -> Result<(usize, SocketAddr)> {
  95         Err(Error::new(ErrorKind::Other, "UdpSocket::peek_from not implemented"))
  96     }
  97
  98     pub fn broadcast(&self) -> Result<bool> {
  99         Err(Error::new(ErrorKind::Other, "UdpSocket::broadcast not implemented"))
 100     }
 101
 102     pub fn multicast_loop_v4(&self) -> Result<bool> {
 103         Err(Error::new(ErrorKind::Other, "UdpSocket::multicast_loop_v4 not implemented"))
 104     }
 105
 106     pub fn multicast_loop_v6(&self) -> Result<bool> {
 107         Err(Error::new(ErrorKind::Other, "UdpSocket::multicast_loop_v6 not implemented"))
 108     }
 109
 110     pub fn multicast_ttl_v4(&self) -> Result<u32> {
 111         Err(Error::new(ErrorKind::Other, "UdpSocket::multicast_ttl_v4 not implemented"))
 112     }
 113
 114     pub fn nonblocking(&self) -> Result<bool> {
 115         self.0.fd().nonblocking()
 116     }
 117
 118     pub fn only_v6(&self) -> Result<bool> {
 119         Err(Error::new(ErrorKind::Other, "UdpSocket::only_v6 not implemented"))
 120     }
 121
 122     pub fn ttl(&self) -> Result<u32> {
 123         let mut ttl = [0];
 124         let file = self.0.dup(b"ttl")?;
 125         file.read(&mut ttl)?;
 126         Ok(ttl[0] as u32)
 127     }
 128
 129     pub fn read_timeout(&self) -> Result<Option<Duration>> {
 130         let mut time = TimeSpec::default();
 131         let file = self.0.dup(b"read_timeout")?;
 132         if file.read(&mut time)? >= mem::size_of::<TimeSpec>() {
 133             Ok(Some(Duration::new(time.tv_sec as u64, time.tv_nsec as u32)))
 134         } else {
 135             Ok(None)
 136         }
 137     }
 138
 139     pub fn write_timeout(&self) -> Result<Option<Duration>> {
 140         let mut time = TimeSpec::default();
 141         let file = self.0.dup(b"write_timeout")?;
 142         if file.read(&mut time)? >= mem::size_of::<TimeSpec>() {
 143             Ok(Some(Duration::new(time.tv_sec as u64, time.tv_nsec as u32)))
 144         } else {
 145             Ok(None)
 146         }
 147     }
 148
 149     pub fn set_broadcast(&self, _broadcast: bool) -> Result<()> {
 150         Err(Error::new(ErrorKind::Other, "UdpSocket::set_broadcast not implemented"))
 151     }
 152
 153     pub fn set_multicast_loop_v4(&self, _multicast_loop_v4: bool) -> Result<()> {
 154         Err(Error::new(ErrorKind::Other, "UdpSocket::set_multicast_loop_v4 not implemented"))
 155     }
 156
 157     pub fn set_multicast_loop_v6(&self, _multicast_loop_v6: bool) -> Result<()> {
 158         Err(Error::new(ErrorKind::Other, "UdpSocket::set_multicast_loop_v6 not implemented"))
 159     }
 160
 161     pub fn set_multicast_ttl_v4(&self, _multicast_ttl_v4: u32) -> Result<()> {
 162         Err(Error::new(ErrorKind::Other, "UdpSocket::set_multicast_ttl_v4 not implemented"))
 163     }
 164
 165     pub fn set_nonblocking(&self, nonblocking: bool) -> Result<()> {
 166         self.0.fd().set_nonblocking(nonblocking)
 167     }
 168
 169     pub fn set_only_v6(&self, _only_v6: bool) -> Result<()> {
 170         Err(Error::new(ErrorKind::Other, "UdpSocket::set_only_v6 not implemented"))
 171     }
 172
 173     pub fn set_ttl(&self, ttl: u32) -> Result<()> {
 174         let file = self.0.dup(b"ttl")?;
 175         file.write(&[cmp::min(ttl, 255) as u8])?;
 176         Ok(())
 177     }
 178
 179     pub fn set_read_timeout(&self, duration_option: Option<Duration>) -> Result<()> {
 180         let file = self.0.dup(b"read_timeout")?;
 181         if let Some(duration) = duration_option {
 182             if duration.as_secs() == 0 && duration.subsec_nanos() == 0 {
 183                 return Err(io::Error::new(io::ErrorKind::InvalidInput,
 184                                           "cannot set a 0 duration timeout"));
 185             }
 186             file.write(&TimeSpec {
 187                 tv_sec: duration.as_secs() as i64,
 188                 tv_nsec: duration.subsec_nanos() as i32
 189             })?;
 190         } else {
 191             file.write(&[])?;
 192         }
 193         Ok(())
 194     }
 195
 196     pub fn set_write_timeout(&self, duration_option: Option<Duration>) -> Result<()> {
 197         let file = self.0.dup(b"write_timeout")?;
 198         if let Some(duration) = duration_option {
 199             if duration.as_secs() == 0 && duration.subsec_nanos() == 0 {
 200                 return Err(io::Error::new(io::ErrorKind::InvalidInput,
 201                                           "cannot set a 0 duration timeout"));
 202             }
 203             file.write(&TimeSpec {
 204                 tv_sec: duration.as_secs() as i64,
 205                 tv_nsec: duration.subsec_nanos() as i32
 206             })?;
 207         } else {
 208             file.write(&[])?;
 209         }
 210         Ok(())
 211     }
 212
 213     pub fn join_multicast_v4(&self, _multiaddr: &Ipv4Addr, _interface: &Ipv4Addr) -> Result<()> {
 214         Err(Error::new(ErrorKind::Other, "UdpSocket::join_multicast_v4 not implemented"))
 215     }
 216
 217     pub fn join_multicast_v6(&self, _multiaddr: &Ipv6Addr, _interface: u32) -> Result<()> {
 218         Err(Error::new(ErrorKind::Other, "UdpSocket::join_multicast_v6 not implemented"))
 219     }
 220
 221     pub fn leave_multicast_v4(&self, _multiaddr: &Ipv4Addr, _interface: &Ipv4Addr) -> Result<()> {
 222         Err(Error::new(ErrorKind::Other, "UdpSocket::leave_multicast_v4 not implemented"))
 223     }
 224
 225     pub fn leave_multicast_v6(&self, _multiaddr: &Ipv6Addr, _interface: u32) -> Result<()> {
 226         Err(Error::new(ErrorKind::Other, "UdpSocket::leave_multicast_v6 not implemented"))
 227     }
 228 }
 229
 230 impl AsInner<File> for UdpSocket {
 231     fn as_inner(&self) -> &File { &self.0 }
 232 }
 233
 234 impl FromInner<File> for UdpSocket {
 235     fn from_inner(file: File) -> UdpSocket {
 236         UdpSocket(file, UnsafeCell::new(None))
 237     }
 238 }
 239
 240 impl IntoInner<File> for UdpSocket {
 241     fn into_inner(self) -> File { self.0 }
 242 }